@polderlabs/bizar-omp 0.2.0 → 0.3.0

package/skills/omp-native-development/scripts/test_tools.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""Offline unit tests. These test the skill utilities, not OMP runtime behavior."""
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+from pathlib import Path
+import subprocess
+import tempfile
+import unittest
+from unittest.mock import patch
+
+import audit_role_config as role
+import omp_docs as docs
+
+
+class RoleAuditTests(unittest.TestCase):
+    def test_nested_role_profile(self):
+        self.assertTrue(role.audit({"modelRoles": {"bizar_build": "@task"}}, ["bizar_build"], [])['static_ok'])
+
+    def test_actual_config_list_shape(self):
+        config = {"modelRoles": {"value": {"bizar_build": "@task"}, "type": "record", "description": "roles"},
+                  "task.agentModelOverrides": {"value": {"Builder": "@bizar_build"}, "type": "record"}}
+        self.assertTrue(role.audit(config, ["bizar_build"], ["Builder"])['static_ok'])
+
+    def test_dotted_settings(self):
+        config = {"modelRoles": {"review": "@slow"}, "task.agentModelOverrides": {"reviewer": "@review"}}
+        self.assertTrue(role.audit(config, [], ["reviewer"])['static_ok'])
+
+    def test_required_role_missing(self):
+        self.assertFalse(role.audit({}, ["bizar_build"], [])['static_ok'])
+
+    def test_builtin_does_not_need_mapping(self):
+        self.assertTrue(role.audit({}, ["tiny"], [])['static_ok'])
+
+    def test_unknown_role_alias(self):
+        self.assertFalse(role.audit({"modelRoles": {"build": "@unknown"}}, [], [])['static_ok'])
+
+    def test_cycle_is_explicitly_bizar_policy(self):
+        result = role.audit({"modelRoles": {"a": "@b", "b": "@a"}}, [], [])
+        self.assertIn("BIZAR_POLICY_CYCLE", [e['code'] for e in result['errors']])
+
+    def test_self_cycle(self):
+        self.assertFalse(role.audit({"modelRoles": {"a": "@a"}}, [], [])['static_ok'])
+
+    def test_legacy_alias_warning_not_error(self):
+        result = role.audit({"modelRoles": {"a": "pi/slow"}}, [], [])
+        self.assertTrue(result['static_ok'])
+        self.assertIn("LEGACY_ALIAS", [w['code'] for w in result['warnings']])
+
+    def test_model_colons_and_routes_not_misparsed_as_roles(self):
+        result = role.audit({"modelRoles": {"a": "provider/model:variant@upstream"}}, [], [])
+        self.assertTrue(result['static_ok'])
+        self.assertFalse(result['native_resolution_tested'])
+
+    def test_outer_role_effort(self):
+        self.assertEqual(role.referenced_roles("@slow:high"), ["slow"])
+        self.assertEqual(role.referenced_roles("@team.review:high"), ["team.review"])
+        self.assertEqual(role.referenced_roles("@team/review"), ["team/review"])
+
+    def test_service_tier_not_effort(self):
+        self.assertFalse(role.audit({"task": {"agentServiceTierOverrides": {"a": "high"}}}, [], ["a"])['static_ok'])
+
+    def test_valid_tier_still_not_native_qualified(self):
+        report = role.audit({"task": {"agentServiceTierOverrides": {"a": "priority"}}}, [], ["a"])
+        self.assertTrue(report['static_ok'])
+        self.assertFalse(report['native_resolution_tested'])
+
+    def test_exact_agent_names(self):
+        self.assertFalse(role.audit({"task": {"agentModelOverrides": {"A": "@slow"}}}, [], ["a"])['static_ok'])
+
+    def test_template_placeholder_rejected(self):
+        self.assertFalse(role.audit({"modelRoles": {"a": "YOUR_PROVIDER/YOUR_MODEL"}}, [], [])['static_ok'])
+
+    def test_credentials_not_echoed(self):
+        cfg = {"auth.broker.token": {"type": "string", "value": "secret-test-string"},
+               "modelRoles": {"a": "@task"}}
+        self.assertNotIn("secret-test-string", json.dumps(role.audit(cfg, [], [])))
+
+    def test_redacted_metadata(self):
+        self.assertEqual(role.get_value({"auth": {"type": "string", "redacted": True}}, "auth", None), None)
+
+    def test_bad_record_and_bad_storage(self):
+        self.assertFalse(role.audit({"modelRoles": []}, [], [])['static_ok'])
+        self.assertFalse(role.audit({"modelRoleStorage": {}}, [], [])['static_ok'])
+
+    def test_prewalk_requires_quoted_string(self):
+        self.assertFalse(role.audit({"task": {"agentPrewalk": {"a": True}}}, [], [])['static_ok'])
+
+    def test_advisor_configured_role(self):
+        cfg = {"modelRoles": {"r": "@slow"}, "task": {"agentAdvisor": {"a": "@r"}}}
+        self.assertTrue(role.audit(cfg, [], ["a"])['static_ok'])
+
+
+class CorpusTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.data = b"# Task\nNative modelRoles and agents.\n"
+        self.entry = {"path": "docs/task.md", "git_blob_sha1": docs.git_blob_hash(self.data), "url": "https://example.invalid/task.md"}
+        self.manifest = {"schema_version": 1, "repository": docs.REPOSITORY, "commit": "a" * 40, "files": [self.entry]}
+        self.mp = self.root / "manifest.json"
+        self.mp.write_text(json.dumps(self.manifest))
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def test_git_blob_format(self):
+        p = subprocess.run(["git", "hash-object", "--stdin"], input=self.data, capture_output=True, check=True)
+        self.assertEqual(docs.git_blob_hash(self.data), p.stdout.decode().strip())
+
+    def test_manifest_loaded(self):
+        self.assertEqual(docs.load_manifest(self.mp)['commit'], 'a' * 40)
+
+    def test_bad_repository_rejected(self):
+        self.manifest['repository'] = 'other/repo'
+        self.mp.write_text(json.dumps(self.manifest))
+        with self.assertRaises(docs.CorpusError):
+            docs.load_manifest(self.mp)
+
+    def test_moving_branch_pin_rejected(self):
+        self.manifest['commit'] = 'main'
+        self.mp.write_text(json.dumps(self.manifest))
+        with self.assertRaises(docs.CorpusError):
+            docs.load_manifest(self.mp)
+
+    def test_duplicate_manifest_entry_rejected(self):
+        self.manifest['files'].append(self.entry)
+        self.mp.write_text(json.dumps(self.manifest))
+        with self.assertRaises(docs.CorpusError):
+            docs.load_manifest(self.mp)
+
+    def test_path_traversal_rejected(self):
+        for name in ('../evil', '/absolute', 'docs/../evil', 'C:\\evil', 'docs//task.md', './docs/a.md'):
+            with self.subTest(name=name), self.assertRaises(docs.CorpusError):
+                docs.safe_path(self.root, name)
+
+    def test_symlink_rejected(self):
+        (self.root / 'docs').symlink_to(self.root, target_is_directory=True)
+        with self.assertRaises(docs.CorpusError):
+            docs.safe_path(self.root, 'docs/task.md')
+
+    def test_html_and_corruption_rejected(self):
+        with self.assertRaises(docs.CorpusError):
+            docs.checked_bytes(self.entry, b'<html>redirect or error</html>')
+
+    def test_missing_corpus_not_complete(self):
+        self.assertFalse(docs.verify(self.manifest, self.root)['complete'])
+
+    def test_atomic_no_overwrite(self):
+        p = self.root / 'a.md'
+        docs.write_new(p, b'one')
+        with self.assertRaises(FileExistsError):
+            docs.write_new(p, b'two')
+        self.assertEqual(p.read_bytes(), b'one')
+
+    def test_mock_http_happy_path(self):
+        with patch.object(docs, 'urlopen', return_value=io.BytesIO(self.data)) as request:
+            self.assertEqual(docs.fetch_file(self.manifest, self.entry, None), self.data)
+            self.assertIn('/' + 'a'*40 + '/docs/task.md', request.call_args.args[0].full_url)
+
+    def test_mock_http_wrong_hash(self):
+        with patch.object(docs, 'urlopen', return_value=io.BytesIO(b'wrong')):
+            with self.assertRaises(docs.CorpusError):
+                docs.fetch_file(self.manifest, self.entry, None)
+
+    def test_mock_http_timeout(self):
+        with patch.object(docs, 'urlopen', side_effect=TimeoutError('fixture timeout')):
+            with self.assertRaises(TimeoutError):
+                docs.fetch_file(self.manifest, self.entry, None)
+
+    def test_sync_and_verify(self):
+        out = self.root / 'corpus'
+        with patch.object(docs, 'urlopen', return_value=io.BytesIO(self.data)):
+            self.assertEqual(docs.sync(self.manifest, out, None)['fetched'], 1)
+        self.assertTrue(docs.verify(self.manifest, out)['complete'])
+        self.assertEqual(docs.sync(self.manifest, out, None)['reused'], 1)
+
+    def test_cli_search_read_and_partial_failure(self):
+        out = self.root / 'corpus'
+        stdout, stderr = io.StringIO(), io.StringIO()
+        with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+            self.assertEqual(docs.main(['--manifest',str(self.mp),'verify','--root',str(out)]),1)
+            self.assertEqual(docs.main(['--manifest',str(self.mp),'search','--root',str(out),'modelRoles']),1)
+        docs.write_new(out / 'docs/task.md', self.data)
+        with contextlib.redirect_stdout(io.StringIO()) as output:
+            self.assertEqual(docs.main(['--manifest',str(self.mp),'search','--root',str(out),'modelRoles']),0)
+        self.assertEqual(json.loads(output.getvalue())['matches'][0]['line'],2)
+        with contextlib.redirect_stdout(io.StringIO()) as output:
+            self.assertEqual(docs.main(['--manifest',str(self.mp),'read','--root',str(out),'docs/task.md','--start','2']),0)
+        self.assertIn('2: Native modelRoles',output.getvalue())
+
+    def test_local_git_end_to_end_and_drift(self):
+        repo = self.root / 'repo'
+        repo.mkdir()
+        def run(*args):
+            return subprocess.run(['git','-C',str(repo),*args],capture_output=True,check=True).stdout
+        run('init','-q')
+        run('config','user.email','fixture@example.invalid')
+        run('config','user.name','Fixture')
+        (repo / 'docs').mkdir()
+        (repo / 'docs/task.md').write_bytes(self.data)
+        run('add','docs/task.md')
+        run('commit','-qm','fixture')
+        self.manifest['commit'] = run('rev-parse','HEAD').decode().strip()
+        self.mp.write_text(json.dumps(self.manifest))
+        out = self.root / 'corpus'
+        self.assertEqual(docs.sync(self.manifest,out,repo)['fetched'],1)
+        (repo / 'docs/task.md').write_bytes(b'Changed\n')
+        run('add','docs/task.md')
+        run('commit','-qm','changed')
+        with contextlib.redirect_stdout(io.StringIO()) as output:
+            self.assertEqual(docs.main(['--manifest',str(self.mp),'drift','--repo',str(repo)]),0)
+        report=json.loads(output.getvalue())
+        self.assertFalse(report['same_commit'])
+        self.assertEqual(len(report['changed_or_missing']),1)
+        self.assertTrue(docs.verify(self.manifest,out)['complete'])
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)