@mmerterden/multi-agent-pipeline 11.2.0 → 11.3.0

package/pipeline/skills/figma-ios/figma-to-component/scripts/lib/test_update_issue.py

@@ -1,298 +0,0 @@
-"""Unit tests for update-issue-from-registry.py pure logic.
-
-Covers:
-- compute_flag_states (dict return, all branches)
-- build_progress_table + rewrite_progress_table
-- build_missing_issue_body
-- is_icon_entry
-- pick_survivor (duplicate rule)
-- sync_one skip short-circuits
-"""
-
-import importlib.util
-import json
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-SCRIPTS_DIR = Path(__file__).parent.parent
-spec = importlib.util.spec_from_file_location(
-    "update_issue", SCRIPTS_DIR / "update-issue-from-registry.py"
-)
-update_issue = importlib.util.module_from_spec(spec)
-sys.modules["update_issue"] = update_issue
-spec.loader.exec_module(update_issue)
-
-
-def _fresh_entry(node_id: str = "1:1") -> dict:
-    return {
-        "nodeId": node_id,
-        "componentName": {"ios": "Button", "android": "Button"},
-        "fileKey": "ABC",
-        "skip": False,
-        "status": {
-            "ios": {
-                "stale": False,
-                "implemented": {"value": False, "version": 0, "hash": None, "at": None},
-                "tested": {"value": False, "against": 0, "at": None},
-                "codeConnect": {"value": False, "against": 0, "at": None},
-                "wiki": {"value": False, "against": 0, "at": None},
-            },
-            "android": {
-                "stale": False,
-                "implemented": {"value": False, "version": 0, "hash": None, "at": None},
-                "tested": {"value": False, "against": 0, "at": None},
-                "codeConnect": {"value": False, "against": 0, "at": None},
-                "wiki": {"value": False, "against": 0, "at": None},
-            },
-        },
-    }
-
-
-class ComputeFlagStatesTests(unittest.TestCase):
-    def test_empty_entry_all_gray(self):
-        result = update_issue.compute_flag_states({}, "ios")
-        self.assertEqual(result, {
-            "implemented": "gray",
-            "tested": "gray",
-            "codeConnect": "gray",
-            "wiki": "gray",
-        })
-
-    def test_returns_all_four_keys_always(self):
-        result = update_issue.compute_flag_states({"nodeId": "1:1"}, "ios")
-        self.assertEqual(set(result.keys()), {"implemented", "tested", "codeConnect", "wiki"})
-
-    def test_implemented_green_when_value_and_not_stale(self):
-        e = _fresh_entry()
-        e["status"]["ios"]["implemented"] = {"value": True, "version": 1, "hash": None, "at": "..."}
-        result = update_issue.compute_flag_states(e, "ios")
-        self.assertEqual(result["implemented"], "green")
-        self.assertEqual(result["tested"], "gray")
-
-    def test_implemented_yellow_when_stale(self):
-        e = _fresh_entry()
-        e["status"]["ios"]["stale"] = True
-        e["status"]["ios"]["implemented"] = {"value": True, "version": 1, "hash": None, "at": "..."}
-        result = update_issue.compute_flag_states(e, "ios")
-        self.assertEqual(result["implemented"], "yellow")
-
-    def test_all_green_against_version_1(self):
-        e = _fresh_entry()
-        e["status"]["ios"]["implemented"] = {"value": True, "version": 1, "hash": None, "at": "..."}
-        for f in ("tested", "codeConnect", "wiki"):
-            e["status"]["ios"][f] = {"value": True, "against": 1, "at": "..."}
-        result = update_issue.compute_flag_states(e, "ios")
-        self.assertEqual(result, {
-            "implemented": "green",
-            "tested": "green",
-            "codeConnect": "green",
-            "wiki": "green",
-        })
-
-    def test_mixed_yellow_when_impl_ahead(self):
-        e = _fresh_entry()
-        e["status"]["ios"]["implemented"] = {"value": True, "version": 3, "hash": None, "at": "..."}
-        e["status"]["ios"]["tested"] = {"value": True, "against": 1, "at": "..."}
-        e["status"]["ios"]["codeConnect"] = {"value": True, "against": 3, "at": "..."}
-        e["status"]["ios"]["wiki"] = {"value": False, "against": 0, "at": None}
-        result = update_issue.compute_flag_states(e, "ios")
-        self.assertEqual(result["implemented"], "green")
-        self.assertEqual(result["tested"], "yellow")
-        self.assertEqual(result["codeConnect"], "green")
-        self.assertEqual(result["wiki"], "gray")
-
-    def test_android_platform_independent(self):
-        e = _fresh_entry()
-        e["status"]["ios"]["implemented"] = {"value": True, "version": 1, "hash": None, "at": "..."}
-        result = update_issue.compute_flag_states(e, "android")
-        self.assertEqual(result["implemented"], "gray")
-
-
-class BuildProgressTableTests(unittest.TestCase):
-    def test_all_gray(self):
-        t = update_issue.build_progress_table({
-            "implemented": "gray", "tested": "gray", "codeConnect": "gray", "wiki": "gray",
-        })
-        self.assertEqual(t.count("⚪"), 4)
-        self.assertNotIn("🟢", t)
-        self.assertNotIn("🟡", t)
-        self.assertIn("Implementation", t)
-        self.assertIn("Code Connect", t)
-
-    def test_all_green(self):
-        t = update_issue.build_progress_table({
-            "implemented": "green", "tested": "green", "codeConnect": "green", "wiki": "green",
-        })
-        self.assertEqual(t.count("🟢"), 4)
-        self.assertNotIn("⚪", t)
-
-    def test_mixed(self):
-        t = update_issue.build_progress_table({
-            "implemented": "green", "tested": "yellow", "codeConnect": "green", "wiki": "gray",
-        })
-        self.assertIn("🟢", t)
-        self.assertIn("🟡", t)
-        self.assertEqual(t.count("⚪"), 1)
-
-    def test_missing_keys_default_to_gray(self):
-        t = update_issue.build_progress_table({})
-        self.assertEqual(t.count("⚪"), 4)
-
-
-class RewriteProgressTableTests(unittest.TestCase):
-    def _green(self):
-        return {"implemented": "green", "tested": "gray", "codeConnect": "gray", "wiki": "gray"}
-
-    def test_replaces_existing_section(self):
-        body = "### Figma URL\n\nhttps://x\n\n### Progress\n\nOLD CONTENT\n\n### Notes\n\nhi\n"
-        new = update_issue.rewrite_progress_table(body, self._green())
-        self.assertNotIn("OLD CONTENT", new)
-        self.assertIn("🟢", new)
-        self.assertIn("### Notes", new)
-
-    def test_appends_when_missing(self):
-        body = "### Figma URL\n\nhttps://x\n\n### Notes\n\nhi\n"
-        new = update_issue.rewrite_progress_table(body, self._green())
-        self.assertIn("### Progress", new)
-        self.assertIn("🟢", new)
-
-    def test_preserves_surrounding_sections(self):
-        body = (
-            "### Figma URL\n\nhttps://x\n\n"
-            "### Progress\n\nOLD\n\n"
-            "### Acceptance Criteria\n\nfoo\n\n"
-            "### Notes\n\nhi\n"
-        )
-        gray = {"implemented": "gray", "tested": "gray", "codeConnect": "gray", "wiki": "gray"}
-        new = update_issue.rewrite_progress_table(body, gray)
-        self.assertIn("### Figma URL", new)
-        self.assertIn("### Acceptance Criteria", new)
-        self.assertIn("foo", new)
-        self.assertIn("### Notes", new)
-        self.assertNotIn("OLD", new)
-
-
-class BuildMissingIssueBodyTests(unittest.TestCase):
-    def test_dict_component_name(self):
-        entry = {
-            "nodeId": "5:17752",
-            "componentName": {"ios": "TurkishButton", "android": "TurkishButton"},
-            "fileKey": "ABCxyz",
-        }
-        states = {"implemented": "green", "tested": "gray", "codeConnect": "gray", "wiki": "gray"}
-        body = update_issue.build_missing_issue_body(entry, states)
-        self.assertIn("TurkishButton", body)
-        self.assertIn("5:17752", body)
-        self.assertIn("ABCxyz", body)
-        self.assertIn("### Progress", body)
-        self.assertIn("🟢", body)
-
-    def test_bare_string_component_name(self):
-        entry = {"nodeId": "7:200", "componentName": "InputArea", "fileKey": "K"}
-        body = update_issue.build_missing_issue_body(entry, {})
-        self.assertIn("InputArea", body)
-        self.assertIn("⚪", body)
-
-    def test_missing_filekey_uses_no_response(self):
-        entry = {"nodeId": "1:1", "componentName": {"ios": "X"}}
-        body = update_issue.build_missing_issue_body(entry, {})
-        self.assertIn("_No response_", body)
-
-
-class IsIconEntryTests(unittest.TestCase):
-    def test_ios_image_prefix_is_icon(self):
-        self.assertTrue(update_issue.is_icon_entry({"componentName": {"ios": "Image.screwdriver"}}))
-
-    def test_android_images_prefix_is_icon(self):
-        self.assertTrue(update_issue.is_icon_entry({"componentName": {"android": "Images.screwdriver"}}))
-
-    def test_normal_component_not_icon(self):
-        self.assertFalse(update_issue.is_icon_entry({"componentName": {"ios": "Button"}}))
-
-    def test_bare_string_image_prefix(self):
-        self.assertTrue(update_issue.is_icon_entry({"componentName": "Image.foo"}))
-
-    def test_bare_string_normal(self):
-        self.assertFalse(update_issue.is_icon_entry({"componentName": "FlightCard"}))
-
-    def test_missing_componentName(self):
-        self.assertFalse(update_issue.is_icon_entry({}))
-
-
-class PickSurvivorTests(unittest.TestCase):
-    def test_lowest_number_when_no_sub_issues(self):
-        issues = [
-            {"number": 42, "sub_issue_count": 0},
-            {"number": 17, "sub_issue_count": 0},
-            {"number": 99, "sub_issue_count": 0},
-        ]
-        survivor = update_issue.pick_survivor(issues)
-        self.assertEqual(survivor["number"], 17)
-
-    def test_issue_with_sub_issues_wins(self):
-        issues = [
-            {"number": 17, "sub_issue_count": 0},
-            {"number": 42, "sub_issue_count": 3},
-            {"number": 99, "sub_issue_count": 0},
-        ]
-        survivor = update_issue.pick_survivor(issues)
-        self.assertEqual(survivor["number"], 42)
-
-    def test_lowest_number_among_those_with_sub_issues(self):
-        issues = [
-            {"number": 42, "sub_issue_count": 5},
-            {"number": 17, "sub_issue_count": 2},
-            {"number": 99, "sub_issue_count": 0},
-        ]
-        survivor = update_issue.pick_survivor(issues)
-        self.assertEqual(survivor["number"], 17)
-
-    def test_single_issue_is_survivor(self):
-        issues = [{"number": 42, "sub_issue_count": 0}]
-        survivor = update_issue.pick_survivor(issues)
-        self.assertEqual(survivor["number"], 42)
-
-
-class SyncOneSkipTests(unittest.TestCase):
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.registry_dir = Path(self.tmp.name)
-
-    def tearDown(self):
-        self.tmp.cleanup()
-
-    def _write(self, node_id: str, data: dict):
-        (self.registry_dir / f"{node_id.replace(':', '-')}.json").write_text(json.dumps(data))
-
-    def test_skip_marked_skip_short_circuits(self):
-        self._write("1:1", {"nodeId": "1:1", "componentName": {"ios": "X"}, "skip": True})
-        result = update_issue.sync_one(
-            registry_dir=self.registry_dir, node_id="1:1", platform="ios",
-            repo="fake/repo", team_label="team:core", dry_run=True,
-        )
-        self.assertEqual(result["action"], "skip_marked_skip")
-
-    def test_skip_icon_short_circuits(self):
-        self._write("1:2", {
-            "nodeId": "1:2",
-            "componentName": {"ios": "Image.foo", "android": "Images.foo"},
-            "skip": False,
-        })
-        result = update_issue.sync_one(
-            registry_dir=self.registry_dir, node_id="1:2", platform="ios",
-            repo="fake/repo", team_label="team:core", dry_run=True,
-        )
-        self.assertEqual(result["action"], "skip_icon")
-
-    def test_missing_entry_returns_error(self):
-        result = update_issue.sync_one(
-            registry_dir=self.registry_dir, node_id="9:99", platform="ios",
-            repo="fake/repo", team_label="team:core", dry_run=False,
-        )
-        self.assertEqual(result["status"], "error")
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/pipeline/skills/figma-ios/figma-to-component/scripts/lib/test_update_issue_gh.py

