arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/test_key_conflict_scope.py

@@ -0,0 +1,92 @@
+"""E-0210/E-0242 locality of key-conflict evaluation status (Python target)."""
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import deliver  # noqa: E402
+import plan  # noqa: E402
+from test_support import vector  # noqa: E402
+
+
+L0_VECTOR = vector("errata/ERR-E0242-KEY-PER-RELATION")
+L1_VECTOR = vector("errata/ERR-E0210-KEYED-RELATION-STAYS-BLOCKED")
+
+
+class KeyConflictScopeTests(unittest.TestCase):
+    def execute(self, ir: dict, case: dict, query: dict) -> dict:
+        with tempfile.TemporaryDirectory(prefix="backend-key-conflict-") as tmp:
+            root = Path(tmp)
+            deliver.emit_project(plan.build_plan(ir), "py", root / "py")
+            for name, document in (("case.json", case), ("query.json", query)):
+                (root / name).write_text(json.dumps(document), encoding="utf-8")
+            result = subprocess.run([sys.executable, str(root / "py/runner.py"), str(root / "case.json"), str(root / "query.json")],
+                                    capture_output=True, text=True, check=True)
+            return json.loads(result.stdout)
+
+    @staticmethod
+    def truth_query(predicate: str, args: list, name: str) -> dict:
+        return {"queryId": f"urn:query:{name}", "kind": "truth",
+                "literal": {"kind": "literal", "polarity": "positive", "predicate": predicate,
+                            "args": copy.deepcopy(args)}}
+
+    def assert_scope(self, ir: dict, case: dict, *, source: dict, downstream: dict, independent: dict) -> None:
+        """A source, its two-hop reader, and an unrelated positive fact stay distinct."""
+        for query, expected in ((source, ("TRUE_ONLY", "NON_EXECUTABLE")),
+                                (downstream, ("TRUE_ONLY", "NON_EXECUTABLE")),
+                                (independent, ("TRUE_ONLY", "COMPUTED"))):
+            answer = self.execute(copy.deepcopy(ir), copy.deepcopy(case), query)
+            self.assertEqual((answer["truthStatus"], answer["evaluationStatus"]), expected)
+            self.assertIn("KEY_CONFLICT", answer["issues"])
+
+    def test_l0_conflict_blocks_source_and_two_hop_reader_only(self):
+        ir = json.loads((L0_VECTOR / "ir.json").read_text(encoding="utf-8"))
+        case = json.loads((L0_VECTOR / "case.json").read_text(encoding="utf-8"))
+        coefficient = ir["nodes"][0]
+        priced = ir["nodes"][2]
+        audited = copy.deepcopy(priced)
+        audited.update(id="urn:law:vectors:err-e0242-key#audited", name="audited")
+        ir["nodes"].append(audited)
+        audited_rule = copy.deepcopy(ir["nodes"][-2])
+        audited_rule.update(id="urn:law:vectors:err-e0242-key#Audited")
+        audited_rule["head"]["predicate"] = audited["id"]
+        audited_rule["body"]["formula"]["predicate"] = priced["id"]
+        audited_rule["body"]["formula"]["args"] = [{"kind": "var", "var": "v0"}]
+        ir["nodes"].append(audited_rule)
+        independent = copy.deepcopy(priced)
+        independent.update(id="urn:law:vectors:err-e0242-key#independent", name="independent")
+        ir["nodes"].append(independent)
+        case["assertions"].append({"id": "urn:assert:independent", "kind": "assertion", "origin": "case_input",
+                                   "literal": {"kind": "literal", "polarity": "positive", "predicate": independent["id"],
+                                               "args": [{"kind": "entity_ref", "id": "urn:entity:zone-1"}]}})
+        source_args = case["assertions"][0]["literal"]["args"]
+        self.assert_scope(ir, case,
+                          source=self.truth_query(coefficient["id"], source_args, "l0-key-source"),
+                          downstream=self.truth_query(audited["id"], source_args[:1], "l0-key-two-hop"),
+                          independent=self.truth_query(independent["id"], source_args[:1], "l0-key-independent"))
+
+    def test_l1_conflict_blocks_source_and_two_hop_reader_only(self):
+        ir = json.loads((L1_VECTOR / "ir.json").read_text(encoding="utf-8"))
+        case = json.loads((L1_VECTOR / "case.json").read_text(encoding="utf-8"))
+        predicates = {node["name"]: node["id"] for node in ir["nodes"] if node.get("kind") == "symbol_decl"}
+        coefficient_args = case["assertions"][0]["literal"]["args"]
+        zone_args = coefficient_args[:1]
+        holder_args = case["assertions"][-1]["literal"]["args"]
+        self.assert_scope(ir, case,
+                          source=self.truth_query(predicates["coefficient"], coefficient_args, "l1-key-source"),
+                          downstream=self.truth_query(predicates["audited"], zone_args, "l1-key-two-hop"),
+                          independent=self.truth_query(predicates["eligible"], holder_args, "l1-key-independent"))
+        status_reader = self.execute(ir, case, self.truth_query(
+            predicates["no_coefficient"], case["assertions"][2]["literal"]["args"], "l1-key-status-reader"))
+        self.assertEqual((status_reader["truthStatus"], status_reader["evaluationStatus"]),
+                         ("TRUE_ONLY", "NON_EXECUTABLE"))
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_key_conflict_targets.py

