| |
| """Pruebas de propiedades que conectan Lean, CSV y ontología generada.""" |
| from __future__ import annotations |
|
|
| import csv |
| import json |
| import unittest |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
|
|
| def load_spec() -> dict: |
| return json.loads((ROOT / "data" / "iom_spec.json").read_text(encoding="utf-8")) |
|
|
|
|
| def load_csv(name: str) -> list[dict]: |
| with (ROOT / "datasets" / name).open(encoding="utf-8", newline="") as fh: |
| return list(csv.DictReader(fh)) |
|
|
|
|
| class PropertyLinksTests(unittest.TestCase): |
| """Conectan la especificación JSON, los CSV regenerados y las reglas formales.""" |
|
|
| @classmethod |
| def setUpClass(cls): |
| cls.spec = load_spec() |
| cls.nodes = load_csv("triad_nodes.csv") |
| cls.relations = load_csv("relation_candidates.csv") |
| cls.vectors = load_csv("vector_steps.csv") |
| cls.n_triads = len(cls.spec["triads"]["adv"]) |
|
|
| def test_spec_has_formal_version(self): |
| self.assertIn("spec_version", self.spec) |
| self.assertRegex(self.spec["spec_version"], r"^\d+\.\d+\.\d+$") |
| self.assertIn("schema_version", self.spec) |
|
|
| def test_node_count_matches_spec(self): |
| expected = self.n_triads * 2 * 3 |
| self.assertEqual(len(self.nodes), expected) |
| indices = {int(r["triad_index"]) for r in self.nodes} |
| self.assertEqual(indices, set(range(1, self.n_triads + 1))) |
|
|
| def test_relation_candidate_count(self): |
| expected = self.n_triads * 6 * 5 |
| self.assertEqual(len(self.relations), expected) |
|
|
| def test_gold_relation_counts(self): |
| counts = {"none": 0, "mirrorOf": 0, "creates": 0} |
| for row in self.relations: |
| counts[row["relation"]] += 1 |
| self.assertEqual(counts["mirrorOf"], 78) |
| self.assertEqual(counts["creates"], 104) |
| self.assertEqual(counts["none"], 208) |
|
|
| def test_mirrorOf_property_holds_in_csv(self): |
| """Cada arista mirrorOf respeta: misma tríada, fase opuesta, posición reflejada.""" |
| for row in self.relations: |
| if row["relation"] != "mirrorOf": |
| continue |
| src, tgt = row["source"], row["target"] |
| s_parts = src.split("_") |
| t_parts = tgt.split("_") |
| self.assertEqual(s_parts[0], t_parts[0], "misma tríada") |
| self.assertNotEqual(s_parts[1], t_parts[1], "fase opuesta") |
| s_pos = int(s_parts[2][1:]) |
| t_pos = int(t_parts[2][1:]) |
| self.assertEqual(t_pos, 2 - s_pos, "posición reflejada") |
|
|
| def test_creates_property_holds_in_csv(self): |
| """Cada arista creates respeta las cuatro reglas de creation_rules.""" |
| rules = self.spec["creation_rules"] |
| allowed = set() |
| for rule in rules: |
| for sp in rule["source_positions"]: |
| for tp in rule["target_positions"]: |
| allowed.add((rule["source_phase"], sp, rule["target_phase"], tp)) |
| for row in self.relations: |
| if row["relation"] != "creates": |
| continue |
| s_parts = row["source"].split("_") |
| t_parts = row["target"].split("_") |
| key = (s_parts[1], int(s_parts[2][1:]), t_parts[1], int(t_parts[2][1:])) |
| self.assertIn(key, allowed, f"creates no permitido: {row['source']} -> {row['target']}") |
|
|
| def test_vector_steps_count(self): |
| self.assertEqual(len(self.vectors), 20) |
|
|
| def test_lean_operators_file_exists_and_mentions_mirror(self): |
| """El código Lean debe existir y referenciar los operadores de espejo.""" |
| lean_spec = (ROOT / "IOM" / "Specification.lean").read_text(encoding="utf-8") |
| self.assertIn("mirror", lean_spec.lower()) |
| self.assertIn("TriadPosition", lean_spec) |
| self.assertTrue((ROOT / "IOM" / "Core.lean").exists()) |
| self.assertTrue((ROOT / "IOM" / "Operators.lean").exists()) |
|
|
| def test_ontology_ttl_contains_mirrorOf_and_creates(self): |
| ttl = (ROOT / "ontology" / "io_ontology.ttl").read_text(encoding="utf-8") |
| self.assertIn("mirrorOf", ttl) |
| self.assertIn("creates", ttl) |
| self.assertIn("OntoNode", ttl) |
|
|
| def test_shacl_shapes_exist(self): |
| shapes = (ROOT / "ontology" / "io_shapes.ttl").read_text(encoding="utf-8") |
| self.assertIn("mirrorOf", shapes) |
| self.assertIn("creates", shapes) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
