File size: 6,169 Bytes
875f067 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 | """The envelope of one turn: what a node receives, what it hands back, and what survives the trip.
A dossier is a nest of exact rationals, and the channel between two nodes is a JSON string inside a
natural language field. The two things that have to survive that trip are the value of a number and
the memory of what the earlier nodes saw, so these tests watch both closely: a number that arrives
rounded, or a dossier that arrives with the earlier turns forgotten, would silently turn a verified
answer into an unsupported one.
"""
import json
import re
from fractions import Fraction
from pathlib import Path
import pytest
from lgphys import agents, families, pipeline, protocol, smt
ROOT = Path(__file__).resolve().parents[1]
CONVERT = "convert 5 km/h to m/s"
def _chain(question: str):
"""Run the eleven nodes the way the orchestrator would, one envelope at a time."""
seed = json.loads((ROOT / "nodes" / "arbiter" / "seed_payload.json").read_text(encoding="utf-8"))
seed["payload"]["naturalLanguage"] = question
seed["payload"]["abstractSyntaxTree"] = "PhysicsProblem " + question
handed, envelopes = seed, []
for name in agents.ALL_AGENTS:
handed = protocol.respond(name, handed, name)
envelopes.append(handed)
return envelopes
def test_a_fraction_survives_the_trip_unchanged():
dossier = protocol.start(CONVERT)
dossier["roads"] = {"read_a": Fraction(25, 18), "read_b": Fraction(25, 18)}
text = protocol.encode(CONVERT, dossier)
assert "25/18" in text
assert not re.search(r"\d+\.\d", text), "a decimal point in an exact rational"
problem, back = protocol.decode(text)
assert problem == CONVERT
assert Fraction(back["roads"]["read_a"]) == Fraction(25, 18)
assert Fraction(back["roads"]["read_b"]) == Fraction(25, 18)
def test_the_marker_keeps_the_prose_and_the_memory_apart():
text = protocol.encode(CONVERT, protocol.start(CONVERT))
assert text.startswith(CONVERT + "\n" + protocol.MARK)
assert text.count(protocol.MARK) == 1
def test_an_envelope_carries_the_three_parts_of_a_claim():
claim = (["declare-fun x () Int"], ["(assert (> x 0))"], "sat")
envelope = protocol.envelope("reader_a", "arbiter", 3, 7, CONVERT, protocol.start(CONVERT), claim)
assert envelope["sender"] == "reader_a" and envelope["recipient"] == "arbiter"
assert envelope["turn"] == 3 and envelope["volatileState"]["internalTimeTick"] == 7
payload = envelope["payload"]
assert payload["abstractSyntaxTree"].startswith("PhysicsProblem")
assert payload["smtConstraints"] == {"declarations": ["declare-fun x () Int"],
"assertions": ["(assert (> x 0))"], "z3Status": "sat"}
def test_an_envelope_without_a_recipient_omits_the_field():
envelope = protocol.envelope("arbiter", None, 0, 0, "", protocol.start(""), ([], ["(assert true)"], "sat"))
assert "recipient" not in envelope
def test_a_node_echoes_the_turn_it_was_handed():
handed = protocol.envelope("reader_b", "reader_a", 4, 11, CONVERT, protocol.start(CONVERT),
([], ["(assert true)"], "sat"))
outgoing = protocol.respond("reader_a", handed, "reader_a")
# The orchestrator keeps the count of the turns; a node that booked its own turn would end the
# session early or run it past the pipeline the topology declares.
assert outgoing["turn"] == 4
assert outgoing["volatileState"]["internalTimeTick"] == 11
assert outgoing["sender"] == "reader_a" and outgoing["recipient"] == "reader_b"
def test_a_node_that_stops_leaves_a_note_instead_of_stopping_the_chain(monkeypatch):
def explode(role, dossier):
raise ZeroDivisionError("the reading fell over")
monkeypatch.setattr(agents, "run_step", explode)
handed = protocol.envelope("domain_a", "reader_b", 2, 5, CONVERT, protocol.start(CONVERT),
([], ["(assert true)"], "sat"))
outgoing = protocol.respond("domain_a", handed, "domain_a")
_problem, dossier = protocol.decode(outgoing["payload"]["naturalLanguage"])
assert "ZeroDivisionError" in dossier["crash"]["domain_a"]
assert outgoing["payload"]["smtConstraints"]["assertions"] == ["(assert true)"]
assert outgoing["payload"]["smtConstraints"]["z3Status"] == "sat"
@pytest.fixture(scope="module")
def envelopes():
"""One chain run, shared by the tests that read it: eleven nodes and one question."""
return _chain(CONVERT)
@pytest.fixture(scope="module")
def carried(envelopes):
"""The dossier as it stands in the last envelope of that chain."""
return protocol.decode(envelopes[-1]["payload"]["naturalLanguage"])[1]
@pytest.fixture(scope="module")
def referee(envelopes):
"""Each claim re-checked by Z3 over the ontology of the node that wrote it."""
checked = []
for name, envelope in zip(agents.ALL_AGENTS, envelopes):
base = (ROOT / "nodes" / name / "ontology.smt2").read_text(encoding="utf-8")
constraints = envelope["payload"]["smtConstraints"]
checked.append({"sender": name, "claimed": constraints["z3Status"],
"referee": smt.referee(base, constraints["declarations"],
constraints["assertions"])})
return checked
def test_the_chain_hands_the_same_answer_through_envelopes_as_in_one_process(carried):
assert not carried.get("crash"), carried.get("crash")
inside = pipeline.run(CONVERT)
assert carried.get("answer") == inside["dossier"].get("answer")
assert sorted(carried.get("states")) == sorted(agents.ALL_AGENTS)
def test_every_claim_holds_against_the_ontology_of_the_node_that_made_it(referee):
for record in referee:
assert record["referee"] == record["claimed"], record
def test_the_verdict_of_the_envelope_chain_is_the_verdict_of_the_session(carried, referee):
decision = pipeline.checked_verdict(carried, referee)
assert decision["status"] == "VERIFIED"
assert decision["assurance"] == 2
family = families.family_for(str(carried.get("kind")))
assert family.gold_equal(carried["answer"], {"value": "25/18", "unit": "m/s"})
|