gowalk-cicd 1.0.0

package/action/scripts/test_asc_build_history.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Tests for asc_build_history.fetch_prerelease_versions and the
+combined-floor wiring that consumes both /preReleaseVersions and
+/builds?include=preReleaseVersion.
+
+Why these live in their own module: they exercise asc_build_history
+directly (not via mmv seams), and they're large enough that bundling
+them with the other floor-check tests pushed test_mmv_floor_check.py
+over the 400-line cap. The /builds?include=preReleaseVersion path is
+covered separately in ``test_asc_builds_prerelease.py``.
+"""
+
+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
+import asc_build_history  # noqa: E402
+
+from tests_common import _FakeResponse, _mk_prerelease_entry, _v  # noqa: E402
+
+
+class PrereleaseFetchShapeTests(unittest.TestCase):
+    """The /preReleaseVersions fetcher must use the correct query shape and
+    paginate."""
+
+    def test_prerelease_fetch_client_side_platform_filter(self):
+        seen_params: list[dict | None] = []
+        payload = {
+            "data": [
+                {
+                    "id": "pr-ios",
+                    "attributes": {"version": "1.0.1", "platform": "IOS"},
+                },
+                {
+                    "id": "pr-mac",
+                    "attributes": {"version": "1.0.2", "platform": "MAC_OS"},
+                },
+                {
+                    "id": "pr-null",
+                    "attributes": {"version": "1.0.3"},
+                },
+            ],
+            "links": {},
+        }
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            seen_params.append(params)
+            return _FakeResponse(payload)
+
+        buf = io.StringIO()
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request), \
+                redirect_stderr(buf):
+            got = asc_build_history.fetch_prerelease_versions("111", "tok")
+
+        self.assertTrue(seen_params)
+        first = seen_params[0] or {}
+        self.assertNotIn("filter[platform]", first)
+        self.assertEqual(first.get("limit"), 200)
+        self.assertEqual(sorted(got), ["1.0.1", "1.0.3"])
+        stderr = buf.getvalue()
+        self.assertIn("version=1.0.1", stderr)
+        self.assertIn("platform=IOS", stderr)
+        self.assertIn("pr-mac", stderr)
+        self.assertIn("MAC_OS", stderr)
+        self.assertIn("not-ios", stderr)
+        self.assertIn("pr-null", stderr)
+
+    def test_prerelease_fetch_combined_floor_only_counts_ios(self):
+        payload = {
+            "data": [
+                {
+                    "id": "pr-ios",
+                    "attributes": {"version": "1.0.4", "platform": "IOS"},
+                },
+                {
+                    "id": "pr-mac-high",
+                    "attributes": {"version": "9.9.9", "platform": "MAC_OS"},
+                },
+            ],
+            "links": {},
+        }
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            return _FakeResponse(payload)
+
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request):
+            floor, _ = mmv.get_combined_floor(
+                "111", "tok", appstore_versions=[],
+            )
+        self.assertEqual(floor, "1.0.4")
+
+    def test_prerelease_fetch_paginated(self):
+        seen_params: list[dict | None] = []
+        page1 = {
+            "data": [
+                _mk_prerelease_entry("1.0.1", pid="pr-101"),
+                _mk_prerelease_entry("1.0.2", pid="pr-102"),
+            ],
+            "links": {
+                "next": "https://api.appstoreconnect.apple.com/v1/apps/111/"
+                        "preReleaseVersions?cursor=PAGE2",
+            },
+        }
+        page2 = {
+            "data": [_mk_prerelease_entry("1.0.4", pid="pr-104")],
+            "links": {},
+        }
+        responses = [_FakeResponse(page1), _FakeResponse(page2)]
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            seen_params.append(params)
+            return responses.pop(0)
+
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request):
+            got = asc_build_history.fetch_prerelease_versions("111", "tok")
+
+        self.assertEqual(sorted(got), ["1.0.1", "1.0.2", "1.0.4"])
+        self.assertEqual(len(responses), 0)
+        for p in seen_params:
+            if p is None:
+                continue
+            self.assertNotIn("filter[platform]", p)
+
+
+class PlatformNullDefensiveInclusionTests(unittest.TestCase):
+    """Null/missing platform must be INCLUDED defensively."""
+
+    def test_platform_null_record_included_defensively(self):
+        payload = {
+            "data": [
+                {
+                    "id": "pr-null",
+                    "attributes": {"version": "1.0.9"},
+                },
+            ],
+            "links": {},
+        }
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            return _FakeResponse(payload)
+
+        buf = io.StringIO()
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request), \
+                redirect_stderr(buf):
+            versions = asc_build_history.fetch_prerelease_versions(
+                "111", "tok",
+            )
+
+        self.assertEqual(versions, ["1.0.9"])
+        stderr = buf.getvalue()
+        self.assertIn("pr-null", stderr)
+        self.assertIn("null", stderr.lower())
+
+    def test_platform_explicit_non_ios_still_excluded(self):
+        payload = {
+            "data": [
+                {
+                    "id": "pr-mac",
+                    "attributes": {"version": "9.9.9", "platform": "MAC_OS"},
+                },
+                {
+                    "id": "pr-tv",
+                    "attributes": {"version": "8.8.8", "platform": "TV_OS"},
+                },
+                {
+                    "id": "pr-vision",
+                    "attributes": {"version": "7.7.7", "platform": "VISION_OS"},
+                },
+            ],
+            "links": {},
+        }
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            return _FakeResponse(payload)
+
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request):
+            versions = asc_build_history.fetch_prerelease_versions(
+                "111", "tok",
+            )
+
+        self.assertEqual(versions, [])
+
+
+class CombinedFloorBuildsViaSourceTests(unittest.TestCase):
+    """Combined floor per_source must include all three sources."""
+
+    def test_per_source_breakdown_includes_buildsViaPreRelease(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=["1.0.7"]):
+            floor, per_source = asc_version_fetch.get_combined_floor(
+                "111", "tok", mmv.semver_tuple,
+                appstore_versions=[_v("1.0", "READY_FOR_SALE")],
+            )
+
+        self.assertEqual(floor, "1.0.7")
+        self.assertEqual(per_source.get("appStoreVersions"), "1.0")
+        self.assertEqual(per_source.get("preReleaseVersions"), "1.0.4")
+        self.assertEqual(per_source.get("buildsViaPreRelease"), "1.0.7")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_asc_builds_prerelease.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Tests for asc_build_history.fetch_builds_prerelease_versions, the
+/v1/builds?include=preReleaseVersion path that powers the
+buildsViaPreRelease component of the combined floor.
+
+This module owns one large class, ``BuildsPreReleaseRelationshipTests``,
+which was lifted out of ``test_asc_build_history.py`` purely to keep
+that file under the 400-line cap. Both modules share helper imports
+from ``tests_common``.
+"""
+
+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
+import asc_build_history  # noqa: E402
+
+from tests_common import _FakeResponse, _v  # noqa: E402
+
+
+def _build_data_entry(build_id: str, build_version: str, pr_id: str) -> dict:
+    """One /v1/builds.data entry with a preReleaseVersion relationship."""
+    return {
+        "id": build_id,
+        "type": "builds",
+        "attributes": {"version": build_version},
+        "relationships": {
+            "preReleaseVersion": {
+                "data": {"type": "preReleaseVersions", "id": pr_id},
+            },
+        },
+    }
+
+
+def _prerelease_included(
+    pr_id: str, pr_version: str, *, platform: str | None = "IOS",
+) -> dict:
+    """One /v1/builds.included entry describing a preReleaseVersion."""
+    attrs: dict = {"version": pr_version}
+    if platform is not None:
+        attrs["platform"] = platform
+    return {
+        "id": pr_id,
+        "type": "preReleaseVersions",
+        "attributes": attrs,
+    }
+
+
+def _build_with_prerelease(
+    build_id: str, build_version: str,
+    pr_id: str, pr_version: str, *, platform: str | None = "IOS",
+) -> dict:
+    """Build the /v1/builds payload pairing one build with one prerelease
+    relationship — the canonical fixture shape these tests exercise."""
+    return {
+        "data": [_build_data_entry(build_id, build_version, pr_id)],
+        "included": [
+            _prerelease_included(pr_id, pr_version, platform=platform),
+        ],
+        "links": {},
+    }
+
+
+def _capture_build_history_request(payload: dict):
+    """Patch asc_build_history.request to return `payload`. Returns
+    (seen_paths, seen_params, ctx) where ctx is the unittest.mock patch."""
+    seen_paths: list[str] = []
+    seen_params: list[dict | None] = []
+
+    def fake_request(method, path, token, *, params=None, **_kw):
+        seen_paths.append(path)
+        seen_params.append(params)
+        return _FakeResponse(payload)
+
+    return seen_paths, seen_params, mock.patch.object(
+        asc_build_history, "request", side_effect=fake_request,
+    )
+
+
+class BuildsPreReleaseRelationshipTests(unittest.TestCase):
+    """/v1/builds?include=preReleaseVersion reveals preReleaseVersions
+    that the direct /preReleaseVersions query might miss."""
+
+    def test_buildsViaPreRelease_included_in_floor(self):
+        payload = _build_with_prerelease(
+            "build-1", "42", "pr-ref-106", "1.0.6",
+        )
+        seen_paths, seen_params, patch_ctx = (
+            _capture_build_history_request(payload)
+        )
+
+        buf = io.StringIO()
+        with patch_ctx, redirect_stderr(buf):
+            versions = asc_build_history.fetch_builds_prerelease_versions(
+                "111", "tok",
+            )
+
+        self.assertEqual(versions, ["1.0.6"])
+        self.assertEqual(seen_paths[0], "/builds")
+        self.assertEqual(seen_params[0].get("filter[app]"), "111")
+        self.assertEqual(seen_params[0].get("include"), "preReleaseVersion")
+
+        with mock.patch.object(
+                asc_build_history, "fetch_prerelease_versions",
+                return_value=[]), \
+                mock.patch.object(
+                    asc_build_history, "fetch_builds_prerelease_versions",
+                    return_value=["1.0.6"]):
+            floor, per_source = asc_version_fetch.get_combined_floor(
+                "111", "tok", mmv.semver_tuple,
+                appstore_versions=[_v("1.0", "READY_FOR_SALE")],
+            )
+
+        self.assertEqual(floor, "1.0.6")
+        self.assertEqual(per_source.get("buildsViaPreRelease"), "1.0.6")
+
+    def test_buildsViaPreRelease_uses_top_level_builds_endpoint(self):
+        payload = _build_with_prerelease("b1", "1", "pr1", "1.0.9")
+        seen_paths, seen_params, patch_ctx = (
+            _capture_build_history_request(payload)
+        )
+
+        with patch_ctx:
+            versions = asc_build_history.fetch_builds_prerelease_versions(
+                "111", "tok",
+            )
+
+        self.assertEqual(versions, ["1.0.9"])
+        self.assertEqual(seen_paths[0], "/builds")
+        self.assertNotEqual(seen_paths[0], "/apps/111/builds")
+        params = seen_params[0] or {}
+        self.assertEqual(params.get("filter[app]"), "111")
+        self.assertEqual(params.get("include"), "preReleaseVersion")
+
+    def test_buildsViaPreRelease_excludes_non_ios_platform(self):
+        payload = {
+            "data": [
+                _build_data_entry("build-mac", "1", "pr-ref-mac"),
+                _build_data_entry("build-null", "2", "pr-ref-null"),
+            ],
+            "included": [
+                _prerelease_included(
+                    "pr-ref-mac", "9.9.9", platform="MAC_OS"),
+                _prerelease_included(
+                    "pr-ref-null", "1.0.8", platform=None),
+            ],
+            "links": {},
+        }
+        _, _, patch_ctx = _capture_build_history_request(payload)
+
+        with patch_ctx:
+            versions = asc_build_history.fetch_builds_prerelease_versions(
+                "111", "tok",
+            )
+
+        self.assertEqual(versions, ["1.0.8"])
+
+    def test_buildsViaPreRelease_handles_missing_relationship(self):
+        payload = {
+            "data": [
+                {
+                    "id": "build-orphan",
+                    "type": "builds",
+                    "attributes": {"version": "1"},
+                    "relationships": {},
+                },
+            ],
+            "included": [],
+            "links": {},
+        }
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            return _FakeResponse(payload)
+
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request):
+            versions = asc_build_history.fetch_builds_prerelease_versions(
+                "111", "tok",
+            )
+
+        self.assertEqual(versions, [])
+
+    def test_buildsViaPreRelease_paginated(self):
+        page1 = _build_with_prerelease("b1", "1", "pr1", "1.0.5")
+        page1["links"] = {
+            "next": "https://api.appstoreconnect.apple.com/v1/"
+                    "builds?cursor=PAGE2",
+        }
+        page2 = _build_with_prerelease("b2", "2", "pr2", "1.0.6")
+        responses = [_FakeResponse(page1), _FakeResponse(page2)]
+        seen_paths: list[str] = []
+
+        def fake_request(method, path, token, *, params=None, **_kw):
+            seen_paths.append(path)
+            return responses.pop(0)
+
+        with mock.patch.object(
+                asc_build_history, "request", side_effect=fake_request):
+            versions = asc_build_history.fetch_builds_prerelease_versions(
+                "111", "tok",
+            )
+
+        self.assertEqual(sorted(versions), ["1.0.5", "1.0.6"])
+        self.assertEqual(len(responses), 0)
+        self.assertEqual(seen_paths[0], "/builds")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/action/scripts/test_asc_common_timeouts.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""
+Tests for round-12 explicit per-request timeouts in ``asc_common.request``.
+
+Without an explicit ``timeout`` kwarg, ``requests.request(...)`` blocks
+forever on a hung TCP socket. CI then ticks until the runner's 6h hard
+limit and a human pages on. The tests here pin:
+
+  * default ``(connect, read)`` = (10.0, 30.0)
+  * env overrides ``ASC_REQUEST_TIMEOUT_CONNECT_SEC`` /
+    ``ASC_REQUEST_TIMEOUT_READ_SEC`` parse + take effect
+  * invalid / negative env values fall back to the defaults so a typo
+    can't disable the timeout
+  * the timeout is forwarded to ``requests.request`` on every attempt
+    (including retries)
+"""
+
+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 asc_common  # noqa: E402
+
+
+class _OkResponse:
+    """Minimal stand-in for a 200 OK response."""
+
+    status_code = 200
+    text = ""
+
+    def json(self) -> dict:
+        return {"data": []}
+
+
+class RequestTimeoutTests(unittest.TestCase):
+    """``request()`` must pass an explicit ``(connect, read)`` timeout."""
+
+    def _capture_timeout_via_request(self, env: dict) -> tuple[float, float]:
+        captured: dict = {}
+
+        def fake_request(method, url, **kwargs):
+            captured["timeout"] = kwargs.get("timeout")
+            return _OkResponse()
+
+        with mock.patch.dict(os.environ, env, clear=False), \
+                mock.patch.object(asc_common.requests, "request",
+                                  side_effect=fake_request):
+            asc_common.request("GET", "/apps/111", "tok")
+
+        return captured.get("timeout")
+
+    def test_default_timeouts_are_10s_connect_30s_read(self):
+        timeout = self._capture_timeout_via_request({
+            "ASC_REQUEST_TIMEOUT_CONNECT_SEC": "",
+            "ASC_REQUEST_TIMEOUT_READ_SEC": "",
+        })
+        self.assertEqual(timeout, (10.0, 30.0))
+
+    def test_env_override_takes_effect(self):
+        timeout = self._capture_timeout_via_request({
+            "ASC_REQUEST_TIMEOUT_CONNECT_SEC": "5",
+            "ASC_REQUEST_TIMEOUT_READ_SEC": "60",
+        })
+        self.assertEqual(timeout, (5.0, 60.0))
+
+    def test_invalid_env_falls_back_to_default(self):
+        """A typo (e.g. ``CONNECT=ten``) MUST NOT disable the timeout."""
+        timeout = self._capture_timeout_via_request({
+            "ASC_REQUEST_TIMEOUT_CONNECT_SEC": "ten",
+            "ASC_REQUEST_TIMEOUT_READ_SEC": "thirty",
+        })
+        self.assertEqual(timeout, (10.0, 30.0))
+
+    def test_non_positive_env_falls_back_to_default(self):
+        """Zero/negative values would disable the timeout; default instead."""
+        timeout = self._capture_timeout_via_request({
+            "ASC_REQUEST_TIMEOUT_CONNECT_SEC": "0",
+            "ASC_REQUEST_TIMEOUT_READ_SEC": "-5",
+        })
+        self.assertEqual(timeout, (10.0, 30.0))
+
+    def test_timeout_forwarded_on_every_retry_attempt(self):
+        """A 503 retry must pass the same timeout on the retry call."""
+        captured_timeouts: list = []
+        responses = iter([_Status(503), _OkResponse()])
+
+        def fake_request(method, url, **kwargs):
+            captured_timeouts.append(kwargs.get("timeout"))
+            return next(responses)
+
+        with mock.patch.dict(
+                os.environ,
+                {"ASC_REQUEST_TIMEOUT_CONNECT_SEC": "",
+                 "ASC_REQUEST_TIMEOUT_READ_SEC": ""},
+                clear=False), \
+                mock.patch.object(asc_common.requests, "request",
+                                  side_effect=fake_request), \
+                mock.patch.object(asc_common.time, "sleep"):
+            asc_common.request("GET", "/apps/111", "tok")
+
+        self.assertEqual(len(captured_timeouts), 2)
+        self.assertEqual(captured_timeouts[0], (10.0, 30.0))
+        self.assertEqual(captured_timeouts[1], (10.0, 30.0))
+
+
+class _Status:
+    """Stand-in for a non-2xx response that should trigger a retry."""
+
+    def __init__(self, code: int) -> None:
+        self.status_code = code
+        self.text = f"<error {code}>"
+
+
+if __name__ == "__main__":
+    unittest.main()