gowalk-cicd 1.0.0

package/action/scripts/test_asc_metadata_detector.py

@@ -0,0 +1,445 @@
+#!/usr/bin/env python3
+"""
+Tests for asc_metadata_detector.py.
+
+All HTTP is stubbed via unittest.mock; no network calls. Focus:
+  * empty_fields correctly excludes URL fields (SKIP_URL_FIELDS).
+  * locale union across appInfo + version resources.
+  * missing resource id for a locale skips its fields without crashing.
+  * no editable appInfo -> empty result, exit 0 (not an error).
+  * detector runtime error -> fail-open JSON on stdout, exit 0.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import asc_metadata_detector as detector  # noqa: E402
+
+
+def _app_info_payload(state: str) -> dict:
+    return {"data": [{"id": "APP_INFO_1", "attributes": {"appStoreState": state}}]}
+
+
+def _loc_item(loc_id: str, locale: str, **attrs) -> dict:
+    return {"id": loc_id, "attributes": {"locale": locale, **attrs}}
+
+
+class FetchEditableAppInfoTests(unittest.TestCase):
+    def test_returns_editable_record(self):
+        with mock.patch.object(
+            detector, "get_json", return_value=_app_info_payload("PREPARE_FOR_SUBMISSION")
+        ):
+            got = detector.fetch_editable_app_info("111", "tok")
+        self.assertEqual(got, {"id": "APP_INFO_1", "state": "PREPARE_FOR_SUBMISSION"})
+
+    def test_returns_none_when_no_editable_state(self):
+        with mock.patch.object(
+            detector, "get_json", return_value=_app_info_payload("READY_FOR_SALE")
+        ):
+            got = detector.fetch_editable_app_info("111", "tok")
+        self.assertIsNone(got)
+
+    def test_returns_none_for_empty_response(self):
+        with mock.patch.object(detector, "get_json", return_value={"data": []}):
+            got = detector.fetch_editable_app_info("111", "tok")
+        self.assertIsNone(got)
+
+
+class BuildStateTests(unittest.TestCase):
+    def test_unions_locales_across_resources(self):
+        app_locs = {
+            "en-US": {"id": "A1", "name": "MyApp", "subtitle": None,
+                      "privacyPolicyUrl": None, "privacyChoicesUrl": None},
+            "ja": {"id": "A2", "name": None, "subtitle": None,
+                   "privacyPolicyUrl": None, "privacyChoicesUrl": None},
+        }
+        ver_locs = {
+            "en-US": {"id": "V1", "description": "desc", "keywords": None,
+                      "promotionalText": None, "whatsNew": None,
+                      "supportUrl": None, "marketingUrl": None},
+            "de-DE": {"id": "V2", "description": None, "keywords": None,
+                      "promotionalText": None, "whatsNew": None,
+                      "supportUrl": None, "marketingUrl": None},
+        }
+        state = detector.build_state("APP1", "VER1", app_locs, ver_locs)
+        self.assertEqual(state["locales"], ["de-DE", "en-US", "ja"])
+        self.assertEqual(state["app_info_id"], "APP1")
+        self.assertEqual(state["version_id"], "VER1")
+
+        self.assertEqual(
+            state["localizations"]["en-US"]["app_info_localization_id"], "A1"
+        )
+        self.assertEqual(
+            state["localizations"]["en-US"]["version_localization_id"], "V1"
+        )
+        # de-DE has no appInfo entry -> id is None
+        self.assertIsNone(
+            state["localizations"]["de-DE"]["app_info_localization_id"]
+        )
+        self.assertEqual(
+            state["localizations"]["de-DE"]["version_localization_id"], "V2"
+        )
+        # ja has no version entry -> id is None
+        self.assertIsNone(
+            state["localizations"]["ja"]["version_localization_id"]
+        )
+
+
+class DiffEmptyFieldsTests(unittest.TestCase):
+    def _state(self, fields_en: dict, **kwargs) -> dict:
+        defaults = {
+            "app_info_localization_id": "A1",
+            "version_localization_id": "V1",
+        }
+        defaults.update(kwargs)
+        return {
+            "localizations": {
+                "en-US": {**defaults, "fields": fields_en},
+            }
+        }
+
+    def test_empty_string_and_whitespace_treated_as_empty(self):
+        state = self._state({
+            "name": "", "subtitle": "   ",
+            "description": None, "keywords": "kw",
+            "promotionalText": None, "whatsNew": "notes",
+        })
+        self.assertEqual(
+            sorted(detector.diff_empty_fields(state)["en-US"]),
+            ["description", "name", "promotionalText", "subtitle"],
+        )
+
+    def test_url_fields_never_reported_empty(self):
+        # supportUrl/marketingUrl/privacyPolicyUrl even when None must NOT
+        # appear in the diff -- they are in SKIP_URL_FIELDS.
+        state = self._state({
+            "name": "X", "subtitle": "Y",
+            "description": "d", "keywords": "k",
+            "promotionalText": "p", "whatsNew": "w",
+            "supportUrl": None, "marketingUrl": "",
+            "privacyPolicyUrl": None,
+        })
+        self.assertEqual(detector.diff_empty_fields(state), {})
+
+    def test_skips_app_level_when_app_info_localization_id_missing(self):
+        state = self._state(
+            {"name": None, "subtitle": None,
+             "description": None, "keywords": None,
+             "promotionalText": None, "whatsNew": None},
+            app_info_localization_id=None,
+        )
+        # name/subtitle must be skipped because app_info_localization_id is None
+        self.assertEqual(
+            sorted(detector.diff_empty_fields(state)["en-US"]),
+            ["description", "keywords", "promotionalText", "whatsNew"],
+        )
+
+    def test_skips_version_level_when_version_localization_id_missing(self):
+        state = self._state(
+            {"name": None, "subtitle": None,
+             "description": None, "keywords": None,
+             "promotionalText": None, "whatsNew": None},
+            version_localization_id=None,
+        )
+        self.assertEqual(
+            sorted(detector.diff_empty_fields(state)["en-US"]),
+            ["name", "subtitle"],
+        )
+
+    def test_fully_populated_returns_empty_dict(self):
+        state = self._state({
+            "name": "X", "subtitle": "Y",
+            "description": "d", "keywords": "k",
+            "promotionalText": "p", "whatsNew": "w",
+        })
+        self.assertEqual(detector.diff_empty_fields(state), {})
+
+
+class ExtractExistingFieldsTests(unittest.TestCase):
+    """Phase-2 orchestration reads ``existing_fields`` as authoritative ASC
+    context (description, etc.) -- must be populated for every locale with
+    all 6 non-URL fields, regardless of which are empty."""
+
+    NON_URL = ("name", "subtitle", "description", "keywords",
+               "promotionalText", "whatsNew")
+
+    def _state(self, fields_en: dict, fields_de: dict | None = None) -> dict:
+        localizations = {
+            "en-US": {
+                "app_info_localization_id": "A1",
+                "version_localization_id": "V1",
+                "fields": fields_en,
+            },
+        }
+        if fields_de is not None:
+            localizations["de-DE"] = {
+                "app_info_localization_id": "A2",
+                "version_localization_id": "V2",
+                "fields": fields_de,
+            }
+        return {"localizations": localizations}
+
+    def test_contains_every_non_url_field_per_locale(self):
+        state = self._state({
+            "name": "MyApp", "subtitle": "Cool",
+            "description": "A desc", "keywords": "k1,k2",
+            "promotionalText": "promo", "whatsNew": "news",
+        })
+        existing = detector.extract_existing_fields(state)
+        self.assertEqual(set(existing), {"en-US"})
+        self.assertEqual(set(existing["en-US"].keys()), set(self.NON_URL))
+
+    def test_preserves_populated_asc_values(self):
+        state = self._state({
+            "name": "MyApp", "subtitle": "Cool",
+            "description": "Great app!", "keywords": "k1,k2",
+            "promotionalText": "promo text", "whatsNew": "v1 notes",
+        })
+        existing = detector.extract_existing_fields(state)["en-US"]
+        self.assertEqual(existing["name"], "MyApp")
+        self.assertEqual(existing["subtitle"], "Cool")
+        self.assertEqual(existing["description"], "Great app!")
+        self.assertEqual(existing["keywords"], "k1,k2")
+        self.assertEqual(existing["promotionalText"], "promo text")
+        self.assertEqual(existing["whatsNew"], "v1 notes")
+
+    def test_normalizes_missing_or_none_to_empty_string(self):
+        state = self._state({
+            "name": None, "subtitle": "",
+            "description": None, "keywords": "",
+            # promotionalText omitted entirely
+            "whatsNew": None,
+        })
+        existing = detector.extract_existing_fields(state)["en-US"]
+        self.assertEqual(existing["name"], "")
+        self.assertEqual(existing["subtitle"], "")
+        self.assertEqual(existing["description"], "")
+        self.assertEqual(existing["keywords"], "")
+        self.assertEqual(existing["promotionalText"], "")
+        self.assertEqual(existing["whatsNew"], "")
+
+    def test_excludes_url_fields(self):
+        state = self._state({
+            "name": "MyApp", "subtitle": "Cool",
+            "description": "d", "keywords": "k",
+            "promotionalText": "p", "whatsNew": "w",
+            "privacyPolicyUrl": "https://x", "privacyChoicesUrl": "https://y",
+            "supportUrl": "https://s", "marketingUrl": "https://m",
+        })
+        existing = detector.extract_existing_fields(state)["en-US"]
+        self.assertNotIn("privacyPolicyUrl", existing)
+        self.assertNotIn("privacyChoicesUrl", existing)
+        self.assertNotIn("supportUrl", existing)
+        self.assertNotIn("marketingUrl", existing)
+
+    def test_populates_all_locales(self):
+        state = self._state(
+            {"name": "EN", "subtitle": "S", "description": "D",
+             "keywords": "K", "promotionalText": "P", "whatsNew": "W"},
+            {"name": "DE", "subtitle": "", "description": "DE desc",
+             "keywords": "", "promotionalText": "", "whatsNew": ""},
+        )
+        existing = detector.extract_existing_fields(state)
+        self.assertEqual(set(existing), {"en-US", "de-DE"})
+        self.assertEqual(existing["de-DE"]["name"], "DE")
+        self.assertEqual(existing["de-DE"]["description"], "DE desc")
+        self.assertEqual(existing["de-DE"]["subtitle"], "")
+
+
+class MainTests(unittest.TestCase):
+    def _env(self) -> dict:
+        return {
+            "ASC_KEY_ID": "k",
+            "ASC_ISSUER_ID": "i",
+            "ASC_KEY_PATH": "/tmp/key.p8",
+            "APP_STORE_APPLE_ID": "111",
+            "APP_STORE_VERSION_ID": "222",
+        }
+
+    def test_no_editable_app_info_emits_empty_fields(self):
+        stdout = io.StringIO()
+        with mock.patch.dict("os.environ", self._env(), clear=True), \
+             mock.patch.object(detector, "make_jwt", return_value="tok"), \
+             mock.patch.object(
+                 detector, "get_json",
+                 return_value=_app_info_payload("READY_FOR_SALE"),
+             ), \
+             mock.patch.object(sys, "stdout", stdout):
+            rc = detector.main()
+        self.assertEqual(rc, 0)
+        payload = json.loads(stdout.getvalue())
+        self.assertEqual(payload, {"empty_fields": {}})
+
+    def test_runtime_error_is_non_fatal(self):
+        stdout = io.StringIO()
+        with mock.patch.dict("os.environ", self._env(), clear=True), \
+             mock.patch.object(detector, "make_jwt", side_effect=RuntimeError("boom")), \
+             mock.patch.object(sys, "stdout", stdout):
+            rc = detector.main()
+        self.assertEqual(rc, 0)
+        payload = json.loads(stdout.getvalue())
+        self.assertEqual(payload, {"empty_fields": {}})
+
+    def test_happy_path_emits_full_state(self):
+        env = self._env()
+
+        def fake_get_json(path, token, params=None):
+            if path.endswith("/appInfos"):
+                return _app_info_payload("PREPARE_FOR_SUBMISSION")
+            if "/appInfoLocalizations" in path:
+                return {"data": [
+                    _loc_item("A1", "en-US", name="MyApp", subtitle=None,
+                              privacyPolicyUrl=None, privacyChoicesUrl=None),
+                    _loc_item("A2", "ja", name=None, subtitle=None,
+                              privacyPolicyUrl=None, privacyChoicesUrl=None),
+                ]}
+            if "/appStoreVersionLocalizations" in path:
+                return {"data": [
+                    _loc_item("V1", "en-US", description="desc",
+                              keywords=None, promotionalText=None,
+                              whatsNew=None, supportUrl=None, marketingUrl=None),
+                    _loc_item("V2", "ja", description=None,
+                              keywords=None, promotionalText=None,
+                              whatsNew=None, supportUrl=None, marketingUrl=None),
+                ]}
+            if path.startswith("/appStoreVersions/") and "Localizations" not in path:
+                return {"data": {"id": "222", "attributes":
+                                 {"appStoreState": "PREPARE_FOR_SUBMISSION"}}}
+            raise AssertionError(f"unexpected path {path}")
+
+        stdout = io.StringIO()
+        with mock.patch.dict("os.environ", env, clear=True), \
+             mock.patch.object(detector, "make_jwt", return_value="tok"), \
+             mock.patch.object(detector, "get_json", side_effect=fake_get_json), \
+             mock.patch.object(sys, "stdout", stdout):
+            rc = detector.main()
+        self.assertEqual(rc, 0)
+        payload = json.loads(stdout.getvalue())
+        self.assertEqual(sorted(payload["locales"]), ["en-US", "ja"])
+        # en-US still missing subtitle, keywords, promotionalText, whatsNew
+        self.assertEqual(
+            sorted(payload["empty_fields"]["en-US"]),
+            ["keywords", "promotionalText", "subtitle", "whatsNew"],
+        )
+        # ja missing everything non-URL
+        self.assertEqual(
+            sorted(payload["empty_fields"]["ja"]),
+            ["description", "keywords", "name", "promotionalText",
+             "subtitle", "whatsNew"],
+        )
+        # app_store_state surfaced for downstream debugging.
+        self.assertEqual(payload["app_store_state"], "PREPARE_FOR_SUBMISSION")
+        # existing_fields surfaces authoritative ASC values for phase-2
+        # prompting -- must be present, keyed by every locale, with all 6
+        # non-URL fields (None/missing normalized to "").
+        self.assertIn("existing_fields", payload)
+        self.assertEqual(set(payload["existing_fields"]), {"en-US", "ja"})
+        self.assertEqual(
+            set(payload["existing_fields"]["en-US"]),
+            {"name", "subtitle", "description", "keywords",
+             "promotionalText", "whatsNew"},
+        )
+        self.assertEqual(payload["existing_fields"]["en-US"]["name"], "MyApp")
+        self.assertEqual(payload["existing_fields"]["en-US"]["description"], "desc")
+        self.assertEqual(payload["existing_fields"]["en-US"]["subtitle"], "")
+        self.assertEqual(payload["existing_fields"]["ja"]["description"], "")
+
+
+class VersionStateGateTests(unittest.TestCase):
+    """Exercise the editable-version-state gate added to stop 409s on
+    /appStoreVersionLocalizations PATCHes when the version is locked."""
+
+    def _env(self) -> dict:
+        return {
+            "ASC_KEY_ID": "k",
+            "ASC_ISSUER_ID": "i",
+            "ASC_KEY_PATH": "/tmp/key.p8",
+            "APP_STORE_APPLE_ID": "111",
+            "APP_STORE_VERSION_ID": "222",
+        }
+
+    def _make_fake_get_json(self, version_state: str):
+        def fake_get_json(path, token, params=None):
+            if path.endswith("/appInfos"):
+                return _app_info_payload("PREPARE_FOR_SUBMISSION")
+            if "/appInfoLocalizations" in path:
+                return {"data": [
+                    _loc_item("A1", "en-US", name=None, subtitle=None,
+                              privacyPolicyUrl=None, privacyChoicesUrl=None),
+                ]}
+            if "/appStoreVersionLocalizations" in path:
+                return {"data": [
+                    _loc_item("V1", "en-US", description=None,
+                              keywords=None, promotionalText=None,
+                              whatsNew=None, supportUrl=None, marketingUrl=None),
+                ]}
+            if path.startswith("/appStoreVersions/") and "Localizations" not in path:
+                return {"data": {"id": "222", "attributes":
+                                 {"appStoreState": version_state}}}
+            raise AssertionError(f"unexpected path {path}")
+        return fake_get_json
+
+    def _run(self, version_state: str) -> dict:
+        stdout = io.StringIO()
+        with mock.patch.dict("os.environ", self._env(), clear=True), \
+             mock.patch.object(detector, "make_jwt", return_value="tok"), \
+             mock.patch.object(
+                 detector, "get_json",
+                 side_effect=self._make_fake_get_json(version_state),
+             ), \
+             mock.patch.object(sys, "stdout", stdout):
+            rc = detector.main()
+        self.assertEqual(rc, 0)
+        return json.loads(stdout.getvalue())
+
+    def test_in_review_clears_version_ids_and_omits_version_fields(self):
+        # IN_REVIEW: version record exists but accepts no localization
+        # PATCHes -- Apple returns 409. Detector must zero the id so the
+        # applier only touches app-level fields (name, subtitle via
+        # appInfoLocalizations, which uses a separate editability gate).
+        payload = self._run("IN_REVIEW")
+        self.assertIsNone(
+            payload["localizations"]["en-US"]["version_localization_id"]
+        )
+        self.assertEqual(payload["empty_fields"]["en-US"], ["name", "subtitle"])
+        for f in ("description", "keywords", "promotionalText", "whatsNew"):
+            self.assertNotIn(f, payload["empty_fields"]["en-US"])
+        self.assertEqual(payload["app_store_state"], "IN_REVIEW")
+
+    def test_waiting_for_review_is_editable_and_preserves_version_fields(self):
+        # WAITING_FOR_REVIEW is in EDITABLE_VERSION_STATES per Apple's docs;
+        # the version id must NOT be cleared even though the app is queued.
+        payload = self._run("WAITING_FOR_REVIEW")
+        self.assertEqual(
+            payload["localizations"]["en-US"]["version_localization_id"], "V1"
+        )
+        self.assertIn("description", payload["empty_fields"]["en-US"])
+
+    def test_prepare_for_submission_preserves_version_level_fields(self):
+        payload = self._run("PREPARE_FOR_SUBMISSION")
+        self.assertEqual(
+            payload["localizations"]["en-US"]["version_localization_id"], "V1"
+        )
+        self.assertIn("description", payload["empty_fields"]["en-US"])
+        self.assertIn("whatsNew", payload["empty_fields"]["en-US"])
+        self.assertEqual(payload["app_store_state"], "PREPARE_FOR_SUBMISSION")
+
+    def test_ready_for_sale_clears_version_ids(self):
+        # READY_FOR_SALE is a live, locked state -- PATCHes would 409.
+        payload = self._run("READY_FOR_SALE")
+        self.assertIsNone(
+            payload["localizations"]["en-US"]["version_localization_id"]
+        )
+        self.assertNotIn("description", payload["empty_fields"].get("en-US", []))
+
+
+if __name__ == "__main__":
+    unittest.main()