Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
103 changes: 103 additions & 0 deletions tests/test_architecture_evidence_topology_diagnostic.py
Original file line number Diff line number Diff line change
Expand Up @@ -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"], []))
Expand Down
32 changes: 30 additions & 2 deletions tools/evidence_topology_diagnostic.py
Original file line number Diff line number Diff line change
Expand Up @@ -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"])
Expand All @@ -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")
Expand Down
Loading