@mmerterden/multi-agent-pipeline 8.6.0

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

@@ -0,0 +1,298 @@
+"""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

@@ -0,0 +1,195 @@
+"""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)