fable-engine 1.3.1__py3-none-any.whl

tests/test_packaging_runtime.py

@@ -0,0 +1,194 @@
+import json
+import os
+import stat
+import subprocess
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from fable_mode import __version__
+from fable_mode.adapters import Host, RegistrationError, detect_hosts, register_hosts, run_argv
+from fable_mode.installer import InstallError, Installer, verify_installation
+from fable_mode.launcher import _smoke
+
+
+class PackagingSecurityTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def test_top_level_wrapper_is_package_aware(self):
+        wrapper = Path(__file__).resolve().parents[1] / "fable_mode_entry.py"
+        result = subprocess.run([sys.executable, str(wrapper), "--version"], capture_output=True, text=True, check=True)
+        self.assertEqual(result.stdout.strip(), __version__)
+
+    def test_unattended_install_requires_confirmation(self):
+        wrapper = Path(__file__).resolve().parents[1] / "fable_mode_entry.py"
+        result = subprocess.run([sys.executable, str(wrapper), "install", "--install-dir", str(self.root / "i")],
+                                capture_output=True, text=True)
+        self.assertEqual(result.returncode, 2)
+        self.assertFalse((self.root / "i").exists())
+
+    def test_unmarked_target_and_source_link_are_refused(self):
+        target = self.root / "target"
+        target.mkdir(); (target / "keep").write_text("keep")
+        with self.assertRaises(InstallError):
+            Installer(target).install()
+        with self.assertRaises(InstallError):
+            Installer(target).uninstall()
+        source = self.root / "source"
+        source.mkdir()
+        # An explicit source override cannot smuggle a symlinked canonical file.
+        (source / "fable_mode").mkdir()
+        try:
+            os.symlink("/etc/passwd", source / "fable_mode" / "__init__.py")
+        except OSError as exc:
+            if getattr(exc, "winerror", None) == 1314 or isinstance(exc, (PermissionError, NotImplementedError)):
+                self.skipTest("Symlink creation requires elevated privilege on Windows")
+            raise
+        with self.assertRaises(InstallError):
+            Installer(self.root / "i", source=source).install()
+
+    def test_transaction_rolls_back_previous_install(self):
+        target = self.root / "i"
+        first = Installer(target).install(); first.transaction.commit()
+        marker_before = (target / ".fable-install.json").read_bytes()
+        # Make the target look valid but break source before second publish.
+        source = self.root / "missing-source"
+        with self.assertRaises(InstallError):
+            Installer(target, source=source).install()
+        self.assertEqual(marker_before, (target / ".fable-install.json").read_bytes())
+        self.assertTrue(verify_installation(target)[0])
+
+    def test_dry_run_has_no_changes(self):
+        target = self.root / "i"
+        result = Installer(target).install(dry_run=True)
+        self.assertFalse(target.exists())
+        self.assertEqual(result.mode, "source")
+
+    def test_config_preserves_keys_and_rejects_links(self):
+        home = self.root / "home"
+        config = home / ".gemini/config/mcp_config.json"
+        config.parent.mkdir(parents=True)
+        config.write_text(json.dumps({"keep": {"x": 1}, "mcpServers": {"old": {}}}))
+        exe = self.root / "fable"; exe.write_text(""); exe.chmod(0o700)
+        host = Host("antigravity", exe, "cli", True)
+        register_hosts({"antigravity": host}, [str(exe), "serve"], home=home)
+        value = json.loads(config.read_text())
+        self.assertEqual(value["keep"], {"x": 1})
+        self.assertNotIn("fable-mode", value["mcpServers"])
+        self.assertEqual(value["mcpServers"]["fable-engine"]["args"], ["serve"])
+        config.unlink()
+        try:
+            os.symlink(config.parent / "elsewhere", config)
+        except OSError as exc:
+            if getattr(exc, "winerror", None) == 1314 or isinstance(exc, (PermissionError, NotImplementedError)):
+                self.skipTest("Symlink creation requires elevated privilege on Windows")
+            raise
+        with self.assertRaises(RegistrationError):
+            register_hosts({"antigravity": host}, [str(exe), "serve"], home=home)
+
+    def test_only_canonical_host_names_are_probed(self):
+        with patch("fable_mode.adapters._which", side_effect=lambda n: None) as which:
+            detect_hosts()
+            self.assertEqual([c.args[0] for c in which.call_args_list], ["claude", "agy", "codex"])
+
+    def test_output_is_bounded_and_timeout_is_reported(self):
+        code, out, err, timed = run_argv([os.environ.get("PYTHON", sys.executable), "-c", "print('x'*1000000)"], timeout=2)
+        self.assertLessEqual(len(out.encode()), 8192)
+        self.assertFalse(timed)
+
+    def test_stale_cli_registration_failure_is_not_healthy(self):
+        exe = self.root / "claude"; exe.write_text(""); exe.chmod(0o700)
+        with patch("fable_mode.adapters.run_argv", return_value=(1, "unexpected failure", "", False)):
+            with self.assertRaises(RegistrationError):
+                register_hosts({"claude": Host("claude", exe, "cli", True)}, [str(exe), "serve"], home=self.root)
+
+    def test_frozen_like_mcp_smoke(self):
+        result = Installer(self.root / "i").install(); result.transaction.commit()
+        self.assertEqual(result.executable_argv[-1], "serve")
+        smoke_ok, smoke_detail = _smoke(result.executable_argv, self.root / "data")
+        self.assertTrue(smoke_ok, smoke_detail)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+class RemediationRegressionTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def test_verify_requires_runtime_manifest_and_rejects_links(self):
+        target = self.root / "install"
+        result = Installer(target).install(); result.transaction.commit()
+        marker = json.loads((target / ".fable-install.json").read_text())
+        marker["files"].pop("fable_engine/server.py")
+        (target / ".fable-install.json").write_text(json.dumps(marker))
+        self.assertFalse(verify_installation(target)[0])
+        with self.assertRaises(InstallError):
+            Installer(target).install()
+        # A fresh valid installation still refuses a symlink substitution.
+        result = Installer(self.root / "fresh-install").install(); result.transaction.commit()
+        runtime = result.install_dir / "runtime" / "fable_engine" / "server.py"
+        moved = runtime.with_suffix(".real"); runtime.rename(moved)
+        try:
+            runtime.symlink_to(moved)
+        except OSError as exc:
+            if getattr(exc, "winerror", None) == 1314 or isinstance(exc, (PermissionError, NotImplementedError)):
+                self.skipTest("Symlink creation requires elevated privilege on Windows")
+            raise
+        self.assertFalse(verify_installation(target)[0])
+
+    def test_cli_registration_cleanup_requires_exact_match(self):
+        from fable_mode.adapters import cleanup_recorded_registrations
+        exe = self.root / "host"
+        record = {"kind": "cli", "host": "claude", "executable": str(exe),
+                  "name": "fable-engine", "command": "fable", "args": ["serve"]}
+        with patch("fable_mode.adapters.run_argv", return_value=(0, json.dumps({"fable-engine": {"command": "other", "args": []}}), "", False)) as runner:
+            self.assertEqual(cleanup_recorded_registrations([record]), ["claude"])
+            self.assertEqual(runner.call_count, 1)
+        with patch("fable_mode.adapters.run_argv", side_effect=[(0, json.dumps({"fable-engine": {"command": "fable", "args": ["serve"]}}), "", False), (0, "", "", False)]) as runner:
+            self.assertEqual(cleanup_recorded_registrations([record]), [])
+            self.assertEqual(runner.call_count, 2)
+
+    def test_file_registration_cleanup_requires_exact_match(self):
+        from fable_mode.adapters import cleanup_recorded_registrations
+        config = self.root / "mcp.json"; config.write_text(json.dumps({"mcpServers": {
+            "fable-engine": {"command": "other", "args": []}, "keep": {"x": 1}}}))
+        skipped = cleanup_recorded_registrations([{"kind": "file", "path": str(config),
+            "name": "fable-engine", "command": "fable", "args": ["serve"]}])
+        self.assertEqual(skipped, [str(config)])
+        self.assertIn("keep", json.loads(config.read_text())["mcpServers"])
+
+    def test_windows_wrapper_regressions_are_static(self):
+        self.assertIn("-3", Path("install.ps1").read_text())
+        self.assertIn("-3", Path("install-antigravity.ps1").read_text())
+
+    @unittest.skipUnless(shutil.which("pip"), "pip unavailable")
+    def test_wheel_lifecycle_from_outside_checkout(self):
+        checkout = Path(__file__).resolve().parents[1]
+        source = self.root / "src"; source.mkdir()
+        for name in ("fable_mode", "fable_engine", "fable_v2", "rules", "docs", "skills"):
+            shutil.copytree(checkout / name, source / name)
+        for name in ("fable_mode_entry.py", "fable_compressor.py", "LICENSE", "README.md", "pyproject.toml", "setup.py", "MANIFEST.in"):
+            shutil.copy2(checkout / name, source / name)
+        dist, site, outside = self.root / "dist", self.root / "site", self.root / "outside"
+        dist.mkdir(); site.mkdir(); outside.mkdir()
+        wheel_build = subprocess.run([sys.executable, "-m", "pip", "wheel", ".", "--no-deps", "--no-build-isolation", "-w", str(dist)], cwd=source, capture_output=True, text=True)
+        self.assertEqual(wheel_build.returncode, 0,
+                         "wheel build failed\nstdout:\n%s\nstderr:\n%s" %
+                         (wheel_build.stdout, wheel_build.stderr))
+        env = os.environ.copy(); env["PIP_USER"] = "0"
+        subprocess.run([sys.executable, "-m", "pip", "install", "--no-deps", "--target", str(site), *map(str, dist.glob("*.whl"))], env=env, check=True, capture_output=True)
+        env["PYTHONPATH"] = str(site); env["FABLE_INSTALL_DIR"] = str(self.root / "install")
+        probe = subprocess.run([sys.executable, "-c", "from fable_mode.installer import Installer,verify_installation; r=Installer().install(); r.transaction.commit(); assert verify_installation(r.install_dir)[0]"], cwd=outside, env=env, check=False, capture_output=True, text=True)
+        self.assertEqual(probe.returncode, 0, f"probe failed:\nstdout:\n{probe.stdout}\nstderr:\n{probe.stderr}")

