gowalk-cicd 1.0.0

package/action/scripts/test_fetch_versions.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Tests for ``mmv.fetch_versions`` (a thin re-export of
+``asc_version_fetch.fetch_versions``).
+
+Covers pagination, the explicit ``filter[platform]=IOS`` query param,
+the ``limit=200`` (ASC max) request shape, and the per-record stderr
+logging used by the CI debug trace. These were factored out of
+``test_mmv_floor_check.py`` to keep that module under the 400-line
+cap while preserving every assertion.
+"""
+
+from __future__ import annotations
+
+import io
+import sys
+import unittest
+from contextlib import redirect_stderr
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import manage_marketing_version as mmv  # noqa: E402
+import asc_version_fetch  # noqa: E402
+
+from tests_common import _FakeResponse  # noqa: E402
+
+
+def _asv_record(
+    vid: str, version: str, state: str, created: str,
+) -> dict:
+    """Build a /v1/apps/{id}/appStoreVersions data entry."""
+    return {
+        "id": vid,
+        "attributes": {
+            "versionString": version,
+            "appStoreState": state,
+            "platform": "IOS",
+            "createdDate": created,
+        },
+    }
+
+
+class FetchVersionsPaginationTests(unittest.TestCase):
+    """fetch_versions MUST follow links.next to exhaustion."""
+
+    def test_fetch_is_paginated(self):
+        page1 = {
+            "data": [
+                _asv_record("id-1.0", "1.0", "READY_FOR_SALE",
+                            "2025-01-01T00:00:00Z"),
+                _asv_record("id-1.0.1", "1.0.1", "PREPARE_FOR_SUBMISSION",
+                            "2025-02-01T00:00:00Z"),
+            ],
+            "links": {
+                "next": "https://api.appstoreconnect.apple.com/v1/apps/111/"
+                        "appStoreVersions?cursor=PAGE2",
+            },
+        }
+        page2 = {
+            "data": [
+                _asv_record("id-1.0.4", "1.0.4", "READY_FOR_SALE",
+                            "2025-04-01T00:00:00Z"),
+            ],
+            "links": {},
+        }
+        responses = [_FakeResponse(page1), _FakeResponse(page2)]
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            return responses.pop(0)
+
+        with mock.patch.object(asc_version_fetch, "request", side_effect=fake_request):
+            got = mmv.fetch_versions("111", "tok")
+
+        versions = {v["versionString"] for v in got}
+        self.assertIn("1.0.4", versions)
+        self.assertIn("1.0", versions)
+        self.assertIn("1.0.1", versions)
+        self.assertEqual(len(responses), 0, "both pages must be consumed")
+
+
+class FetchVersionsPlatformFilterTests(unittest.TestCase):
+    """fetch_versions MUST pass filter[platform]=IOS."""
+
+    def test_platform_filter_applied(self):
+        seen_params: list[dict | None] = []
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            seen_params.append(params)
+            return _FakeResponse({"data": [], "links": {}})
+
+        with mock.patch.object(asc_version_fetch, "request", side_effect=fake_request):
+            mmv.fetch_versions("111", "tok")
+
+        self.assertTrue(seen_params)
+        first = seen_params[0] or {}
+        self.assertEqual(first.get("filter[platform]"), "IOS")
+
+
+class FetchVersionsLimitTests(unittest.TestCase):
+    """fetch_versions MUST request limit=200 (ASC max)."""
+
+    def test_limit_200_requested(self):
+        seen_params: list[dict | None] = []
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            seen_params.append(params)
+            return _FakeResponse({"data": [], "links": {}})
+
+        with mock.patch.object(asc_version_fetch, "request", side_effect=fake_request):
+            mmv.fetch_versions("111", "tok")
+
+        first = seen_params[0] or {}
+        self.assertEqual(first.get("limit"), 200)
+
+
+class FetchVersionsLoggingTests(unittest.TestCase):
+    """Every fetched record MUST be logged to stderr."""
+
+    def test_every_record_logged(self):
+        page1 = {
+            "data": [
+                {
+                    "id": "id-1.0.4",
+                    "attributes": {
+                        "versionString": "1.0.4",
+                        "appStoreState": "READY_FOR_SALE",
+                        "platform": "IOS",
+                        "createdDate": "2025-04-01T00:00:00Z",
+                    },
+                },
+                {
+                    "id": "id-1.0.1",
+                    "attributes": {
+                        "versionString": "1.0.1",
+                        "appStoreState": "PREPARE_FOR_SUBMISSION",
+                        "platform": "IOS",
+                        "createdDate": "2025-02-01T00:00:00Z",
+                    },
+                },
+            ],
+            "links": {},
+        }
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            return _FakeResponse(page1)
+
+        buf = io.StringIO()
+        with mock.patch.object(asc_version_fetch, "request", side_effect=fake_request), \
+                redirect_stderr(buf):
+            mmv.fetch_versions("111", "tok")
+
+        stderr = buf.getvalue()
+        self.assertIn("1.0.4", stderr)
+        self.assertIn("READY_FOR_SALE", stderr)
+        self.assertIn("id-1.0.4", stderr)
+        self.assertIn("1.0.1", stderr)
+        self.assertIn("PREPARE_FOR_SUBMISSION", stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_ground_truth_floor.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+Tests for the independent narrow per-state ASC ground-truth floor query.
+
+Extracted from ``test_mmv_floor_check.py`` (round 11) so each test
+file stays under the 10-functions-per-file cap. Counting nested
+``fake_request`` closures, the parent file was at 13 defs; pulling
+``GroundTruthFloorTests`` out drops both files below the cap.
+
+Covers ``mmv.get_ground_truth_floor`` -- the defence-in-depth narrow
+query the floor check uses to validate the main fetch's combined
+floor. Each test pins the per-state filter behaviour so a buggy main
+fetch can't silently mask a higher ship-blocking row.
+"""
+
+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 asc_version_fetch  # noqa: E402
+import manage_marketing_version as mmv  # noqa: E402
+
+from tests_common import _FakeResponse  # noqa: E402
+
+
+class GroundTruthFloorTests(unittest.TestCase):
+    """Independent narrow per-state query is the self-correcting floor."""
+
+    def test_ground_truth_floor_finds_ready_for_sale(self):
+        def fake_request(method, path, token, *, params=None, **_kw):
+            state_filter = (params or {}).get("filter[appStoreState]", "")
+            if "READY_FOR_SALE" in state_filter:
+                return _FakeResponse({
+                    "data": [{
+                        "id": "id-1.0.4",
+                        "attributes": {
+                            "versionString": "1.0.4",
+                            "appStoreState": "READY_FOR_SALE",
+                            "platform": "IOS",
+                            "createdDate": "2025-04-01T00:00:00Z",
+                        },
+                    }],
+                    "links": {},
+                })
+            return _FakeResponse({"data": [], "links": {}})
+
+        with mock.patch.object(asc_version_fetch, "request", side_effect=fake_request):
+            floor = mmv.get_ground_truth_floor("111", "tok")
+
+        self.assertEqual(floor, "1.0.4")
+
+    def test_ground_truth_floor_considers_all_ship_blocking_states(self):
+        def fake_request(method, path, token, *, params=None, **_kw):
+            state_filter = (params or {}).get("filter[appStoreState]", "")
+            if "PENDING_APPLE_RELEASE" in state_filter:
+                return _FakeResponse({
+                    "data": [{
+                        "id": "id-1.0.6",
+                        "attributes": {
+                            "versionString": "1.0.6",
+                            "appStoreState": "PENDING_APPLE_RELEASE",
+                            "platform": "IOS",
+                            "createdDate": "2025-06-01T00:00:00Z",
+                        },
+                    }],
+                    "links": {},
+                })
+            if "READY_FOR_SALE" in state_filter:
+                return _FakeResponse({
+                    "data": [{
+                        "id": "id-1.0.4",
+                        "attributes": {
+                            "versionString": "1.0.4",
+                            "appStoreState": "READY_FOR_SALE",
+                            "platform": "IOS",
+                            "createdDate": "2025-04-01T00:00:00Z",
+                        },
+                    }],
+                    "links": {},
+                })
+            return _FakeResponse({"data": [], "links": {}})
+
+        with mock.patch.object(asc_version_fetch, "request", side_effect=fake_request):
+            floor = mmv.get_ground_truth_floor("111", "tok")
+
+        self.assertEqual(floor, "1.0.6")
+
+    def test_ground_truth_floor_returns_none_when_no_ship_blocking(self):
+        def fake_request(method, path, token, *, params=None, **_kw):
+            return _FakeResponse({"data": [], "links": {}})
+
+        with mock.patch.object(asc_version_fetch, "request", side_effect=fake_request):
+            floor = mmv.get_ground_truth_floor("111", "tok")
+
+        self.assertIsNone(floor)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_manage_marketing_version.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Tests for ``manage_marketing_version``'s validation + main() entrypoint.
+
+After round-8 split, this file holds only the input-validation and
+``main()`` end-to-end scenarios plus the round-12 fail-closed
+unknown-ASC-state rejection. Sibling test files cover the rest:
+
+  * ``test_manage_marketing_version_match.py`` -- row-matching at the
+    target versionString (REUSE / terminal-collision reject /
+    in-review reject / DEVELOPER_REJECTED reuse).
+  * ``test_manage_marketing_version_floor.py`` -- floor-vs-target
+    compare scenarios.
+  * ``test_manage_marketing_version_autoroll.py`` -- round-7 auto-roll
+    lock-in (terminal collisions auto-roll; in-review rejects).
+
+The original snowballing-bump bug guarded against: when the project
+sat at MARKETING_VERSION=1.0.0 across CI runs, the old code computed
+``next = combined_floor + patch`` -- the marketing version drifted
+upward in TestFlight (1.0.0 -> 1.0.7 -> ...) without ever round-tripping
+back to the repo. Each new run started from 1.0.0 and got bumped again,
+server-side only.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import sys
+import unittest
+from contextlib import redirect_stderr
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import manage_marketing_version as mmv  # noqa: E402
+
+from tests_common import (  # noqa: E402
+    _Env,
+    _assert_decide_exits,
+    _assert_mentions_build_setting_source,
+    _v,
+)
+
+
+class ValidationAndMainTests(unittest.TestCase):
+    """Semver validation, end-to-end main(), and missing-env scenarios."""
+
+    def test_target_invalid_semver_exits_1(self):
+        """Scenario 7: target 'foo' (invalid semver) -> SystemExit(1)."""
+        stderr = _assert_decide_exits(
+            self, "foo", [], ground_truth=None, expected_code=1,
+        )
+        self.assertIn("MARKETING_VERSION", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_main_end_to_end_with_marketing_version_env(self):
+        """Scenario 8: xcodegen-style end-to-end via main()."""
+        out_buf = io.StringIO()
+        err_buf = io.StringIO()
+        env_overrides = {
+            "ASC_KEY_ID": "kid",
+            "ASC_ISSUER_ID": "iid",
+            "ASC_KEY_PATH": "/tmp/ignored.p8",
+            "APP_STORE_APPLE_ID": "111",
+            "MARKETING_VERSION": "1.0.0",
+        }
+        empty_breakdown = {"appStoreVersions": None,
+                           "preReleaseVersions": None,
+                           "buildsViaPreRelease": None}
+        with mock.patch.dict(os.environ, env_overrides, clear=False), \
+                mock.patch.object(mmv, "make_jwt", return_value="tok"), \
+                mock.patch.object(mmv, "fetch_versions", return_value=[]), \
+                mock.patch.object(mmv, "get_ground_truth_floor", return_value=None), \
+                mock.patch.object(
+                    mmv, "get_combined_floor",
+                    return_value=(None, empty_breakdown)), \
+                mock.patch.object(mmv, "create_or_reuse_with_stale",
+                                  return_value="created-100"), \
+                mock.patch("sys.stdout", out_buf), \
+                redirect_stderr(err_buf):
+            mmv.main()
+        decision = json.loads(out_buf.getvalue().strip())
+        self.assertEqual(decision["versionString"], "1.0.0")
+        self.assertEqual(decision["decision"], "CREATE")
+        self.assertEqual(decision["appStoreVersionId"], "created-100")
+
+    def test_missing_marketing_version_env_exits_1(self):
+        """Scenario 9: MARKETING_VERSION missing -> SystemExit(1)."""
+        buf = io.StringIO()
+        env_overrides = {
+            "ASC_KEY_ID": "kid",
+            "ASC_ISSUER_ID": "iid",
+            "ASC_KEY_PATH": "/tmp/ignored.p8",
+            "APP_STORE_APPLE_ID": "111",
+        }
+        with mock.patch.dict(os.environ, env_overrides, clear=False), \
+                _Env("MARKETING_VERSION", None), \
+                mock.patch.object(mmv, "make_jwt", return_value="tok"), \
+                mock.patch.object(mmv, "fetch_versions", return_value=[]), \
+                redirect_stderr(buf):
+            with self.assertRaises(SystemExit) as ctx:
+                mmv.main()
+        self.assertEqual(ctx.exception.code, 1)
+        stderr = buf.getvalue()
+        self.assertIn("MARKETING_VERSION", stderr)
+
+    def test_target_matches_unknown_state_exits_2_fail_closed(self):
+        """Round 12: row exists at target with an ASC state in NONE of
+        our allowlists (TERMINAL / IN_REVIEW / BLOCKING / REUSABLE) ->
+        SystemExit(2) rather than silently CREATEing into a 409.
+
+        The earlier classifier returned ``"none"`` for unknown states,
+        so the script proceeded to CREATE -- which 409s against the
+        existing row on every CI run. Failing closed surfaces the
+        unrecognized state to the human so they can update the
+        classifier or bump MARKETING_VERSION manually."""
+        unknown = _v("1.0.0", "TOTALLY_NEW_APPLE_STATE", vid="ed-unk-100")
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [unknown],
+            ground_truth="1.0.0", combined_floor="1.0.0",
+        )
+        self.assertIn("1.0.0", stderr)
+        self.assertIn("TOTALLY_NEW_APPLE_STATE", stderr)
+        self.assertIn("unrecognized state", stderr)
+        self.assertIn("ed-unk-100", stderr)
+        self.assertIn("Update mmv classifier", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_manage_marketing_version_autoroll.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+Tests for the auto-roll-vs-in-review policy in
+``manage_marketing_version.decide_for_version``.
+
+Round-7 codex finding lock-in: auto-roll fires for TERMINAL collisions
+(READY_FOR_SALE etc.) but NOT for in-review collisions
+(WAITING_FOR_REVIEW / IN_REVIEW). In-review must always reject so the
+developer can resolve the ambiguity manually -- Apple is actively
+reviewing the row, and advancing past it would race the review
+process.
+
+Extracted from ``test_manage_marketing_version.py`` so each test file
+stays under the 10-functions-per-file cap (round 8).
+"""
+
+from __future__ import annotations
+
+import io
+import os
+import sys
+import unittest
+from contextlib import redirect_stderr
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import manage_marketing_version as mmv  # noqa: E402
+
+from tests_common import _v  # noqa: E402
+
+
+class AutoRollTerminalVsInReviewTests(unittest.TestCase):
+    """auto-roll fires only for terminal collisions; in-review rejects."""
+
+    def _run(self, asc_state, policy):
+        """Drive ``decide_for_version`` with a single floor row at 1.0.5
+        in ``asc_state`` and the given auto-bump ``policy``. Returns
+        ``(result_or_none, exit_code_or_none, stderr)``."""
+        floor = "1.0.5"
+        per_source = {
+            "appStoreVersions": floor,
+            "preReleaseVersions": None,
+            "buildsViaPreRelease": None,
+        }
+        with mock.patch.object(
+                mmv, "create_or_reuse_with_stale", return_value="rolled-id"), \
+                mock.patch.object(
+                    mmv, "get_combined_floor",
+                    return_value=(floor, per_source)), \
+                mock.patch.object(
+                    mmv, "get_ground_truth_floor", return_value=floor), \
+                mock.patch(
+                    "version_utils.write_marketing_version",
+                    return_value=True), \
+                mock.patch.dict(
+                    os.environ,
+                    {
+                        "MARKETING_VERSION_AUTO_BUMP": policy,
+                        # Round-9 persistence-context gate: auto-bump
+                        # only fires on push to the default branch.
+                        # Pin those envs here so the auto-roll tests
+                        # exercise the actual auto-bump code path
+                        # (rather than the persistence-context refusal).
+                        "GITHUB_EVENT_NAME": "push",
+                        "GITHUB_REF": "refs/heads/main",
+                        "GITHUB_DEFAULT_BRANCH": "main",
+                    },
+                    clear=False):
+            versions = [_v(floor, asc_state)]
+            buf = io.StringIO()
+            with redirect_stderr(buf):
+                try:
+                    result = mmv.decide_for_version(
+                        floor, versions, app_id="111", token="tok",
+                    )
+                    return result, None, buf.getvalue()
+                except SystemExit as exc:
+                    return None, exc.code, buf.getvalue()
+
+    def test_ready_for_sale_with_autobump_creates_next_patch(self):
+        result, exit_code, _ = self._run("READY_FOR_SALE", "patch")
+        self.assertIsNone(exit_code, "auto-roll must succeed for terminal")
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(result["versionString"], "1.0.6")
+
+    def test_pending_apple_release_with_autobump_creates_next_patch(self):
+        result, exit_code, _ = self._run("PENDING_APPLE_RELEASE", "patch")
+        self.assertIsNone(exit_code)
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(result["versionString"], "1.0.6")
+
+    def test_processing_for_app_store_with_autobump_creates_next_patch(self):
+        result, exit_code, _ = self._run("PROCESSING_FOR_APP_STORE", "patch")
+        self.assertIsNone(exit_code)
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(result["versionString"], "1.0.6")
+
+    def test_waiting_for_review_with_autobump_rejects_loudly(self):
+        """Round-7: in-review must NEVER auto-roll regardless of policy."""
+        result, exit_code, stderr = self._run("WAITING_FOR_REVIEW", "patch")
+        self.assertIsNone(result)
+        self.assertEqual(exit_code, 2)
+        self.assertIn("currently in App Review", stderr)
+
+    def test_in_review_with_autobump_rejects_loudly(self):
+        result, exit_code, stderr = self._run("IN_REVIEW", "patch")
+        self.assertIsNone(result)
+        self.assertEqual(exit_code, 2)
+        self.assertIn("currently in App Review", stderr)
+
+    def test_pending_developer_release_with_autobump_rejects_loudly(self):
+        """Round-11: PENDING_DEVELOPER_RELEASE means Apple approved
+        the build and is waiting on the developer's manual release
+        click. Auto-rolling past it would bypass the developer's
+        release decision -- silently shipping the next patch while
+        the approved build sits unreleased. Must reject loudly so a
+        human resolves the ambiguity."""
+        result, exit_code, stderr = self._run(
+            "PENDING_DEVELOPER_RELEASE", "patch",
+        )
+        self.assertIsNone(result)
+        self.assertEqual(exit_code, 2)
+        self.assertIn("PENDING_DEVELOPER_RELEASE", stderr)
+        self.assertIn("manual release", stderr)
+
+    def test_terminal_with_policy_none_rejects(self):
+        result, exit_code, stderr = self._run("READY_FOR_SALE", "none")
+        self.assertIsNone(result)
+        self.assertEqual(exit_code, 2)
+        self.assertIn("READY_FOR_SALE", stderr)
+
+    def test_in_review_with_policy_none_rejects(self):
+        result, exit_code, stderr = self._run("WAITING_FOR_REVIEW", "none")
+        self.assertIsNone(result)
+        self.assertEqual(exit_code, 2)
+        self.assertIn("currently in App Review", stderr)
+
+    def test_editable_state_reuses_unchanged(self):
+        """Sanity: PREPARE_FOR_SUBMISSION at target REUSEs unchanged."""
+        result, exit_code, _ = self._run("PREPARE_FOR_SUBMISSION", "patch")
+        self.assertIsNone(exit_code)
+        self.assertEqual(result["decision"], "REUSE")
+        self.assertEqual(result["versionString"], "1.0.5")
+
+
+if __name__ == "__main__":
+    unittest.main()