@mmerterden/multi-agent-pipeline 8.6.0

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

@@ -0,0 +1,343 @@
+"""Unit tests for backfill-status.py.
+
+Covers the pure decision function and the full run_backfill orchestration
+with a synthetic sources tree.
+
+Run: python3 -m unittest test_backfill_status.py
+"""
+
+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(
+    "backfill_status", SCRIPTS_DIR / "backfill-status.py"
+)
+backfill_status = importlib.util.module_from_spec(spec)
+sys.modules["backfill_status"] = backfill_status
+spec.loader.exec_module(backfill_status)
+
+
+class BuildSwiftFileIndexTests(unittest.TestCase):
+    def test_index_walks_sources(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            (root / "UI/Buttons").mkdir(parents=True)
+            (root / "UI/Cards").mkdir(parents=True)
+            (root / "UI/Buttons/Button.swift").write_text("struct Button {}")
+            (root / "UI/Cards/Card.swift").write_text("struct Card {}")
+            index = backfill_status.build_swift_file_index(root)
+            self.assertIn("Button", index)
+            self.assertIn("Card", index)
+            self.assertTrue(str(index["Button"]).endswith("Button.swift"))
+
+    def test_index_ignores_non_swift(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            (root / "README.md").write_text("# hi")
+            (root / "Script.py").write_text("pass")
+            index = backfill_status.build_swift_file_index(root)
+            self.assertEqual(index, {})
+
+    def test_index_nonexistent_dir_returns_empty(self):
+        index = backfill_status.build_swift_file_index(Path("/nope"))
+        self.assertEqual(index, {})
+
+
+class DecideBackfillTests(unittest.TestCase):
+    def test_skip_entry_marked_skip(self):
+        entry = {"nodeId": "1:1", "componentName": {"ios": "Button"}, "skip": True}
+        index = {"Button": Path("/fake/Button.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "skip_marked_skip")
+        self.assertEqual(d["codeconnect_action"], "skip_marked_skip")
+
+    def test_skip_entry_with_existing_status(self):
+        entry = {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "status": {
+                "ios": {
+                    "implemented": {"value": True, "version": 2, "hash": None, "at": "..."},
+                },
+            },
+        }
+        index = {"Button": Path("/fake/Button.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "skip_existing_status")
+        self.assertEqual(d["codeconnect_action"], "skip_existing_status")
+
+    def test_skip_when_no_component_name_ios(self):
+        entry = {"nodeId": "1:1", "componentName": {"android": "Button"}}
+        index = {}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "skip_no_name")
+
+    def test_skip_when_no_swift_file(self):
+        entry = {"nodeId": "1:1", "componentName": {"ios": "MissingButton"}}
+        index = {"OtherButton": Path("/fake/OtherButton.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "skip_no_swift")
+        self.assertEqual(d["codeconnect_action"], "skip_no_impl")
+
+    def test_set_impl_with_legacy_cc_true(self):
+        entry = {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "codeConnect": {"ios": True, "android": False},
+        }
+        index = {"Button": Path("/fake/Button.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "set")
+        self.assertEqual(d["codeconnect_action"], "set")
+        self.assertTrue(d["swift_path"].endswith("Button.swift"))
+
+    def test_set_impl_with_legacy_cc_false(self):
+        entry = {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "codeConnect": {"ios": False, "android": False},
+        }
+        index = {"Button": Path("/fake/Button.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "set")
+        self.assertEqual(d["codeconnect_action"], "skip_legacy_false")
+
+    def test_set_impl_without_legacy_cc_block(self):
+        entry = {"nodeId": "1:1", "componentName": {"ios": "Button"}}
+        index = {"Button": Path("/fake/Button.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "set")
+        self.assertEqual(d["codeconnect_action"], "skip_legacy_false")
+
+    def test_legacy_status_string_is_skipped(self):
+        # Real registry data has entries like {"status": "implemented"}
+        entry = {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "status": "implemented",
+            "codeConnect": {"ios": True, "android": False},
+        }
+        index = {"Button": Path("/fake/Button.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "skip_legacy_status_string")
+        self.assertEqual(d["codeconnect_action"], "skip_legacy_status_string")
+
+    def test_component_name_as_bare_string(self):
+        # Legacy entries have componentName as "ButtonScan" not a dict
+        entry = {
+            "nodeId": "1:1",
+            "componentName": "ButtonScan",
+            "codeConnect": {"ios": True, "android": False},
+        }
+        index = {"ButtonScan": Path("/fake/ButtonScan.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "set")
+        self.assertEqual(d["component_name_ios"], "ButtonScan")
+
+    def test_non_dict_codeconnect_treated_as_missing(self):
+        entry = {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "codeConnect": "legacy_string",
+        }
+        index = {"Button": Path("/fake/Button.swift")}
+        d = backfill_status.decide_backfill(entry, index)
+        self.assertEqual(d["impl_action"], "set")
+        self.assertEqual(d["codeconnect_action"], "skip_legacy_false")
+
+
+class RunBackfillTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.registry = self.root / "registry"
+        self.sources = self.root / "sources"
+        self.registry.mkdir()
+        self.sources.mkdir()
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _write_reg(self, filename: str, data: dict):
+        (self.registry / filename).write_text(json.dumps(data))
+
+    def _write_swift(self, rel_path: str):
+        p = self.sources / rel_path
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text("// stub\n")
+
+    def test_dry_run_makes_no_writes(self):
+        self._write_reg("1-1.json", {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "codeConnect": {"ios": True, "android": False},
+        })
+        self._write_swift("UI/Button.swift")
+
+        summary = backfill_status.run_backfill(
+            registry_dir=self.registry,
+            sources_dir=self.sources,
+            dry_run=True,
+        )
+
+        self.assertEqual(summary["status"], "ok")
+        self.assertTrue(summary["dry_run"])
+        self.assertEqual(summary["total_files"], 1)
+        self.assertEqual(summary["swift_files_indexed"], 1)
+
+        # Original file untouched
+        data = json.loads((self.registry / "1-1.json").read_text())
+        self.assertNotIn("status", data)
+
+    def test_real_run_writes_status_block(self):
+        self._write_reg("1-1.json", {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "codeConnect": {"ios": True, "android": False},
+            "confluence": {"page": None, "ios": None, "android": None},
+            "testingIdentifiers": [],
+            "localizationKeys": [],
+            "accessibilityKeys": [],
+            "analyticsEvents": [],
+            "fileKey": "abc",
+        })
+        self._write_swift("UI/Button.swift")
+
+        summary = backfill_status.run_backfill(
+            registry_dir=self.registry,
+            sources_dir=self.sources,
+            dry_run=False,
+        )
+        self.assertEqual(summary["status"], "ok")
+
+        data = json.loads((self.registry / "1-1.json").read_text())
+        self.assertTrue(data["status"]["ios"]["implemented"]["value"])
+        self.assertEqual(data["status"]["ios"]["implemented"]["version"], 1)
+        self.assertTrue(data["status"]["ios"]["codeConnect"]["value"])
+        self.assertEqual(data["status"]["ios"]["codeConnect"]["against"], 1)
+        # Legacy field preserved
+        self.assertTrue(data["codeConnect"]["ios"])
+        # Other legacy fields intact
+        self.assertEqual(data["fileKey"], "abc")
+        self.assertEqual(data["componentName"], {"ios": "Button"})
+
+    def test_real_run_skips_component_without_swift_file(self):
+        self._write_reg("1-1.json", {
+            "nodeId": "1:1",
+            "componentName": {"ios": "MissingButton"},
+            "codeConnect": {"ios": False, "android": False},
+        })
+        # No Swift file written
+
+        summary = backfill_status.run_backfill(
+            registry_dir=self.registry,
+            sources_dir=self.sources,
+            dry_run=False,
+        )
+        self.assertEqual(summary["status"], "ok")
+
+        data = json.loads((self.registry / "1-1.json").read_text())
+        self.assertNotIn("status", data)  # nothing written
+
+    def test_real_run_skips_component_marked_skip(self):
+        self._write_reg("1-1.json", {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "codeConnect": {"ios": True, "android": False},
+            "skip": True,
+        })
+        self._write_swift("UI/Button.swift")
+
+        backfill_status.run_backfill(
+            registry_dir=self.registry,
+            sources_dir=self.sources,
+            dry_run=False,
+        )
+        data = json.loads((self.registry / "1-1.json").read_text())
+        self.assertNotIn("status", data)
+
+    def test_real_run_sets_impl_but_not_cc_when_legacy_cc_false(self):
+        self._write_reg("1-1.json", {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "codeConnect": {"ios": False, "android": False},
+        })
+        self._write_swift("UI/Button.swift")
+
+        backfill_status.run_backfill(
+            registry_dir=self.registry,
+            sources_dir=self.sources,
+            dry_run=False,
+        )
+        data = json.loads((self.registry / "1-1.json").read_text())
+        self.assertTrue(data["status"]["ios"]["implemented"]["value"])
+        self.assertFalse(data["status"]["ios"]["codeConnect"]["value"])
+        self.assertFalse(data["codeConnect"]["ios"])
+
+    def test_limit_honoured(self):
+        for i in range(5):
+            self._write_reg(f"1-{i}.json", {
+                "nodeId": f"1:{i}",
+                "componentName": {"ios": f"Comp{i}"},
+                "codeConnect": {"ios": True, "android": False},
+            })
+            self._write_swift(f"UI/Comp{i}.swift")
+
+        summary = backfill_status.run_backfill(
+            registry_dir=self.registry,
+            sources_dir=self.sources,
+            dry_run=False,
+            limit=2,
+        )
+        self.assertEqual(summary["total_files"], 2)
+
+        # Verify only the first 2 (alphabetical: 1-0, 1-1) got a status block
+        written_count = 0
+        for i in range(5):
+            data = json.loads((self.registry / f"1-{i}.json").read_text())
+            if "status" in data:
+                written_count += 1
+        self.assertEqual(written_count, 2)
+
+    def test_existing_status_is_not_overwritten(self):
+        self._write_reg("1-1.json", {
+            "nodeId": "1:1",
+            "componentName": {"ios": "Button"},
+            "codeConnect": {"ios": True, "android": False},
+            "status": {
+                "ios": {
+                    "stale": False,
+                    "implemented": {"value": True, "version": 7, "hash": "sha256:existing", "at": "2026-03-01T00:00:00Z"},
+                    "tested": {"value": True, "against": 7, "at": "..."},
+                    "codeConnect": {"value": True, "against": 7, "at": "..."},
+                    "wiki": {"value": True, "against": 7, "at": "..."},
+                },
+                "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},
+                },
+            },
+        })
+        self._write_swift("UI/Button.swift")
+
+        backfill_status.run_backfill(
+            registry_dir=self.registry,
+            sources_dir=self.sources,
+            dry_run=False,
+        )
+        data = json.loads((self.registry / "1-1.json").read_text())
+        # Version untouched
+        self.assertEqual(data["status"]["ios"]["implemented"]["version"], 7)
+        self.assertEqual(data["status"]["ios"]["implemented"]["hash"], "sha256:existing")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

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

@@ -0,0 +1,206 @@
+"""Unit tests for figma-update.py.
+
+Tests only the pure logic (scan_registry_for_file_keys, update_file_components)
+and the top-level orchestration with `fetch_file_last_modified` monkey-patched.
+No real network calls.
+
+Run: python3 -m unittest test_figma_update.py
+"""
+
+import importlib.util
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+# Load figma-update.py as a module (its filename has a dash so it's not a
+# normal import target).
+SCRIPTS_DIR = Path(__file__).parent.parent
+spec = importlib.util.spec_from_file_location(
+    "figma_update", SCRIPTS_DIR / "figma-update.py"
+)
+figma_update = importlib.util.module_from_spec(spec)
+sys.modules["figma_update"] = figma_update
+spec.loader.exec_module(figma_update)
+
+
+class ScanRegistryTests(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, filename: str, data: dict):
+        (self.registry_dir / filename).write_text(json.dumps(data))
+
+    def test_scan_empty_dir(self):
+        result = figma_update.scan_registry_for_file_keys(self.registry_dir)
+        self.assertEqual(result, {})
+
+    def test_scan_groups_by_file_key(self):
+        self._write("1-1.json", {"nodeId": "1:1", "fileKey": "FILEA"})
+        self._write("1-2.json", {"nodeId": "1:2", "fileKey": "FILEA"})
+        self._write("2-1.json", {"nodeId": "2:1", "fileKey": "FILEB"})
+        result = figma_update.scan_registry_for_file_keys(self.registry_dir)
+        self.assertEqual(sorted(result["FILEA"]), ["1:1", "1:2"])
+        self.assertEqual(result["FILEB"], ["2:1"])
+
+    def test_scan_skips_invalid_json(self):
+        (self.registry_dir / "bad.json").write_text("{not json")
+        self._write("good.json", {"nodeId": "1:1", "fileKey": "F"})
+        result = figma_update.scan_registry_for_file_keys(self.registry_dir)
+        self.assertEqual(result, {"F": ["1:1"]})
+
+    def test_scan_skips_entries_missing_nodeid_or_filekey(self):
+        self._write("orphan1.json", {"nodeId": "1:1"})  # no fileKey
+        self._write("orphan2.json", {"fileKey": "F"})  # no nodeId
+        self._write("good.json", {"nodeId": "2:2", "fileKey": "G"})
+        result = figma_update.scan_registry_for_file_keys(self.registry_dir)
+        self.assertEqual(result, {"G": ["2:2"]})
+
+    def test_scan_missing_dir(self):
+        result = figma_update.scan_registry_for_file_keys(Path("/nonexistent/path"))
+        self.assertEqual(result, {})
+
+
+class UpdateFileComponentsTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.registry_dir = Path(self.tmp.name)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _seed(self, node_id: str, **extra):
+        path = self.registry_dir / f"{node_id.replace(':', '-')}.json"
+        data = {"nodeId": node_id, "fileKey": "FILEA"}
+        data.update(extra)
+        # Seed an implemented flag so mark_stale actually flips it
+        data["status"] = {
+            "ios": {
+                "stale": False,
+                "implemented": {"value": True, "version": 1, "hash": None, "at": "2026-04-01T00:00:00Z"},
+                "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},
+            },
+        }
+        path.write_text(json.dumps(data))
+
+    def test_real_write_marks_implemented_platforms_stale(self):
+        self._seed("1:1")
+        self._seed("1:2")
+
+        summary = figma_update.update_file_components(
+            registry_dir=self.registry_dir,
+            file_key="FILEA",
+            node_ids=["1:1", "1:2"],
+            new_last_modified="2026-04-15T10:00:00Z",
+            dry_run=False,
+        )
+
+        self.assertEqual(sorted(summary["updated"]), ["1:1", "1:2"])
+        self.assertEqual(summary["skipped"], [])
+
+        for nid in ("1-1", "1-2"):
+            data = json.loads((self.registry_dir / f"{nid}.json").read_text())
+            self.assertTrue(data["status"]["ios"]["stale"])
+            self.assertFalse(data["status"]["android"]["stale"])  # android wasn't implemented
+            self.assertEqual(data["figmaUpdatedAt"], "2026-04-15T10:00:00Z")
+
+    def test_real_write_skips_when_figma_is_older(self):
+        self._seed("1:1", figmaUpdatedAt="2026-04-20T00:00:00Z")
+
+        summary = figma_update.update_file_components(
+            registry_dir=self.registry_dir,
+            file_key="FILEA",
+            node_ids=["1:1"],
+            new_last_modified="2026-04-10T00:00:00Z",
+            dry_run=False,
+        )
+        self.assertEqual(summary["updated"], [])
+        self.assertEqual(summary["skipped"], ["1:1"])
+
+        data = json.loads((self.registry_dir / "1-1.json").read_text())
+        self.assertFalse(data["status"]["ios"]["stale"])
+        self.assertEqual(data["figmaUpdatedAt"], "2026-04-20T00:00:00Z")
+
+    def test_dry_run_does_not_write(self):
+        self._seed("1:1")
+        summary = figma_update.update_file_components(
+            registry_dir=self.registry_dir,
+            file_key="FILEA",
+            node_ids=["1:1"],
+            new_last_modified="2026-04-15T10:00:00Z",
+            dry_run=True,
+        )
+        self.assertEqual(summary["updated"], ["1:1"])
+
+        data = json.loads((self.registry_dir / "1-1.json").read_text())
+        self.assertFalse(data["status"]["ios"]["stale"])  # NOT written
+        self.assertNotIn("figmaUpdatedAt", data)
+
+    def test_dry_run_correctly_identifies_skippable_nodes(self):
+        self._seed("1:1", figmaUpdatedAt="2026-04-20T00:00:00Z")
+        summary = figma_update.update_file_components(
+            registry_dir=self.registry_dir,
+            file_key="FILEA",
+            node_ids=["1:1"],
+            new_last_modified="2026-04-10T00:00:00Z",
+            dry_run=True,
+        )
+        self.assertEqual(summary["updated"], [])
+        self.assertEqual(summary["skipped"], ["1:1"])
+
+    def test_limit_truncates_node_list(self):
+        for i in range(5):
+            self._seed(f"1:{i}")
+
+        summary = figma_update.update_file_components(
+            registry_dir=self.registry_dir,
+            file_key="FILEA",
+            node_ids=[f"1:{i}" for i in range(5)],
+            new_last_modified="2026-04-15T10:00:00Z",
+            dry_run=False,
+            limit=2,
+        )
+        self.assertEqual(len(summary["updated"]), 2)
+        # Nodes 2, 3, 4 should still have no figmaUpdatedAt
+        for untouched in ("1-2", "1-3", "1-4"):
+            data = json.loads((self.registry_dir / f"{untouched}.json").read_text())
+            self.assertNotIn("figmaUpdatedAt", data)
+
+    def test_missing_registry_file_is_skipped(self):
+        summary = figma_update.update_file_components(
+            registry_dir=self.registry_dir,
+            file_key="FILEA",
+            node_ids=["99:99"],
+            new_last_modified="2026-04-15T10:00:00Z",
+            dry_run=False,
+        )
+        self.assertEqual(summary["updated"], [])
+        self.assertEqual(summary["skipped"], ["99:99"])
+
+
+class FetchFunctionExistsTests(unittest.TestCase):
+    """Smoke-check the HTTP helper has the right signature — do NOT call it."""
+
+    def test_fetch_file_last_modified_exists(self):
+        self.assertTrue(callable(figma_update.fetch_file_last_modified))
+
+    def test_load_figma_token_exists(self):
+        self.assertTrue(callable(figma_update.load_figma_token))
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)