ci(embedded): Patrol E2E with local mock auth and CI matrix

.github/scripts/combine_e2e_summary.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+function main() {
+  const args = process.argv.slice(2);
+  let artifactsDir = "";
+  let summaryFile = "";
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--artifacts-dir" && args[i + 1]) artifactsDir = args[++i];
+    if (args[i] === "--summary" && args[i + 1]) summaryFile = args[++i];
+  }
+
+  if (!artifactsDir) {
+    console.error("Usage: combine_e2e_summary.js --artifacts-dir <dir> --summary <file>");
+    process.exit(1);
+  }
+
+  const lines = ["# Flutter Embedded E2E Summary\n"];
+  let totalTests = 0;
+  let totalPassed = 0;
+  let totalFailed = 0;
+
+  if (fs.existsSync(artifactsDir)) {
+    const entries = fs.readdirSync(artifactsDir);
+    for (const entry of entries.sort()) {
+      const entryPath = path.join(artifactsDir, entry);
+      if (!fs.statSync(entryPath).isDirectory()) continue;
+
+      lines.push(`## ${entry}\n`);
+
+      const xmlFiles = (fs.readdirSync(entryPath) || []).filter((f) => f.endsWith(".xml"));
+      if (xmlFiles.length === 0) {
+        lines.push("No JUnit XML reports found.\n");
+        continue;
+      }
+
+      for (const xmlFile of xmlFiles) {
+        const content = fs.readFileSync(path.join(entryPath, xmlFile), "utf-8");
+        const testsMatch = content.match(/tests="(\d+)"/);
+        const failuresMatch = content.match(/failures="(\d+)"/);
+        const errorsMatch = content.match(/errors="(\d+)"/);
+
+        const tests = testsMatch ? parseInt(testsMatch[1], 10) : 0;
+        const failures = (failuresMatch ? parseInt(failuresMatch[1], 10) : 0) +
+                         (errorsMatch ? parseInt(errorsMatch[1], 10) : 0);
+        const passed = tests - failures;
+
+        totalTests += tests;
+        totalPassed += passed;
+        totalFailed += failures;
+
+        const emoji = failures > 0 ? "❌" : "✅";
+        lines.push(`${emoji} **${xmlFile}**: ${passed}/${tests} passed\n`);
+      }
+    }
+  }
+
+  lines.unshift("");
+  lines.unshift(`**Total**: ${totalPassed}/${totalTests} passed, ${totalFailed} failed`);
+  lines.unshift("");
+
+  const output = lines.join("\n");
+
+  if (summaryFile) {
+    fs.writeFileSync(summaryFile, output);
+    console.log(`Summary written to ${summaryFile}`);
+  } else {
+    console.log(output);
+  }
+}
+
+main();