@@ -0,0 +1,17 @@
+"""Secondary emitters must refuse current admission until separately recertified."""
+from pathlib import Path
+import tempfile
+import unittest
+import deliver
+import plan
+
+
+class KeyConflictTargetTests(unittest.TestCase):
+    def test_current_release_refuses_before_writing_any_generated_file(self):
+        current = plan.build_plan({"semanticVersion": "0.2.11", "schemaVersion": "law.core.ir/0.7", "nodes": []})
+        for target in ('rb', 'php', 'dart', 'scala', 'bsl'):
+            with self.subTest(target=target), tempfile.TemporaryDirectory() as tmp:
+                output = Path(tmp) / "project"
+                with self.assertRaisesRegex(plan.Refused, "admission:current"):
+                    deliver.emit_project(current, target, output)
+                self.assertFalse(output.exists())

arxo_codegen/test_package_layout.py

@@ -0,0 +1,163 @@
+"""DECISION-0423 §2.7 (шаг 5): имена API по языку, различимые внутренние имена
+и устанавливаемый пакет Python с исполняемым примером README."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+import tempfile
+import tomllib
+import unittest
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+sys.path.insert(0, str(HERE / "harness/verify/ci/gates/backends"))
+import deliver  # noqa: E402
+import l1_fixtures as FX  # noqa: E402
+import package  # noqa: E402
+import plan  # noqa: E402
+from test_support import fixture_root, materialize_core_kit  # noqa: E402
+
+
+def names(lang: str, entries: list) -> dict:
+    return deliver.emitter(lang).api_names([{"name": n} for n in entries])
+
+
+class ApiNamesTests(unittest.TestCase):
+    def test_case_follows_the_language_and_collisions_are_resolved_after_it(self):
+        entries = ["isEligible", "is_eligible", "vat_rate", "HTTPServer", "vatID"]
+        self.assertEqual(names("py", entries), {"isEligible": "is_eligible", "is_eligible": "is_eligible_2",
+                                                "vat_rate": "vat_rate", "HTTPServer": "http_server",
+                                                "vatID": "vat_id"})
+        self.assertEqual(names("ts", entries), {"isEligible": "isEligible", "is_eligible": "isEligible2",
+                                                "vat_rate": "vatRate", "HTTPServer": "httpServer",
+                                                "vatID": "vatID"})
+        self.assertEqual(names("go", entries), {"isEligible": "IsEligible", "is_eligible": "IsEligible2",
+                                                "vat_rate": "VatRate", "HTTPServer": "HTTPServer",
+                                                "vatID": "VatID"})
+
+    def test_letters_outside_ascii_are_kept(self):
+        name = plan._api_slug("urn:x#безопасность_обеспечена")
+        self.assertEqual(name, "безопасность_обеспечена")
+        self.assertEqual(names("py", [name])[name], "безопасность_обеспечена")
+        self.assertEqual(names("ts", [name])[name], "безопасностьОбеспечена")
+        self.assertEqual(names("go", [name])[name], "БезопасностьОбеспечена")
+
+    def test_go_keeps_only_letters_and_digits_and_ts_never_starts_with_a_digit(self):
+        # «ि» и «ा» — знаки гласных (Mc): Python и JavaScript их допускают, Go — нет.
+        self.assertEqual(names("go", ["किताब"])["किताब"], "कतब")
+        self.assertEqual(names("py", ["किताब"])["किताब"], "किताब")
+        self.assertEqual(names("ts", ["2x"])["2x"], "_2x")
+
+
+class InternalNamesTests(unittest.TestCase):
+    def test_ascii_names_are_unchanged_and_other_scripts_get_a_digest(self):
+        self.assertEqual(plan._slug("urn:x#vehicle_insured"), "vehicle_insured")
+        first, second = plan._slug("urn:x#вред_возмещён"), plan._slug("urn:x#долг_погашено")
+        self.assertTrue(first.isascii() and second.isascii())
+        self.assertNotEqual(first, second)
+
+    def test_relations_of_one_package_never_share_a_table(self):
+        fx = {"name": "cyr", "preds": {"вред_возмещён": 1, "долг_погашено": 1, "итог_получен": 1},
+              "rules": [("R1", "strict", "итог_получен(X)", "вред_возмещён(X)"),
+                        ("R2", "strict", "итог_получен(X)", "долг_погашено(X)")]}
+        tables = [t["name"] for t in plan.build_plan(FX.program(fx))["tables"]]
+        self.assertEqual(len(tables), len(set(tables)), tables)
+
+    def test_a_third_collision_is_a_named_refusal(self):
+        builder = plan.Builder(FX.program({"name": "x", "preds": {"p": 1}}))
+        builder.table_name("urn:x#a-b")
+        builder.table_name("urn:x#a_b")
+        with self.assertRaisesRegex(plan.Refused, "совпадающие имена таблиц"):
+            builder.table_name("urn:x#a.b")
+
+
+def rybka() -> dict:
+    return json.loads((fixture_root() / "corpus/clir/codegen-api-defeasible.lawir.json").read_text(encoding="utf-8"))
+
+
+class PythonPackageTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # Паспорт пакета несёт семантический хэш §209 — нужен проверенный комплект ядра.
+        import core_support
+        cls._kit = tempfile.TemporaryDirectory(prefix="package-kit-")
+        kit = Path(cls._kit.name) / "kit"
+        materialize_core_kit(kit, source_commit="5" * 40)
+        core_support.configure_core_kit(kit)
+
+    @classmethod
+    def tearDownClass(cls):
+        import core_support
+        core_support.configure_core_kit(None)
+        cls._kit.cleanup()
+
+    def test_package_imports_from_src_runs_its_readme_example_and_reports_itself(self):
+        ir = rybka()
+        with tempfile.TemporaryDirectory(prefix="package-py-") as raw:
+            out = Path(raw) / "pkg"
+            passport = package.package(ir, "py", out, name="example-rybka", version="1.2.3")
+            self.assertEqual(passport["semanticHash"], deliver.semantic_hash(ir))
+            self.assertEqual(passport["distribution"],
+                             {"format": package.FORMAT, "name": "example-rybka", "version": "1.2.3"})
+            project = tomllib.loads((out / "pyproject.toml").read_text(encoding="utf-8"))["project"]
+            self.assertEqual(project["requires-python"], ">=" + deliver.emitter("py").TOOLCHAIN_MIN)
+            self.assertEqual(json.loads((out / "law-backend.json").read_text(encoding="utf-8")), passport)
+            sample = re.search(r"```python\n(.*?)```", (out / "README.md").read_text(encoding="utf-8"), re.S).group(1)
+            env = dict(os.environ, PYTHONPATH=str(out / "src"))
+            run = subprocess.run([sys.executable, "-c", sample], cwd=raw, env=env, capture_output=True, text=True,
+                                 check=True)
+            self.assertEqual(run.stdout.split(), ["TRUE_ONLY", "COMPUTED"])
+            info = subprocess.run([sys.executable, "-c", "import json, example_rybka as m; print(json.dumps(m.info()))"],
+                                  cwd=raw, env=env, capture_output=True, text=True, check=True)
+            self.assertEqual(json.loads(info.stdout)["files"], passport["files"])
+            mapping = json.loads((out / "src/example_rybka/api-map.json").read_text(encoding="utf-8"))
+            ask = next(f for f in mapping["functions"] if f["function"] == "ask_exceeds_grant_limit")
+            self.assertTrue(ask["rules"] and all(r["id"].startswith("urn:") for r in ask["rules"]))
+            self.assertFalse((out / "src/example_rybka/_internal/runner.py").exists())
+            # DECISION-0423 §2.8: провенанс генератора и ABI в паспорте.
+            self.assertEqual(passport["generator"]["name"], "arxo-codegen")
+            self.assertTrue(passport["coreKit"]["manifestSha256"].startswith("sha256:"))
+            self.assertEqual(passport["api"], {"abi": package.API_ABI, "valueFormat": package.VALUE_FORMAT})
+            self.assertIn("defeasible", passport["capabilities"])
+            probe = ("import example_rybka as m\n"
+                     "t = m.money('100.50', 'KZT')\n"
+                     "print(m.to_value(t)); print(m.from_value(m.to_value(t)) == t)\n"
+                     "print(m.to_value(m.integer(2**62))); print(m.VALUE_FORMAT)\n")
+            value = subprocess.run([sys.executable, "-c", probe], cwd=raw, env=env, capture_output=True, text=True,
+                                   check=True)
+            self.assertEqual(value.stdout.splitlines(), [
+                '{"currency":"KZT","kind":"value","type":{"name":"urn:law:std#Money"},"value":"100.50"}', "True",
+                '{"kind":"value","type":{"name":"urn:law:std#Integer"},"value":4611686018427387904}',
+                package.VALUE_FORMAT])
+
+    def test_refusals_are_named(self):
+        ir = rybka()
+        with tempfile.TemporaryDirectory(prefix="package-refusal-") as raw:
+            with self.assertRaisesRegex(package.PackageError, "SemVer"):
+                package.package(ir, "py", Path(raw) / "a", name="x", version="1")
+            with self.assertRaisesRegex(package.PackageError, "--module"):
+                package.package(ir, "go", Path(raw) / "b", name="x", version="1.0.0")
+            with self.assertRaisesRegex(package.PackageError, "только для"):
+                package.package(ir, "xlsx", Path(raw) / "c", name="x", version="1.0.0")
+            with self.assertRaisesRegex(package.PackageError, "уже существует"):
+                package.package(ir, "py", Path(raw), name="x", version="1.0.0")
+
+
+class ToolchainTests(unittest.TestCase):
+    def test_minimum_versions_are_the_versions_ci_checks(self):
+        workflow = HERE / ".github/workflows/candidate.yml"
+        if not workflow.is_file():
+            self.skipTest("вне checkout arxo-codegen нет workflow CI")
+        text = workflow.read_text(encoding="utf-8")
+        version = lambda key: re.search(rf"{key}:\s*'([\d.]+)'", text).group(1)
+        self.assertEqual(deliver.emitter("py").TOOLCHAIN_MIN, ".".join(version("python-version").split(".")[:2]))
+        self.assertEqual(deliver.emitter("ts").TOOLCHAIN_MIN, version("node-version").split(".")[0])
+        self.assertEqual(deliver.emitter("go").TOOLCHAIN_MIN, ".".join(version("go-version").split(".")[:2]))
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_plan_language_version.py

@@ -0,0 +1,44 @@
+"""Stage R: exact current release/schema admission at every planner entry."""
+from __future__ import annotations
+import sys
+import unittest
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import plan
+
+
+def ir(version="0.2.11", schema="law.core.ir/0.7"):
+    return {"semanticVersion": version, "schemaVersion": schema, "nodes": []}
+
+
+class BackendPlanLanguageVersionTests(unittest.TestCase):
+    def test_exact_current_release_is_accepted(self):
+        self.assertEqual(plan.build_plan(ir())["planVersion"], "law-backend-plan/0.20")
+        self.assertEqual(plan.build_plan(ir())["basePlanVersion"], "law-backend-plan/0.7")
+        self.assertEqual(plan.survey_plan(ir()), [])
+        self.assertEqual(plan.Builder(ir()).build()["planVersion"], "law-backend-plan/0.7")
+
+    def test_no_family_alias_old_or_future_release_is_admitted(self):
+        for entry in (plan.build_plan, plan.survey_plan, plan.Builder):
+            for version in (None, "0.1.1", "0.2", "0.2.4", "0.2.10", "0.2.12", "0.4.1", "law.core/0.2.11"):
+                with self.subTest(entry=entry.__name__, version=version), self.assertRaisesRegex(
+                        plan.Refused, "SEMANTIC_RELEASE_UNAVAILABLE"):
+                    entry(ir(version))
+
+    def test_schema_is_checked_independently_of_semantics(self):
+        for entry in (plan.build_plan, plan.survey_plan, plan.Builder):
+            for schema in (None, "law.core.ir/0.2", "law.core.ir/0.6", "law.core.ir/0.8"):
+                with self.subTest(entry=entry.__name__, schema=schema), self.assertRaisesRegex(
+                        plan.Refused, "SEMANTIC_RELEASE_UNAVAILABLE"):
+                    entry(ir(schema=schema))
+
+    def test_each_dependency_must_have_the_current_envelope(self):
+        for entry in (plan.build_plan, plan.survey_plan, plan.Builder):
+            for dependency in (ir("0.2.4"), ir(schema="law.core.ir/0.6")):
+                with self.subTest(entry=entry.__name__, dependency=dependency), self.assertRaisesRegex(
+                        plan.Refused, "SEMANTIC_RELEASE_UNAVAILABLE"):
+                    entry(ir(), [dependency])
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_positions_refusal.py

@@ -0,0 +1,43 @@
+"""Owner's stage-R choice: positions cannot run the old norm status ladder."""
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import deliver
+import plan
+
+
+class PositionsRefusalTests(unittest.TestCase):
+    def test_primary_targets_do_not_advertise_positions(self):
+        for language in ("py", "ts", "go"):
+            with self.subTest(language=language):
+                self.assertNotIn("positions", deliver.emitter(language).QUERY_KINDS)
+
+    def test_library_refuses_before_creating_or_running_a_model(self):
+        model = plan.build_plan({"schemaVersion": "law.core.ir/0.7", "semanticVersion": "0.2.11", "nodes": []})
+        with tempfile.TemporaryDirectory(prefix="positions-api-refusal-") as tmp:
+            root = Path(tmp)
+            deliver.emit_project(model, "py", root)
+            probe = """import json, model, evaluate, runtime
+def must_not_run():
+    raise AssertionError('old norm model was executed')
+model.new_model = must_not_run
+try:
+    evaluate.evaluate({}, {'kind': 'positions'})
+except runtime.Refused as exc:
+    print(json.dumps({'refused': str(exc)}))
+else:
+    raise AssertionError('positions unexpectedly answered')
+"""
+            result = subprocess.run([sys.executable, "-B", "-c", probe], cwd=root,
+                                    capture_output=True, text=True, check=True)
+        self.assertEqual(json.loads(result.stdout), {
+            "refused": "POSITIONS_UNAVAILABLE: positions requires current norm ranks (W6)"})
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_recertify_registry.py

