gowalk-cicd 1.0.0

package/action/scripts/test_resolve_marketing_version.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Tests for resolve_marketing_version.py."""
+
+from __future__ import annotations
+
+import io
+import os
+import plistlib
+import subprocess
+import sys
+import tempfile
+import unittest
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import resolve_marketing_version as rmv  # noqa: E402
+
+
+class _Env:
+    """Scoped env override that restores prior state on exit."""
+
+    def __init__(self, mapping: dict[str, str | None]) -> None:
+        self._mapping = mapping
+        self._prev: dict[str, str | None] = {}
+
+    def __enter__(self) -> "_Env":
+        for k, v in self._mapping.items():
+            self._prev[k] = os.environ.get(k)
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+        return self
+
+    def __exit__(self, *_exc) -> None:
+        for k, prev in self._prev.items():
+            if prev is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = prev
+
+
+def _fake_run(stdout: str = "", returncode: int = 0):
+    """Build a fake subprocess.run replacement returning stdout."""
+    def runner(cmd, check=False, capture_output=True, text=True, timeout=None):
+        return subprocess.CompletedProcess(
+            cmd, returncode=returncode, stdout=stdout, stderr="",
+        )
+    return runner
+
+
+class GrepSettingTests(unittest.TestCase):
+    def test_grep_marketing_version(self):
+        text = (
+            "    OTHER = foo\n"
+            "    MARKETING_VERSION = 1.2.3\n"
+            "    SOMETHING_ELSE = bar\n"
+        )
+        self.assertEqual(rmv._grep_setting(text, "MARKETING_VERSION"), "1.2.3")
+
+    def test_grep_returns_empty_on_miss(self):
+        text = "    OTHER = foo\n"
+        self.assertEqual(rmv._grep_setting(text, "MARKETING_VERSION"), "")
+
+    def test_grep_strips_surrounding_whitespace(self):
+        text = "    MARKETING_VERSION = 2.0   \n"
+        self.assertEqual(rmv._grep_setting(text, "MARKETING_VERSION"), "2.0")
+
+
+class ResolveTests(unittest.TestCase):
+    """End-to-end resolution paths via main() exercise."""
+
+    def test_marketing_version_from_build_settings(self):
+        stdout = "    MARKETING_VERSION = 1.1.2\n    INFOPLIST_FILE = Info.plist\n"
+        out_buf = io.StringIO()
+        err_buf = io.StringIO()
+        env = {"PROJECT": "App.xcodeproj", "WORKSPACE": "",
+               "SCHEME": "App", "CONFIGURATION": "Release"}
+        with _Env(env), \
+                mock.patch.object(rmv.subprocess, "run", side_effect=_fake_run(stdout)), \
+                redirect_stdout(out_buf), redirect_stderr(err_buf):
+            rmv.main()
+        self.assertEqual(out_buf.getvalue().strip(), "MARKETING_VERSION=1.1.2")
+        self.assertIn("Resolved MARKETING_VERSION=1.1.2", err_buf.getvalue())
+        self.assertIn("xcodebuild -showBuildSettings", err_buf.getvalue())
+
+    def test_falls_back_to_info_plist(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_dir = Path(tmp)
+            plist_path = tmp_dir / "Info.plist"
+            with open(plist_path, "wb") as fh:
+                plistlib.dump({"CFBundleShortVersionString": "1.0.7"}, fh)
+            stdout = f"    INFOPLIST_FILE = {plist_path.name}\n"
+            project = str(tmp_dir / "App.xcodeproj")
+            out_buf = io.StringIO()
+            err_buf = io.StringIO()
+            env = {"PROJECT": project, "WORKSPACE": "",
+                   "SCHEME": "App", "CONFIGURATION": "Release"}
+            with _Env(env), \
+                    mock.patch.object(
+                        rmv.subprocess, "run", side_effect=_fake_run(stdout)), \
+                    redirect_stdout(out_buf), redirect_stderr(err_buf):
+                rmv.main()
+            self.assertEqual(out_buf.getvalue().strip(),
+                             "MARKETING_VERSION=1.0.7")
+            self.assertIn("Info.plist CFBundleShortVersionString",
+                          err_buf.getvalue())
+
+    def test_empty_settings_exits_1_with_migration_hint(self):
+        out_buf = io.StringIO()
+        err_buf = io.StringIO()
+        env = {"PROJECT": "App.xcodeproj", "WORKSPACE": "",
+               "SCHEME": "App", "CONFIGURATION": "Release"}
+        with _Env(env), \
+                mock.patch.object(rmv.subprocess, "run", side_effect=_fake_run("")), \
+                redirect_stdout(out_buf), redirect_stderr(err_buf):
+            with self.assertRaises(SystemExit) as ctx:
+                rmv.main()
+        self.assertEqual(ctx.exception.code, 1)
+        self.assertEqual(out_buf.getvalue(), "")
+        stderr = err_buf.getvalue()
+        self.assertIn("::error::", stderr)
+        self.assertIn("MARKETING_VERSION", stderr)
+        self.assertIn("MIGRATION.md", stderr)
+
+    def test_invalid_semver_in_settings_exits_1(self):
+        stdout = "    MARKETING_VERSION = banana\n"
+        out_buf = io.StringIO()
+        err_buf = io.StringIO()
+        env = {"PROJECT": "App.xcodeproj", "WORKSPACE": "",
+               "SCHEME": "App", "CONFIGURATION": "Release"}
+        with _Env(env), \
+                mock.patch.object(rmv.subprocess, "run", side_effect=_fake_run(stdout)), \
+                redirect_stdout(out_buf), redirect_stderr(err_buf):
+            with self.assertRaises(SystemExit) as ctx:
+                rmv.main()
+        self.assertEqual(ctx.exception.code, 1)
+        self.assertIn("::error::", err_buf.getvalue())
+
+    def test_subprocess_error_falls_through_to_error(self):
+        def raiser(*_a, **_kw):
+            raise OSError("xcodebuild not found")
+        out_buf = io.StringIO()
+        err_buf = io.StringIO()
+        env = {"PROJECT": "App.xcodeproj", "WORKSPACE": "",
+               "SCHEME": "App", "CONFIGURATION": "Release"}
+        with _Env(env), \
+                mock.patch.object(rmv.subprocess, "run", side_effect=raiser), \
+                redirect_stdout(out_buf), redirect_stderr(err_buf):
+            with self.assertRaises(SystemExit) as ctx:
+                rmv.main()
+        self.assertEqual(ctx.exception.code, 1)
+        self.assertIn("::error::", err_buf.getvalue())
+
+    def test_project_takes_precedence_over_workspace(self):
+        # MARKETING_VERSION is an app-target setting; the bare -project
+        # avoids evaluating the whole CocoaPods workspace graph, which can
+        # time out -showBuildSettings on CI runners.
+        captured: dict = {}
+
+        def runner(cmd, **_kw):
+            captured["cmd"] = cmd
+            return subprocess.CompletedProcess(
+                cmd, returncode=0, stdout="    MARKETING_VERSION = 1.0\n", stderr="",
+            )
+
+        env = {"WORKSPACE": "App.xcworkspace", "PROJECT": "App.xcodeproj",
+               "SCHEME": "App", "CONFIGURATION": "Release"}
+        out_buf = io.StringIO()
+        err_buf = io.StringIO()
+        with _Env(env), \
+                mock.patch.object(rmv.subprocess, "run", side_effect=runner), \
+                redirect_stdout(out_buf), redirect_stderr(err_buf):
+            rmv.main()
+        self.assertIn("-project", captured["cmd"])
+        self.assertIn("App.xcodeproj", captured["cmd"])
+        self.assertNotIn("-workspace", captured["cmd"])
+        self.assertEqual(out_buf.getvalue().strip(),
+                         "MARKETING_VERSION=1.0")
+
+    def test_workspace_used_when_no_project(self):
+        captured: dict = {}
+
+        def runner(cmd, **_kw):
+            captured["cmd"] = cmd
+            return subprocess.CompletedProcess(
+                cmd, returncode=0, stdout="    MARKETING_VERSION = 1.0\n", stderr="",
+            )
+
+        env = {"WORKSPACE": "App.xcworkspace", "PROJECT": "",
+               "SCHEME": "App", "CONFIGURATION": "Release"}
+        out_buf = io.StringIO()
+        err_buf = io.StringIO()
+        with _Env(env), \
+                mock.patch.object(rmv.subprocess, "run", side_effect=runner), \
+                redirect_stdout(out_buf), redirect_stderr(err_buf):
+            rmv.main()
+        self.assertIn("-workspace", captured["cmd"])
+        self.assertNotIn("-project", captured["cmd"])
+
+
+class FlutterVarRefExpansionTests(unittest.TestCase):
+    """Flutter templates put $(FLUTTER_BUILD_NAME) in the plist; the real
+    value comes from Generated.xcconfig and shows up in build settings."""
+
+    def test_expands_flutter_build_name_from_settings(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plist_path = Path(tmp) / "Info.plist"
+            with open(plist_path, "wb") as fh:
+                plistlib.dump(
+                    {"CFBundleShortVersionString": "$(FLUTTER_BUILD_NAME)"}, fh)
+            stdout = (
+                f"    INFOPLIST_FILE = {plist_path.name}\n"
+                "    FLUTTER_BUILD_NAME = 1.2.0\n"
+            )
+            project = str(Path(tmp) / "Runner.xcodeproj")
+            out_buf = io.StringIO()
+            err_buf = io.StringIO()
+            env = {"PROJECT": project, "WORKSPACE": "",
+                   "SCHEME": "Runner", "CONFIGURATION": "Release"}
+            with _Env(env), \
+                    mock.patch.object(
+                        rmv.subprocess, "run", side_effect=_fake_run(stdout)), \
+                    redirect_stdout(out_buf), redirect_stderr(err_buf):
+                rmv.main()
+            self.assertEqual(out_buf.getvalue().strip(),
+                             "MARKETING_VERSION=1.2.0")
+            self.assertIn("expanded via build settings", err_buf.getvalue())
+
+    def test_unresolvable_reference_exits_1(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plist_path = Path(tmp) / "Info.plist"
+            with open(plist_path, "wb") as fh:
+                plistlib.dump(
+                    {"CFBundleShortVersionString": "$(NOT_DEFINED_ANYWHERE)"}, fh)
+            stdout = f"    INFOPLIST_FILE = {plist_path.name}\n"
+            project = str(Path(tmp) / "Runner.xcodeproj")
+            env = {"PROJECT": project, "WORKSPACE": "",
+                   "SCHEME": "Runner", "CONFIGURATION": "Release"}
+            out_buf = io.StringIO()
+            err_buf = io.StringIO()
+            with _Env(env), \
+                    mock.patch.object(
+                        rmv.subprocess, "run", side_effect=_fake_run(stdout)), \
+                    redirect_stdout(out_buf), redirect_stderr(err_buf):
+                with self.assertRaises(SystemExit) as ctx:
+                    rmv.main()
+            self.assertEqual(ctx.exception.code, 1)
+            self.assertIn("::error::", err_buf.getvalue())
+
+    def test_expands_braced_and_modifier_forms(self):
+        settings = "    FLUTTER_BUILD_NAME = 2.1.0\n"
+        self.assertEqual(
+            rmv._expand_setting_refs("${FLUTTER_BUILD_NAME}", settings),
+            "2.1.0")
+        self.assertEqual(
+            rmv._expand_setting_refs(
+                "$(FLUTTER_BUILD_NAME:default=1.0)", settings),
+            "2.1.0")
+
+
+class PlistEdgeCasesTests(unittest.TestCase):
+    def test_missing_short_version_string_returns_empty(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plist_path = Path(tmp) / "Info.plist"
+            with open(plist_path, "wb") as fh:
+                plistlib.dump({"CFBundleName": "App"}, fh)  # no version key
+            stdout = f"    INFOPLIST_FILE = {plist_path.name}\n"
+            project = str(Path(tmp) / "App.xcodeproj")
+            env = {"PROJECT": project, "WORKSPACE": "",
+                   "SCHEME": "App", "CONFIGURATION": "Release"}
+            with _Env(env), \
+                    mock.patch.object(
+                        rmv.subprocess, "run", side_effect=_fake_run(stdout)):
+                value, source = rmv._resolve()
+            self.assertEqual(value, "")
+            self.assertEqual(source, "")
+
+    def test_corrupt_plist_falls_through_safely(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plist_path = Path(tmp) / "Info.plist"
+            plist_path.write_bytes(b"not a plist")
+            stdout = f"    INFOPLIST_FILE = {plist_path.name}\n"
+            project = str(Path(tmp) / "App.xcodeproj")
+            env = {"PROJECT": project, "WORKSPACE": "",
+                   "SCHEME": "App", "CONFIGURATION": "Release"}
+            with _Env(env), \
+                    mock.patch.object(
+                        rmv.subprocess, "run", side_effect=_fake_run(stdout)):
+                value, _source = rmv._resolve()
+            self.assertEqual(value, "")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_reuse_stale_editable.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+Tests for ``asc_version_create.reuse_stale_editable`` — the
+PATCH-rename / DELETE-then-POST fallback / failure-mode helper.
+
+Split out of ``test_mmv_decide_create.py`` (Issue 15: file
+function-count cap) so that:
+  - ``test_reuse_stale_editable.py`` owns the asc_version_create
+    seam: PATCH succeeds, PATCH fails -> DELETE+POST, PATCH+DELETE
+    both fail -> exit 5, full-flow logging.
+  - ``test_mmv_decide_create.py`` owns the orchestrator
+    decisions made via ``_stale_editable_id`` and ``decide_create``.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import sys
+import unittest
+from contextlib import redirect_stderr
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import asc_version_create  # noqa: E402
+
+
+class _FakeResp:
+    def __init__(self, status_code: int, *, payload: dict | None = None,
+                 text: str = "", headers: dict | None = None) -> None:
+        self.status_code = status_code
+        self.text = text if text else (json.dumps(payload) if payload else "")
+        self.headers = headers or {}
+        self._payload = payload
+
+    def json(self) -> dict:
+        return self._payload or {}
+
+
+class ReuseStaleEditablePatchTests(unittest.TestCase):
+    """PATCH succeeds: stale editable is renamed to target."""
+
+    def test_stale_editable_patch_path_reuses_and_skips_post(self):
+        patch_calls: list[dict] = []
+        post_calls: list[str] = []
+        delete_calls: list[str] = []
+
+        def fake_patch(app_id, existing_id, target, token):
+            patch_calls.append({
+                "app_id": app_id, "existing_id": existing_id,
+                "target": target, "token": token,
+            })
+            return _FakeResp(200, payload={
+                "data": {
+                    "id": existing_id,
+                    "type": "appStoreVersions",
+                    "attributes": {"versionString": target},
+                },
+            })
+
+        def fake_post(app_id, version, token):
+            post_calls.append(version)
+            return _FakeResp(201, payload={"data": {"id": "should-not-happen"}})
+
+        def fake_delete(app_id, existing_id, token):
+            delete_calls.append(existing_id)
+            return _FakeResp(204)
+
+        buf = io.StringIO()
+        with redirect_stderr(buf):
+            got = asc_version_create.reuse_stale_editable(
+                app_id="111", existing_id="ed-101",
+                target_version="1.0.6", token="tok",
+                patch_fn=fake_patch, delete_fn=fake_delete,
+                post_fn=fake_post,
+            )
+
+        self.assertEqual(len(patch_calls), 1)
+        self.assertEqual(patch_calls[0]["existing_id"], "ed-101")
+        self.assertEqual(patch_calls[0]["target"], "1.0.6")
+        self.assertEqual(post_calls, [])
+        self.assertEqual(delete_calls, [])
+        self.assertEqual(got, "ed-101")
+
+
+class ReuseStaleEditablePatchFailsDeleteCreateTests(unittest.TestCase):
+    def test_stale_editable_patch_fails_falls_back_to_delete_create(self):
+        sequence: list[str] = []
+
+        def fake_patch(app_id, existing_id, target, token):
+            sequence.append("PATCH")
+            return _FakeResp(409, payload={
+                "errors": [{"code": "SOME.REJECTION", "detail": "nope"}],
+            })
+
+        def fake_delete(app_id, existing_id, token):
+            sequence.append(f"DELETE:{existing_id}")
+            return _FakeResp(204)
+
+        def fake_post(app_id, version, token):
+            sequence.append(f"POST:{version}")
+            return _FakeResp(201, payload={"data": {"id": "new-106"}})
+
+        buf = io.StringIO()
+        with redirect_stderr(buf):
+            got = asc_version_create.reuse_stale_editable(
+                app_id="111", existing_id="ed-101",
+                target_version="1.0.6", token="tok",
+                patch_fn=fake_patch, delete_fn=fake_delete,
+                post_fn=fake_post,
+            )
+
+        self.assertEqual(sequence, ["PATCH", "DELETE:ed-101", "POST:1.0.6"])
+        self.assertEqual(got, "new-106")
+
+
+class ReuseStaleEditableDeleteFailsTests(unittest.TestCase):
+    def test_stale_editable_delete_fails_exits_clean(self):
+        def fake_patch(app_id, existing_id, target, token):
+            return _FakeResp(409, payload={
+                "errors": [{"code": "SOME.REJECTION", "detail": "nope"}],
+            })
+
+        def fake_delete(app_id, existing_id, token):
+            return _FakeResp(409, payload={
+                "errors": [{"code": "ENTITY_ERROR.STATE_INVALID",
+                            "detail": "version locked by review"}],
+            })
+
+        def fake_post(app_id, version, token):
+            raise AssertionError("POST must NOT be called when DELETE fails")
+
+        buf = io.StringIO()
+        with redirect_stderr(buf):
+            with self.assertRaises(SystemExit) as ctx:
+                asc_version_create.reuse_stale_editable(
+                    app_id="111", existing_id="ed-101",
+                    target_version="1.0.6", token="tok",
+                    patch_fn=fake_patch, delete_fn=fake_delete,
+                    post_fn=fake_post,
+                )
+
+        self.assertEqual(ctx.exception.code, 5)
+        stderr = buf.getvalue()
+        self.assertIn("ed-101", stderr)
+
+
+class ReuseStaleEditableLoggingTests(unittest.TestCase):
+    def test_reuse_stale_editable_logs_full_flow(self):
+        def fake_patch(app_id, existing_id, target, token):
+            return _FakeResp(409, payload={
+                "errors": [{"code": "SOME.REJECTION", "detail": "nope"}],
+            })
+
+        def fake_delete(app_id, existing_id, token):
+            return _FakeResp(204)
+
+        def fake_post(app_id, version, token):
+            return _FakeResp(201, payload={"data": {"id": "new-106"}})
+
+        buf = io.StringIO()
+        with redirect_stderr(buf):
+            asc_version_create.reuse_stale_editable(
+                app_id="111", existing_id="ed-101",
+                target_version="1.0.6", token="tok",
+                patch_fn=fake_patch, delete_fn=fake_delete,
+                post_fn=fake_post,
+            )
+
+        stderr = buf.getvalue()
+        self.assertIn("[reuse-stale]", stderr)
+        self.assertIn("PATCH", stderr)
+        self.assertIn("ed-101", stderr)
+        self.assertIn("1.0.6", stderr)
+        self.assertIn("PATCH failed", stderr)
+        self.assertIn("DELETE", stderr)
+        self.assertIn("retrying POST", stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_set_app_store_whats_new.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Tests for set_app_store_whats_new.py's fill-empty backstop mode."""
+
+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 set_app_store_whats_new as sw  # noqa: E402
+
+
+def _loc(loc_id, locale, whats_new=None):
+    attrs = {"locale": locale}
+    if whats_new is not None:
+        attrs["whatsNew"] = whats_new
+    return {"id": loc_id, "attributes": attrs}
+
+
+class UpdateAllLocalizationsTests(unittest.TestCase):
+    def _run(self, entries, only_if_empty):
+        patched = []
+
+        def fake_patch(token, loc_id, whats_new):
+            patched.append(loc_id)
+            return True
+
+        with mock.patch.object(sw, "get_json", return_value={"data": entries}), \
+                mock.patch.object(sw, "_patch_localization", side_effect=fake_patch):
+            count = sw._update_all_localizations(
+                "tok", "v1", "1.0.1", "DEFAULT", "en-US",
+                only_if_empty=only_if_empty)
+        return count, patched
+
+    def test_force_mode_patches_every_locale(self):
+        entries = [_loc("a", "en-US", "existing"), _loc("b", "ru", ""),
+                   _loc("c", "de", None)]
+        count, patched = self._run(entries, only_if_empty=False)
+        self.assertEqual(count, 3)
+        self.assertEqual(set(patched), {"a", "b", "c"})
+
+    def test_backstop_fills_only_empty_locales(self):
+        entries = [_loc("a", "en-US", "AI generated notes"),
+                   _loc("b", "ru", ""),      # empty -> fill
+                   _loc("c", "de", "   "),    # blank whitespace -> fill
+                   _loc("d", "fr", None)]     # missing -> fill
+        count, patched = self._run(entries, only_if_empty=True)
+        self.assertEqual(count, 3)
+        self.assertEqual(set(patched), {"b", "c", "d"})
+        self.assertNotIn("a", patched)  # AI content preserved
+
+    def test_backstop_noop_when_all_present(self):
+        entries = [_loc("a", "en-US", "notes"), _loc("b", "ru", "notes")]
+        count, patched = self._run(entries, only_if_empty=True)
+        self.assertEqual(count, 0)
+        self.assertEqual(patched, [])
+
+    def test_seeds_when_no_localizations(self):
+        with mock.patch.object(sw, "get_json", return_value={"data": []}), \
+                mock.patch.object(sw, "_create_localization", return_value="new1") as cre:
+            count = sw._update_all_localizations(
+                "tok", "v1", "1.0.1", "DEFAULT", "en-US", only_if_empty=True)
+        self.assertEqual(count, 1)
+        cre.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()