.github/scripts/generate_e2e_matrix.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+// One scenario per shard: pairs of heavy tests (login + 240s token waits) still
+// exceeded 90m; isolating avoids a single stuck/hung test blocking a whole pair.
+const MAX_TESTS_PER_SHARD = 1;
+
+const ROOT = path.resolve(__dirname, "../..");
+const CONFIG = {
+  catalog: path.join(ROOT, "embedded/e2e/scenario-catalog.json"),
+  testSources: [
+    path.join(ROOT, "embedded/integration_test/e2e/embedded_e2e_test.dart"),
+  ],
+};
+
+function readCatalogMethods(catalogPath) {
+  const raw = JSON.parse(fs.readFileSync(catalogPath, "utf-8"));
+  const entries = raw.tests || raw.scenarios || [];
+  return entries
+    .map((entry) => entry.method)
+    .filter((method) => typeof method === "string" && method.length > 0);
+}
+
+function readDartTestMethods(testSources) {
+  const methods = new Set();
+  const re = /e2ePatrolTest\(\s*'(test[A-Za-z0-9_]+)'/gm;
+  for (const sourcePath of testSources) {
+    const source = fs.readFileSync(sourcePath, "utf-8");
+    for (const match of source.matchAll(re)) {
+      methods.add(match[1]);
+    }
+  }
+  return [...methods];
+}
+
+function parseExcludeList(raw) {
+  return new Set(
+    String(raw || "")
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean),
+  );
+}
+
+function validateCatalog(catalogMethods, sourceMethods) {
+  const catalogSet = new Set(catalogMethods);
+  const sourceSet = new Set(sourceMethods);
+  const catalogOnly = catalogMethods.filter((m) => !sourceSet.has(m));
+  const sourceOnly = sourceMethods.filter((m) => !catalogSet.has(m));
+  if (catalogOnly.length === 0 && sourceOnly.length === 0) return;
+  const problems = [];
+  if (catalogOnly.length) problems.push(`catalog-only: ${catalogOnly.join(", ")}`);
+  if (sourceOnly.length) problems.push(`uncatalogued: ${sourceOnly.join(", ")}`);
+  throw new Error(`embedded E2E catalog drift: ${problems.join("; ")}`);
+}
+
+/** When building a platform-specific shard list, excluded tests stay in the repo/catalog but are omitted from the matrix. */
+function validateShardMethods(shardMethods, sourceMethods) {
+  const sourceSet = new Set(sourceMethods);
+  const unknown = shardMethods.filter((m) => !sourceSet.has(m));
+  if (unknown.length) {
+    throw new Error(`shard methods not found in Dart sources: ${unknown.join(", ")}`);
+  }
+}
+
+function splitIntoShards(items, shardCount) {
+  const shards = Array.from({ length: shardCount }, () => []);
+  items.forEach((item, i) => shards[i % shardCount].push(item));
+  return shards;
+}
+
+function main() {
+  const parsed = parseInt(process.env.INPUT_SHARD_COUNT || "1", 10);
+  const shardCount = Number.isNaN(parsed) ? 1 : Math.max(1, parsed);
+
+  const catalogMethods = readCatalogMethods(CONFIG.catalog);
+  const exclude = parseExcludeList(process.env.INPUT_EXCLUDE_METHODS);
+  const methods = exclude.size
+    ? catalogMethods.filter((m) => !exclude.has(m))
+    : catalogMethods;
+  const sourceMethods = readDartTestMethods(CONFIG.testSources);
+  if (exclude.size) {
+    for (const m of exclude) {
+      if (!catalogMethods.includes(m)) {
+        throw new Error(`INPUT_EXCLUDE_METHODS: not in catalog: ${m}`);
+      }
+    }
+    validateShardMethods(methods, sourceMethods);
+  } else {
+    validateCatalog(catalogMethods, sourceMethods);
+  }
+
+  const autoShards = Math.ceil(methods.length / MAX_TESTS_PER_SHARD);
+  const effectiveShardCount =
+    shardCount > 1 ? Math.min(shardCount, methods.length || 1) : Math.max(1, autoShards);
+
+  const include = [];
+  if (effectiveShardCount <= 1 || methods.length === 0) {
+    include.push({
+      "shard-index": 1,
+      "shard-total": 1,
+      "test-methods": "",
+    });
+  } else {
+    const shards = splitIntoShards(methods, effectiveShardCount);
+    shards.forEach((shard, i) => {
+      include.push({
+        "shard-index": i + 1,
+        "shard-total": effectiveShardCount,
+        "test-methods": shard.join(","),
+      });
+    });
+  }
+
+  const matrix = JSON.stringify({ include });
+  const outputFile = process.env.GITHUB_OUTPUT;
+  if (outputFile) {
+    fs.appendFileSync(outputFile, `matrix=${matrix}\n`);
+  }
+  console.log(matrix);
+}
+
+main();