@@ -0,0 +1,77 @@
+import copy
+import hashlib
+from pathlib import Path
+import tempfile
+import unittest
+
+import check_conformance as C
+import recertify_registry as R
+
+
+class RegistryRecertificationTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.root = Path(self.tmp.name)
+        (self.root / "emit.py").write_text("unchanged input")
+        self.manifest = {"format": "law.codegen-fixtures/0.1", "files": [
+            {"path": "vectors/A/ir.json", "sha256": "sha256:x", "bytes": 1}],
+            "vectors": [{"id": "A", "path": "vectors/A"}]}
+        self.report = {"scope": {"mode": "full", "targets": ["py", "ts", "go"],
+                                  "activeSemanticVersions": ["0.2.11"]},
+                       "fixturePayloadSha256": C.fixture_payload_digest(self.manifest),
+                       "generatorInputs": {"emit.py": "sha256:" + hashlib.sha256(b"unchanged input").hexdigest()},
+                       "vectors": [{"id": "A", "semanticVersion": "0.2.11", "actual": "match"}]}
+        self.previous = {"vectors": {"A": {"outcome": "match"}}}
+
+    def certify(self, report=None, qualifications=()):
+        return R.certify(report or self.report, self.manifest, self.previous, qualifications, self.root)
+
+    def test_complete_frozen_observation_pins_every_vector(self):
+        registry, receipt = self.certify()
+        self.assertEqual(registry["vectors"]["A"]["inputsSha256"], C.vector_input_digests(self.manifest)["A"])
+        self.assertEqual(receipt["status"], "verified")
+
+    def test_partial_or_missing_target_cannot_be_certified(self):
+        for changes in ({"mode": "partial"}, {"targets": ["py"]}, {"activeSemanticVersions": ["0.2.4"]}):
+            x = copy.deepcopy(self.report); x["scope"].update(changes)
+            with self.subTest(changes=changes), self.assertRaises(ValueError):
+                self.certify(x)
+
+    def test_changed_sources_or_fixture_bytes_invalidate_observation(self):
+        x = copy.deepcopy(self.report); x["fixturePayloadSha256"] = "sha256:stale"
+        with self.assertRaisesRegex(ValueError, "payload is stale"):
+            self.certify(x)
+        (self.root / "emit.py").write_text("new implementation")
+        with self.assertRaisesRegex(ValueError, "source is stale"):
+            self.certify()
+
+    def test_crash_divergence_and_execution_errors_cannot_be_pinned(self):
+        for outcome in ("crash", "divergence", "not-executed"):
+            x = copy.deepcopy(self.report); x["vectors"][0]["actual"] = outcome
+            with self.subTest(outcome=outcome), self.assertRaises(ValueError):
+                self.certify(x)
+        x = copy.deepcopy(self.report); x["commandFailures"] = ["timeout"]
+        with self.assertRaises(ValueError):
+            self.certify(x)
+
+    def test_missing_or_duplicated_vector_is_not_full_coverage(self):
+        for rows in ([], self.report["vectors"] * 2):
+            x = copy.deepcopy(self.report); x["vectors"] = rows
+            with self.assertRaisesRegex(ValueError, "inventory exactly"):
+                self.certify(x)
+
+    def test_lost_match_requires_a_qualification_of_this_exact_outcome(self):
+        x = copy.deepcopy(self.report); x["vectors"][0]["actual"] = "plan: NORM_RANKS_UNAVAILABLE"
+        with self.assertRaisesRegex(ValueError, "explicit current qualification"):
+            self.certify(x)
+        q = {"id": "A", "after": "plan: NORM_RANKS_UNAVAILABLE", "category": "semantic_change",
+             "reason": "E-0325: owner defers ranks to W6"}
+        self.assertEqual(self.certify(x, [q])[1]["qualifiedLostMatches"], ["A"])
+        q["after"] = "match"
+        with self.assertRaises(ValueError):
+            self.certify(x, [q])
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_ruby_target.py

