gowalk-cicd 1.0.0

package/action/scripts/test_manage_marketing_version_floor.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Tests for ``decide_for_version`` floor-vs-target scenarios.
+
+Covers what happens when the project's MARKETING_VERSION sits below /
+above / equal to the ASC combined floor (max of appStoreVersions +
+preReleaseVersions + buildsViaPreRelease):
+
+  * floor strictly above target with editable at target -> SystemExit(2)
+    (must NOT silently downgrade)
+  * floor equals target with no row at target -> SystemExit(2)
+    (CREATE would collide)
+  * floor None (true first-release) -> CREATE proceeds
+  * target below floor where floor came from a higher editable ->
+    SystemExit(2)
+  * target strictly above the floor -> CREATE
+  * target equal to a terminal floor row -> SystemExit(2)
+    (the auto-roll variant of this lives in
+    test_manage_marketing_version_autoroll.py)
+  * target below a terminal row -> SystemExit(2)
+
+Match-at-target scenarios live in
+``test_manage_marketing_version_match.py``. main() / env-validation
+scenarios stay in ``test_manage_marketing_version.py``. Split out in
+round 8 to keep each test file under the 10-functions-per-file cap.
+"""
+
+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))
+
+from tests_common import (  # noqa: E402
+    _assert_decide_exits,
+    _assert_mentions_build_setting_source,
+    _run_decide_for_version,
+    _v,
+)
+
+
+def setUpModule() -> None:
+    """Pin auto-bump to 'none' for the whole floor-tests module.
+
+    The floor-vs-target tests assert the historical fail-on-floor /
+    historical reject behavior. With auto-bump enabled (the default
+    'patch'), the round-7 auto-roll would CREATE the next patch
+    instead of rejecting on terminal collisions, which is a
+    different code path covered by
+    ``test_manage_marketing_version_autoroll.py``.
+
+    Pinning the env via setUpModule (rather than per-test) keeps each
+    test pure -- they exercise floor reasoning, not policy gating."""
+    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 FloorVsTargetTests(unittest.TestCase):
+    """``decide_for_version`` floor-vs-target compare scenarios."""
+
+    def test_reuse_blocked_when_floor_strictly_above_target(self):
+        """Issue 3 regression: editable matches target but floor came
+        from a HIGHER source. REUSE must NOT silently downgrade."""
+        editable = _v("1.0.0", "PREPARE_FOR_SUBMISSION", vid="ed-100")
+        per_source = {
+            "appStoreVersions": "2.0.0",
+            "preReleaseVersions": "2.0.0",
+            "buildsViaPreRelease": None,
+        }
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [editable],
+            ground_truth="2.0.0", combined_floor="2.0.0",
+            per_source=per_source,
+        )
+        self.assertIn("1.0.0", stderr)
+        self.assertIn("2.0.0", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_create_blocked_when_floor_equals_target_no_match(self):
+        """No editable at target but floor equals target -- CREATE
+        blocked (would collide with whatever pinned the floor)."""
+        per_source = {
+            "appStoreVersions": None,
+            "preReleaseVersions": "1.0.0",
+            "buildsViaPreRelease": None,
+        }
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [],
+            ground_truth=None, combined_floor="1.0.0",
+            per_source=per_source,
+        )
+        self.assertIn("strictly greater than", stderr)
+        self.assertIn("1.0.0", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_create_proceeds_when_floor_none_and_target_present(self):
+        """First-release scenario: ASC empty, target 1.0.0 -> CREATE 1.0.0."""
+        result, stderr, calls = _run_decide_for_version(
+            "1.0.0", versions=[],
+            ground_truth=None, combined_floor=None,
+        )
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(result["versionString"], "1.0.0")
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0].args[1], "1.0.0")
+        self.assertIn("decision=CREATE", stderr)
+
+    def test_target_below_floor_with_editable_at_floor_exits_2(self):
+        """Scenario 3: target 1.0.0 + editable PFS at 1.0.6 with combined
+        floor 1.0.6 -> SystemExit(2) with build-setting source mention."""
+        editable = _v("1.0.6", "PREPARE_FOR_SUBMISSION", vid="ed-106")
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [editable], ground_truth="1.0.6",
+        )
+        self.assertIn("1.0.0", stderr)
+        self.assertIn("1.0.6", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_target_strictly_above_floor_creates(self):
+        """Scenario 4: target 1.0.5 + appStoreVersions [1.0.4 RFS] -> CREATE 1.0.5."""
+        versions = [_v("1.0.4", "READY_FOR_SALE", vid="rfs-104")]
+        result, stderr, calls = _run_decide_for_version(
+            "1.0.5", versions=versions, ground_truth="1.0.4",
+        )
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(result["versionString"], "1.0.5")
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0].args[1], "1.0.5")
+        self.assertIn("decision=CREATE", stderr)
+
+    def test_target_equal_to_terminal_exits_2(self):
+        """Scenario 5: target 1.0.4 + appStoreVersions [1.0.4 RFS] ->
+        SystemExit(2). When auto-bump policy='none' (the default in this
+        test fixture's _run_decide_for_version helper), no auto-roll
+        fires, so the historical reject path applies.
+
+        The auto-roll variant (same scenario but auto-bump=patch ->
+        CREATE 1.0.5) lives in
+        test_manage_marketing_version_autoroll.py."""
+        versions = [_v("1.0.4", "READY_FOR_SALE", vid="rfs-104")]
+        stderr = _assert_decide_exits(
+            self, "1.0.4", versions, ground_truth="1.0.4",
+        )
+        self.assertIn("1.0.4", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_target_below_terminal_exits_2(self):
+        """Scenario 6: target 1.0.3 + appStoreVersions [1.0.4 RFS] -> SystemExit(2)."""
+        versions = [_v("1.0.4", "READY_FOR_SALE", vid="rfs-104")]
+        stderr = _assert_decide_exits(
+            self, "1.0.3", versions, ground_truth="1.0.4",
+        )
+        self.assertIn("1.0.3", stderr)
+        self.assertIn("1.0.4", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_manage_marketing_version_match.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+Tests for ``decide_for_version`` row-matching scenarios.
+
+Covers what happens when the project's MARKETING_VERSION matches (or
+doesn't match) an existing ASC row:
+
+  * empty ASC -> CREATE
+  * editable PFS at target -> REUSE
+  * steady-state TestFlight (target == combined_floor with editable
+    match) -> REUSE
+  * terminal / in-review collision at target -> SystemExit(2)
+    (the auto-roll lock-in test for terminal-but-autobump-enabled lives
+    in test_manage_marketing_version_autoroll.py)
+  * DEVELOPER_REJECTED at target -> REUSE (developer pulled it from
+    review; safe to mutate)
+
+Floor-vs-target scenarios live in
+``test_manage_marketing_version_floor.py``. main() / env-validation
+scenarios stay in ``test_manage_marketing_version.py``. Split out in
+round 8 to keep each test file under the 10-functions-per-file cap.
+"""
+
+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))
+
+from tests_common import (  # noqa: E402
+    _assert_decide_exits,
+    _assert_mentions_build_setting_source,
+    _run_decide_for_version,
+    _v,
+)
+
+
+def setUpModule() -> None:
+    """Pin auto-bump to 'none' for the whole match-tests module.
+
+    The terminal-at-target / in-review-at-target tests assert the
+    historical SystemExit(2) reject behavior. With auto-bump enabled
+    (the default 'patch'), the round-7 auto-roll would CREATE the
+    next patch on TERMINAL collisions, which is a different code path
+    covered by ``test_manage_marketing_version_autoroll.py``."""
+    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 MatchAtTargetTests(unittest.TestCase):
+    """``decide_for_version`` row-matching at the target versionString."""
+
+    def test_target_1_0_0_empty_asc_creates(self):
+        """Scenario 1: target 1.0.0 + ASC empty -> CREATE."""
+        result, stderr, calls = _run_decide_for_version(
+            "1.0.0", versions=[], ground_truth=None,
+        )
+        self.assertEqual(result["decision"], "CREATE")
+        self.assertEqual(result["versionString"], "1.0.0")
+        self.assertEqual(result["appStoreVersionId"], "new-created-id")
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0].args[1], "1.0.0")
+        self.assertIn("decision=CREATE", stderr)
+
+    def test_target_matches_existing_editable_reuses(self):
+        """Scenario 2: target 1.0.0 + editable PFS at 1.0.0 -> REUSE id."""
+        editable = _v("1.0.0", "PREPARE_FOR_SUBMISSION", vid="ed-100")
+        result, stderr, calls = _run_decide_for_version(
+            "1.0.0", versions=[editable], ground_truth=None,
+        )
+        self.assertEqual(result["decision"], "REUSE")
+        self.assertEqual(result["versionString"], "1.0.0")
+        self.assertEqual(result["appStoreVersionId"], "ed-100")
+        self.assertEqual(calls, [])
+        self.assertIn("decision=REUSE", stderr)
+        self.assertIn("matches MARKETING_VERSION", stderr)
+
+    def test_reuse_when_target_equals_combined_floor_steady_state(self):
+        """Steady-state TestFlight iteration: project still sits at 1.0.0,
+        ASC has the editable PFS row at 1.0.0 AND the prior TestFlight
+        upload registered the same version under preReleaseVersions
+        (combined_floor=1.0.0). REUSE must succeed -- the cross-check is
+        not allowed to compare the target to itself."""
+        editable = _v("1.0.0", "PREPARE_FOR_SUBMISSION", vid="ed-100")
+        per_source = {
+            "appStoreVersions": "1.0.0",
+            "preReleaseVersions": "1.0.0",
+            "buildsViaPreRelease": "1.0.0",
+        }
+        result, stderr, calls = _run_decide_for_version(
+            "1.0.0", versions=[editable],
+            ground_truth="1.0.0", combined_floor="1.0.0",
+            per_source=per_source,
+        )
+        self.assertEqual(result["decision"], "REUSE")
+        self.assertEqual(result["appStoreVersionId"], "ed-100")
+        self.assertEqual(calls, [])
+        self.assertNotIn("must be strictly greater", stderr)
+        self.assertIn("decision=REUSE", stderr)
+
+    def test_target_matches_terminal_at_target_exits_2(self):
+        """Same versionString already shipped (READY_FOR_SALE) at exactly
+        target -> SystemExit(2)."""
+        terminal = _v("1.0.0", "READY_FOR_SALE", vid="rfs-100")
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [terminal],
+            ground_truth="1.0.0", combined_floor="1.0.0",
+        )
+        self.assertIn("1.0.0", stderr)
+        self.assertIn("READY_FOR_SALE", stderr)
+        self.assertIn("fresh marketing version", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_target_matches_editable_and_terminal_exits_2(self):
+        """Issue 8 regression guard: ASC normally enforces a single row
+        per versionString, but if both editable PFS and terminal RFS
+        co-exist at target, REUSE'ing the editable would silently
+        proceed past a row the user actually shipped."""
+        editable = _v("1.0.0", "PREPARE_FOR_SUBMISSION", vid="ed-100")
+        terminal = _v("1.0.0", "READY_FOR_SALE", vid="rfs-100")
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [editable, terminal],
+            ground_truth="1.0.0", combined_floor="1.0.0",
+        )
+        self.assertIn("1.0.0", stderr)
+        self.assertIn("READY_FOR_SALE", stderr)
+        self.assertIn("editable row at the same versionString", stderr)
+        self.assertIn("fresh marketing version", stderr)
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_target_matches_waiting_for_review_exits_2(self):
+        """Issue 13: REUSE must NOT attach a TestFlight build to a
+        version Apple is reviewing. WAITING_FOR_REVIEW is editable in
+        ASC's broad sense, but mutating it would interfere with App
+        Review. SystemExit(2) with "review" wording."""
+        in_review = _v("1.0.0", "WAITING_FOR_REVIEW", vid="ed-wfr-100")
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [in_review],
+            ground_truth="1.0.0", combined_floor="1.0.0",
+        )
+        self.assertIn("1.0.0", stderr)
+        self.assertIn("WAITING_FOR_REVIEW", stderr)
+        self.assertIn("ed-wfr-100", stderr)
+        self.assertIn("review", stderr.lower())
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_target_matches_in_review_exits_2(self):
+        """Issue 13: IN_REVIEW match is also blocked, same as
+        WAITING_FOR_REVIEW. Apple is actively reviewing the row."""
+        in_review = _v("1.0.0", "IN_REVIEW", vid="ed-ir-100")
+        stderr = _assert_decide_exits(
+            self, "1.0.0", [in_review],
+            ground_truth="1.0.0", combined_floor="1.0.0",
+        )
+        self.assertIn("1.0.0", stderr)
+        self.assertIn("IN_REVIEW", stderr)
+        self.assertIn("ed-ir-100", stderr)
+        self.assertIn("review", stderr.lower())
+        _assert_mentions_build_setting_source(self, stderr)
+
+    def test_target_matches_developer_rejected_reuses(self):
+        """Issue 13: DEVELOPER_REJECTED is in REUSABLE_STATES — the
+        developer explicitly took the row out of review, so REUSE is
+        the correct steady-state behaviour."""
+        rejected = _v("1.0.0", "DEVELOPER_REJECTED", vid="ed-dr-100")
+        result, stderr, calls = _run_decide_for_version(
+            "1.0.0", versions=[rejected], ground_truth=None,
+        )
+        self.assertEqual(result["decision"], "REUSE")
+        self.assertEqual(result["appStoreVersionId"], "ed-dr-100")
+        self.assertEqual(calls, [])
+        self.assertIn("decision=REUSE", stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_mmv_409_classifier.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+Tests for the POST /appStoreVersions 409-classifier path.
+
+The single-source-of-truth fix means CI must NEVER bump MARKETING_VERSION
+on its own; every 409 from POST that is not an actual race-recovered
+REUSE-by-fetch must surface the underlying ASC error and exit non-zero.
+This file pins:
+
+  - 409 RELATIONSHIP.INVALID / unknown-code / version-collision under the
+    no-bump default -> SystemExit(4) without bump.
+  - The pre-flight request body is logged before POST so failures point
+    at the offending payload immediately.
+  - Failure response bodies log untruncated (full ASC errors).
+  - 409 race-recovery via fetch_versions reconcile (REUSE-by-fetch).
+"""
+
+from __future__ import annotations
+
+import io
+import json
+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_build_history  # noqa: E402
+import asc_version_create  # noqa: E402
+
+from tests_common import _v  # noqa: E402
+
+
+def _patch_empty_fetches():
+    """Common patch set for create_or_reuse 409-classifier tests: empty
+    fetch_versions + empty preReleaseVersions/builds so the floor never
+    blocks before the 409 path runs."""
+    return (
+        mock.patch.object(mmv, "fetch_versions", return_value=[]),
+        mock.patch.object(
+            asc_build_history, "fetch_prerelease_versions", return_value=[],
+        ),
+        mock.patch.object(
+            asc_build_history, "fetch_builds_prerelease_versions",
+            return_value=[],
+        ),
+    )
+
+
+class Status409ClassifierTests(unittest.TestCase):
+    """Guards: 409 RELATIONSHIP.INVALID/etc. must fail fast (NOT bump)."""
+
+    def _conflict(self, code: str, pointer: str | None = None,
+                  detail: str = "conflict") -> mock.Mock:
+        err: dict = {"status": "409", "code": code, "detail": detail}
+        if pointer:
+            err["source"] = {"pointer": pointer}
+        resp = mock.Mock()
+        resp.status_code = 409
+        resp.headers = {"X-ASC-Request-Id": "abc-123"}
+        resp.text = json.dumps({"errors": [err]})
+        return resp
+
+    def test_create_version_payload_shape(self):
+        captured: dict = {}
+
+        def fake_request(method, path, token, **kwargs):
+            captured["method"] = method
+            captured["path"] = path
+            captured["json_body"] = kwargs.get("json_body")
+            out = mock.Mock()
+            out.status_code = 201
+            out.json.return_value = {"data": {"id": "ok"}}
+            return out
+
+        with mock.patch.object(asc_version_create, "request", side_effect=fake_request):
+            asc_version_create.create_version("6755308530", "1.0.6", "tok")
+
+        self.assertEqual(captured["method"], "POST")
+        self.assertEqual(captured["path"], "/appStoreVersions")
+        body = captured["json_body"]
+        data = body["data"]
+        self.assertEqual(data["type"], "appStoreVersions")
+        self.assertEqual(data["attributes"]["platform"], "IOS")
+        self.assertEqual(data["attributes"]["versionString"], "1.0.6")
+        app_rel = data["relationships"]["app"]["data"]
+        self.assertEqual(app_rel["type"], "apps")
+        self.assertEqual(app_rel["id"], "6755308530")
+        self.assertIsInstance(app_rel["id"], str)
+
+    def test_request_body_logged_before_post(self):
+        buf = io.StringIO()
+        logged_before_post: list[bool] = []
+
+        def fake_request(method, path, token, **kwargs):
+            logged_before_post.append(
+                "[create-version] request body" in buf.getvalue()
+            )
+            out = mock.Mock()
+            out.status_code = 201
+            out.json.return_value = {"data": {"id": "ok"}}
+            return out
+
+        with mock.patch.object(asc_version_create, "request", side_effect=fake_request), \
+                redirect_stderr(buf):
+            asc_version_create.create_version("111", "1.0.6", "tok")
+
+        self.assertTrue(logged_before_post and logged_before_post[0])
+        stderr = buf.getvalue()
+        self.assertIn("[create-version] request body", stderr)
+        self.assertIn("1.0.6", stderr)
+        self.assertIn("appStoreVersions", stderr)
+
+    def test_response_body_logged_on_failure_untruncated(self):
+        big_detail = "x" * 2500
+        resp = self._conflict(
+            "ENTITY_ERROR.RELATIONSHIP.INVALID",
+            pointer="/data/relationships/app",
+            detail=big_detail,
+        )
+        buf = io.StringIO()
+        fv, fpr, fbpr = _patch_empty_fetches()
+        with mock.patch.object(mmv, "create_version", return_value=resp), \
+                fv, fpr, fbpr, redirect_stderr(buf):
+            with self.assertRaises(SystemExit):
+                mmv.create_or_reuse("111", "1.0.6", "tok")
+
+        stderr = buf.getvalue()
+        self.assertIn(big_detail, stderr)
+        self.assertIn("/data/relationships/app", stderr)
+
+    def test_409_relationship_invalid_fails_fast(self):
+        """409 RELATIONSHIP.INVALID -> SystemExit(4); never reaches bump_fn."""
+        resp = self._conflict(
+            "ENTITY_ERROR.RELATIONSHIP.INVALID",
+            pointer="/data/relationships/app",
+        )
+        attempts: list[str] = []
+
+        def fake_create(app_id, version, token):
+            attempts.append(version)
+            return resp
+
+        buf = io.StringIO()
+        fv, fpr, fbpr = _patch_empty_fetches()
+        with mock.patch.object(mmv, "create_version", side_effect=fake_create), \
+                fv, fpr, fbpr, redirect_stderr(buf):
+            with self.assertRaises(SystemExit) as ctx:
+                mmv.create_or_reuse("111", "1.0.6", "tok")
+
+        self.assertEqual(attempts, ["1.0.6"])
+        self.assertEqual(ctx.exception.code, 4)
+        stderr = buf.getvalue()
+        self.assertIn("RELATIONSHIP.INVALID", stderr)
+        self.assertIn("/data/relationships/app", stderr)
+
+    def test_409_unknown_code_fails_fast_with_diagnostic(self):
+        resp = self._conflict(
+            "ENTITY_ERROR.SOMETHING_NEW",
+            pointer="/data/attributes/platform",
+            detail="unexpected thing",
+        )
+        attempts: list[str] = []
+
+        def fake_create(app_id, version, token):
+            attempts.append(version)
+            return resp
+
+        buf = io.StringIO()
+        fv, fpr, fbpr = _patch_empty_fetches()
+        with mock.patch.object(mmv, "create_version", side_effect=fake_create), \
+                fv, fpr, fbpr, redirect_stderr(buf):
+            with self.assertRaises(SystemExit):
+                mmv.create_or_reuse("111", "1.0.6", "tok")
+
+        self.assertEqual(attempts, ["1.0.6"])
+        stderr = buf.getvalue()
+        self.assertIn("ENTITY_ERROR.SOMETHING_NEW", stderr)
+
+    def test_409_version_collision_no_bump_exits_4(self):
+        """Even a real version-collision 409 must exit 4 now."""
+        collision_resp = self._conflict(
+            "CONFLICT.VERSION_EXISTS",
+            detail="A version with this versionString already exists.",
+        )
+        attempts: list[str] = []
+
+        def fake_create(app_id, version, token):
+            attempts.append(version)
+            return collision_resp
+
+        buf = io.StringIO()
+        fv, fpr, fbpr = _patch_empty_fetches()
+        with mock.patch.object(mmv, "create_version", side_effect=fake_create), \
+                fv, fpr, fbpr, redirect_stderr(buf):
+            with self.assertRaises(SystemExit) as ctx:
+                mmv.create_or_reuse("111", "1.0.6", "tok")
+
+        self.assertEqual(attempts, ["1.0.6"])
+        self.assertEqual(ctx.exception.code, 4)
+        stderr = buf.getvalue()
+        self.assertIn("hidden", stderr.lower())
+
+    def test_409_reuses_existing_version_by_versionString(self):
+        """If POST returns 409 and fetch_versions surfaces a matching id,
+        create_or_reuse returns that id (REUSE-by-fetch path)."""
+        fake_resp = mock.Mock()
+        fake_resp.status_code = 409
+        fake_resp.headers = {}
+        fake_resp.text = ""
+
+        with mock.patch.object(mmv, "create_version", return_value=fake_resp), \
+                mock.patch.object(
+                    mmv, "fetch_versions",
+                    return_value=[_v("1.2.3", "PREPARE_FOR_SUBMISSION", vid="race-id")],
+                ), \
+                mock.patch.object(
+                    asc_build_history, "fetch_prerelease_versions",
+                    return_value=[]), \
+                mock.patch.object(
+                    asc_build_history, "fetch_builds_prerelease_versions",
+                    return_value=[]):
+            got = mmv.create_or_reuse("111", "1.2.3", "tok")
+        self.assertEqual(got, "race-id")
+
+
+if __name__ == "__main__":
+    unittest.main()