gowalk-cicd 1.0.0

package/action/scripts/test_next_build_number.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+Tests for next_build_number.py.
+
+All ASC HTTP is stubbed via unittest.mock; no network calls. Focus:
+  * ``/builds`` alone returns the correct max + 1.
+  * ``/preReleaseVersions`` surfaces fresh uploads missing from ``/builds``.
+  * Union takes the max across both sources.
+  * Non-integer / malformed version strings are ignored, not fatal.
+  * ASC failure falls back to the local pbxproj CURRENT_PROJECT_VERSION.
+  * Both sources empty + no pbxproj -> exit non-zero with a clear error.
+"""
+
+from __future__ import annotations
+
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import next_build_number as nb  # noqa: E402
+
+
+def _build(version: str, state: str = "VALID", uploaded: str = "") -> dict:
+    return {
+        "type": "builds",
+        "attributes": {
+            "version": version,
+            "processingState": state,
+            "uploadedDate": uploaded,
+        },
+    }
+
+
+class BuildVersionIntTests(unittest.TestCase):
+    def test_parses_integer_version_string(self):
+        self.assertEqual(nb._build_version_int(_build("12")), 12)
+
+    def test_returns_none_for_non_integer(self):
+        self.assertIsNone(nb._build_version_int(_build("1.0.3")))
+
+    def test_returns_none_for_missing_attributes(self):
+        self.assertIsNone(nb._build_version_int({}))
+
+
+class FetchBuildsTests(unittest.TestCase):
+    def test_returns_versions_from_builds_endpoint(self):
+        payload = {"data": [_build("3"), _build("7"), _build("1")]}
+        with mock.patch.object(nb, "get_json", return_value=payload) as mget:
+            got = nb.fetch_build_versions("111", "tok")
+        self.assertEqual(got, {1, 3, 7})
+        # Confirm the call used filter[app] and no state filter.
+        _args, kwargs = mget.call_args
+        self.assertEqual(kwargs["params"]["filter[app]"], "111")
+        self.assertNotIn("filter[processingState]", kwargs["params"])
+
+    def test_empty_data_returns_empty_set(self):
+        with mock.patch.object(nb, "get_json", return_value={"data": []}):
+            self.assertEqual(nb.fetch_build_versions("111", "tok"), set())
+
+
+class FetchPreReleaseVersionsTests(unittest.TestCase):
+    def test_harvests_included_builds(self):
+        payload = {
+            "data": [{"type": "preReleaseVersions", "id": "P1"}],
+            "included": [
+                _build("5", "PROCESSING", "2026-04-18T10:00:00Z"),
+                {"type": "apps", "id": "X"},  # non-build resource ignored
+                _build("9"),
+            ],
+        }
+        with mock.patch.object(nb, "get_json", return_value=payload):
+            got = nb.fetch_prerelease_versions("111", "tok")
+        self.assertEqual(got, {5, 9})
+
+    def test_missing_included_is_handled(self):
+        with mock.patch.object(nb, "get_json", return_value={"data": []}):
+            got = nb.fetch_prerelease_versions("111", "tok")
+        self.assertEqual(got, set())
+
+
+class ResolveNextBuildNumberTests(unittest.TestCase):
+    def test_max_across_both_sources_plus_one(self):
+        with mock.patch.object(nb, "fetch_build_versions", return_value={1, 2}), \
+             mock.patch.object(nb, "fetch_prerelease_versions", return_value={5}):
+            self.assertEqual(nb.resolve_next_build_number("111", "tok"), 6)
+
+    def test_prerelease_fills_gap_when_builds_empty(self):
+        # Simulates the exact bug: /builds misses the fresh upload but
+        # /preReleaseVersions still sees it.
+        with mock.patch.object(nb, "fetch_build_versions", return_value=set()), \
+             mock.patch.object(nb, "fetch_prerelease_versions", return_value={1}):
+            self.assertEqual(nb.resolve_next_build_number("111", "tok"), 2)
+
+    def test_both_empty_returns_one(self):
+        with mock.patch.object(nb, "fetch_build_versions", return_value=set()), \
+             mock.patch.object(nb, "fetch_prerelease_versions", return_value=set()):
+            self.assertEqual(nb.resolve_next_build_number("111", "tok"), 1)
+
+    def test_ignores_non_integer_versions(self):
+        # fetch_* functions already filter; resolve just unions and maxes.
+        with mock.patch.object(nb, "fetch_build_versions", return_value={3}), \
+             mock.patch.object(nb, "fetch_prerelease_versions", return_value={3}):
+            self.assertEqual(nb.resolve_next_build_number("111", "tok"), 4)
+
+
+class MainFallbackTests(unittest.TestCase):
+    def _run_main(self) -> str:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            nb.main()
+        return buf.getvalue().strip()
+
+    def test_asc_success_prints_next(self):
+        env = {
+            "APP_STORE_APPLE_ID": "111",
+            "ASC_KEY_ID": "K",
+            "ASC_ISSUER_ID": "I",
+            "ASC_KEY_PATH": "/tmp/x",
+        }
+        with mock.patch.dict(nb.os.environ, env, clear=False), \
+             mock.patch.object(nb, "make_jwt", return_value="tok"), \
+             mock.patch.object(nb, "resolve_next_build_number", return_value=42):
+            self.assertEqual(self._run_main(), "42")
+
+    def test_asc_failure_falls_back_to_pbxproj(self):
+        env = {
+            "APP_STORE_APPLE_ID": "111",
+            "ASC_KEY_ID": "K",
+            "ASC_ISSUER_ID": "I",
+            "ASC_KEY_PATH": "/tmp/x",
+        }
+        with mock.patch.dict(nb.os.environ, env, clear=False), \
+             mock.patch.object(nb, "make_jwt", return_value="tok"), \
+             mock.patch.object(
+                 nb, "resolve_next_build_number",
+                 side_effect=RuntimeError("ASC 503"),
+             ), \
+             mock.patch.object(nb, "_read_pbxproj_build_number", return_value=7):
+            self.assertEqual(self._run_main(), "8")
+
+    def test_asc_failure_and_no_pbxproj_exits_nonzero(self):
+        env = {
+            "APP_STORE_APPLE_ID": "111",
+            "ASC_KEY_ID": "K",
+            "ASC_ISSUER_ID": "I",
+            "ASC_KEY_PATH": "/tmp/x",
+        }
+        with mock.patch.dict(nb.os.environ, env, clear=False), \
+             mock.patch.object(nb, "make_jwt", return_value="tok"), \
+             mock.patch.object(
+                 nb, "resolve_next_build_number",
+                 side_effect=RuntimeError("ASC 503"),
+             ), \
+             mock.patch.object(nb, "_read_pbxproj_build_number", return_value=None):
+            with self.assertRaises(SystemExit):
+                nb.main()
+
+    def test_missing_apple_id_raises_actionable_error(self):
+        env_missing = {k: "" for k in [
+            "APP_STORE_APPLE_ID", "ASC_KEY_ID", "ASC_ISSUER_ID", "ASC_KEY_PATH",
+        ]}
+        with mock.patch.dict(nb.os.environ, env_missing, clear=False):
+            with self.assertRaises(SystemExit) as ctx:
+                nb.main()
+        self.assertIn("APP_STORE_APPLE_ID", str(ctx.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_read_config_auto_detect.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+Integration tests for read_config (post-YAML-removal). Verify that:
+- resolve_xcode runs auto_detect when input is empty.
+- resolve_xcode honors INPUT_* overrides.
+- resolve_app calls auto_detect_bundle_id when input is empty.
+- Source labels for log output are auditable.
+"""
+
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import auto_detect  # noqa: E402
+import read_config  # noqa: E402
+
+
+def _empty_inputs() -> dict:
+    return {
+        "PROJECT": "",
+        "WORKSPACE": "",
+        "SCHEME": "",
+        "CONFIGURATION": "",
+        "PROFILE_NAME": "",
+        "BUNDLE_ID": "",
+        "TEAM_ID": "",
+        "APP_STORE_APPLE_ID": "",
+        "USES_NON_EXEMPT": "",
+        "WHATS_NEW": "",
+        "LOCALE": "",
+        "RUN_TESTS": "",
+        "TEST_COMMAND": "",
+        "TEST_DESTINATION": "",
+    }
+
+
+class ResolveXcodeAutoDetectTests(unittest.TestCase):
+    def setUp(self):
+        auto_detect._clear_caches()
+
+    def test_auto_detect_used_when_inputs_empty(self):
+        workspace = Path("/fake/workspace")
+        with mock.patch.object(
+            auto_detect,
+            "auto_detect_project",
+            return_value=("MyApp.xcodeproj", ""),
+        ) as m_proj, mock.patch.object(
+            auto_detect, "auto_detect_scheme", return_value="MyApp",
+        ) as m_scheme:
+            xc = read_config.resolve_xcode(workspace, _empty_inputs())
+
+        m_proj.assert_called_once_with(workspace)
+        m_scheme.assert_called_once()
+        self.assertEqual(xc["project"], ("MyApp.xcodeproj", "auto-detect"))
+        self.assertEqual(xc["workspace"], ("", "empty"))
+        self.assertEqual(xc["scheme"], ("MyApp", "auto-detect"))
+        self.assertEqual(xc["configuration"], ("Release", "default"))
+        self.assertEqual(xc["profile_name"], ("MyApp CI", "default"))
+
+    def test_input_value_wins_over_auto_detect(self):
+        workspace = Path("/fake/workspace")
+        inputs = _empty_inputs()
+        inputs["PROJECT"] = "OverrideProject.xcodeproj"
+        inputs["SCHEME"] = "OverrideScheme"
+        with mock.patch.object(
+            auto_detect, "auto_detect_project",
+            return_value=("Auto.xcodeproj", ""),
+        ) as m_proj, mock.patch.object(
+            auto_detect, "auto_detect_scheme", return_value="AutoScheme",
+        ) as m_scheme:
+            xc = read_config.resolve_xcode(workspace, inputs)
+        m_proj.assert_not_called()
+        m_scheme.assert_not_called()
+        self.assertEqual(xc["project"], ("OverrideProject.xcodeproj", "input"))
+        self.assertEqual(xc["scheme"], ("OverrideScheme", "input"))
+
+    def test_workspace_input_wins(self):
+        workspace = Path("/fake/workspace")
+        inputs = _empty_inputs()
+        inputs["WORKSPACE"] = "MyApp.xcworkspace"
+        with mock.patch.object(
+            auto_detect, "auto_detect_scheme", return_value="MyApp",
+        ):
+            xc = read_config.resolve_xcode(workspace, inputs)
+        self.assertEqual(xc["workspace"], ("MyApp.xcworkspace", "input"))
+        self.assertEqual(xc["project"], ("", "empty"))
+
+    def test_workspace_auto_detect_preferred_over_xcodeproj(self):
+        workspace = Path("/fake/workspace")
+        with mock.patch.object(
+            auto_detect, "auto_detect_project",
+            return_value=("", "MyApp.xcworkspace"),
+        ), mock.patch.object(
+            auto_detect, "auto_detect_scheme", return_value="MyApp",
+        ):
+            xc = read_config.resolve_xcode(workspace, _empty_inputs())
+        self.assertEqual(xc["workspace"], ("MyApp.xcworkspace", "auto-detect"))
+        self.assertEqual(xc["project"], ("", "empty"))
+
+    def test_scheme_empty_when_auto_detect_fails(self):
+        workspace = Path("/fake/workspace")
+        with mock.patch.object(
+            auto_detect, "auto_detect_project",
+            return_value=("MyApp.xcodeproj", ""),
+        ), mock.patch.object(
+            auto_detect, "auto_detect_scheme", return_value=None,
+        ):
+            xc = read_config.resolve_xcode(workspace, _empty_inputs())
+        self.assertEqual(xc["scheme"], ("", "empty"))
+
+    def test_configuration_input_wins_over_default(self):
+        workspace = Path("/fake/workspace")
+        inputs = _empty_inputs()
+        inputs["CONFIGURATION"] = "Debug"
+        with mock.patch.object(
+            auto_detect, "auto_detect_project", return_value=("X.xcodeproj", ""),
+        ), mock.patch.object(
+            auto_detect, "auto_detect_scheme", return_value="X",
+        ):
+            xc = read_config.resolve_xcode(workspace, inputs)
+        self.assertEqual(xc["configuration"], ("Debug", "input"))
+
+
+class ResolveAppAutoDetectTests(unittest.TestCase):
+    def setUp(self):
+        auto_detect._clear_caches()
+
+    def _xc(self, **over) -> dict:
+        base = {
+            "project": "MyApp.xcodeproj",
+            "workspace": "",
+            "scheme": "MyApp",
+            "configuration": "Release",
+        }
+        base.update(over)
+        return base
+
+    def test_auto_detects_bundle_when_input_empty(self):
+        creds = {"key_id": "K", "issuer_id": "I", "key_path": "/tmp/k.p8"}
+        scripts_dir = Path(__file__).resolve().parent
+        workspace = Path("/fake/workspace")
+        with mock.patch.object(
+            auto_detect,
+            "auto_detect_bundle_id",
+            return_value="com.example.myapp",
+        ) as m_bundle, mock.patch.object(
+            read_config,
+            "derive_team_if_empty",
+            return_value=("TEAM123456", "derived_from_asc_key"),
+        ), mock.patch.object(
+            read_config, "lookup_app_id_via_api", return_value="1234567890",
+        ):
+            app = read_config.resolve_app(
+                _empty_inputs(), creds, scripts_dir,
+                workspace=workspace, xcode=self._xc(),
+            )
+        m_bundle.assert_called_once()
+        self.assertEqual(app["bundle_id"], ("com.example.myapp", "auto-detect"))
+        self.assertEqual(app["team_id"], ("TEAM123456", "derived_from_asc_key"))
+        self.assertEqual(app["app_store_apple_id"], ("1234567890", "api-lookup"))
+
+    def test_input_bundle_wins_over_auto_detect(self):
+        creds = {"key_id": "K", "issuer_id": "I", "key_path": "/tmp/k.p8"}
+        scripts_dir = Path(__file__).resolve().parent
+        workspace = Path("/fake/workspace")
+        inputs = _empty_inputs()
+        inputs["BUNDLE_ID"] = "com.input.bundle"
+        with mock.patch.object(
+            auto_detect, "auto_detect_bundle_id", return_value="com.auto.different",
+        ) as m_bundle, mock.patch.object(
+            read_config, "derive_team_if_empty",
+            return_value=("T", "derived_from_asc_key"),
+        ), mock.patch.object(
+            read_config, "lookup_app_id_via_api", return_value="1",
+        ):
+            app = read_config.resolve_app(
+                inputs, creds, scripts_dir,
+                workspace=workspace, xcode=self._xc(),
+            )
+        m_bundle.assert_not_called()
+        self.assertEqual(app["bundle_id"], ("com.input.bundle", "input"))
+
+    def test_input_team_id_wins_over_derive(self):
+        creds = {"key_id": "K", "issuer_id": "I", "key_path": "/tmp/k.p8"}
+        scripts_dir = Path(__file__).resolve().parent
+        workspace = Path("/fake/workspace")
+        inputs = _empty_inputs()
+        inputs["TEAM_ID"] = "INPUTTEAM1"
+        inputs["BUNDLE_ID"] = "com.x.y"
+        with mock.patch.object(
+            read_config, "derive_team_if_empty",
+        ) as m_derive, mock.patch.object(
+            read_config, "lookup_app_id_via_api", return_value="1",
+        ):
+            app = read_config.resolve_app(
+                inputs, creds, scripts_dir,
+                workspace=workspace, xcode=self._xc(),
+            )
+        m_derive.assert_not_called()
+        self.assertEqual(app["team_id"], ("INPUTTEAM1", "input"))
+
+    def test_input_apple_id_skips_api_lookup(self):
+        creds = {"key_id": "K", "issuer_id": "I", "key_path": "/tmp/k.p8"}
+        scripts_dir = Path(__file__).resolve().parent
+        workspace = Path("/fake/workspace")
+        inputs = _empty_inputs()
+        inputs["APP_STORE_APPLE_ID"] = "9999999"
+        inputs["BUNDLE_ID"] = "com.x.y"
+        with mock.patch.object(
+            read_config, "derive_team_if_empty",
+            return_value=("T", "derived_from_asc_key"),
+        ), mock.patch.object(
+            read_config, "lookup_app_id_via_api",
+        ) as m_lookup:
+            app = read_config.resolve_app(
+                inputs, creds, scripts_dir,
+                workspace=workspace, xcode=self._xc(),
+            )
+        m_lookup.assert_not_called()
+        self.assertEqual(app["app_store_apple_id"], ("9999999", "input"))
+
+
+class DefaultsTests(unittest.TestCase):
+    """Defaults emitted when nothing comes from inputs."""
+
+    def test_resolve_testflight_returns_default_whats_new_and_locale(self):
+        tf = read_config.resolve_testflight(_empty_inputs())
+        self.assertEqual(tf["whats_new"][1], "default")
+        self.assertIn("Improved performance", tf["whats_new"][0])
+        self.assertEqual(tf["locale"], ("en-US", "default"))
+
+    def test_resolve_testflight_input_wins(self):
+        inputs = _empty_inputs()
+        inputs["WHATS_NEW"] = "release notes here"
+        inputs["LOCALE"] = "fr-FR"
+        tf = read_config.resolve_testflight(inputs)
+        self.assertEqual(tf["whats_new"], ("release notes here", "input"))
+        self.assertEqual(tf["locale"], ("fr-FR", "input"))
+
+    def test_resolve_tests_defaults_to_false(self):
+        tests = read_config.resolve_tests(_empty_inputs())
+        self.assertEqual(tests["run_tests"], ("false", "default"))
+        self.assertEqual(tests["test_command"], ("", "empty"))
+        self.assertEqual(tests["test_destination"], ("", "empty"))
+
+    def test_resolve_ios_defaults_to_false(self):
+        ios = read_config.resolve_ios(_empty_inputs())
+        self.assertEqual(ios["uses_non_exempt"], ("false", "default"))
+
+
+if __name__ == "__main__":
+    unittest.main()