test: fix android coverage pull and adb reverse failure e2e flakes

Move Android native coverage pull to a post-Detox CI step with polling,
harden Detox adb reverse teardown, and make Jacoco/Codecov best-effort.

Author: mikehardy

.github/workflows/tests_e2e_android.yml

@@ -260,10 +260,11 @@ jobs:
             $ANDROID_HOME/platform-tools/adb devices
             nohup sh -c "$ANDROID_HOME/platform-tools/adb logcat '*:D' > adb-log.txt" &
             yarn tests:android:test-cover --headless
-            yarn tests:android:test:jacoco-report
+            yarn tests:android:post-e2e-coverage
 
       # https://github.com/codecov/codecov-action/releases
       - uses: codecov/codecov-action@e53489f4d376d79066609109e7a95a29eb3740b1 # v7.0.0
+        continue-on-error: true
         with:
           verbose: true
 

.yarn/patches/detox-npm-20.51.0-3e13b6e309.patch

@@ -146,3 +146,28 @@ index 10743c87d17de135317e1bac3e65159b9872412f..abbb302307fbd5eabbbff875983f284a
    }
  }
 
+diff --git a/src/devices/common/drivers/android/exec/ADB.js b/src/devices/common/drivers/android/exec/ADB.js
+index 1111111111111111111111111111111111111111..2222222222222222222222222222222222222222 100644
+--- a/src/devices/common/drivers/android/exec/ADB.js
++++ b/src/devices/common/drivers/android/exec/ADB.js
+@@ -379,7 +379,19 @@ class ADB {
+   }
+ 
+   async reverseRemove(deviceId, port) {
+-    return this.adbCmd(deviceId, `reverse --remove tcp:${port}`);
++    try {
++      return await this.adbCmd(deviceId, `reverse --remove tcp:${port}`);
++    } catch (error) {
++      const details = `${error.stderr || ''} ${error.message || ''}`;
++      if (/listener .* not found/i.test(details)) {
++        log.warn(
++          { deviceId, port },
++          'Ignoring missing adb reverse listener during Detox teardown',
++        );
++        return;
++      }
++      throw error;
++    }
+   }
+ 
+   async emuKill(deviceId) {

okf-bundle/ci-workflows/android.md

@@ -1,3 +1,46 @@
 # Android CI workflows
 
-TBD — Gradle/Detox emulator reliability, `coverage.ec` pull behavior, and artifact troubleshooting.
+## E2E job shape
+
+1. `yarn tests:android:test-cover --headless` — Detox + Jet (pass/fail gate)
+2. `yarn tests:android:post-e2e-coverage` — poll/pull `coverage.ec`, Jacoco report (best-effort, never fails the job)
+3. Codecov upload — `continue-on-error: true`
+
+Native Android coverage is **not** pulled inside `tests/e2e/firebase.test.js`. Pulling mid-Detox ran before `DetoxTest.dumpCoverageData()` and routinely missed the file.
+
+## CI failure: Jet 1006 → adb `reverse --remove` mid-run
+
+Observed on [run 27803881448](https://github.com/invertase/react-native-firebase/actions/runs/27803881448):
+
+| Time | Event |
+|------|--------|
+| Jet attempt 1 | Mocha-remote WS **1006** → Jet grace timer starts |
+| Same second | Detox runs `adb reverse --remove tcp:<detox-port>` |
+| +15s | Grace expires → Jet exits → orchestration retries |
+| Attempt 2 | **2586 tests pass** |
+| Teardown | `adb reverse --remove` fails again → Jest FAIL |
+
+**Why reverse cleanup runs mid-run:** Detox `AndroidDriver._launchInstrumentationProcess()` registers a termination handler that always calls `adb reverse --remove` when instrumentation stops:
+
+```342:347:tests/node_modules/detox/src/devices/runtime/drivers/android/AndroidDriver.js
+    const serverPort = await this._reverseServerPort(adbName);
+    this.instrumentation.setTerminationFn(async () => {
+      await this._terminateInstrumentation();
+      await this.adb.reverseRemove(adbName, serverPort);
+    });
+```
+
+When the Jet/app WebSocket drops (1006), Detox can treat the session as dead and tear down instrumentation **while Jet is still in its 15s reconnect grace**. That triggers `reverseRemove` before the orchestration retry's `terminateApp()`. If the listener was never established or was already removed, adb exits non-zero.
+
+**Mitigation (patched):** `.yarn/patches/detox-npm-20.51.0-*.patch` makes `ADB.reverseRemove` ignore `listener 'tcp:…' not found` during teardown.
+
+**Orchestration retry:** `firebase.test.js` still retries on `RETRYABLE_DISCONNECT`; attempt 2 can pass all tests even when attempt 1's teardown logged adb noise.
+
+## Troubleshooting
+
+| Symptom | Likely cause |
+|---------|----------------|
+| `[native-coverage] Android native coverage pull failed` | Detox exited before instrumentation wrote `coverage.ec`; post-e2e poll may still recover it |
+| Empty Jacoco XML (~235 bytes) | No `.ec` pulled — check post-e2e logs |
+| `adb reverse --remove` in Detox logs | Expected on 1006; should be warn-only after Detox patch |
+| Detox red, tests green in log | Pre-patch: teardown adb error; re-run or check patch applied |

okf-bundle/testing/coverage-design.md

@@ -108,13 +108,13 @@ After a Detox/macOS e2e run, expect log lines like `[jet-coverage] WS received N
 ## Pipeline
 
 1. Gradle enables `testCoverageEnabled` on RNFB Android library modules (`tests/android/build.gradle`).
-2. Detox e2e runs; the instrumented app writes `coverage.ec`.
-3. When the Jet process exits successfully, `tests/scripts/pull-native-coverage.js` copies the `.ec` file to `tests/android/app/build/output/coverage/emulator_coverage.ec`. **A failed pull logs a warning and does not fail the Detox test** (intermittent on CI when `coverage.ec` is not flushed in time). Jacoco report may be empty for that run.
-4. `yarn tests:android:test:jacoco-report` runs `jacocoAndroidTestReport`, producing XML at:
+2. Detox e2e runs; the instrumented app writes `coverage.ec` when instrumentation finishes (`DetoxTest.dumpCoverageData()` after `Detox.runTests()` returns).
+3. **After Detox exits**, `yarn tests:android:post-e2e-coverage` (CI) or `yarn tests:android:pull-native-coverage` polls for `coverage.ec`, pulls it to `tests/android/app/build/output/coverage/emulator_coverage.ec`, then runs `jacocoAndroidTestReport`. A missing file logs a warning and does **not** fail the Detox test or the CI job (`continue-on-error` on Codecov upload).
+4. Jacoco XML is produced at:
 
    `tests/android/app/build/reports/jacoco/jacocoAndroidTestReport/jacocoAndroidTestReport.xml`
 
-CI runs steps 3–4 in sequence inside the emulator job.
+CI runs step 3 inside the emulator job immediately after `yarn tests:android:test-cover`.
 
 ## Jacoco configuration notes
 
@@ -186,7 +186,7 @@ yarn tests:ios:test-cover-and-process   # clean Detox run + process (no --reuse)
 
 # Android (after e2e)
 yarn tests:android:test-cover-reuse
-yarn tests:android:test:jacoco-report
+yarn tests:android:post-e2e-coverage
 
 # Codecov CLI (optional)
 .codecov-venv/bin/codecovcli upload-process \
@@ -207,7 +207,8 @@ These must all be true for native iOS coverage to work. If any break, the e2e te
 | Profile path set at launch | `AppDelegate` → `RNFBTestingConfigureCoverageProfilePath()` |
 | JS module name matches native export | `RCT_EXPORT_MODULE(RNFBTestingCoverage)` + `NativeModules.RNFBTestingCoverage` in `tests/app.js` |
 | Flush runs after Mocha tests | Jet `after` hook in `tests/app.js` |
-| Profraw pulled before Detox teardown | `pull-native-coverage.js` on Jet `close` in `firebase.test.js` |
+| Profraw pulled before Detox teardown | `pull-native-coverage.js` on Jet `close` in `firebase.test.js` (iOS only) |
+| Android `coverage.ec` pulled after Detox | `yarn tests:android:post-e2e-coverage` in CI / local post-e2e step |
 | Fresh profraw processed after e2e | `process-ios-native-coverage.js` (deletes profraw after export) |
 
 # Troubleshooting

package.json

@@ -49,6 +49,8 @@
     "tests:android:test-reuse": "cd tests && yarn detox test --configuration android.emu.debug --reuse",
     "tests:android:test-cover": "cd tests && yarn detox test --configuration android.emu.debug --loglevel verbose",
     "tests:android:test-cover-reuse": "cd tests && yarn detox test --configuration android.emu.debug --reuse",
+    "tests:android:pull-native-coverage": "node tests/scripts/pull-native-coverage.js --android-pull",
+    "tests:android:post-e2e-coverage": "node tests/scripts/pull-native-coverage.js --android-post-e2e",
     "tests:android:test:jacoco-report": "cd tests/android && ./gradlew jacocoAndroidTestReport",
     "tests:ios:build": "cd tests && yarn detox build --configuration ios.sim.debug",
     "tests:ios:build:release": "cd tests && yarn detox build --configuration ios.sim.release",

tests/e2e/firebase.test.js

@@ -19,7 +19,7 @@ const { spawn } = require('child_process');
 const net = require('net');
 const path = require('path');
 
-const { pullAndroidCoverage, pullIosCoverage } = require('../scripts/pull-native-coverage');
+const { pullIosCoverage } = require('../scripts/pull-native-coverage');
 
 const JET_REMOTE_PORT = parseInt(process.env.JET_REMOTE_PORT || '8090', 10);
 const METRO_PORT = parseInt(process.env.JET_METRO_PORT || process.env.RCT_METRO_PORT || '8081', 10);
@@ -326,15 +326,12 @@ describe('Jet Tests', function () {
       }
     }
 
-    try {
-      if (platform === 'android' && process.platform !== 'win32') {
-        pullAndroidCoverage(deviceId, { testsDir, softFail: true });
-      }
-      if (platform === 'ios' && process.platform === 'darwin') {
+    if (platform === 'ios' && process.platform === 'darwin') {
+      try {
         pullIosCoverage(deviceId, { testsDir });
+      } catch (e) {
+        throw new Error(`Failed to download native coverage data: ${e.message}`);
       }
-    } catch (e) {
-      throw new Error(`Failed to download native coverage data: ${e.message}`);
     }
   });
 

tests/scripts/pull-native-coverage.js

@@ -1,23 +1,69 @@
-const { execSync } = require('child_process');
+const { execSync, spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
 const TEST_APP_PACKAGE = 'com.invertase.testing';
+const ANDROID_COVERAGE_EMU_PATH = `/data/user/0/${TEST_APP_PACKAGE}/files/coverage.ec`;
+
+function getAdbBinary() {
+  return process.env.ANDROID_HOME
+    ? `${process.env.ANDROID_HOME}/platform-tools/adb`
+    : 'adb';
+}
+
+function resolveAndroidDeviceId(preferredDeviceId) {
+  if (preferredDeviceId) {
+    return preferredDeviceId;
+  }
+
+  if (process.env.ANDROID_SERIAL) {
+    return process.env.ANDROID_SERIAL;
+  }
+
+  const adb = getAdbBinary();
+  const output = execSync(`${adb} devices`, { encoding: 'utf8' });
+  const deviceLine = output
+    .split('\n')
+    .slice(1)
+    .map(line => line.trim())
+    .find(line => line.endsWith('\tdevice'));
+
+  if (!deviceLine) {
+    throw new Error('No online Android device found for native coverage pull');
+  }
+
+  return deviceLine.split('\t')[0];
+}
+
+function androidCoverageFileExists(deviceId) {
+  const adb = getAdbBinary();
+  const serial = deviceId ? `-s ${deviceId}` : '';
+
+  try {
+    execSync(
+      `${adb} ${serial} shell "run-as ${TEST_APP_PACKAGE} test -f ${ANDROID_COVERAGE_EMU_PATH}"`,
+      { stdio: 'pipe' },
+    );
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
 
 function pullAndroidCoverage(deviceId, options = {}) {
   const { softFail = false, testsDir = path.resolve(__dirname, '..') } = options;
-  const emuOrig = `/data/user/0/${TEST_APP_PACKAGE}/files/coverage.ec`;
   const emuDest = '/data/local/tmp/detox/coverage.ec';
   const localDestDir = path.join(testsDir, 'android/app/build/output/coverage');
   const localDestFile = path.join(localDestDir, 'emulator_coverage.ec');
-  const adb = process.env.ANDROID_HOME
-    ? `${process.env.ANDROID_HOME}/platform-tools/adb`
-    : 'adb';
+  const adb = getAdbBinary();
+  const serial = deviceId ? `-s ${deviceId}` : '';
 
   try {
-    execSync(`${adb} -s ${deviceId} shell "run-as ${TEST_APP_PACKAGE} cat ${emuOrig} > ${emuDest}"`);
+    execSync(
+      `${adb} ${serial} shell "run-as ${TEST_APP_PACKAGE} cat ${ANDROID_COVERAGE_EMU_PATH} > ${emuDest}"`,
+    );
     fs.mkdirSync(localDestDir, { recursive: true });
-    execSync(`${adb} -s ${deviceId} pull ${emuDest} ${localDestFile}`);
+    execSync(`${adb} ${serial} pull ${emuDest} ${localDestFile}`);
     console.log(`Coverage data downloaded to: ${localDestFile}`);
     return localDestFile;
   } catch (error) {
@@ -30,6 +76,39 @@ function pullAndroidCoverage(deviceId, options = {}) {
   }
 }
 
+async function pullAndroidCoverageWithRetry(deviceId, options = {}) {
+  const {
+    softFail = true,
+    testsDir = path.resolve(__dirname, '..'),
+    retries = 15,
+    intervalMs = 2000,
+  } = options;
+
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    if (androidCoverageFileExists(deviceId)) {
+      const pulled = pullAndroidCoverage(deviceId, { softFail: true, testsDir });
+      if (pulled) {
+        return pulled;
+      }
+    } else if (attempt === 1 || attempt % 5 === 0) {
+      console.log(
+        `[native-coverage] Waiting for ${ANDROID_COVERAGE_EMU_PATH} (attempt ${attempt}/${retries})`,
+      );
+    }
+
+    if (attempt < retries) {
+      await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+  }
+
+  const message = `Android native coverage file not found after ${retries} attempts`;
+  if (softFail) {
+    console.warn(`[native-coverage] ${message}`);
+    return null;
+  }
+  throw new Error(message);
+}
+
 function pullIosCoverage(deviceId, options = {}) {
   const testsDir = options.testsDir || path.resolve(__dirname, '..');
   const localDestDir = path.join(testsDir, 'ios/build/output/coverage');
@@ -63,7 +142,62 @@ function pullIosCoverage(deviceId, options = {}) {
   return destPaths;
 }
 
+function runJacocoAndroidTestReport() {
+  const androidDir = path.resolve(__dirname, '../android');
+  const result = spawnSync('./gradlew', ['jacocoAndroidTestReport'], {
+    cwd: androidDir,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  if (result.status !== 0) {
+    console.warn(
+      `[native-coverage] jacocoAndroidTestReport exited with status ${result.status ?? 'unknown'}`,
+    );
+    return false;
+  }
+
+  return true;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--android-pull')) {
+    const deviceId = resolveAndroidDeviceId();
+    console.log(`[native-coverage] Pulling Android coverage from ${deviceId}`);
+    await pullAndroidCoverageWithRetry(deviceId, { softFail: true });
+    return;
+  }
+
+  if (args.includes('--android-post-e2e')) {
+    const deviceId = resolveAndroidDeviceId();
+    console.log(`[native-coverage] Post-e2e Android coverage on ${deviceId}`);
+    const pulled = await pullAndroidCoverageWithRetry(deviceId, { softFail: true });
+    runJacocoAndroidTestReport();
+    if (!pulled) {
+      console.warn('[native-coverage] Jacoco report may be empty (no coverage.ec pulled)');
+    }
+    return;
+  }
+
+  console.error(
+    'Usage: node tests/scripts/pull-native-coverage.js --android-pull|--android-post-e2e',
+  );
+  process.exit(1);
+}
+
+if (require.main === module) {
+  main().catch(error => {
+    console.warn(`[native-coverage] ${error.message}`);
+    process.exit(0);
+  });
+}
+
 module.exports = {
   pullAndroidCoverage,
+  pullAndroidCoverageWithRetry,
   pullIosCoverage,
+  resolveAndroidDeviceId,
+  runJacocoAndroidTestReport,
 };