gowalk-cicd 1.0.0

package/action/scripts/test_mmv_autobump_persist_gate.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+Tests for the persistence-context gate on auto-bump (round-9 lock-in).
+
+``mmv_floor_check.maybe_auto_bump`` only fires when the run can also
+commit the bumped value back to the default branch. The action's
+commit-back step is gated on ``event=push`` AND
+``ref=refs/heads/<default>``; auto-bumping in any other context
+(workflow_dispatch / pull_request / push to a feature branch) would
+upload an IPA at the bumped version while git stays at the old
+value, causing the next run to recompute against stale state.
+
+These tests pin the persistence-context envs explicitly to prove the
+gate's exact triggers / refusals. They are intentionally separate
+from ``test_manage_marketing_version_autoroll.py`` (which exercises
+the auto-roll DECISION matrix at terminal vs in-review) so each test
+file stays under the 10-functions-per-file cap.
+"""
+
+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 mmv_floor_check  # noqa: E402
+
+
+class PersistenceContextGateTests(unittest.TestCase):
+    """``maybe_auto_bump`` must refuse when the run cannot commit back."""
+
+    def _run(self, env_overrides: dict) -> tuple[object, str]:
+        """Drive ``maybe_auto_bump`` with the given env overrides; mocks
+        ``write_marketing_version`` so the only thing under test is the
+        policy + persistence-context gating. Returns (result, stderr)."""
+        env = {"MARKETING_VERSION_AUTO_BUMP": "patch"}
+        env.update(env_overrides)
+        buf = io.StringIO()
+        with mock.patch.dict(os.environ, env, clear=False), \
+                mock.patch(
+                    "version_utils.write_marketing_version",
+                    return_value=True), \
+                redirect_stderr(buf):
+            result = mmv_floor_check.maybe_auto_bump("1.0.5", "1.0.5")
+        return result, buf.getvalue()
+
+    def test_push_to_default_branch_fires_autobump(self):
+        result, _ = self._run({
+            "GITHUB_EVENT_NAME": "push",
+            "GITHUB_REF": "refs/heads/main",
+            "GITHUB_DEFAULT_BRANCH": "main",
+        })
+        self.assertEqual(result, "1.0.6")
+
+    def test_workflow_dispatch_refuses_autobump(self):
+        result, stderr = self._run({
+            "GITHUB_EVENT_NAME": "workflow_dispatch",
+            "GITHUB_REF": "refs/heads/main",
+            "GITHUB_DEFAULT_BRANCH": "main",
+        })
+        self.assertIsNone(result)
+        self.assertIn("cannot persist the bump", stderr)
+        self.assertIn("workflow_dispatch", stderr)
+
+    def test_push_to_feature_branch_refuses_autobump(self):
+        result, stderr = self._run({
+            "GITHUB_EVENT_NAME": "push",
+            "GITHUB_REF": "refs/heads/feature-x",
+            "GITHUB_DEFAULT_BRANCH": "main",
+        })
+        self.assertIsNone(result)
+        self.assertIn("cannot persist the bump", stderr)
+        self.assertIn("feature-x", stderr)
+
+    def test_pull_request_refuses_autobump(self):
+        result, stderr = self._run({
+            "GITHUB_EVENT_NAME": "pull_request",
+            "GITHUB_REF": "refs/pull/42/merge",
+            "GITHUB_DEFAULT_BRANCH": "main",
+        })
+        self.assertIsNone(result)
+        self.assertIn("cannot persist the bump", stderr)
+
+    def test_missing_default_branch_env_refuses_autobump(self):
+        """Defensive: empty default-branch env -> refuse."""
+        result, stderr = self._run({
+            "GITHUB_EVENT_NAME": "push",
+            "GITHUB_REF": "refs/heads/main",
+            "GITHUB_DEFAULT_BRANCH": "",
+        })
+        self.assertIsNone(result)
+        self.assertIn("cannot persist the bump", stderr)
+
+    def test_alternative_default_branch_master_works(self):
+        """Sanity: a repo whose default branch is `master` still bumps."""
+        result, _ = self._run({
+            "GITHUB_EVENT_NAME": "push",
+            "GITHUB_REF": "refs/heads/master",
+            "GITHUB_DEFAULT_BRANCH": "master",
+        })
+        self.assertEqual(result, "1.0.6")
+
+    def test_policy_none_short_circuits_before_persist_check(self):
+        """Order-of-checks lock-in: policy=none returns None silently
+        without surfacing the persistence-context warning."""
+        env = {
+            "MARKETING_VERSION_AUTO_BUMP": "none",
+            "GITHUB_EVENT_NAME": "workflow_dispatch",
+            "GITHUB_REF": "refs/heads/main",
+            "GITHUB_DEFAULT_BRANCH": "main",
+        }
+        buf = io.StringIO()
+        with mock.patch.dict(os.environ, env, clear=False), \
+                mock.patch(
+                    "version_utils.write_marketing_version",
+                    return_value=True), \
+                redirect_stderr(buf):
+            result = mmv_floor_check.maybe_auto_bump("1.0.5", "1.0.5")
+        self.assertIsNone(result)
+        # Persistence-context warning must NOT fire when policy=none.
+        self.assertNotIn("cannot persist the bump", buf.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_mmv_decide_create.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Tests for mmv_decide_create.py — the orchestrator decisions made via
+``_stale_editable_id`` and ``decide_create``.
+
+Covers:
+  - StaleEditableSelectionTests: ``_stale_editable_id`` decides the
+    kwarg passed into ``create_or_reuse_with_stale``; lower-version
+    editables get PATCH-renamed; equal/higher-version editables fail
+    fast (Issue 10) so a future draft cannot be silently downgraded.
+  - In-review rows (Issue 13) are skipped as PATCH-rename candidates;
+    the CREATE path falls through to a plain POST.
+
+The asc_version_create.reuse_stale_editable seam (PATCH /
+DELETE+POST fallback / exit-5 path / logging) lives in
+``test_reuse_stale_editable.py``. The 409 classifier path (POST
+returns 409, never bumps, fails fast) lives in
+``test_mmv_409_classifier.py``.
+"""
+
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from tests_common import (  # noqa: E402
+    _assert_decide_exits,
+    _run_decide_for_version,
+    _v,
+)
+
+
+class StaleEditableSelectionTests(unittest.TestCase):
+    """``_stale_editable_id`` decides the kwarg that ``decide_create``
+    passes into ``create_or_reuse_with_stale``. Lower-version editables
+    get PATCH-renamed to target; equal/higher-version editables fail
+    fast (Issue 10) so a future draft cannot be silently downgraded."""
+
+    def test_create_patch_renames_stale_editable_to_target(self):
+        """target=1.1.0 with editable PFS at 1.0.5 -> CREATE via PATCH-rename;
+        stale_editable_id kwarg must be the lower editable's id."""
+        editable = _v("1.0.5", "PREPARE_FOR_SUBMISSION", vid="ed-105")
+        result, stderr, calls = _run_decide_for_version(
+            "1.1.0", versions=[editable], ground_truth="1.0.5",
+        )
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(result["versionString"], "1.1.0")
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0].kwargs.get("stale_editable_id"), "ed-105")
+        self.assertIn("PATCH-rename of stale editable id=ed-105", stderr)
+
+    def test_create_no_stale_editable_no_patch(self):
+        """target=1.1.0 with no editable at all -> CREATE via plain POST;
+        stale_editable_id kwarg must be None."""
+        result, stderr, calls = _run_decide_for_version(
+            "1.1.0", versions=[], ground_truth=None,
+        )
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(len(calls), 1)
+        self.assertIsNone(calls[0].kwargs.get("stale_editable_id"))
+        self.assertNotIn("PATCH-rename", stderr)
+
+    def test_create_blocked_by_higher_editable_pfs(self):
+        """Issue 10: a future draft at 1.2.0 (PFS) must NOT be PATCH-renamed
+        downward to 1.1.0; SystemExit(2) with downgrade wording."""
+        higher = _v("1.2.0", "PREPARE_FOR_SUBMISSION", vid="ed-120")
+        stderr = _assert_decide_exits(
+            self, "1.1.0", [higher], ground_truth=None,
+        )
+        self.assertIn("1.2.0", stderr)
+        self.assertIn("ed-120", stderr)
+        self.assertIn("downgrade", stderr.lower())
+        self.assertIn("PREPARE_FOR_SUBMISSION", stderr)
+
+    def test_create_blocked_by_higher_editable_other_state(self):
+        """Issue 10 covers every editable state, not just PFS. A draft
+        in WAITING_FOR_REVIEW above target must also block CREATE."""
+        higher = _v("1.2.0", "WAITING_FOR_REVIEW", vid="ed-wfr-120")
+        stderr = _assert_decide_exits(
+            self, "1.1.0", [higher], ground_truth=None,
+        )
+        self.assertIn("1.2.0", stderr)
+        self.assertIn("ed-wfr-120", stderr)
+        self.assertIn("downgrade", stderr.lower())
+        self.assertIn("WAITING_FOR_REVIEW", stderr)
+
+    def test_create_blocked_by_equal_version_editable(self):
+        """When an editable already sits at exactly target, REUSE wins
+        via ``_find_match_at_target`` BEFORE decide_create is reached;
+        no CREATE-path downgrade-rename is attempted."""
+        match = _v("1.1.0", "PREPARE_FOR_SUBMISSION", vid="ed-110")
+        result, stderr, calls = _run_decide_for_version(
+            "1.1.0", versions=[match], ground_truth=None,
+        )
+        self.assertEqual(result["decision"], "REUSE")
+        self.assertEqual(result["appStoreVersionId"], "ed-110")
+        self.assertEqual(calls, [])
+        self.assertIn("decision=REUSE", stderr)
+
+    def test_lower_in_review_skipped_create_via_post(self):
+        """Issue 13: a WAITING_FOR_REVIEW row at version < target must
+        NOT be PATCH-renamed (Apple is reviewing it). CREATE falls
+        through to a plain POST with stale_editable_id=None."""
+        in_review = _v("1.0.5", "WAITING_FOR_REVIEW", vid="ed-wfr-105")
+        result, stderr, calls = _run_decide_for_version(
+            "1.1.0", versions=[in_review], ground_truth="1.0.5",
+        )
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(result["versionString"], "1.1.0")
+        self.assertEqual(len(calls), 1)
+        self.assertIsNone(calls[0].kwargs.get("stale_editable_id"))
+        self.assertNotIn("PATCH-rename", stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_mmv_floor_check.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Tests for mmv_floor_check.py.
+
+Covers:
+  - ``get_combined_floor`` per-source breakdown across appStoreVersions,
+    preReleaseVersions, and builds->preReleaseVersion.
+
+``get_ground_truth_floor`` tests live in ``test_ground_truth_floor.py``
+(round 11 split). The cross-check error-message tests live in
+``test_mmv_floor_crosscheck.py`` (round 8 split).
+``fetch_versions`` pagination / filter / limit / logging tests live in
+``test_fetch_versions.py``. The /builds and /preReleaseVersions
+fetcher tests live in ``test_asc_build_history.py`` and
+``test_asc_builds_prerelease.py`` respectively.
+"""
+
+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 manage_marketing_version as mmv  # noqa: E402
+import asc_build_history  # noqa: E402
+
+from tests_common import (  # noqa: E402
+    _FakeResponse,
+    _mk_prerelease_entry,
+    _v,
+)
+
+
+def _builds_payload_with_prerelease(
+    build_id: str, build_version: str, pr_id: str, pr_version: str,
+) -> dict:
+    """Combined-floor fixture: one /builds record paired with a
+    preReleaseVersion include. Used to verify the combined-floor wiring
+    consults the relationship rather than build.attributes.version."""
+    return {
+        "data": [{
+            "id": build_id,
+            "type": "builds",
+            "attributes": {"version": build_version},
+            "relationships": {
+                "preReleaseVersion": {
+                    "data": {"type": "preReleaseVersions", "id": pr_id},
+                },
+            },
+        }],
+        "included": [{
+            "id": pr_id,
+            "type": "preReleaseVersions",
+            "attributes": {"version": pr_version, "platform": "IOS"},
+        }],
+        "links": {},
+    }
+
+
+class CombinedFloorTests(unittest.TestCase):
+    """Combined floor spans appStoreVersions + preReleaseVersions +
+    builds->preReleaseVersion. /v1/apps/{id}/builds.attributes.version
+    (integer build number) is NOT consulted as a marketing version."""
+
+    def test_combined_floor_excludes_builds_attributes_version(self):
+        seen_paths: list[str] = []
+        seen_params: list[dict | None] = []
+        builds_payload = _builds_payload_with_prerelease(
+            "b-42", "42", "pr-10", "1.0",
+        )
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            seen_paths.append(path)
+            seen_params.append(params)
+            if "/builds" in path:
+                return _FakeResponse(builds_payload)
+            return _FakeResponse({"data": [], "links": {}})
+
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request):
+            floor, _ = mmv.get_combined_floor(
+                "111", "tok",
+                appstore_versions=[_v("1.0", "READY_FOR_SALE")],
+            )
+
+        self.assertTrue(seen_paths)
+        self.assertTrue(any("/builds" in p for p in seen_paths))
+        self.assertTrue(any("/preReleaseVersions" in p for p in seen_paths))
+        builds_params = [
+            p for p, path in zip(seen_params, seen_paths)
+            if "/builds" in path and p is not None
+        ]
+        self.assertTrue(builds_params)
+        self.assertEqual(builds_params[0].get("include"), "preReleaseVersion")
+        self.assertEqual(floor, "1.0")
+        self.assertFalse(
+            hasattr(asc_build_history, "fetch_build_versions"),
+            "asc_build_history.fetch_build_versions must stay removed",
+        )
+
+    def test_combined_floor_includes_prerelease(self):
+        with mock.patch.object(
+                asc_build_history, "fetch_prerelease_versions",
+                return_value=["1.0.4"]), \
+                mock.patch.object(
+                    asc_build_history, "fetch_builds_prerelease_versions",
+                    return_value=[]):
+            floor, _ = mmv.get_combined_floor(
+                "111", "tok",
+                appstore_versions=[_v("1.0", "READY_FOR_SALE")],
+            )
+        self.assertEqual(floor, "1.0.4")
+
+    def test_combined_floor_none_when_empty_everywhere(self):
+        with mock.patch.object(
+                asc_build_history, "fetch_prerelease_versions",
+                return_value=[]), \
+                mock.patch.object(
+                    asc_build_history, "fetch_builds_prerelease_versions",
+                    return_value=[]):
+            floor, _ = mmv.get_combined_floor(
+                "111", "tok", appstore_versions=[],
+            )
+        self.assertIsNone(floor)
+
+    def test_combined_floor_unknown_endpoint_shape_doesnt_crash(self):
+        def fake_request(method, path, token, *, params=None, **_kw):
+            return _FakeResponse({
+                "data": [
+                    {"id": "null-version", "attributes": {}},
+                    _mk_prerelease_entry("1.0.3", pid="good"),
+                ],
+                "links": {},
+            })
+
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request):
+            prereleases = asc_build_history.fetch_prerelease_versions(
+                "111", "tok"
+            )
+        self.assertEqual(prereleases, ["1.0.3"])
+
+
+# GroundTruthCrossCheckMessageTests +
+# GroundTruthCrossCheckProductionPerSourceTests were extracted to
+# test_mmv_floor_crosscheck.py (round 8).
+# ComputeNextVersionStrictnessTests was extracted to
+# test_compute_next_version.py (round 8).
+# GroundTruthFloorTests was extracted to test_ground_truth_floor.py
+# (round 11).
+# All three splits keep this file under the 10-functions-per-file cap.
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_mmv_floor_crosscheck.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+Tests for the ground-truth cross-check error message produced by
+``assert_target_meets_floor``.
+
+Covers the per-source breakdown surfaced in production (not
+synthesized): when the binding floor comes from preReleaseVersions or
+buildsViaPreRelease, the error message MUST attribute the floor to the
+real source rather than emitting ``<none>``.
+
+Extracted from ``test_mmv_floor_check.py`` in round 8 to keep each
+test file under the 10-functions-per-file cap. The
+``GroundTruthFloorTests`` and ``CombinedFloorTests`` classes still
+live in ``test_mmv_floor_check.py``.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+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_build_history  # noqa: E402
+
+from tests_common import (  # noqa: E402
+    _assert_decide_exits,
+    _assert_mentions_build_setting_source,
+    _v,
+)
+
+
+def setUpModule() -> None:
+    """Pin auto-bump to 'none' for the whole module.
+
+    The cross-check tests assert the historical fail-on-floor error
+    message text. With auto-bump enabled (the default 'patch'), the
+    floor-violation path would auto-bump instead of failing, which
+    is a different code path covered elsewhere."""
+    global _ENV_PATCH
+    _ENV_PATCH = mock.patch.dict(
+        os.environ, {"MARKETING_VERSION_AUTO_BUMP": "none"}, clear=False,
+    )
+    _ENV_PATCH.start()
+
+
+def tearDownModule() -> None:
+    _ENV_PATCH.stop()
+
+
+class GroundTruthCrossCheckMessageTests(unittest.TestCase):
+    """The cross-check error message MUST name each source separately
+    AND reference at least one build-setting source name."""
+
+    def test_error_message_lists_each_source_max(self):
+        per_source = {
+            "appStoreVersions": "1.0",
+            "preReleaseVersions": "1.0.4",
+            "buildsViaPreRelease": None,
+        }
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [_v("1.0", "READY_FOR_SALE")],
+            ground_truth="1.0.4", combined_floor="1.0.4",
+            per_source=per_source,
+        )
+        self.assertIn("appStoreVersions", stderr)
+        self.assertIn("preReleaseVersions", stderr)
+        self.assertIn("buildsViaPreRelease", stderr)
+        self.assertIn("1.0.4", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+
+class GroundTruthCrossCheckProductionPerSourceTests(unittest.TestCase):
+    """Production seam: when the binding floor comes from preReleaseVersions
+    or buildsViaPreRelease, the error message MUST surface the real
+    per-source value (not synthesized `<none>`)."""
+
+    def test_error_attributes_floor_to_prerelease_when_prerelease_pinned(self):
+        per_source = {
+            "appStoreVersions": "1.0",
+            "preReleaseVersions": "1.1.1",
+            "buildsViaPreRelease": None,
+        }
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [_v("1.0", "READY_FOR_SALE")],
+            ground_truth=None, combined_floor="1.1.1",
+            per_source=per_source,
+        )
+        self.assertIn("preReleaseVersions=1.1.1", stderr)
+        self.assertNotIn("preReleaseVersions=<none>", stderr)
+        self.assertIn("appStoreVersions=1.0", stderr)
+        self.assertIn("1.1.1", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_error_attributes_floor_to_buildsViaPreRelease_when_builds_pinned(self):
+        per_source = {
+            "appStoreVersions": "1.0",
+            "preReleaseVersions": None,
+            "buildsViaPreRelease": "1.2.0",
+        }
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [_v("1.0", "READY_FOR_SALE")],
+            ground_truth=None, combined_floor="1.2.0",
+            per_source=per_source,
+        )
+        self.assertIn("buildsViaPreRelease=1.2.0", stderr)
+        self.assertNotIn("buildsViaPreRelease=<none>", stderr)
+
+    def test_get_combined_floor_returns_tuple_in_production(self):
+        """The mmv.get_combined_floor wrapper now forwards (floor, per_source)
+        from asc_version_fetch verbatim -- no synthesis."""
+        with mock.patch.object(
+                asc_build_history, "fetch_prerelease_versions",
+                return_value=["1.1.1"]), \
+                mock.patch.object(
+                    asc_build_history, "fetch_builds_prerelease_versions",
+                    return_value=[]):
+            floor, per_source = mmv.get_combined_floor(
+                "111", "tok",
+                appstore_versions=[_v("1.0", "READY_FOR_SALE")],
+            )
+        self.assertEqual(floor, "1.1.1")
+        self.assertEqual(per_source.get("preReleaseVersions"), "1.1.1")
+        self.assertEqual(per_source.get("appStoreVersions"), "1.0")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_mmv_helpers.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""
+Tests for pure-helper functions in the manage_marketing_version family.
+
+Covers:
+  - ``semver_tuple`` parsing edge cases.
+  - ``bump_patch_for_message`` text used inside the build-setting error
+    message.
+
+Split out of ``test_manage_marketing_version.py`` (Issue 15: file
+function-count cap) so each file groups tests by behaviour boundary.
+``DecideForVersionTests`` remains in the original module since those
+tests are the orchestrator's primary surface.
+"""
+
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import manage_marketing_version as mmv  # noqa: E402
+
+from mmv_floor_check import bump_patch_for_message  # noqa: E402
+
+
+class SemverParsingTests(unittest.TestCase):
+    """Pure-function coverage: semver_tuple."""
+
+    def test_semver_tuple_parses_three_part(self):
+        self.assertEqual(mmv.semver_tuple("1.2.3"), (1, 2, 3))
+
+    def test_semver_tuple_parses_two_part_as_zero_patch(self):
+        self.assertEqual(mmv.semver_tuple("1.2"), (1, 2, 0))
+
+    def test_semver_tuple_nonmatch_returns_sentinel(self):
+        self.assertEqual(mmv.semver_tuple("beta"), (-1, -1, -1))
+        self.assertEqual(mmv.semver_tuple(""), (-1, -1, -1))
+
+
+class BumpPatchForMessageTests(unittest.TestCase):
+    """Helper used in the build-setting error message text."""
+
+    def test_bumps_three_part_patch(self):
+        self.assertEqual(bump_patch_for_message("1.0.6"), "1.0.7")
+
+    def test_treats_missing_patch_as_zero(self):
+        self.assertEqual(bump_patch_for_message("1.2"), "1.2.1")
+
+    def test_non_semver_returns_passthrough_hint(self):
+        self.assertIn("foo", bump_patch_for_message("foo"))
+
+
+if __name__ == "__main__":
+    unittest.main()