gowalk-cicd 1.0.4 → 1.0.5

package/README.md

@@ -147,7 +147,7 @@ configuration for either:
 |---|---|---|
 | Detected by | `pubspec.yaml` at the repo root | `settings.gradle(.kts)` + `gradlew` at the root or under `android/` |
 | App module | `android/app` | the one module applying `com.android.application` (version-catalog aliases are resolved; a module named `app` wins a tie against a wear/automotive sibling) |
-| Tests (`run-tests`) | `flutter analyze` + `flutter test` | `<module>:testReleaseUnitTest` |
+| Tests (`run-tests`) | `flutter analyze` + `flutter test` | `gradlew test` (all variants, all modules) |
 | Build | `flutter build appbundle --release` | `<module>:bundleRelease` |
 | Toolchain installed | Flutter + JDK 17 | JDK 21 only |
 

package/action/.daemux-version

@@ -1 +1 @@
-1.0.4
+1.0.5

package/action/scripts/auto_detect.py

@@ -52,8 +52,15 @@ from cfg_io import log, notice
 APP_PRODUCT_TYPE = "com.apple.product-type.application"
 # Timeouts (seconds) — xcodebuild can hang on missing toolchains or
 # package resolution. CI should fail fast rather than spin forever.
-LIST_TIMEOUT = 60
-SETTINGS_TIMEOUT = 120
+#
+# The first xcodebuild invocation on a cold runner also resolves the Swift
+# Package Manager graph, and a project that depends on firebase-ios-sdk spends
+# minutes cloning before it prints a single scheme. That is legitimate work,
+# not a hang, so `-list` gets a budget that survives it and a one-shot
+# pre-resolution retry (see _list_schemes) rather than a tighter deadline.
+LIST_TIMEOUT = 180
+SETTINGS_TIMEOUT = 300
+RESOLVE_TIMEOUT = 900
 
 # Process-local caches keyed by (project, workspace_file) or
 # (project, workspace_file, scheme, configuration). Cleared between test
@@ -221,6 +228,39 @@ def _pick_by_basename(matches: list[Path], workspace: Path, label: str) -> Path:
     return matches[0]
 
 
