bigpowers 2.76.3 → 2.77.1

package/tests/test_srp_engine.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""tests/test_srp_engine.py — unit tests for rewrite_links_for_pi and link_utils.
+
+Run: python3 -m pytest tests/test_srp_engine.py -v
+  or: python3 tests/test_srp_engine.py
+"""
+import os
+import sys
+import unittest
+
+# Make scripts/lib importable without installation.
+_REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_LIB = os.path.join(_REPO_ROOT, "scripts", "lib")
+sys.path.insert(0, _LIB)
+sys.path.insert(0, os.path.join(_REPO_ROOT, "scripts"))
+
+# srp-engine.py has a hyphen so we load it via importlib.
+import importlib.util as _ilu
+_spec = _ilu.spec_from_file_location("srp_engine", os.path.join(_LIB, "srp-engine.py"))
+_srp = _ilu.module_from_spec(_spec)
+sys.modules["srp_engine"] = _srp
+_spec.loader.exec_module(_srp)
+
+from srp_engine import rewrite_links_for_pi  # type: ignore[import]
+from link_utils import strip_code_spans, LINK_RE, MACHINE_PATH_RE
+
+
+class TestStripCodeSpans(unittest.TestCase):
+    def test_fenced_block_blanked(self):
+        md = "Before.\n```\n[fake](fake.md)\n```\nAfter."
+        shadow = strip_code_spans(md)
+        self.assertNotIn("[fake](fake.md)", shadow)
+        self.assertEqual(len(shadow), len(md))  # positions preserved
+
+    def test_inline_code_blanked(self):
+        md = "Use `[x](y.md)` as an example."
+        shadow = strip_code_spans(md)
+        self.assertNotIn("[x](y.md)", shadow)
+        self.assertEqual(len(shadow), len(md))
+
+    def test_real_link_survives(self):
+        md = "See [docs](guide.md) for details."
+        shadow = strip_code_spans(md)
+        self.assertIn("[docs](guide.md)", shadow)
+
+
+class TestLinkRE(unittest.TestCase):
+    def test_plain_link(self):
+        m = LINK_RE.search("[text](target.md)")
+        self.assertIsNotNone(m)
+        self.assertEqual(m.group(2), "target.md")
+
+    def test_link_with_title(self):
+        m = LINK_RE.search('[text](target.md "My Title")')
+        self.assertIsNotNone(m)
+        self.assertEqual(m.group(2), "target.md")
+
+    def test_link_with_fragment(self):
+        m = LINK_RE.search("[text](doc.md#section)")
+        self.assertIsNotNone(m)
+        self.assertEqual(m.group(2), "doc.md#section")
+
+    def test_no_match_on_image(self):
+        # Image links (![...](url)) contain the same syntax — LINK_RE will match
+        # the inner part; they should be treated as pass-through by callers.
+        m = LINK_RE.search("![alt](image.png)")
+        # The regex matches the inner ](url) portion — callers must handle images.
+        self.assertIsNotNone(m)
+
+
+class TestMachinePathRE(unittest.TestCase):
+    def test_file_uri(self):
+        self.assertTrue(MACHINE_PATH_RE.search("file:///Users/alice/project"))
+
+    def test_macos_path(self):
+        self.assertTrue(MACHINE_PATH_RE.search("/Users/alice/project"))
+
+    def test_linux_path(self):
+        self.assertTrue(MACHINE_PATH_RE.search("/home/alice/project"))
+
+    def test_windows_path_single_backslash(self):
+        self.assertTrue(MACHINE_PATH_RE.search("C:\\Users\\alice"))
+
+    def test_github_url_not_flagged(self):
+        self.assertFalse(
+            MACHINE_PATH_RE.search("https://github.com/danielvm-git/bigpowers")
+        )
+
+
+class TestRewriteLinksForPi(unittest.TestCase):
+    """Tests run without a real repo tree — path existence is irrelevant here;
+    we only verify that the URL construction logic is correct."""
+
+    NAME = "my-skill"
+
+    def _rw(self, body):
+        return rewrite_links_for_pi(body, self.NAME)
+
+    def test_external_link_untouched(self):
+        body = "[docs](https://example.com)"
+        self.assertEqual(self._rw(body), body)
+
+    def test_anchor_only_untouched(self):
+        body = "[section](#heading)"
+        self.assertEqual(self._rw(body), body)
+
+    def test_absolute_path_untouched(self):
+        body = "[root](/absolute/path.md)"
+        self.assertEqual(self._rw(body), body)
+
+    def test_relative_link_repointed(self):
+        body = "[ref](REFERENCE.md)"
+        result = self._rw(body)
+        # Must not contain the original bare target
+        self.assertNotIn("](REFERENCE.md)", result)
+        # Must be a relative path targeting the skills source tree
+        self.assertIn("REFERENCE.md", result)
+
+    def test_fragment_preserved(self):
+        body = "[section](REFERENCE.md#anchor)"
+        result = self._rw(body)
+        self.assertIn("#anchor", result)
+        # Fragment must not be mangled into a path component
+        self.assertNotIn("anchor" + os.sep, result)
+
+    def test_link_with_title_attribute(self):
+        body = '[ref](REFERENCE.md "My Title")'
+        result = self._rw(body)
+        # Must not be left unrewritten
+        self.assertNotIn("](REFERENCE.md", result)
+
+    def test_code_block_links_not_rewritten(self):
+        body = "Real: [ref](REFERENCE.md)\n\n```\n[fake](nowhere.md)\n```\n"
+        result = self._rw(body)
+        # The real link should be rewritten
+        self.assertNotIn("](REFERENCE.md)", result)
+        # The code-block link must be untouched
+        self.assertIn("[fake](nowhere.md)", result)
+
+    def test_inline_code_link_not_rewritten(self):
+        body = "Example: `[x](bad.md)` — real [ref](REFERENCE.md)."
+        result = self._rw(body)
+        self.assertIn("[x](bad.md)", result)  # inline code preserved
+        self.assertNotIn("](REFERENCE.md)", result)  # real link rewritten
+
+
+if __name__ == "__main__":
+    unittest.main()