diff --git a/tests/test_architecture_evidence_topology_diagnostic.py b/tests/test_architecture_evidence_topology_diagnostic.py index f086ca554..d6e5207da 100644 --- a/tests/test_architecture_evidence_topology_diagnostic.py +++ b/tests/test_architecture_evidence_topology_diagnostic.py @@ -120,6 +120,109 @@ def test_node_metadata_changes_not_scientifically_interpreted(self): self.assertEqual((r["before"]["all_edges"]["beta0"], r["after"]["all_edges"]["beta0"]), (1, 1)) self.assertNotIn("classification", r) + def compare_documents(self, before, after): + sources = [] + for name, document in (("before.json", before), ("after.json", after)): + # Preserve insertion order so key-order controls reach the real CLI. + raw = json.dumps(document, separators=(",", ":")).encode("utf-8") + path = self.root / name + path.write_bytes(raw) + sources.append((path, hashlib.sha256(raw).hexdigest())) + (p, pd), (q, qd) = sources + rc, report, err = self.call(p, pd, "--compare", q, "--compare-sha256", qd) + self.assertEqual((rc, err), (0, "")) + self.assertEqual(report["before"]["raw_sha256"], pd) + self.assertEqual(report["after"]["raw_sha256"], qd) + self.assertEqual(report["scientific_effect"], "NONE") + self.assertIs(report["scientific_status_authority"], False) + self.assertEqual(report["before"]["all_edges"], report["after"]["all_edges"]) + self.assertEqual(report["before"]["required_edges_only"], + report["after"]["required_edges_only"]) + self.assertEqual(report["delta"]["nodes_added"], []) + self.assertEqual(report["delta"]["nodes_removed"], []) + self.assertEqual(report["delta"]["typed_edges_added"], []) + self.assertEqual(report["delta"]["typed_edges_removed"], []) + return report["delta"] + + def test_boolean_number_node_changes_are_reported(self): + for old, new in ((True, 1), (False, 0), (True, 1.0), (False, 0.0)): + for left, right in ((old, new), (new, old)): + with self.subTest(left=left, right=right): + before, after = graph(["a", "b"], []), graph(["a", "b"], []) + before["nodes"]["a"]["value"] = left + after["nodes"]["a"]["value"] = right + delta = self.compare_documents(before, after) + self.assertEqual(delta["node_attributes_changed"], ["a"]) + self.assertIs(delta["other_metadata_changed"], False) + + def test_nested_boolean_number_node_changes_are_reported(self): + for old, new in ((True, 1), (False, 0), (True, 1.0), (False, 0.0)): + for left, right in ((old, new), (new, old)): + with self.subTest(left=left, right=right): + before, after = graph(["a", "b"], []), graph(["a", "b"], []) + before["nodes"]["b"]["value"] = {"outer": [{"inner": [left]}]} + after["nodes"]["b"]["value"] = {"outer": [{"inner": [right]}]} + delta = self.compare_documents(before, after) + self.assertEqual(delta["node_attributes_changed"], ["b"]) + self.assertIs(delta["other_metadata_changed"], False) + + def test_boolean_number_metadata_changes_are_reported(self): + for old, new in ((True, 1), (False, 0), (True, 1.0), (False, 0.0)): + for left, right in ((old, new), (new, old)): + with self.subTest(left=left, right=right): + delta = self.compare_documents(graph(["a"], [], value=left), + graph(["a"], [], value=right)) + self.assertEqual(delta["node_attributes_changed"], []) + self.assertIs(delta["other_metadata_changed"], True) + + def test_nested_boolean_number_metadata_changes_are_reported(self): + for old, new in ((True, 1), (False, 0), (True, 1.0), (False, 0.0)): + for left, right in ((old, new), (new, old)): + with self.subTest(left=left, right=right): + before = graph(["a"], [], value=[{"outer": [left]}]) + after = graph(["a"], [], value=[{"outer": [right]}]) + delta = self.compare_documents(before, after) + self.assertEqual(delta["node_attributes_changed"], []) + self.assertIs(delta["other_metadata_changed"], True) + + def test_parsed_value_equivalence_does_not_invent_changes(self): + cases = ((True, True), (False, False), (None, None), ([], []), ({}, {}), + (1, 1.0), (0, -0.0), + ({"a": [True, None, 1], "b": {"x": False}}, + {"b": {"x": False}, "a": [True, None, 1.0]})) + for left, right in cases: + with self.subTest(left=left, right=right): + before, after = graph(["a"], [], value=left), graph(["a"], [], value=right) + before["nodes"]["a"]["value"] = left + after["nodes"]["a"]["value"] = right + delta = self.compare_documents(before, after) + self.assertEqual(delta["node_attributes_changed"], []) + self.assertIs(delta["other_metadata_changed"], False) + + def test_other_parsed_value_changes_remain_reported(self): + cases = ((1, 2), (None, False), ("1", 1), ([], {}), + ([1], [1, 2]), ([1, 2], [2, 1]), + ({"a": None}, {"b": None}), ({"a": []}, {"a": [], "b": 0})) + for left, right in cases: + with self.subTest(left=left, right=right): + before, after = graph(["a"], [], value=left), graph(["a"], [], value=right) + before["nodes"]["a"]["value"] = left + after["nodes"]["a"]["value"] = right + delta = self.compare_documents(before, after) + self.assertEqual(delta["node_attributes_changed"], ["a"]) + self.assertIs(delta["other_metadata_changed"], True) + + def test_deeply_nested_parsed_values_keep_comparison_semantics(self): + for right, changed in ((True, False), (1, True)): + with self.subTest(changed=changed): + left = True + for _ in range(300): + left, right = [left], [right] + delta = self.compare_documents(graph(["a"], [], value=left), + graph(["a"], [], value=right)) + self.assertEqual(delta["node_attributes_changed"], []) + self.assertIs(delta["other_metadata_changed"], changed) + def test_no_comparison_without_both_flags(self): p, pd = self.source("a.json", graph(["a"], [])) q, qd = self.source("b.json", graph(["b"], [])) diff --git a/tools/evidence_topology_diagnostic.py b/tools/evidence_topology_diagnostic.py index 01e662ea7..36e4cc7c6 100644 --- a/tools/evidence_topology_diagnostic.py +++ b/tools/evidence_topology_diagnostic.py @@ -183,6 +183,33 @@ def _edge_record(edge): return {"from": src, "to": dst, "relation": relation, "required": required} +def _json_equal(left, right): + """Compare parsed values without Python's bool/number coercion. + + Preserve existing numeric equality (1 == 1.0, 0 == -0.0) and parser + precision. This is not lexical or lossless-decimal comparison; raw source + digests retain byte identity. Object order is immaterial; array order is + significant. Use an explicit stack to avoid a new recursion-depth limit. + """ + pending = [(left, right)] + while pending: + a, b = pending.pop() + if type(a) is bool or type(b) is bool: + if type(a) is not type(b) or a != b: + return False + elif type(a) is dict and type(b) is dict: + if a.keys() != b.keys(): + return False + pending.extend((value, b[key]) for key, value in a.items()) + elif type(a) is list and type(b) is list: + if len(a) != len(b): + return False + pending.extend(zip(a, b)) + elif a != b: + return False + return True + + def compare(first, second): left, right = first["nodes"], second["nodes"] old, new = set(first["edges"]), set(second["edges"]) @@ -191,10 +218,11 @@ def compare(first, second): return { "nodes_added": sorted(new_ids - old_ids), "nodes_removed": sorted(old_ids - new_ids), - "node_attributes_changed": sorted(node for node in old_ids & new_ids if left[node] != right[node]), + "node_attributes_changed": sorted(node for node in old_ids & new_ids + if not _json_equal(left[node], right[node])), "typed_edges_added": [_edge_record(e) for e in sorted(new - old)], "typed_edges_removed": [_edge_record(e) for e in sorted(old - new)], - "other_metadata_changed": first["metadata"] != second["metadata"], + "other_metadata_changed": not _json_equal(first["metadata"], second["metadata"]), "beta_delta": { subset: {key: b[subset][key] - a[subset][key] for key in ("beta0", "beta1")} for subset in ("all_edges", "required_edges_only")