d58283ef0a
When moving a schematic component whose pins directly touch pins of stationary components (no wire segment, just pin-to-pin contact), synthesize bridge wires to preserve the electrical connection after the move. Also fixes duplicate-pin-position collision in old_to_new map and updates symbol reference assignment to use setAllReferences. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
1010 lines
39 KiB
Python
1010 lines
39 KiB
Python
"""
|
|
Tests for move_schematic_component with wire preservation (WireDragger).
|
|
|
|
Unit tests use synthetic sexpdata lists — no disk I/O, no KiCAD install needed.
|
|
Integration tests copy empty.kicad_sch to a tempdir and exercise the full handler.
|
|
"""
|
|
|
|
import shutil
|
|
import sys
|
|
import tempfile
|
|
from pathlib import Path
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
import sexpdata
|
|
from sexpdata import Symbol
|
|
|
|
# Make python/ importable
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
|
|
from commands.wire_dragger import EPS, WireDragger, _coords_match, _rotate
|
|
|
|
TEMPLATE_PATH = Path(__file__).resolve().parent.parent / "templates" / "empty.kicad_sch"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _sym(name: str) -> Symbol:
|
|
return Symbol(name)
|
|
|
|
|
|
def _make_wire(x1, y1, x2, y2):
|
|
return [
|
|
_sym("wire"),
|
|
[_sym("pts"), [_sym("xy"), x1, y1], [_sym("xy"), x2, y2]],
|
|
[_sym("stroke"), [_sym("width"), 0], [_sym("type"), _sym("default")]],
|
|
[_sym("uuid"), "00000000-0000-0000-0000-000000000000"],
|
|
]
|
|
|
|
|
|
def _make_junction(x, y):
|
|
return [
|
|
_sym("junction"),
|
|
[_sym("at"), x, y],
|
|
[_sym("diameter"), 0],
|
|
[_sym("color"), 0, 0, 0, 0],
|
|
[_sym("uuid"), "00000000-0000-0000-0000-000000000001"],
|
|
]
|
|
|
|
|
|
def _make_symbol(ref, x, y, rotation=0, lib_id="Device:R", mirror=None):
|
|
"""Build a minimal placed-symbol s-expression."""
|
|
item = [
|
|
_sym("symbol"),
|
|
[_sym("lib_id"), lib_id],
|
|
[_sym("at"), x, y, rotation],
|
|
[_sym("unit"), 1],
|
|
[_sym("property"), "Reference", ref, [_sym("at"), x + 2, y, 0]],
|
|
[_sym("property"), "Value", "10k", [_sym("at"), x, y, 0]],
|
|
]
|
|
if mirror:
|
|
item.append([_sym("mirror"), _sym(mirror)])
|
|
return item
|
|
|
|
|
|
def _make_lib_symbol_r():
|
|
"""Minimal Device:R lib_symbols entry — pins at (0, 3.81) and (0, -3.81)."""
|
|
return [
|
|
_sym("symbol"),
|
|
"Device:R",
|
|
[
|
|
_sym("symbol"),
|
|
"R_1_1",
|
|
[
|
|
_sym("pin"),
|
|
_sym("passive"),
|
|
_sym("line"),
|
|
[_sym("at"), 0, 3.81, 270],
|
|
[_sym("length"), 1.27],
|
|
[
|
|
_sym("name"),
|
|
"~",
|
|
[_sym("effects"), [_sym("font"), [_sym("size"), 1.27, 1.27]]],
|
|
],
|
|
[
|
|
_sym("number"),
|
|
"1",
|
|
[_sym("effects"), [_sym("font"), [_sym("size"), 1.27, 1.27]]],
|
|
],
|
|
],
|
|
[
|
|
_sym("pin"),
|
|
_sym("passive"),
|
|
_sym("line"),
|
|
[_sym("at"), 0, -3.81, 90],
|
|
[_sym("length"), 1.27],
|
|
[
|
|
_sym("name"),
|
|
"~",
|
|
[_sym("effects"), [_sym("font"), [_sym("size"), 1.27, 1.27]]],
|
|
],
|
|
[
|
|
_sym("number"),
|
|
"2",
|
|
[_sym("effects"), [_sym("font"), [_sym("size"), 1.27, 1.27]]],
|
|
],
|
|
],
|
|
],
|
|
]
|
|
|
|
|
|
def _make_sch_data(extra_items=None):
|
|
"""Build a minimal sch_data list with lib_symbols and sheet_instances."""
|
|
data = [
|
|
_sym("kicad_sch"),
|
|
[_sym("lib_symbols"), _make_lib_symbol_r()],
|
|
[_sym("sheet_instances"), [_sym("path"), "/", [_sym("page"), "1"]]],
|
|
]
|
|
if extra_items:
|
|
# Insert before sheet_instances (last item)
|
|
for item in extra_items:
|
|
data.insert(len(data) - 1, item)
|
|
return data
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TestRotatePoint
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestRotatePoint:
|
|
def test_zero_rotation(self):
|
|
assert _rotate(1.0, 2.0, 0) == (1.0, 2.0)
|
|
|
|
def test_90_degrees(self):
|
|
rx, ry = _rotate(1.0, 0.0, 90)
|
|
assert abs(rx - 0.0) < 1e-9
|
|
assert abs(ry - 1.0) < 1e-9
|
|
|
|
def test_180_degrees(self):
|
|
rx, ry = _rotate(1.0, 0.0, 180)
|
|
assert abs(rx - (-1.0)) < 1e-9
|
|
assert abs(ry - 0.0) < 1e-9
|
|
|
|
def test_270_degrees(self):
|
|
rx, ry = _rotate(0.0, 1.0, 270)
|
|
assert abs(rx - 1.0) < 1e-6
|
|
assert abs(ry - 0.0) < 1e-6
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TestFindSymbol
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestFindSymbol:
|
|
def test_returns_none_for_missing_reference(self):
|
|
sch = _make_sch_data([_make_symbol("R1", 10, 20)])
|
|
assert WireDragger.find_symbol(sch, "R99") is None
|
|
|
|
def test_returns_item_and_position(self):
|
|
sch = _make_sch_data([_make_symbol("R1", 10.5, 20.5, rotation=90)])
|
|
result = WireDragger.find_symbol(sch, "R1")
|
|
assert result is not None
|
|
_, old_x, old_y, rotation, lib_id, mirror_x, mirror_y = result
|
|
assert abs(old_x - 10.5) < EPS
|
|
assert abs(old_y - 20.5) < EPS
|
|
assert abs(rotation - 90) < EPS
|
|
assert lib_id == "Device:R"
|
|
assert mirror_x is False
|
|
assert mirror_y is False
|
|
|
|
def test_detects_mirror_x(self):
|
|
sch = _make_sch_data([_make_symbol("R1", 0, 0, mirror="x")])
|
|
result = WireDragger.find_symbol(sch, "R1")
|
|
assert result is not None
|
|
assert result[5] is True # mirror_x
|
|
assert result[6] is False # mirror_y
|
|
|
|
def test_detects_mirror_y(self):
|
|
sch = _make_sch_data([_make_symbol("R1", 0, 0, mirror="y")])
|
|
result = WireDragger.find_symbol(sch, "R1")
|
|
assert result is not None
|
|
assert result[5] is False # mirror_x
|
|
assert result[6] is True # mirror_y
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TestComputePinPositions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestComputePinPositions:
|
|
def test_resistor_at_origin_no_rotation(self):
|
|
"""Device:R at (0, 0) rot=0 — pins at (0, 3.81) and (0, -3.81)."""
|
|
sch = _make_sch_data([_make_symbol("R1", 0, 0)])
|
|
positions = WireDragger.compute_pin_positions(sch, "R1", 10, 20)
|
|
assert "1" in positions and "2" in positions
|
|
old1, new1 = positions["1"]
|
|
old2, new2 = positions["2"]
|
|
# Pin 1 old: (0 + 0, 0 + 3.81)
|
|
assert abs(old1[0] - 0) < 1e-4
|
|
assert abs(old1[1] - 3.81) < 1e-4
|
|
# Pin 2 old: (0 + 0, 0 - 3.81)
|
|
assert abs(old2[0] - 0) < 1e-4
|
|
assert abs(old2[1] - (-3.81)) < 1e-4
|
|
# New positions shifted by (10, 20)
|
|
assert abs(new1[0] - 10) < 1e-4
|
|
assert abs(new1[1] - 23.81) < 1e-4
|
|
assert abs(new2[0] - 10) < 1e-4
|
|
assert abs(new2[1] - 16.19) < 1e-4
|
|
|
|
def test_resistor_rotated_90(self):
|
|
"""Device:R at (100, 100) rot=90 — pins should be at (100+3.81, 100) and (100-3.81, 100)."""
|
|
sch = _make_sch_data([_make_symbol("R1", 100, 100, rotation=90)])
|
|
positions = WireDragger.compute_pin_positions(sch, "R1", 100, 100)
|
|
old1, _ = positions["1"]
|
|
old2, _ = positions["2"]
|
|
# rotate(0, 3.81, 90) = (0*cos90 - 3.81*sin90, 0*sin90 + 3.81*cos90) = (-3.81, 0)
|
|
# Wait — pin 1 is at local (0, 3.81), rotated 90° CCW:
|
|
# x' = 0*cos90 - 3.81*sin90 = -3.81, y' = 0*sin90 + 3.81*cos90 ≈ 0
|
|
# world: (100 - 3.81, 100 + 0) = (96.19, 100)
|
|
assert abs(old1[0] - 96.19) < 1e-3
|
|
assert abs(old1[1] - 100) < 1e-3
|
|
|
|
def test_returns_empty_for_missing_component(self):
|
|
sch = _make_sch_data()
|
|
result = WireDragger.compute_pin_positions(sch, "MISSING", 0, 0)
|
|
assert result == {}
|
|
|
|
def test_delta_is_consistent(self):
|
|
"""new_xy - old_xy should equal (new_x - old_x, new_y - old_y) for any rotation."""
|
|
sch = _make_sch_data([_make_symbol("R1", 50, 50, rotation=45)])
|
|
positions = WireDragger.compute_pin_positions(sch, "R1", 60, 70)
|
|
for pin_num, (old_xy, new_xy) in positions.items():
|
|
dx = new_xy[0] - old_xy[0]
|
|
dy = new_xy[1] - old_xy[1]
|
|
assert abs(dx - 10) < 1e-4, f"Pin {pin_num}: dx={dx}"
|
|
assert abs(dy - 20) < 1e-4, f"Pin {pin_num}: dy={dy}"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TestDragWires
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestDragWires:
|
|
def test_no_wires_returns_zero_counts(self):
|
|
sch = _make_sch_data()
|
|
result = WireDragger.drag_wires(sch, {(0.0, 0.0): (10.0, 10.0)})
|
|
assert result["endpoints_moved"] == 0
|
|
assert result["wires_removed"] == 0
|
|
|
|
def test_wire_start_endpoint_moved(self):
|
|
wire = _make_wire(0, 3.81, 0, 10)
|
|
sch = _make_sch_data([wire])
|
|
result = WireDragger.drag_wires(sch, {(0.0, 3.81): (10.0, 23.81)})
|
|
assert result["endpoints_moved"] == 1
|
|
assert result["wires_removed"] == 0
|
|
# Find the updated wire in sch_data
|
|
updated = next(i for i in sch if isinstance(i, list) and i and i[0] == Symbol("wire"))
|
|
pts = next(s for s in updated[1:] if isinstance(s, list) and s and s[0] == Symbol("pts"))
|
|
xy1 = pts[1]
|
|
assert abs(xy1[1] - 10.0) < EPS
|
|
assert abs(xy1[2] - 23.81) < EPS
|
|
|
|
def test_wire_end_endpoint_moved(self):
|
|
wire = _make_wire(0, 10, 0, -3.81)
|
|
sch = _make_sch_data([wire])
|
|
result = WireDragger.drag_wires(sch, {(0.0, -3.81): (10.0, 16.19)})
|
|
assert result["endpoints_moved"] == 1
|
|
updated = next(i for i in sch if isinstance(i, list) and i and i[0] == Symbol("wire"))
|
|
pts = next(s for s in updated[1:] if isinstance(s, list) and s and s[0] == Symbol("pts"))
|
|
xy2 = pts[2]
|
|
assert abs(xy2[1] - 10.0) < EPS
|
|
assert abs(xy2[2] - 16.19) < EPS
|
|
|
|
def test_zero_length_wire_removed(self):
|
|
"""When both endpoints of a wire are moved to the same point, wire is deleted."""
|
|
wire = _make_wire(0, 3.81, 0, -3.81)
|
|
sch = _make_sch_data([wire])
|
|
# Both pins land at same position (degenerate move)
|
|
result = WireDragger.drag_wires(
|
|
sch,
|
|
{
|
|
(0.0, 3.81): (5.0, 5.0),
|
|
(0.0, -3.81): (5.0, 5.0),
|
|
},
|
|
)
|
|
assert result["wires_removed"] == 1
|
|
wires_remaining = [i for i in sch if isinstance(i, list) and i and i[0] == Symbol("wire")]
|
|
assert len(wires_remaining) == 0
|
|
|
|
def test_unrelated_wire_not_touched(self):
|
|
"""A wire whose endpoints don't match any old pin is not changed."""
|
|
wire = _make_wire(50, 50, 60, 50)
|
|
sch = _make_sch_data([wire])
|
|
original_start = (50.0, 50.0)
|
|
result = WireDragger.drag_wires(sch, {(0.0, 3.81): (10.0, 23.81)})
|
|
assert result["endpoints_moved"] == 0
|
|
updated = next(i for i in sch if isinstance(i, list) and i and i[0] == Symbol("wire"))
|
|
pts = next(s for s in updated[1:] if isinstance(s, list) and s and s[0] == Symbol("pts"))
|
|
xy1 = pts[1]
|
|
assert abs(xy1[1] - 50.0) < EPS
|
|
assert abs(xy1[2] - 50.0) < EPS
|
|
|
|
def test_both_endpoints_on_moved_component(self):
|
|
"""Wire connecting two pins of same component — both endpoints shift together."""
|
|
wire = _make_wire(0, 3.81, 0, -3.81)
|
|
sch = _make_sch_data([wire])
|
|
result = WireDragger.drag_wires(
|
|
sch,
|
|
{
|
|
(0.0, 3.81): (10.0, 23.81),
|
|
(0.0, -3.81): (10.0, 16.19),
|
|
},
|
|
)
|
|
assert result["endpoints_moved"] == 2
|
|
assert result["wires_removed"] == 0
|
|
|
|
def test_junction_moved_with_endpoint(self):
|
|
junction = _make_junction(0, 3.81)
|
|
sch = _make_sch_data([junction])
|
|
WireDragger.drag_wires(sch, {(0.0, 3.81): (10.0, 23.81)})
|
|
updated_j = next(i for i in sch if isinstance(i, list) and i and i[0] == Symbol("junction"))
|
|
at_sub = next(
|
|
s for s in updated_j[1:] if isinstance(s, list) and s and s[0] == Symbol("at")
|
|
)
|
|
assert abs(at_sub[1] - 10.0) < EPS
|
|
assert abs(at_sub[2] - 23.81) < EPS
|
|
|
|
def test_junction_at_unrelated_position_not_touched(self):
|
|
junction = _make_junction(99, 99)
|
|
sch = _make_sch_data([junction])
|
|
WireDragger.drag_wires(sch, {(0.0, 3.81): (10.0, 23.81)})
|
|
updated_j = next(i for i in sch if isinstance(i, list) and i and i[0] == Symbol("junction"))
|
|
at_sub = next(
|
|
s for s in updated_j[1:] if isinstance(s, list) and s and s[0] == Symbol("at")
|
|
)
|
|
assert abs(at_sub[1] - 99.0) < EPS
|
|
assert abs(at_sub[2] - 99.0) < EPS
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TestUpdateSymbolPosition
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestUpdateSymbolPosition:
|
|
def test_updates_position(self):
|
|
sch = _make_sch_data([_make_symbol("R1", 10, 20)])
|
|
result = WireDragger.update_symbol_position(sch, "R1", 30, 40)
|
|
assert result is True
|
|
found = WireDragger.find_symbol(sch, "R1")
|
|
assert abs(found[1] - 30) < EPS
|
|
assert abs(found[2] - 40) < EPS
|
|
|
|
def test_returns_false_for_missing(self):
|
|
sch = _make_sch_data()
|
|
assert WireDragger.update_symbol_position(sch, "MISSING", 0, 0) is False
|
|
|
|
def test_preserves_rotation(self):
|
|
sch = _make_sch_data([_make_symbol("R1", 10, 20, rotation=90)])
|
|
WireDragger.update_symbol_position(sch, "R1", 30, 40)
|
|
found = WireDragger.find_symbol(sch, "R1")
|
|
assert abs(found[3] - 90) < EPS # rotation preserved
|
|
|
|
def test_property_labels_follow_symbol_move(self):
|
|
"""Property (at ...) positions must shift by the same delta as the symbol."""
|
|
sym = _make_symbol("R1", 100, 80)
|
|
sch = _make_sch_data([sym])
|
|
|
|
# Record initial property positions
|
|
prop_k = _sym("property")
|
|
at_k = _sym("at")
|
|
initial_positions = {}
|
|
for sub in sym[1:]:
|
|
if isinstance(sub, list) and sub and sub[0] == prop_k:
|
|
name = sub[1]
|
|
for psub in sub[2:]:
|
|
if isinstance(psub, list) and psub and psub[0] == at_k:
|
|
initial_positions[name] = (psub[1], psub[2])
|
|
break
|
|
assert len(initial_positions) >= 2 # Reference and Value at minimum
|
|
|
|
# Move component from (100, 80) to (120, 100) — delta (20, 20)
|
|
result = WireDragger.update_symbol_position(sch, "R1", 120, 100)
|
|
assert result is True
|
|
|
|
# Verify each property shifted by (20, 20)
|
|
for sub in sym[1:]:
|
|
if isinstance(sub, list) and sub and sub[0] == prop_k:
|
|
name = sub[1]
|
|
for psub in sub[2:]:
|
|
if isinstance(psub, list) and psub and psub[0] == at_k:
|
|
expected_x = initial_positions[name][0] + 20
|
|
expected_y = initial_positions[name][1] + 20
|
|
assert (
|
|
abs(psub[1] - expected_x) < EPS
|
|
), f"{name} x: expected {expected_x}, got {psub[1]}"
|
|
assert (
|
|
abs(psub[2] - expected_y) < EPS
|
|
), f"{name} y: expected {expected_y}, got {psub[2]}"
|
|
break
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Integration tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.integration
|
|
class TestMoveWithWirePreservation:
|
|
"""Integration tests using a real .kicad_sch file."""
|
|
|
|
def _make_schematic(self, extra_sexp=""):
|
|
"""Copy empty.kicad_sch to a temp file and optionally append content."""
|
|
tmp = Path(tempfile.mkdtemp()) / "test.kicad_sch"
|
|
shutil.copy(TEMPLATE_PATH, tmp)
|
|
if extra_sexp:
|
|
content = tmp.read_text(encoding="utf-8")
|
|
idx = content.rfind(")")
|
|
content = content[:idx] + "\n" + extra_sexp + "\n)"
|
|
tmp.write_text(content, encoding="utf-8")
|
|
return tmp
|
|
|
|
def _add_resistor(self, path: Path, ref: str, x: float, y: float, rotation: float = 0) -> Path:
|
|
"""Append a Device:R symbol to the schematic file."""
|
|
import uuid
|
|
|
|
u = str(uuid.uuid4())
|
|
sexp = f"""
|
|
(symbol (lib_id "Device:R") (at {x} {y} {rotation}) (unit 1)
|
|
(in_bom yes) (on_board yes) (dnp no)
|
|
(uuid "{u}")
|
|
(property "Reference" "{ref}" (at {x + 2.032} {y} 90)
|
|
(effects (font (size 1.27 1.27)))
|
|
)
|
|
(property "Value" "10k" (at {x} {y} 90)
|
|
(effects (font (size 1.27 1.27)))
|
|
)
|
|
(property "Footprint" "" (at {x - 1.778} {y} 90)
|
|
(effects (font (size 1.27 1.27)) hide)
|
|
)
|
|
(property "Datasheet" "~" (at {x} {y} 0)
|
|
(effects (font (size 1.27 1.27)) hide)
|
|
)
|
|
(pin "1" (uuid "{uuid.uuid4()}"))
|
|
(pin "2" (uuid "{uuid.uuid4()}"))
|
|
(instances (project "test" (path "/" (reference "{ref}") (unit 1))))
|
|
)"""
|
|
content = path.read_text(encoding="utf-8")
|
|
idx = content.rfind(")")
|
|
path.write_text(content[:idx] + "\n" + sexp + "\n)", encoding="utf-8")
|
|
return path
|
|
|
|
def _add_wire(self, path: Path, x1, y1, x2, y2) -> Path:
|
|
"""Append a wire to the schematic file."""
|
|
import uuid
|
|
|
|
wire_sexp = f"""
|
|
(wire (pts (xy {x1} {y1}) (xy {x2} {y2}))
|
|
(stroke (width 0) (type default))
|
|
(uuid "{uuid.uuid4()}")
|
|
)"""
|
|
content = path.read_text(encoding="utf-8")
|
|
idx = content.rfind(")")
|
|
path.write_text(content[:idx] + "\n" + wire_sexp + "\n)", encoding="utf-8")
|
|
return path
|
|
|
|
def _parse_wires(self, path: Path):
|
|
"""Return list of ((x1,y1),(x2,y2)) for every wire in the file."""
|
|
content = path.read_text(encoding="utf-8")
|
|
data = sexpdata.loads(content)
|
|
wires = []
|
|
for item in data:
|
|
if not (isinstance(item, list) and item and item[0] == Symbol("wire")):
|
|
continue
|
|
pts = next(
|
|
(s for s in item[1:] if isinstance(s, list) and s and s[0] == Symbol("pts")),
|
|
None,
|
|
)
|
|
if pts is None:
|
|
continue
|
|
xys = [
|
|
p for p in pts[1:] if isinstance(p, list) and len(p) >= 3 and p[0] == Symbol("xy")
|
|
]
|
|
if len(xys) >= 2:
|
|
wires.append(
|
|
(
|
|
(float(xys[0][1]), float(xys[0][2])),
|
|
(float(xys[-1][1]), float(xys[-1][2])),
|
|
)
|
|
)
|
|
return wires
|
|
|
|
def _get_symbol_pos(self, path: Path, ref: str):
|
|
content = path.read_text(encoding="utf-8")
|
|
data = sexpdata.loads(content)
|
|
found = WireDragger.find_symbol(data, ref)
|
|
if found is None:
|
|
return None
|
|
return found[1], found[2]
|
|
|
|
def test_symbol_position_updated(self):
|
|
sch = self._make_schematic()
|
|
self._add_resistor(sch, "R1", 100, 100)
|
|
# Call handler directly
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
result = iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "R1",
|
|
"position": {"x": 120, "y": 130},
|
|
},
|
|
)
|
|
assert result["success"], result.get("message")
|
|
pos = self._get_symbol_pos(sch, "R1")
|
|
assert abs(pos[0] - 120) < EPS
|
|
assert abs(pos[1] - 130) < EPS
|
|
|
|
def test_connected_wire_endpoint_follows_pin(self):
|
|
"""Wire endpoint at pin 1 of R1 should move with the component."""
|
|
sch = self._make_schematic()
|
|
# R1 at (100, 100) — pin 1 at (100, 103.81)
|
|
self._add_resistor(sch, "R1", 100, 100)
|
|
self._add_wire(sch, 100, 103.81, 100, 120) # wire from pin 1 upward
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
result = iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "R1",
|
|
"position": {"x": 110, "y": 100},
|
|
},
|
|
)
|
|
assert result["success"], result.get("message")
|
|
assert result["wiresMoved"] >= 1
|
|
|
|
wires = self._parse_wires(sch)
|
|
assert len(wires) == 1
|
|
# Pin 1 new world position: (110 + 0, 100 + 3.81) = (110, 103.81)
|
|
w = wires[0]
|
|
endpoints = {w[0], w[1]}
|
|
new_pin1 = (110.0, 103.81)
|
|
assert any(
|
|
abs(ep[0] - new_pin1[0]) < 0.01 and abs(ep[1] - new_pin1[1]) < 0.01 for ep in endpoints
|
|
), f"Expected pin endpoint near {new_pin1}, got {endpoints}"
|
|
|
|
def test_unrelated_wire_unchanged(self):
|
|
"""A wire not connected to R1 must not be modified."""
|
|
sch = self._make_schematic()
|
|
self._add_resistor(sch, "R1", 100, 100)
|
|
self._add_wire(sch, 50, 50, 60, 50) # unrelated wire
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "R1",
|
|
"position": {"x": 110, "y": 110},
|
|
},
|
|
)
|
|
|
|
wires = self._parse_wires(sch)
|
|
unrelated = [(s, e) for s, e in wires if abs(s[0] - 50) < 0.01 and abs(s[1] - 50) < 0.01]
|
|
assert len(unrelated) == 1
|
|
|
|
def test_no_zero_length_wires_after_move(self):
|
|
"""No zero-length wires should appear in the file after a move."""
|
|
sch = self._make_schematic()
|
|
self._add_resistor(sch, "R1", 100, 100)
|
|
# Wire from pin 1 to pin 2 of same component (intra-component wire)
|
|
self._add_wire(sch, 100, 103.81, 100, 96.19)
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "R1",
|
|
"position": {"x": 110, "y": 100},
|
|
},
|
|
)
|
|
|
|
wires = self._parse_wires(sch)
|
|
for start, end in wires:
|
|
assert not (
|
|
abs(start[0] - end[0]) < EPS and abs(start[1] - end[1]) < EPS
|
|
), f"Zero-length wire found at {start}"
|
|
|
|
def test_preserve_wires_false_skips_wire_update(self):
|
|
"""preserveWires=False should move the symbol but leave wires alone."""
|
|
sch = self._make_schematic()
|
|
self._add_resistor(sch, "R1", 100, 100)
|
|
self._add_wire(sch, 100, 103.81, 100, 120)
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
result = iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "R1",
|
|
"position": {"x": 110, "y": 100},
|
|
"preserveWires": False,
|
|
},
|
|
)
|
|
assert result["success"]
|
|
assert result["wiresMoved"] == 0
|
|
|
|
# Wire should still start at old pin position
|
|
wires = self._parse_wires(sch)
|
|
assert len(wires) == 1
|
|
endpoints = {wires[0][0], wires[0][1]}
|
|
old_pin1 = (100.0, 103.81)
|
|
assert any(
|
|
abs(ep[0] - old_pin1[0]) < 0.01 and abs(ep[1] - old_pin1[1]) < 0.01 for ep in endpoints
|
|
), f"Wire should still be at {old_pin1}, got {endpoints}"
|
|
|
|
def test_missing_component_returns_error(self):
|
|
sch = self._make_schematic()
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
result = iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "NOTHERE",
|
|
"position": {"x": 0, "y": 0},
|
|
},
|
|
)
|
|
assert not result["success"]
|
|
assert "not found" in result.get("message", "").lower()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TestSynthesizeTouchingPinWires (unit)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestSynthesizeTouchingPinWires:
|
|
"""Unit tests for WireDragger.synthesize_touching_pin_wires."""
|
|
|
|
def _make_two_resistors(self, r1_x, r1_y, r2_x, r2_y):
|
|
"""Build sch_data with R1 and R2, each Device:R."""
|
|
return _make_sch_data(
|
|
[
|
|
_make_symbol("R1", r1_x, r1_y),
|
|
_make_symbol("R2", r2_x, r2_y),
|
|
]
|
|
)
|
|
|
|
def test_no_stationary_symbols_returns_zero(self):
|
|
"""With only the moved component in sch_data, nothing is synthesized."""
|
|
sch = _make_sch_data([_make_symbol("R1", 0, 0)])
|
|
pin_positions = WireDragger.compute_pin_positions(sch, "R1", 10, 20)
|
|
count = WireDragger.synthesize_touching_pin_wires(sch, "R1", pin_positions)
|
|
assert count == 0
|
|
|
|
def test_touching_pin_gap_generates_wire(self):
|
|
"""
|
|
R1 at (0, 0) pin2 at (0, -3.81).
|
|
R2 at (0, -7.62) pin1 at (0, -3.81). ← pins touch
|
|
Moving R1 to (10, 0) causes pin2 to move to (10, -3.81).
|
|
A wire from (0, -3.81) to (10, -3.81) should be synthesized.
|
|
"""
|
|
# R2 pin1 is at (0, -7.62 + 3.81) = (0, -3.81)
|
|
sch = self._make_two_resistors(0, 0, 0, -7.62)
|
|
|
|
# Verify the touching: R1 pin2 old = (0, -3.81), R2 pin1 = (0, -3.81)
|
|
pin_positions = WireDragger.compute_pin_positions(sch, "R1", 10, 0)
|
|
old2, new2 = pin_positions["2"]
|
|
assert abs(old2[0] - 0) < 1e-3 and abs(old2[1] - (-3.81)) < 1e-3
|
|
assert abs(new2[0] - 10) < 1e-3 and abs(new2[1] - (-3.81)) < 1e-3
|
|
|
|
wire_count_before = sum(
|
|
1 for item in sch if isinstance(item, list) and item and item[0] == _sym("wire")
|
|
)
|
|
count = WireDragger.synthesize_touching_pin_wires(sch, "R1", pin_positions)
|
|
assert count == 1, f"Expected 1 synthesized wire, got {count}"
|
|
|
|
wires = [
|
|
item for item in sch if isinstance(item, list) and item and item[0] == _sym("wire")
|
|
]
|
|
assert len(wires) == wire_count_before + 1
|
|
|
|
# The new wire should span (0, -3.81) → (10, -3.81)
|
|
new_wire = wires[-1]
|
|
pts = next(s for s in new_wire[1:] if isinstance(s, list) and s and s[0] == _sym("pts"))
|
|
xys = [p for p in pts[1:] if isinstance(p, list) and len(p) >= 3 and p[0] == _sym("xy")]
|
|
assert len(xys) == 2
|
|
endpoints = {
|
|
(round(float(xys[0][1]), 3), round(float(xys[0][2]), 3)),
|
|
(round(float(xys[1][1]), 3), round(float(xys[1][2]), 3)),
|
|
}
|
|
assert (0.0, -3.81) in endpoints, f"Expected (0, -3.81) in wire endpoints, got {endpoints}"
|
|
assert (
|
|
10.0,
|
|
-3.81,
|
|
) in endpoints, f"Expected (10, -3.81) in wire endpoints, got {endpoints}"
|
|
|
|
def test_no_wire_when_pin_didnt_move(self):
|
|
"""
|
|
If old_xy == new_xy for a touching pin (component moved but this pin stayed put),
|
|
no wire should be synthesized.
|
|
"""
|
|
# R1 at (0, 0), R2 at (0, -7.62) — pin2 of R1 and pin1 of R2 touch at (0, -3.81)
|
|
sch = self._make_two_resistors(0, 0, 0, -7.62)
|
|
# Moving R1 to (0, 0) — effectively no move, same position
|
|
pin_positions = WireDragger.compute_pin_positions(sch, "R1", 0, 0)
|
|
count = WireDragger.synthesize_touching_pin_wires(sch, "R1", pin_positions)
|
|
assert count == 0
|
|
|
|
def test_no_wire_when_rejoins_other_stationary_pin(self):
|
|
"""
|
|
If the moved pin's new position coincides with another stationary pin,
|
|
no wire should be synthesized (they touch again).
|
|
"""
|
|
# R1 at (0, 0), R2 at (0, -7.62), R3 at (10, -7.62)
|
|
# R1 pin2 was touching R2 pin1 at (0, -3.81).
|
|
# Moving R1 to (10, 0): pin2 lands at (10, -3.81) which is R3 pin1.
|
|
sch = _make_sch_data(
|
|
[
|
|
_make_symbol("R1", 0, 0),
|
|
_make_symbol("R2", 0, -7.62),
|
|
_make_symbol("R3", 10, -7.62),
|
|
]
|
|
)
|
|
pin_positions = WireDragger.compute_pin_positions(sch, "R1", 10, 0)
|
|
count = WireDragger.synthesize_touching_pin_wires(sch, "R1", pin_positions)
|
|
assert count == 0, f"Expected 0 synthesized wires (rejoined), got {count}"
|
|
|
|
def test_empty_pin_positions_returns_zero(self):
|
|
sch = _make_sch_data([_make_symbol("R1", 0, 0)])
|
|
count = WireDragger.synthesize_touching_pin_wires(sch, "R1", {})
|
|
assert count == 0
|
|
|
|
def test_non_touching_pins_not_affected(self):
|
|
"""
|
|
When R1 and R2 are NOT touching (different positions), no wire is synthesized.
|
|
"""
|
|
# R1 at (0, 0), R2 at (100, 100) — far apart
|
|
sch = self._make_two_resistors(0, 0, 100, 100)
|
|
pin_positions = WireDragger.compute_pin_positions(sch, "R1", 10, 0)
|
|
count = WireDragger.synthesize_touching_pin_wires(sch, "R1", pin_positions)
|
|
assert count == 0
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TestOldToNewCollision (unit) — regression for the duplicate-pin-position bug
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestOldToNewCollision:
|
|
"""Verify that coincident pins do not silently overwrite each other in old_to_new."""
|
|
|
|
def test_handler_logs_warning_on_collision(self, caplog):
|
|
"""
|
|
When two pins share the same old position, a warning should be logged
|
|
and the *first* mapping should be kept (not overwritten by the second).
|
|
"""
|
|
import logging
|
|
|
|
# Build a fake pin_positions dict with a deliberate collision
|
|
pin_positions = {
|
|
"1": ((0.0, 3.81), (10.0, 23.81)),
|
|
"2": ((0.0, 3.81), (10.0, 16.19)), # same old_xy as pin "1"
|
|
}
|
|
|
|
old_to_new = {}
|
|
with caplog.at_level(logging.WARNING, logger="kicad_interface"):
|
|
for _pin, (old_xy, new_xy) in pin_positions.items():
|
|
if old_xy in old_to_new:
|
|
import logging as _logging
|
|
|
|
logger_inner = _logging.getLogger("kicad_interface")
|
|
logger_inner.warning(
|
|
f"move_schematic_component: pin {_pin!r} shares old position {old_xy} "
|
|
f"with another pin; keeping first entry, skipping duplicate"
|
|
)
|
|
continue
|
|
old_to_new[old_xy] = new_xy
|
|
|
|
# Only one entry should exist, and it should be the first one
|
|
assert len(old_to_new) == 1
|
|
assert old_to_new[(0.0, 3.81)] == (10.0, 23.81)
|
|
# Warning should have been logged
|
|
assert any("skipping duplicate" in r.message for r in caplog.records)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TestTouchingPinIntegration (integration)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.integration
|
|
class TestTouchingPinIntegration:
|
|
"""Integration tests for pin-touching connection wire synthesis."""
|
|
|
|
def _make_schematic(self, extra_sexp=""):
|
|
"""Copy empty.kicad_sch to a temp file."""
|
|
tmp = Path(tempfile.mkdtemp()) / "test.kicad_sch"
|
|
shutil.copy(TEMPLATE_PATH, tmp)
|
|
if extra_sexp:
|
|
content = tmp.read_text(encoding="utf-8")
|
|
idx = content.rfind(")")
|
|
content = content[:idx] + "\n" + extra_sexp + "\n)"
|
|
tmp.write_text(content, encoding="utf-8")
|
|
return tmp
|
|
|
|
def _add_resistor(self, path: Path, ref: str, x: float, y: float, rotation: float = 0) -> Path:
|
|
import uuid as _uuid
|
|
|
|
u = str(_uuid.uuid4())
|
|
sexp = f"""
|
|
(symbol (lib_id "Device:R") (at {x} {y} {rotation}) (unit 1)
|
|
(in_bom yes) (on_board yes) (dnp no)
|
|
(uuid "{u}")
|
|
(property "Reference" "{ref}" (at {x + 2.032} {y} 90)
|
|
(effects (font (size 1.27 1.27)))
|
|
)
|
|
(property "Value" "10k" (at {x} {y} 90)
|
|
(effects (font (size 1.27 1.27)))
|
|
)
|
|
(property "Footprint" "" (at {x - 1.778} {y} 90)
|
|
(effects (font (size 1.27 1.27)) hide)
|
|
)
|
|
(property "Datasheet" "~" (at {x} {y} 0)
|
|
(effects (font (size 1.27 1.27)) hide)
|
|
)
|
|
(pin "1" (uuid "{_uuid.uuid4()}"))
|
|
(pin "2" (uuid "{_uuid.uuid4()}"))
|
|
(instances (project "test" (path "/" (reference "{ref}") (unit 1))))
|
|
)"""
|
|
content = path.read_text(encoding="utf-8")
|
|
idx = content.rfind(")")
|
|
path.write_text(content[:idx] + "\n" + sexp + "\n)", encoding="utf-8")
|
|
return path
|
|
|
|
def _parse_wires(self, path: Path):
|
|
content = path.read_text(encoding="utf-8")
|
|
data = sexpdata.loads(content)
|
|
wires = []
|
|
for item in data:
|
|
if not (isinstance(item, list) and item and item[0] == Symbol("wire")):
|
|
continue
|
|
pts = next(
|
|
(s for s in item[1:] if isinstance(s, list) and s and s[0] == Symbol("pts")),
|
|
None,
|
|
)
|
|
if pts is None:
|
|
continue
|
|
xys = [
|
|
p for p in pts[1:] if isinstance(p, list) and len(p) >= 3 and p[0] == Symbol("xy")
|
|
]
|
|
if len(xys) >= 2:
|
|
wires.append(
|
|
(
|
|
(float(xys[0][1]), float(xys[0][2])),
|
|
(float(xys[-1][1]), float(xys[-1][2])),
|
|
)
|
|
)
|
|
return wires
|
|
|
|
def test_touching_pin_wire_created_on_move(self):
|
|
"""
|
|
R1 at (100, 100) and R2 at (100, 92.38) share a touching pin:
|
|
R1 pin2 = (100, 96.19), R2 pin1 = (100, 96.19).
|
|
Moving R1 to (110, 100) should synthesize a wire from (100, 96.19) to (110, 96.19).
|
|
"""
|
|
sch = self._make_schematic()
|
|
# R1 pin2 world position = 100 + (-3.81) = 96.19
|
|
# R2 pin1 world position = 92.38 + 3.81 = 96.19
|
|
self._add_resistor(sch, "R1", 100, 100)
|
|
self._add_resistor(sch, "R2", 100, 92.38)
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
result = iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "R1",
|
|
"position": {"x": 110, "y": 100},
|
|
},
|
|
)
|
|
assert result["success"], result.get("message")
|
|
assert (
|
|
result.get("wiresSynthesized", 0) >= 1
|
|
), f"Expected at least 1 synthesized wire, got {result}"
|
|
|
|
wires = self._parse_wires(sch)
|
|
# There should be a wire bridging the old and new pin2 positions
|
|
old_pin2 = (100.0, 96.19)
|
|
new_pin2 = (110.0, 96.19)
|
|
bridging = [
|
|
(s, e)
|
|
for s, e in wires
|
|
if (
|
|
(
|
|
abs(s[0] - old_pin2[0]) < 0.05
|
|
and abs(s[1] - old_pin2[1]) < 0.05
|
|
and abs(e[0] - new_pin2[0]) < 0.05
|
|
and abs(e[1] - new_pin2[1]) < 0.05
|
|
)
|
|
or (
|
|
abs(e[0] - old_pin2[0]) < 0.05
|
|
and abs(e[1] - old_pin2[1]) < 0.05
|
|
and abs(s[0] - new_pin2[0]) < 0.05
|
|
and abs(s[1] - new_pin2[1]) < 0.05
|
|
)
|
|
)
|
|
]
|
|
assert (
|
|
len(bridging) >= 1
|
|
), f"Expected a bridging wire from {old_pin2} to {new_pin2}, got wires: {wires}"
|
|
|
|
def test_no_wire_synthesized_when_no_touching_pins(self):
|
|
"""
|
|
Two resistors with no pin overlap should not generate any synthesized wires.
|
|
"""
|
|
sch = self._make_schematic()
|
|
self._add_resistor(sch, "R1", 100, 100)
|
|
self._add_resistor(sch, "R2", 150, 150) # far away
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
result = iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "R1",
|
|
"position": {"x": 110, "y": 100},
|
|
},
|
|
)
|
|
assert result["success"], result.get("message")
|
|
assert result.get("wiresSynthesized", 0) == 0
|
|
|
|
def test_existing_wires_still_dragged_with_touching_pins(self):
|
|
"""
|
|
When R1 has both an explicit wire AND a touching-pin connection,
|
|
both should be handled: the wire dragged and the touching-pin bridged.
|
|
"""
|
|
sch = self._make_schematic()
|
|
# R1 at (100, 100), R2 at (100, 92.38) — pin2 of R1 touches pin1 of R2
|
|
self._add_resistor(sch, "R1", 100, 100)
|
|
self._add_resistor(sch, "R2", 100, 92.38)
|
|
|
|
# Also add an explicit wire at pin1 of R1 (100, 103.81) going up
|
|
import uuid as _uuid
|
|
|
|
wire_sexp = f"""
|
|
(wire (pts (xy 100 103.81) (xy 100 115))
|
|
(stroke (width 0) (type default))
|
|
(uuid "{_uuid.uuid4()}")
|
|
)"""
|
|
content = sch.read_text(encoding="utf-8")
|
|
idx = content.rfind(")")
|
|
sch.write_text(content[:idx] + "\n" + wire_sexp + "\n)", encoding="utf-8")
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
|
from kicad_interface import KiCADInterface
|
|
|
|
iface = KiCADInterface()
|
|
result = iface.handle_command(
|
|
"move_schematic_component",
|
|
{
|
|
"schematicPath": str(sch),
|
|
"reference": "R1",
|
|
"position": {"x": 110, "y": 100},
|
|
},
|
|
)
|
|
assert result["success"], result.get("message")
|
|
assert result.get("wiresMoved", 0) >= 1, "Expected at least one wire endpoint dragged"
|
|
assert result.get("wiresSynthesized", 0) >= 1, "Expected at least one touching-pin wire"
|