+def _resolve_package_dependencies(
+    workspace: Path, project: str, workspace_file: str
+) -> bool:
+    """Resolve the SPM graph once so later xcodebuild calls are cheap.
+
+    Returns True when resolution finished (regardless of exit status — a
+    project with no packages still exits cleanly and a partial resolve may
+    be enough for ``-list``), False when it could not be run at all.
+    """
+    cmd = ["xcodebuild", "-resolvePackageDependencies"]
+    if workspace_file:
+        cmd += ["-workspace", workspace_file]
+    elif project:
+        cmd += ["-project", project]
+    else:
+        return False
+    log("auto-detect: pre-resolving Swift package dependencies")
+    try:
+        result = subprocess.run(
+            cmd, cwd=str(workspace), capture_output=True, text=True,
+            timeout=RESOLVE_TIMEOUT,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        log(f"auto-detect: xcodebuild -resolvePackageDependencies failed: {exc!r}")
+        return False
+    if result.returncode != 0:
+        log(
+            f"auto-detect: xcodebuild -resolvePackageDependencies returned "
+            f"{result.returncode}: {result.stderr.strip()[:500]}"
+        )
+    return True
+
+
 def _list_schemes(
     workspace: Path, project: str, workspace_file: str
 ) -> Optional[list[str]]:
@@ -243,7 +283,27 @@ def _list_schemes(
             cmd, cwd=str(workspace), capture_output=True, text=True,
             timeout=LIST_TIMEOUT,
         )
-    except (OSError, subprocess.TimeoutExpired) as exc:
+    except subprocess.TimeoutExpired as exc:
+        # Almost always SPM resolution rather than a hang: `-list` implicitly
+        # resolves the package graph, and a cold Firebase/GoogleSignIn clone
+        # outlasts any deadline short enough to still catch a real hang. Pay
+        # for the resolve once, explicitly, then retry. Swallowing this is what
+        # produced the downstream "MARKETING_VERSION for scheme=" failure --
+        # an empty scheme reads as "project has none", not "we never asked".
+        log(f"auto-detect: xcodebuild -list timed out: {exc!r}")
+        if not _resolve_package_dependencies(workspace, project, workspace_file):
+            _list_cache[key] = None
+            return None
+        try:
+            result = subprocess.run(
+                cmd, cwd=str(workspace), capture_output=True, text=True,
+                timeout=LIST_TIMEOUT,
+            )
+        except (OSError, subprocess.TimeoutExpired) as retry_exc:
+            log(f"auto-detect: xcodebuild -list failed after resolve: {retry_exc!r}")
+            _list_cache[key] = None
+            return None
+    except OSError as exc:
         log(f"auto-detect: xcodebuild -list failed: {exc!r}")
         _list_cache[key] = None
         return None

package/action/scripts/test_auto_detect.py

@@ -9,6 +9,7 @@ All tests run offline. xcodebuild invocations are stubbed through
 from __future__ import annotations
 
 import json
+import subprocess
 import sys
 import tempfile
 import unittest
@@ -318,6 +319,54 @@ class AutoDetectSchemeTests(unittest.TestCase):
             scheme = auto_detect.auto_detect_scheme(root, "Proj.xcodeproj", "")
         self.assertIsNone(scheme)
 
+    def test_resolves_packages_and_retries_when_list_times_out(self):
+        # `-list` implicitly resolves the SPM graph, so a cold runner cloning
+        # firebase-ios-sdk blows the deadline on the first call. Treating that
+        # as "no schemes" is what left SCHEME empty and failed the build much
+        # later, on an unrelated-looking MARKETING_VERSION error.
+        calls: list[str] = []
+
+        def fake_run(cmd, **kw):
+            if "-resolvePackageDependencies" in cmd:
+                calls.append("resolve")
+                result = mock.MagicMock()
+                result.returncode = 0
+                result.stdout = ""
+                return result
+            if "-list" in cmd:
+                calls.append("list")
+                if calls.count("list") == 1:
+                    raise subprocess.TimeoutExpired(cmd, auto_detect.LIST_TIMEOUT)
+                result = mock.MagicMock()
+                result.returncode = 0
+                result.stdout = self._list_output(["MyApp"])
+                return result
+            result = mock.MagicMock()
+            result.returncode = 0
+            result.stdout = self._show_settings(APP_TYPE)
+            return result
+
+        root = Path("/tmp/repo")
+        with mock.patch.object(auto_detect.subprocess, "run", side_effect=fake_run):
+            scheme = auto_detect.auto_detect_scheme(root, "Proj.xcodeproj", "")
+
+        self.assertEqual(scheme, "MyApp")
+        self.assertEqual(calls[:3], ["list", "resolve", "list"])
+
+    def test_gives_up_when_list_times_out_again_after_resolving(self):
+        def fake_run(cmd, **kw):
+            if "-resolvePackageDependencies" in cmd:
+                result = mock.MagicMock()
+                result.returncode = 0
+                result.stdout = ""
+                return result
+            raise subprocess.TimeoutExpired(cmd, auto_detect.LIST_TIMEOUT)
+
+        root = Path("/tmp/repo")
+        with mock.patch.object(auto_detect.subprocess, "run", side_effect=fake_run):
+            scheme = auto_detect.auto_detect_scheme(root, "Proj.xcodeproj", "")
+        self.assertIsNone(scheme)
+
 
 class AutoDetectBundleIdTests(unittest.TestCase):
     """auto_detect_bundle_id: extract PRODUCT_BUNDLE_IDENTIFIER from showBuildSettings."""

package/android-action/.daemux-version

@@ -1 +1 @@
-1.0.4
+1.0.5

package/android-action/action.yml

@@ -109,13 +109,19 @@ runs:
     # resolve_android.py has already rewritten versionCode/versionName in the
     # module build file, so these are plain Gradle invocations with no extra
     # properties for the project to have to opt into reading.
+    # `test` is the aggregate task ("Run unit tests for all variants") and is the
+    # only one guaranteed to exist: AGP only creates testXUnitTest tasks for the
+    # variants it enables, and AGP 9 disables the release unit test variant by
+    # default, so `:app:testReleaseUnitTest` is simply absent in many projects.
+    # Running it unqualified also mirrors `flutter test`, which covers the whole
+    # package rather than one module.
     - name: Test Android app
       if: ${{ steps.config.outputs.project_kind == 'gradle' && inputs.run-tests == 'true' }}
       shell: bash
       working-directory: ${{ steps.config.outputs.gradle_root || '.' }}
       run: |
         chmod +x ./gradlew
-        ./gradlew "${ANDROID_GRADLE_MODULE}:testReleaseUnitTest" --console=plain --stacktrace
+        ./gradlew test --console=plain --stacktrace
 
     - name: Build release Android App Bundle with Gradle
       if: ${{ steps.config.outputs.project_kind == 'gradle' }}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gowalk-cicd",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Zero-config GitHub Actions delivery for iOS TestFlight and Android Google Play.",
   "type": "module",
   "bin": {