Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
"""Tests for the op-list vocabulary and validator (ops.py)."""
from __future__ import annotations
import json
import pytest
from akcli import ops
from akcli.errors import AkcliError
def _doc(op_list):
return {"protocol_version": 2, "target_format": "kicad", "ops": op_list}
def test_protocol_version_and_op_names():
assert ops.PROTOCOL_VERSION == 2
assert "place_component" in ops.OP_NAMES
assert "place_gnd" in ops.OP_NAMES and "place_vcc" in ops.OP_NAMES
# 13 original + delete_component / delete_object / move_component +
# rename_net + add_sheet + graphics (add_rectangle/add_text_box) +
# route_net + set_title_block
# (graphic annotation / group frames)
assert len(ops.OP_NAMES) == 22
assert {"delete_component", "delete_object", "move_component",
"rename_net", "add_sheet"} <= ops.OP_NAMES
def test_valid_oplist_has_no_errors():
doc = _doc([
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"x_mil": 100, "y_mil": 200, "rotation": 90},
{"op": "add_wire", "vertices": [[0, 0], [0, 100], "U1.1"]},
{"op": "place_power_port", "lib_id": "power:GND", "net_name": "GND", "at": [0, 0]},
])
assert ops.validate_oplist(doc) == []
def test_protocol_mismatch():
doc = _doc([])
doc["protocol_version"] = ops.PROTOCOL_VERSION + 1
errs = ops.validate_oplist(doc)
assert any(e.code == "PROTOCOL_MISMATCH" for e in errs)
def test_unknown_op_is_unsupported():
errs = ops.validate_oplist(_doc([{"op": "frobnicate"}]))
assert any(e.code == "OP_UNSUPPORTED" for e in errs)
def test_free_angle_rotation_rejected():
errs = ops.validate_oplist(_doc([
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"x_mil": 0, "y_mil": 0, "rotation": 45},
]))
assert any(e.code == "BAD_ANGLE" for e in errs)
def test_add_text_free_angle_allowed():
errs = ops.validate_oplist(_doc([
{"op": "add_text", "text": "note", "at": [0, 0], "angle": 33.5},
]))
assert errs == []
def test_malformed_wire_vertices_rejected():
errs = ops.validate_oplist(_doc([{"op": "add_wire", "vertices": [[0, 0]]}]))
assert any(e.code == "NON_ORTHOGONAL_WIRE" for e in errs)
errs2 = ops.validate_oplist(_doc([{"op": "add_wire", "vertices": [[0, 0], [1, 2, 3]]}]))
assert any(e.code == "NON_ORTHOGONAL_WIRE" for e in errs2)
def test_missing_required_field():
errs = ops.validate_oplist(_doc([{"op": "place_component", "lib_id": "Device:R"}]))
assert any(e.code == "OP_UNSUPPORTED" and "designator" in e.message for e in errs)
def test_bad_target_format():
doc = _doc([])
doc["target_format"] = "eagle"
errs = ops.validate_oplist(doc)
assert any(e.code == "OP_UNSUPPORTED" for e in errs)
def test_endpoint_pin_ref_accepted_but_only_for_wire():
# add_bus only accepts plain points, not pin refs
errs = ops.validate_oplist(_doc([{"op": "add_bus", "vertices": ["U1.1", [0, 0]]}]))
assert any(e.code == "NON_ORTHOGONAL_WIRE" for e in errs)
def test_load_oplist_roundtrip(tmp_path):
p = tmp_path / "ops.json"
doc = _doc([{"op": "add_junction", "at": [0, 0]}])
p.write_text(json.dumps(doc))
loaded = ops.load_oplist(p)
assert loaded == doc
def test_load_oplist_bad_json(tmp_path):
p = tmp_path / "bad.json"
p.write_text("{not json")
with pytest.raises(AkcliError) as ei:
ops.load_oplist(p)
assert ei.value.code == "OP_UNSUPPORTED"
def test_op_accessor():
op = ops.Op({"op": "add_junction", "at": [1, 2]})
assert op.name == "add_junction"
assert op["at"] == [1, 2]
assert op.get("missing", 7) == 7
def test_capabilities_loadable():
cap = ops.load_capabilities()
assert cap["ops"]["add_bus"]["altium"] is False
assert cap["ops"]["place_component"]["kicad"] is True
# add_sheet is kicad-only (hierarchical authoring)
assert cap["ops"]["add_sheet"] == {
"kicad": True, "altium": False,
"notes": "hierarchical (sheet ...) node + sheet pins; child file "
"authored separately (or created in-transaction with "
"create: true). OP_UNSUPPORTED on Altium live v1"}
assert cap["ops"]["rename_net"] == {
"kicad": True, "altium": False,
"notes": "rewrites label texts + power-port net Values; "
"0 matches = replay-safe note"}
# ------------------------------------------------------ validator hardening ----
def test_field_type_table_enforced():
errs = ops.validate_oplist(_doc([
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"x_mil": "oops", "y_mil": 0},
]))
assert len(errs) == 1 and errs[0].op_index == 0
assert "x_mil" in errs[0].message and "number" in errs[0].message
errs = ops.validate_oplist(_doc([
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"x_mil": 0, "y_mil": 0, "unit": 0},
]))
assert any("unit" in e.message and ">= 1" in e.message for e in errs)
errs = ops.validate_oplist(_doc([
{"op": "delete_component", "designator": "R1", "cascade": "yes"},
]))
assert any("cascade" in e.message for e in errs)
def test_unknown_field_did_you_mean():
errs = ops.validate_oplist(_doc([
{"op": "add_net_label", "name": "N1", "at": [0, 0], "rotatoin": 90},
]))
assert len(errs) == 1
assert "unknown field 'rotatoin'" in errs[0].message
assert "did you mean 'rotation'" in errs[0].message
# keys starting with "_" are annotation-safe
assert ops.validate_oplist(_doc([
{"op": "add_junction", "at": [0, 0], "_note": "T here"},
])) == []
# --------------------------------------------------------------------------- #
# protocol 2 field renames (docs/migration-0.21.md)
# --------------------------------------------------------------------------- #
@pytest.mark.parametrize("op,old,new", [
({"op": "add_net_label", "name": "N1", "at": [0, 0]},
"orientation", "rotation"),
({"op": "set_component_parameters", "designator": "R1"},
"reference", "new_designator"),
({"op": "set_component_parameters", "designator": "R1"},
"instance_references", "instance_designators"),
({"op": "rename_net", "old_name": "A", "new_name": "B"},
"from", "old_name"),
({"op": "rename_net", "old_name": "A", "new_name": "B"},
"to", "new_name"),
])
def test_v1_field_name_reports_the_rename(op, old, new):
"""A protocol-1 spelling gets NAMED, not a bare unknown-field guess.
``from`` -> ``old_name`` is invisible to difflib, so without the rename
table the most common upgrade error would arrive with no hint at all.
"""
errs = ops.validate_oplist(_doc([{**op, old: 0}]))
assert len(errs) == 1
assert errs[0].code == "OP_UNSUPPORTED"
assert (f"field {old!r} was renamed to {new!r} in protocol "
f"{ops.PROTOCOL_VERSION}") in errs[0].message
def test_rename_hints_are_scoped_to_the_op_that_moved():
"""route_net/connect_and_label keep from/to; connect_and_label keeps
orientation — none of them may be reported as a stale v1 spelling."""
assert ops.validate_oplist(_doc([
{"op": "route_net", "from": "R1.1", "to": "R2.1"},
{"op": "connect_and_label", "from": "R1.2", "to": "R2.2", "net": "N",
"orientation": 90},
])) == []
def test_protocol_1_document_reports_both_the_envelope_and_the_renames():
"""The whole upgrade is diagnosable from ONE run of the validator."""
doc = _doc([{"op": "add_net_label", "name": "N1", "at": [0, 0],
"orientation": 90}])
doc["protocol_version"] = 1
errs = ops.validate_oplist(doc)
assert any(e.code == "PROTOCOL_MISMATCH" for e in errs)
assert any("renamed to 'rotation'" in e.message for e in errs)
def test_unknown_op_did_you_mean():
errs = ops.validate_oplist(_doc([{"op": "plce_component"}]))
assert any("did you mean 'place_component'" in e.message for e in errs)
def test_duplicate_designator_unit_lint():
errs = ops.validate_oplist(_doc([
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"x_mil": 0, "y_mil": 0},
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"x_mil": 100, "y_mil": 0},
]))
assert len(errs) == 1 and errs[0].op_index == 1
assert "duplicate placement" in errs[0].message and "'R1'" in errs[0].message
# a different UNIT of the same part is legitimate
assert ops.validate_oplist(_doc([
{"op": "place_component", "lib_id": "X:OPA", "designator": "U1",
"x_mil": 0, "y_mil": 0, "unit": 1},
{"op": "place_component", "lib_id": "X:OPA", "designator": "U1",
"x_mil": 500, "y_mil": 0, "unit": 2},
])) == []
# delete-then-replace in one op-list is NOT a duplicate
assert ops.validate_oplist(_doc([
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"x_mil": 0, "y_mil": 0},
{"op": "delete_component", "designator": "R1"},
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"x_mil": 300, "y_mil": 0},
])) == []
def test_delete_object_exactly_one_of_uuid_match():
assert any("exactly one" in e.message for e in
ops.validate_oplist(_doc([{"op": "delete_object"}])))
assert any("exactly one" in e.message for e in ops.validate_oplist(_doc([
{"op": "delete_object", "uuid": "u", "match": {"kind": "wire"}}])))
assert ops.validate_oplist(_doc([
{"op": "delete_object", "match": {"kind": "label", "name": "N1"}}])) == []
errs = ops.validate_oplist(_doc([
{"op": "delete_object", "match": {"kind": "resistor"}}]))
assert any("match.kind" in e.message for e in errs)
errs = ops.validate_oplist(_doc([
{"op": "delete_object", "match": {"kind": "wire", "att": [0, 0]}}]))
assert any("match.att" in e.message and "did you mean" in e.message
for e in errs)
def test_mid_anchor_accepted_for_labels_and_ports_only():
assert ops.parse_mid_anchor("mid(U1.1,U2.3)") == ("U1.1", "U2.3")
assert ops.parse_mid_anchor("mid( R1.2 , R2.1 )") == ("R1.2", "R2.1")
assert ops.parse_mid_anchor("mid(U1.1)") is None
assert ops.validate_oplist(_doc([
{"op": "add_net_label", "name": "N", "at": "mid(U1.1,U2.3)"},
{"op": "place_power_port", "lib_id": "power:PWR_FLAG",
"net_name": "PWR_FLAG", "at": "mid(U1.1,U2.3)"},
])) == []
# malformed mid() is rejected, not treated as a pin ref
errs = ops.validate_oplist(_doc([
{"op": "add_net_label", "name": "N", "at": "mid(U1.1,U2"},
]))
assert any("at" in e.message for e in errs)
# wire vertices do NOT take mid() anchors
errs = ops.validate_oplist(_doc([
{"op": "add_wire", "vertices": ["mid(U1.1,U2.3)", [0, 0]]},
]))
assert any(e.code == "NON_ORTHOGONAL_WIRE" for e in errs)
def test_rename_net_validation():
assert ops.validate_oplist(_doc([
{"op": "rename_net", "old_name": "A", "new_name": "B"},
{"op": "rename_net", "old_name": "A", "new_name": "B",
"scope": "global"},
])) == []
errs = ops.validate_oplist(_doc([{"op": "rename_net", "old_name": "A"}]))
assert any("'new_name'" in e.message for e in errs)
errs = ops.validate_oplist(_doc([
{"op": "rename_net", "old_name": "A", "new_name": "B",
"scope": "power"}]))
assert any("scope" in e.message for e in errs)
def test_top_level_array_root_names_the_wrapper(tmp_path):
# the most natural agent mistake gets the exact wrapper skeleton back
p = tmp_path / "arr.json"
p.write_text(json.dumps([{"op": "add_junction", "at": [0, 0]}]))
with pytest.raises(AkcliError) as exc:
ops.load_oplist(p)
assert '"ops": [...]' in exc.value.message
def test_missing_vertices_is_one_error_not_two():
errs = ops.validate_oplist(_doc([{"op": "add_wire"}]))
assert len(errs) == 1
assert errs[0].code == "OP_UNSUPPORTED"
assert "missing required field 'vertices'" in errs[0].message
def test_wrong_type_vertices_is_op_unsupported_not_wire_code():
errs = ops.validate_oplist(_doc([{"op": "add_wire", "vertices": "oops"}]))
assert [e.code for e in errs] == ["OP_UNSUPPORTED"]
def test_place_component_at_field_gets_coordinate_hint():
errs = ops.validate_oplist(_doc([
{"op": "place_component", "lib_id": "Device:R", "designator": "R1",
"at": [0, 0]},
]))
hint = next(e for e in errs if "unknown field 'at'" in e.message)
assert "x_mil" in hint.message
def test_duplicate_annotation_key_lint():
errs = ops.validate_oplist(_doc([
{"op": "add_text", "text": "ONE", "at": [0, 0], "key": "n"},
{"op": "add_text", "text": "TWO", "at": [500, 0], "key": "n"},
]))
assert len(errs) == 1 and errs[0].op_index == 1
assert "duplicate annotation key" in errs[0].message
# different tags may share a key (uuids are seeded per tag)
assert ops.validate_oplist(_doc([
{"op": "add_text", "text": "T", "at": [0, 0], "key": "n"},
{"op": "add_rectangle", "start": [0, 0], "end": [100, 100],
"key": "n"},
])) == []
# keyless annotations never collide (coord+index seeded)
assert ops.validate_oplist(_doc([
{"op": "add_text", "text": "A", "at": [0, 0]},
{"op": "add_text", "text": "B", "at": [0, 0]},
])) == []
def test_writer_annotation_key_collision_guard():
from akcli.writers import kicad as kwriter
ctx = kwriter._ctx_new()
uid1 = kwriter._annotation_uuid(
"00000000-0000-0000-0000-000000000000", "text",
{"key": "n"}, "0:0", 0, ctx)
# the same op re-claimed at the same index is idempotent
assert kwriter._annotation_uuid(
"00000000-0000-0000-0000-000000000000", "text",
{"key": "n"}, "0:0", 0, ctx) == uid1
with pytest.raises(AkcliError) as ei:
kwriter._annotation_uuid(
"00000000-0000-0000-0000-000000000000", "text",
{"key": "n"}, "9:9", 3, ctx)
assert "collides" in str(ei.value)
def test_writer_handlers_census_matches_registry():
"""Lockstep step 3 (writer handler) has a gate like every other step."""
from akcli.writers import kicad as kwriter
assert set(kwriter._HANDLERS) == set(ops.OP_NAMES)
assert set(ops._MACRO_EXPANDERS) == set(ops.MACRO_OPS)
2126c3284This file is pinned to the selected release. Download the original to open it in your design tool.