@@ -1,195 +0,0 @@
-"""Subprocess path tests for update-issue-from-registry.py.
-
-Covers gh wrapper, gh_graphql wrapper, close_duplicate,
-create_missing_issue, get_issue_body, rewrite_issue_body.
-
-sync_one is not fully exercised here  -  its full happy path requires
-mocking the entire REST-then-GraphQL sequence, which gets brittle.
-Instead we trust the unit tests for pure-logic pieces
-(compute_flag_states, pick_survivor, etc.) and the real single-node
-smoke run (tracked in temp/step7.7-*.md) to verify end-to-end.
-"""
-
-import importlib.util
-import json
-import sys
-import unittest
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-SCRIPTS_DIR = Path(__file__).parent.parent
-spec = importlib.util.spec_from_file_location(
-    "update_issue", SCRIPTS_DIR / "update-issue-from-registry.py"
-)
-update_issue = importlib.util.module_from_spec(spec)
-sys.modules["update_issue"] = update_issue
-spec.loader.exec_module(update_issue)
-
-
-def _mock_gh_result(stdout: str = "", returncode: int = 0, stderr: str = "") -> MagicMock:
-    r = MagicMock()
-    r.stdout = stdout
-    r.returncode = returncode
-    r.stderr = stderr
-    return r
-
-
-class GhWrapperTests(unittest.TestCase):
-    def test_dry_run_skips_subprocess(self):
-        with patch.object(update_issue.subprocess, "run") as mock_run:
-            result = update_issue.gh(["issue", "view", "1"], dry_run=True)
-        mock_run.assert_not_called()
-        self.assertEqual(result, "")
-
-    def test_success_returns_stdout(self):
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result("hello")):
-            out = update_issue.gh(["issue", "view", "1"])
-        self.assertEqual(out, "hello")
-
-    def test_failure_raises(self):
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result("", 1, "boom")):
-            with self.assertRaises(RuntimeError):
-                update_issue.gh(["issue", "view", "1"])
-
-    def test_missing_binary(self):
-        with patch.object(update_issue.subprocess, "run", side_effect=FileNotFoundError()):
-            with self.assertRaises(RuntimeError):
-                update_issue.gh(["issue", "view", "1"])
-
-    def test_always_captures(self):
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result("ok")) as mock_run:
-            update_issue.gh(["issue", "view", "1"])
-        self.assertTrue(mock_run.call_args[1].get("capture_output"))
-
-
-class GhGraphqlTests(unittest.TestCase):
-    def test_parses_data_field(self):
-        payload = json.dumps({"data": {"viewer": {"login": "me"}}})
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result(payload)):
-            out = update_issue.gh_graphql("query { viewer { login } }")
-        self.assertEqual(out, {"viewer": {"login": "me"}})
-
-    def test_raises_on_errors(self):
-        payload = json.dumps({"errors": [{"message": "bad"}]})
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result(payload)):
-            with self.assertRaises(RuntimeError):
-                update_issue.gh_graphql("query { x }")
-
-    def test_dry_run_returns_empty_dict(self):
-        with patch.object(update_issue.subprocess, "run") as mock_run:
-            out = update_issue.gh_graphql("query { x }", dry_run=True)
-        mock_run.assert_not_called()
-        self.assertEqual(out, {})
-
-    def test_bad_json_raises(self):
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result("not json")):
-            with self.assertRaises(RuntimeError):
-                update_issue.gh_graphql("query { x }")
-
-
-class CloseDuplicateTests(unittest.TestCase):
-    def test_posts_comment_then_closes(self):
-        calls = []
-
-        def fake_run(args, **kwargs):
-            calls.append(list(args))
-            return _mock_gh_result("")
-
-        with patch.object(update_issue.subprocess, "run", side_effect=fake_run):
-            update_issue.close_duplicate(99, 42, "r", dry_run=False)
-
-        self.assertEqual(len(calls), 2)
-        self.assertIn("comment", calls[0])
-        self.assertIn("99", calls[0])
-        self.assertIn("close", calls[1])
-        self.assertIn("99", calls[1])
-        body_idx = calls[0].index("--body") + 1
-        self.assertIn("#42", calls[0][body_idx])
-
-
-class CreateMissingIssueTests(unittest.TestCase):
-    def test_builds_correct_gh_create_invocation(self):
-        entry = {
-            "nodeId": "5:17752",
-            "componentName": {"ios": "Button", "android": "Button"},
-            "fileKey": "K",
-        }
-        create_stdout = "https://github.com/o/r/issues/123\n"
-        states = {"implemented": "green", "tested": "gray", "codeConnect": "gray", "wiki": "gray"}
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result(create_stdout)) as mock_run:
-            num = update_issue.create_missing_issue(
-                entry, states, "o/r", "team:core", dry_run=False,
-            )
-
-        self.assertEqual(num, 123)
-        args = mock_run.call_args[0][0]
-        self.assertIn("create", args)
-        label_values = [args[i + 1] for i, a in enumerate(args) if a == "--label"]
-        self.assertIn("component", label_values)
-        self.assertIn("team:core", label_values)
-        # Critical: no flag labels applied at creation
-        self.assertNotIn("implemented:green", label_values)
-        self.assertNotIn("implemented:yellow", label_values)
-
-    def test_title_uses_component_name(self):
-        entry = {"nodeId": "1:1", "componentName": "MyThing", "fileKey": "K"}
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result("https://gh/issues/5")) as mock_run:
-            update_issue.create_missing_issue(entry, {}, "o/r", "team:core", dry_run=False)
-        args = mock_run.call_args[0][0]
-        title_idx = args.index("--title") + 1
-        self.assertIn("MyThing", args[title_idx])
-
-    def test_dry_run_returns_none(self):
-        entry = {"nodeId": "1:1", "componentName": {"ios": "X"}, "fileKey": "K"}
-        with patch.object(update_issue.subprocess, "run") as mock_run:
-            num = update_issue.create_missing_issue(entry, {}, "o/r", "team:core", dry_run=True)
-        mock_run.assert_not_called()
-        self.assertIsNone(num)
-
-
-class GetIssueBodyTests(unittest.TestCase):
-    def test_parses_json_body(self):
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result(json.dumps({"body": "hello"}))):
-            body = update_issue.get_issue_body(42, "r")
-        self.assertEqual(body, "hello")
-
-    def test_handles_bad_json(self):
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result("not json")):
-            body = update_issue.get_issue_body(42, "r")
-        self.assertEqual(body, "")
-
-
-class SyncProjectFieldsTests(unittest.TestCase):
-    def test_calls_graphql_once_per_flag(self):
-        graphql_calls = []
-
-        def fake_run(args, **kwargs):
-            # Only graphql calls matter
-            graphql_calls.append(args)
-            return _mock_gh_result(json.dumps({"data": {"updateProjectV2ItemFieldValue": {"projectV2Item": {"id": "X"}}}}))
-
-        states = {"implemented": "green", "tested": "yellow", "codeConnect": "gray", "wiki": "green"}
-        with patch.object(update_issue.subprocess, "run", side_effect=fake_run):
-            applied = update_issue.sync_project_fields(
-                item_id="I",
-                flag_states=states,
-            )
-        # All 4 flags mapped
-        self.assertEqual(len(graphql_calls), 4)
-        self.assertEqual(applied["implemented"], "green")
-        self.assertEqual(applied["tested"], "yellow")
-        self.assertEqual(applied["codeConnect"], "gray")
-        self.assertEqual(applied["wiki"], "green")
-
-    def test_unknown_flag_is_skipped(self):
-        with patch.object(update_issue.subprocess, "run", return_value=_mock_gh_result(json.dumps({"data": {}}))) as mock_run:
-            applied = update_issue.sync_project_fields(
-                item_id="I",
-                flag_states={"implemented": "green", "bogus": "green"},
-            )
-        self.assertIn("implemented", applied)
-        self.assertNotIn("bogus", applied)
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)