tests/test_proof_engine.py

@@ -0,0 +1,259 @@
+import hashlib
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from fable_v2.protocol import (
+    FileChangeRecord,
+    ModelVelocityProfile,
+    ProofReceipt,
+    ToolReceipt,
+    VisualMockupSpec,
+)
+from fable_v2.proof_engine import (
+    DeterministicProofValidator,
+    ProofStatus,
+    ProofType,
+    ProofValidationResult,
+)
+from fable_v2.system3.kripke import KripkeStructure
+from fable_v2.system3.oracle import Prop, ProofOracle
+
+
+class TestDeterministicProofValidator(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.validator = DeterministicProofValidator(workspace_root=self.root)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def test_ast_valid_python_file(self):
+        py_file = self.root / 'sample_module.py'
+        code = "def calculate_metric(x: int, y: int) -> int:\n    return x + y\n\nclass MetricEngine:\n    pass\n"
+        py_file.write_text(code, encoding='utf-8')
+        res = self.validator.validate_ast(
+            code_or_path=str(py_file),
+            required_symbols=['calculate_metric', 'MetricEngine'],
+            claim='Verify sample_module exports required symbols',
+        )
+        self.assertTrue(res.passed)
+        self.assertEqual(res.confidence, 1.0)
+        self.assertEqual(res.proof_type, ProofType.AST_GROUNDED.value)
+
+    def test_ast_missing_symbol_rejected(self):
+        code = "def foo(): pass\n"
+        res = self.validator.validate_ast(
+            code_or_path=code,
+            required_symbols=['foo', 'bar'],
+            claim='Missing symbol check',
+        )
+        self.assertFalse(res.passed)
+
+    def test_file_sha256_valid(self):
+        content = b'Deterministic payload 123456789'
+        expected_sha = hashlib.sha256(content).hexdigest()
+        file_path = self.root / 'data.bin'
+        file_path.write_bytes(content)
+
+        res = self.validator.validate_file_sha256(
+            file_path=str(file_path),
+            expected_sha256=expected_sha,
+            claim='Validate binary data integrity',
+        )
+        self.assertTrue(res.passed)
+        self.assertEqual(res.proof_type, ProofType.FILE_SHA256.value)
+
+    def test_tool_receipt_validation(self):
+        rcpt = ToolReceipt.from_result(
+            receipt_id='rcpt-001',
+            session_id='sess-001',
+            capability='unit_test',
+            tool_name='pytest',
+            tool_input={'args': ['-k', 'test_core']},
+            tool_output={'passed': True, 'duration': 0.05},
+            success=True,
+        )
+        session_receipts = {'rcpt-001': rcpt}
+
+        res = self.validator.validate_tool_receipt(
+            receipt=rcpt,
+            session_receipts=session_receipts,
+            claim='Unit test execution receipt',
+        )
+        self.assertTrue(res.passed)
+        self.assertEqual(res.proof_type, ProofType.EMPIRICAL_RECEIPT.value)
+
+    def test_anti_tautology_rejects_generic_strings(self):
+        bad_claims = [
+            'tested',
+            'verified',
+            'works',
+            'it works',
+            'done',
+            'fixed',
+            'looks good',
+            'success',
+            'true',
+            'x == x',
+            '1 == 1',
+        ]
+        for bad in bad_claims:
+            self.assertTrue(self.validator.is_tautological(bad))
+
+    def test_formal_logic_curry_howard(self):
+        from fable_v2.system3.oracle import Implies
+        A = Prop('A')
+        B = Prop('B')
+        prop = Implies(A, Implies(B, A))
+        res = self.validator.validate_formal_logic(
+            proposition_or_formula=prop,
+            claim='Constructive tautology A -> B -> A',
+        )
+        self.assertTrue(res.passed)
+        self.assertEqual(res.proof_type, ProofType.FORMAL_LOGIC.value)
+
+    def test_temporal_invariant_kripke_ctl(self):
+        ks = KripkeStructure(name='StateMachine')
+        ks.add_world('w_init', {'initialized', 'safe'}, is_initial=True)
+        ks.add_world('w_work', {'safe', 'active'})
+        ks.add_transition('w_init', 'w_work')
+        ks.add_transition('w_work', 'w_work')
+
+        res = self.validator.validate_temporal_invariant(
+            formula='AG(safe)',
+            kripke_structure=ks,
+            initial_world='w_init',
+            claim='Safety invariant holds',
+        )
+        self.assertTrue(res.passed)
+
+    def test_vector_coordinates_validation(self):
+        valid_bbox = {'x': 100, 'y': 200, 'width': 800, 'height': 600}
+        res = self.validator.validate_vector_coordinates(
+            coordinates_data=valid_bbox,
+            claim='Layout bounding box spec',
+        )
+        self.assertTrue(res.passed)
+
+    def test_polyglot_ast_typescript_and_rust(self):
+        ts_code = "export interface UserProfile {\n  id: string;\n}\n\nexport function fetchUserProfile(id: string): UserProfile {\n  return { id };\n}\n"
+        res_ts = self.validator.validate_ast(
+            code_or_path=ts_code,
+            required_symbols=['UserProfile', 'fetchUserProfile'],
+            claim='Verify TypeScript interface and function export',
+        )
+        self.assertTrue(res_ts.passed)
+        self.assertEqual(res_ts.metadata.get('language'), 'typescript')
+
+        rs_code = "pub struct CausalGraph {\n  nodes: usize,\n}\n\npub fn create_graph() -> CausalGraph {\n  CausalGraph { nodes: 0 }\n}\n"
+        res_rs = self.validator.validate_ast(
+            code_or_path=rs_code,
+            required_symbols=['CausalGraph', 'create_graph'],
+            claim='Verify Rust struct and function',
+        )
+        self.assertTrue(res_rs.passed)
+        self.assertEqual(res_rs.metadata.get('language'), 'rust')
+
+    def test_unregistered_tool_receipt_rejected(self):
+        res = self.validator.validate_tool_receipt(
+            receipt="stdout: Fake execution output without registration",
+            session_receipts={},
+            claim="Fake claim with stdout substring",
+        )
+        self.assertFalse(res.passed)
+        self.assertIn("not found in active session receipts", res.details)
+
+    def test_kripke_safety_fails_on_tainted_context(self):
+        clean_res = self.validator.validate_temporal_invariant(
+            formula="AG(safe)",
+            context={"safe": True, "has_failures": False},
+        )
+        self.assertTrue(clean_res.passed)
+
+        tainted_res = self.validator.validate_temporal_invariant(
+            formula="AG(safe)",
+            context={"safe": False, "has_failures": True},
+        )
+        self.assertFalse(tainted_res.passed)
+
+    def test_svg_viewbox_coordinate_validation(self):
+        valid_svg = '<svg viewBox="0 0 800 600" xmlns="http://www.w3.org/2000/svg"><rect x="10" y="20" width="100" height="50" /></svg>'
+        res = self.validator.validate_vector_coordinates(
+            coordinates_data=valid_svg,
+            claim="Valid SVG viewport check",
+        )
+        self.assertTrue(res.passed)
+        self.assertEqual(res.metadata["viewBox"], [0.0, 0.0, 800.0, 600.0])
+
+        invalid_svg = '<svg viewBox="0 0 -100 600"></svg>'
+        res_inv = self.validator.validate_vector_coordinates(
+            coordinates_data=invalid_svg,
+            claim="Invalid SVG viewport check",
+        )
+        self.assertFalse(res_inv.passed)
+
+
+class TestProtocolDataclasses(unittest.TestCase):
+    def test_proof_receipt_to_dict(self):
+        rcpt = ProofReceipt(
+            receipt_id='rcpt-123',
+            claim='Cryptographic SHA256 match',
+            proof_type='file_sha256',
+            target_resource='/app/core.py',
+            sha256_digest='abc' * 20 + 'abcd',
+            verified_at='2026-09-02T12:00:00Z',
+            verifier_details={'size_bytes': 1024},
+        )
+        d = rcpt.to_dict()
+        self.assertEqual(d['receipt_id'], 'rcpt-123')
+
+    def test_file_change_record_to_dict(self):
+        change = FileChangeRecord(
+            file_path='fable_v2/proof_engine.py',
+            change_type='create',
+            before_hash=None,
+            after_hash='def' * 21 + 'd',
+            diff_summary='+500 lines DeterministicProofValidator',
+            rationale='Implement deterministic proof engine',
+            affected_invariants=('AG(safe)', 'AST_grounding'),
+            timestamp='2026-09-02T12:00:00Z',
+        )
+        d = change.to_dict()
+        self.assertEqual(d['file_path'], 'fable_v2/proof_engine.py')
+
+    def test_visual_mockup_spec_to_dict(self):
+        mockup = VisualMockupSpec(
+            mockup_id='mockup-001',
+            concept_name='Cinematic Glass',
+            aesthetic_archetype='glassmorphism',
+            prompt='High contrast dark mode',
+            image_url=None,
+            coordinates_data={'card_w': 320},
+            palette=('#0f172a', '#38bdf8'),
+            typography={'heading': 'Inter Display'},
+            status='approved',
+            selected_by_user=True,
+            created_at='2026-09-02T12:00:00Z',
+        )
+        d = mockup.to_dict()
+        self.assertEqual(d['mockup_id'], 'mockup-001')
+
+    def test_model_velocity_profile_to_dict(self):
+        profile = ModelVelocityProfile(
+            model_tier='pro',
+            tokens_per_sec=42.5,
+            avg_tool_latency_sec=1.1,
+            sample_count=10,
+            high_throughput_mode=False,
+            exploration_multiplier=1.0,
+            last_updated='2026-09-02T12:00:00Z',
+        )
+        d = profile.to_dict()
+        self.assertEqual(d['model_tier'], 'pro')
+
+
+if __name__ == '__main__':
+    unittest.main()