@@ -0,0 +1,41 @@
+"""Availability contract for the Ruby target; no Ruby compilation."""
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+import unittest
+from unittest import mock
+
+
+PATH = Path(__file__).resolve().parent / "targets" / "rb" / "emit.py"
+SPEC = importlib.util.spec_from_file_location("ruby_target_for_test", PATH)
+ruby = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(ruby)
+
+
+class RubyTargetAvailabilityTests(unittest.TestCase):
+    def test_rejects_pre_three_ruby_before_build(self):
+        with mock.patch.object(ruby.shutil, "which", return_value="/usr/bin/ruby"), \
+             mock.patch.object(ruby.subprocess, "check_output", return_value="ruby 2.6.10p210"):
+            available, reason = ruby.available()
+        self.assertFalse(available)
+        self.assertIn("Ruby >= 3.0", reason)
+        self.assertIn("ruby 2.6", reason)
+
+    def test_accepts_supported_ruby(self):
+        with mock.patch.object(ruby.shutil, "which", return_value="/opt/ruby/bin/ruby"), \
+             mock.patch.object(ruby.subprocess, "check_output", return_value="ruby 3.3.1p55"):
+            available, reason = ruby.available()
+        self.assertTrue(available)
+        self.assertIn("ruby 3.3", reason)
+
+    def test_rejects_unreadable_version(self):
+        with mock.patch.object(ruby.shutil, "which", return_value="/usr/bin/ruby"), \
+             mock.patch.object(ruby.subprocess, "check_output", return_value="unexpected"):
+            available, reason = ruby.available()
+        self.assertFalse(available)
+        self.assertIn("не прочитана версия", reason)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_runtime_cert.py