.github/scripts/run_embedded_e2e_shard.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+METHODS="${E2E_METHODS:-}"
+MAX_RETRIES="${PATROL_MAX_RETRIES:-1}"
+
+cd embedded
+TEST_FILE="integration_test/e2e/embedded_e2e_test.dart"
+
+flutter pub get
+
+run_patrol() {
+  local -a cmd=(patrol test)
+  if [[ -n "${IOS_DEVICE:-}" ]]; then
+    cmd+=(-d "$IOS_DEVICE")
+  fi
+  cmd+=(-t "$TEST_FILE")
+  cmd+=("$@")
+  cmd+=(--uninstall)
+  if [[ "${PATROL_VERBOSE:-}" == "1" ]]; then
+    cmd+=(--verbose)
+  fi
+  local capture
+  capture="$(mktemp)"
+  set +e
+  if [[ -n "${PATROL_LOG_FILE:-}" ]]; then
+    "${cmd[@]}" 2>&1 | tee -a "$PATROL_LOG_FILE" | tee "$capture"
+    local rc="${PIPESTATUS[0]}"
+  else
+    "${cmd[@]}" 2>&1 | tee "$capture"
+    local rc="${PIPESTATUS[0]}"
+  fi
+  set -e
+  # Patrol CLI 3.6.0 has a known bug in PatrolLogReader (`Bad state: No element`)
+  # that crashes the wrapper, returning a non-zero exit code.
+  #
+  # Case 1: crash AFTER every test passed — treat as pass.
+  # Case 2: crash BEFORE any test result was reported — flake, let the
+  #         outer retry loop try again instead of failing the shard.
+  # Case 3: crash WITH an observed FAILED result — genuine failure, propagate.
+  if [[ "$rc" -ne 0 ]] && grep -q "Bad state: No element" "$capture" \
+       && grep -q "PatrolLogReader.readEntries" "$capture"; then
+    local has_failed_result
+    has_failed_result=0
+    if grep -q "test result: FAILED" "$capture"; then has_failed_result=1; fi
+    if grep -q "❌ Failed: [1-9]" "$capture"; then has_failed_result=1; fi
+
+    if [[ "$has_failed_result" -eq 0 ]]; then
+      if grep -q "❌ Failed: 0" "$capture" && grep -q "✅ Successful:" "$capture"; then
+        echo "::warning::Patrol CLI crashed in PatrolLogReader after success — treating as pass"
+        rm -f "$capture"
+        return 0
+      fi
+      if grep -q "test result: PASSED" "$capture"; then
+        echo "::warning::Patrol CLI crashed in PatrolLogReader after success — treating as pass"
+        rm -f "$capture"
+        return 0
+      fi
+      # Crash BEFORE any test result was emitted — pure Patrol flake.
+      # Return a distinct exit code so the outer retry loop retries.
+      echo "::warning::Patrol CLI crashed in PatrolLogReader before any test result — treating as flake, will retry"
+      rm -f "$capture"
+      return 77
+    fi
+  fi
+  rm -f "$capture"
+  return "$rc"
+}
+
+# Best-effort recovery between retries (Android emulator / adb flakes, e.g. exit 224).
+recover_between_retries() {
+  if command -v adb >/dev/null 2>&1; then
+    adb kill-server || true
+    adb start-server || true
+    sleep 3
+  fi
+}
+
+run_with_retries() {
+  local -a patrol_args=("$@")
+  local attempt=1
+  local status=0
+  while [[ "$attempt" -le "$MAX_RETRIES" ]]; do
+    if [[ "$attempt" -gt 1 ]]; then
+      echo "::warning::Patrol attempt $((attempt - 1)) failed; retrying ($attempt/$MAX_RETRIES)..."
+      recover_between_retries
+    fi
+    set +e
+    run_patrol "${patrol_args[@]}"
+    status=$?
+    set -e
+    if [[ "$status" -eq 0 ]]; then
+      return 0
+    fi
+    attempt=$((attempt + 1))
+  done
+  # Normalize sentinel exit codes (77 = patrol flake, retries exhausted) to 1
+  # so the shell step fails with a clean non-zero rather than a surprising code.
+  if [[ "$status" -eq 77 ]]; then
+    return 1
+  fi
+  return "$status"
+}
+
+# One patrol invocation per shard: comma-separated E2E_TEST_FILTER matches multiple
+# e2ePatrolTest entries without paying for N× iOS xcodebuild + install cycles.
+if [[ -n "$METHODS" ]]; then
+  echo "::notice::Running E2E shard tests: $METHODS"
+  run_with_retries --dart-define="E2E_TEST_FILTER=$METHODS"
+  exit $?
+fi
+
+echo "::notice::Running full E2E suite"
+run_with_retries