@@ -0,0 +1,83 @@
+"""Focused tests for runtime capability contracts; no target compilation."""
+from __future__ import annotations
+
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import runtime_cert as cert
+
+
+FIXTURE = Path(__file__).resolve().parent / "runtime-cert.json"
+
+
+class RuntimeCertTests(unittest.TestCase):
+    def fixture(self) -> dict:
+        return cert.load_fixture(FIXTURE)
+
+    def test_every_declared_target_keeps_the_mandatory_common_subset(self):
+        fixture = self.fixture()
+        for target in cert.TARGET_OPERATIONS:
+            selected = cert.profile(target, fixture)
+            self.assertTrue(cert.BASELINE_OPERATIONS <= set(selected["checkedOperations"]), target)
+
+    def test_lightweight_profile_is_bounded_and_reviewable(self):
+        selected = cert.profile("lua", self.fixture())
+        self.assertIn("dec-plain", selected["checkedFixtureIds"])
+        self.assertIn("rat-canonical", selected["unsupportedFixtureIds"])
+        self.assertIn("abs-rational", selected["unsupportedOperandFixtureIds"])
+        self.assertEqual(selected["unsupportedOperandForms"]["abs-rational"], ["rat"])
+        self.assertNotIn("rat", selected["checkedOperations"])
+        self.assertIn("rat", selected["unsupportedOperations"])
+        self.assertEqual(len(selected["checkedFixtureIds"]), 133)
+
+    def test_unknown_fixture_operation_is_a_hard_error(self):
+        fixture = json.loads(FIXTURE.read_text(encoding="utf-8"))
+        fixture["cases"].append({"id": "future-op", "op": "future", "args": [], "expect": None})
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary) / "cert.json"
+            path.write_text(json.dumps(fixture), encoding="utf-8")
+            with self.assertRaisesRegex(cert.FixtureError, "неизвестная операция"):
+                cert.load_fixture(path)
+
+    def test_unknown_literal_form_is_a_hard_error(self):
+        fixture = json.loads(FIXTURE.read_text(encoding="utf-8"))
+        fixture["cases"][0]["args"] = [{"futureLiteral": "x"}]
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary) / "cert.json"
+            path.write_text(json.dumps(fixture), encoding="utf-8")
+            with self.assertRaisesRegex(cert.FixtureError, "literal-теги"):
+                cert.load_fixture(path)
+
+    def test_missing_baseline_fixture_operation_is_a_hard_error(self):
+        fixture = json.loads(FIXTURE.read_text(encoding="utf-8"))
+        fixture["cases"] = [case for case in fixture["cases"] if case["op"] != "dec"]
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary) / "cert.json"
+            path.write_text(json.dumps(fixture), encoding="utf-8")
+            with self.assertRaisesRegex(cert.FixtureError, "baseline"):
+                cert.load_fixture(path)
+
+    def test_declared_extension_without_compatible_case_is_a_hard_error(self):
+        fixture = self.fixture()
+        fixture["cases"] = [case for case in fixture["cases"] if case["op"] != "rat"]
+        with self.assertRaisesRegex(cert.FixtureError, "объявленных операций: rat"):
+            cert.profile("py", fixture)
+
+    def test_answer_requires_exactly_the_selected_cases(self):
+        cases = cert.profile("lua", self.fixture())["fixture"]["cases"]
+        answer = [{"id": cases[0]["id"], "got": cases[0]["expect"]},
+                  {"id": cases[0]["id"], "got": cases[0]["expect"]},
+                  {"id": "rat-canonical", "got": "1/2"}]
+        errors = cert.validate_answer("lua", cases, answer)
+        self.assertTrue(any("повтор" in error for error in errors))
+        self.assertTrue(any("невыбранного" in error for error in errors))
+        self.assertTrue(any("не исполнен" in error for error in errors))
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_secondary_key_conflict_scope.py

@@ -0,0 +1,17 @@
+"""Secondary emitters must refuse current admission until separately recertified."""
+from pathlib import Path
+import tempfile
+import unittest
+import deliver
+import plan
+
+
+class SecondaryKeyConflictScopeTests(unittest.TestCase):
+    def test_current_release_refuses_before_writing_any_generated_file(self):
+        current = plan.build_plan({"semanticVersion": "0.2.11", "schemaVersion": "law.core.ir/0.7", "nodes": []})
+        for target in ('cs', 'java', 'kt', 'rs', 'swift'):
+            with self.subTest(target=target), tempfile.TemporaryDirectory() as tmp:
+                output = Path(tmp) / "project"
+                with self.assertRaisesRegex(plan.Refused, "admission:current"):
+                    deliver.emit_project(current, target, output)
+                self.assertFalse(output.exists())