feat: add connected_pin_count to list_schematic_nets and list_floating_labels tool
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Eugene Mikhantyev
516
tests/test_net_connectivity.py
Normal file
516
tests/test_net_connectivity.py
Normal file
@@ -0,0 +1,516 @@
|
||||
"""
|
||||
Tests for connected_pin_count in list_schematic_nets and the list_floating_labels tool.
|
||||
|
||||
Covers:
|
||||
- Schema registration for list_floating_labels (TestListFloatingLabelsSchema)
|
||||
- Handler dispatch registration (TestListFloatingLabelsDispatch)
|
||||
- Parameter validation (TestListFloatingLabelsParamValidation)
|
||||
- Core logic: list_floating_labels (TestListFloatingLabelsCoreLogic)
|
||||
- Core logic: count_pins_on_net (TestCountPinsOnNet)
|
||||
- connected_pin_count field in list_schematic_nets handler (TestListSchematicNetsConnectedPinCount)
|
||||
- Integration: floating labels in a real schematic file (TestListFloatingLabelsIntegration)
|
||||
"""
|
||||
|
||||
import shutil
|
||||
import sys
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent / "python"))
|
||||
|
||||
from commands.wire_connectivity import (
|
||||
_build_adjacency,
|
||||
_parse_virtual_connections,
|
||||
_parse_wires,
|
||||
count_pins_on_net,
|
||||
list_floating_labels,
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Shared mock helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
TEMPLATE_SCH = Path(__file__).parent.parent / "python" / "templates" / "empty.kicad_sch"
|
||||
|
||||
|
||||
def _make_point(x: float, y: float) -> MagicMock:
|
||||
pt = MagicMock()
|
||||
pt.value = [x, y]
|
||||
return pt
|
||||
|
||||
|
||||
def _make_wire(x1: float, y1: float, x2: float, y2: float) -> MagicMock:
|
||||
wire = MagicMock()
|
||||
wire.pts = MagicMock()
|
||||
wire.pts.xy = [_make_point(x1, y1), _make_point(x2, y2)]
|
||||
return wire
|
||||
|
||||
|
||||
def _make_label(name: str, x: float, y: float) -> MagicMock:
|
||||
label = MagicMock()
|
||||
label.value = name
|
||||
label.at = MagicMock()
|
||||
label.at.value = [x, y, 0]
|
||||
return label
|
||||
|
||||
|
||||
def _make_schematic_no_labels_no_symbols(*wires: Any) -> MagicMock:
|
||||
sch = MagicMock()
|
||||
sch.wire = list(wires)
|
||||
del sch.label
|
||||
del sch.symbol
|
||||
return sch
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestListFloatingLabelsSchema
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
class TestListFloatingLabelsSchema:
|
||||
"""Verify the list_floating_labels schema is registered and well-formed."""
|
||||
|
||||
def test_schema_registered(self) -> None:
|
||||
from schemas.tool_schemas import TOOL_SCHEMAS
|
||||
|
||||
assert "list_floating_labels" in TOOL_SCHEMAS
|
||||
|
||||
def test_schema_required_fields(self) -> None:
|
||||
from schemas.tool_schemas import TOOL_SCHEMAS
|
||||
|
||||
required = TOOL_SCHEMAS["list_floating_labels"]["inputSchema"]["required"]
|
||||
assert required == ["schematicPath"]
|
||||
|
||||
def test_schema_has_title_and_description(self) -> None:
|
||||
from schemas.tool_schemas import TOOL_SCHEMAS
|
||||
|
||||
schema = TOOL_SCHEMAS["list_floating_labels"]
|
||||
assert schema.get("title")
|
||||
assert schema.get("description")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestListFloatingLabelsDispatch
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
class TestListFloatingLabelsDispatch:
|
||||
"""Verify the handler is wired into KiCadInterface.command_routes."""
|
||||
|
||||
def test_list_floating_labels_in_routes(self) -> None:
|
||||
with patch("kicad_interface.USE_IPC_BACKEND", False):
|
||||
from kicad_interface import KiCADInterface
|
||||
|
||||
iface = KiCADInterface.__new__(KiCADInterface)
|
||||
iface.board = None
|
||||
iface.project_filename = None
|
||||
iface.use_ipc = False
|
||||
iface.ipc_backend = MagicMock()
|
||||
iface.ipc_board_api = None
|
||||
iface.footprint_library = MagicMock()
|
||||
iface.project_commands = MagicMock()
|
||||
iface.board_commands = MagicMock()
|
||||
iface.component_commands = MagicMock()
|
||||
iface.routing_commands = MagicMock()
|
||||
KiCADInterface.__init__(iface)
|
||||
|
||||
assert "list_floating_labels" in iface.command_routes
|
||||
assert callable(iface.command_routes["list_floating_labels"])
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestListFloatingLabelsParamValidation
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
class TestListFloatingLabelsParamValidation:
|
||||
"""Handler returns error for missing schematicPath."""
|
||||
|
||||
def _make_handler(self) -> Any:
|
||||
with patch("kicad_interface.USE_IPC_BACKEND", False):
|
||||
from kicad_interface import KiCADInterface
|
||||
|
||||
iface = KiCADInterface.__new__(KiCADInterface)
|
||||
return iface._handle_list_floating_labels
|
||||
|
||||
def test_missing_schematic_path(self) -> None:
|
||||
handler = self._make_handler()
|
||||
result = handler({})
|
||||
assert result["success"] is False
|
||||
assert "schematicPath" in result["message"]
|
||||
|
||||
def test_bad_schematic_path_returns_error(self) -> None:
|
||||
handler = self._make_handler()
|
||||
result = handler({"schematicPath": "/nonexistent/path/test.kicad_sch"})
|
||||
assert result["success"] is False
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestListFloatingLabelsCoreLogic
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
class TestListFloatingLabelsCoreLogic:
|
||||
"""Unit tests for the list_floating_labels function."""
|
||||
|
||||
def test_no_labels_returns_empty(self) -> None:
|
||||
sch = _make_schematic_no_labels_no_symbols()
|
||||
result = list_floating_labels(sch, "/tmp/test.kicad_sch")
|
||||
assert result == []
|
||||
|
||||
def test_label_with_no_wires_and_no_pins_is_floating(self) -> None:
|
||||
label = _make_label("SDA", 10.0, 5.0)
|
||||
sch = MagicMock()
|
||||
sch.wire = []
|
||||
sch.label = [label]
|
||||
del sch.symbol
|
||||
result = list_floating_labels(sch, "/tmp/test.kicad_sch")
|
||||
assert len(result) == 1
|
||||
assert result[0]["name"] == "SDA"
|
||||
assert result[0]["x"] == pytest.approx(10.0)
|
||||
assert result[0]["y"] == pytest.approx(5.0)
|
||||
assert result[0]["type"] == "label"
|
||||
|
||||
def test_label_connected_to_pin_not_floating(self) -> None:
|
||||
"""Label at (0,0) connected to a pin at (2,0) via wire should NOT be floating."""
|
||||
wire = _make_wire(0.0, 0.0, 2.0, 0.0)
|
||||
label = _make_label("SCL", 0.0, 0.0)
|
||||
|
||||
sch = MagicMock()
|
||||
sch.wire = [wire]
|
||||
sch.label = [label]
|
||||
|
||||
# Mock a symbol whose pin is at (2, 0)
|
||||
symbol = MagicMock()
|
||||
symbol.property = MagicMock()
|
||||
symbol.property.Reference = MagicMock()
|
||||
symbol.property.Reference.value = "U1"
|
||||
sch.symbol = [symbol]
|
||||
|
||||
with patch(
|
||||
"commands.pin_locator.PinLocator.get_all_symbol_pins",
|
||||
return_value={"1": (2.0, 0.0)},
|
||||
):
|
||||
result = list_floating_labels(sch, "/tmp/test.kicad_sch")
|
||||
|
||||
assert result == []
|
||||
|
||||
def test_label_not_connected_to_any_pin_is_floating(self) -> None:
|
||||
"""Label at (0,0) with no wires to any pin should be floating."""
|
||||
label = _make_label("MOSI", 0.0, 0.0)
|
||||
wire = _make_wire(0.0, 0.0, 1.0, 0.0)
|
||||
|
||||
sch = MagicMock()
|
||||
sch.wire = [wire]
|
||||
sch.label = [label]
|
||||
|
||||
# A symbol whose pin is at a completely different location
|
||||
symbol = MagicMock()
|
||||
symbol.property = MagicMock()
|
||||
symbol.property.Reference = MagicMock()
|
||||
symbol.property.Reference.value = "U2"
|
||||
sch.symbol = [symbol]
|
||||
|
||||
with patch(
|
||||
"commands.pin_locator.PinLocator.get_all_symbol_pins",
|
||||
return_value={"1": (99.0, 99.0)},
|
||||
):
|
||||
result = list_floating_labels(sch, "/tmp/test.kicad_sch")
|
||||
|
||||
assert len(result) == 1
|
||||
assert result[0]["name"] == "MOSI"
|
||||
|
||||
def test_label_directly_on_pin_not_floating(self) -> None:
|
||||
"""Label placed directly at a pin position (no wire needed) should NOT be floating."""
|
||||
label = _make_label("PWR", 5.0, 3.0)
|
||||
|
||||
sch = MagicMock()
|
||||
sch.wire = []
|
||||
sch.label = [label]
|
||||
|
||||
symbol = MagicMock()
|
||||
symbol.property = MagicMock()
|
||||
symbol.property.Reference = MagicMock()
|
||||
symbol.property.Reference.value = "R1"
|
||||
sch.symbol = [symbol]
|
||||
|
||||
# Pin is exactly at the label position
|
||||
with patch(
|
||||
"commands.pin_locator.PinLocator.get_all_symbol_pins",
|
||||
return_value={"1": (5.0, 3.0)},
|
||||
):
|
||||
result = list_floating_labels(sch, "/tmp/test.kicad_sch")
|
||||
|
||||
assert result == []
|
||||
|
||||
def test_multiple_labels_mixed_floating_and_connected(self) -> None:
|
||||
"""Two labels: one connected, one floating."""
|
||||
label_connected = _make_label("NET_A", 0.0, 0.0)
|
||||
label_floating = _make_label("NET_B", 20.0, 20.0)
|
||||
wire = _make_wire(0.0, 0.0, 2.0, 0.0)
|
||||
|
||||
sch = MagicMock()
|
||||
sch.wire = [wire]
|
||||
sch.label = [label_connected, label_floating]
|
||||
|
||||
symbol = MagicMock()
|
||||
symbol.property = MagicMock()
|
||||
symbol.property.Reference = MagicMock()
|
||||
symbol.property.Reference.value = "C1"
|
||||
sch.symbol = [symbol]
|
||||
|
||||
with patch(
|
||||
"commands.pin_locator.PinLocator.get_all_symbol_pins",
|
||||
return_value={"1": (2.0, 0.0)},
|
||||
):
|
||||
result = list_floating_labels(sch, "/tmp/test.kicad_sch")
|
||||
|
||||
assert len(result) == 1
|
||||
assert result[0]["name"] == "NET_B"
|
||||
|
||||
def test_template_symbols_skipped(self) -> None:
|
||||
"""Symbols with _TEMPLATE references should be skipped, not crash."""
|
||||
label = _make_label("VBUS", 0.0, 0.0)
|
||||
|
||||
sch = MagicMock()
|
||||
sch.wire = []
|
||||
sch.label = [label]
|
||||
|
||||
template_sym = MagicMock()
|
||||
template_sym.property = MagicMock()
|
||||
template_sym.property.Reference = MagicMock()
|
||||
template_sym.property.Reference.value = "_TEMPLATE_R"
|
||||
sch.symbol = [template_sym]
|
||||
|
||||
with patch(
|
||||
"commands.pin_locator.PinLocator.get_all_symbol_pins",
|
||||
return_value={"1": (0.0, 0.0)},
|
||||
) as mock_pins:
|
||||
result = list_floating_labels(sch, "/tmp/test.kicad_sch")
|
||||
|
||||
# _TEMPLATE_ symbols are skipped; mock_pins should not have been called
|
||||
mock_pins.assert_not_called()
|
||||
assert len(result) == 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestCountPinsOnNet
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
class TestCountPinsOnNet:
|
||||
"""Unit tests for count_pins_on_net."""
|
||||
|
||||
def _build_graph(self, sch: Any, schematic_path: str): # type: ignore[return]
|
||||
all_wires = _parse_wires(sch)
|
||||
if all_wires:
|
||||
adjacency, iu_to_wires = _build_adjacency(all_wires)
|
||||
else:
|
||||
adjacency, iu_to_wires = [], {}
|
||||
point_to_label, label_to_points = _parse_virtual_connections(sch, schematic_path)
|
||||
return all_wires, iu_to_wires, adjacency, point_to_label, label_to_points
|
||||
|
||||
def test_no_labels_returns_zero(self) -> None:
|
||||
sch = _make_schematic_no_labels_no_symbols()
|
||||
all_wires, iu_to_wires, adj, p2l, l2p = self._build_graph(sch, "/tmp/t.kicad_sch")
|
||||
count = count_pins_on_net(
|
||||
sch, "/tmp/t.kicad_sch", "VCC", all_wires, iu_to_wires, adj, p2l, l2p
|
||||
)
|
||||
assert count == 0
|
||||
|
||||
def test_unknown_net_returns_zero(self) -> None:
|
||||
wire = _make_wire(0.0, 0.0, 1.0, 0.0)
|
||||
label = _make_label("SDA", 0.0, 0.0)
|
||||
sch = MagicMock()
|
||||
sch.wire = [wire]
|
||||
sch.label = [label]
|
||||
del sch.symbol
|
||||
all_wires, iu_to_wires, adj, p2l, l2p = self._build_graph(sch, "/tmp/t.kicad_sch")
|
||||
count = count_pins_on_net(
|
||||
sch, "/tmp/t.kicad_sch", "UNKNOWN_NET", all_wires, iu_to_wires, adj, p2l, l2p
|
||||
)
|
||||
assert count == 0
|
||||
|
||||
def test_counts_pin_via_wire(self) -> None:
|
||||
"""Label at (0,0), wire to (2,0), pin at (2,0) → count == 1."""
|
||||
wire = _make_wire(0.0, 0.0, 2.0, 0.0)
|
||||
label = _make_label("SCL", 0.0, 0.0)
|
||||
sch = MagicMock()
|
||||
sch.wire = [wire]
|
||||
sch.label = [label]
|
||||
symbol = MagicMock()
|
||||
symbol.property = MagicMock()
|
||||
symbol.property.Reference = MagicMock()
|
||||
symbol.property.Reference.value = "U1"
|
||||
sch.symbol = [symbol]
|
||||
all_wires, iu_to_wires, adj, p2l, l2p = self._build_graph(sch, "/tmp/t.kicad_sch")
|
||||
with patch(
|
||||
"commands.pin_locator.PinLocator.get_all_symbol_pins",
|
||||
return_value={"3": (2.0, 0.0)},
|
||||
):
|
||||
count = count_pins_on_net(
|
||||
sch, "/tmp/t.kicad_sch", "SCL", all_wires, iu_to_wires, adj, p2l, l2p
|
||||
)
|
||||
assert count == 1
|
||||
|
||||
def test_no_symbol_attribute_returns_zero(self) -> None:
|
||||
wire = _make_wire(0.0, 0.0, 2.0, 0.0)
|
||||
label = _make_label("SDA", 0.0, 0.0)
|
||||
sch = MagicMock()
|
||||
sch.wire = [wire]
|
||||
sch.label = [label]
|
||||
del sch.symbol
|
||||
all_wires, iu_to_wires, adj, p2l, l2p = self._build_graph(sch, "/tmp/t.kicad_sch")
|
||||
count = count_pins_on_net(
|
||||
sch, "/tmp/t.kicad_sch", "SDA", all_wires, iu_to_wires, adj, p2l, l2p
|
||||
)
|
||||
assert count == 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestListSchematicNetsConnectedPinCount
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
class TestListSchematicNetsConnectedPinCount:
|
||||
"""Verify connected_pin_count is present in list_schematic_nets response."""
|
||||
|
||||
def _make_handler(self) -> Any:
|
||||
with patch("kicad_interface.USE_IPC_BACKEND", False):
|
||||
from kicad_interface import KiCADInterface
|
||||
|
||||
iface = KiCADInterface.__new__(KiCADInterface)
|
||||
return iface._handle_list_schematic_nets
|
||||
|
||||
def test_connected_pin_count_present_in_response(self) -> None:
|
||||
handler = self._make_handler()
|
||||
|
||||
label = _make_label("NET1", 0.0, 0.0)
|
||||
mock_sch = MagicMock()
|
||||
mock_sch.wire = []
|
||||
mock_sch.label = [label]
|
||||
del mock_sch.global_label
|
||||
del mock_sch.symbol
|
||||
|
||||
with (
|
||||
patch("kicad_interface.SchematicManager.load_schematic", return_value=mock_sch),
|
||||
patch(
|
||||
"kicad_interface.ConnectionManager.get_net_connections",
|
||||
return_value=[],
|
||||
),
|
||||
):
|
||||
result = handler({"schematicPath": "/tmp/test.kicad_sch"})
|
||||
|
||||
assert result["success"] is True
|
||||
assert len(result["nets"]) == 1
|
||||
net = result["nets"][0]
|
||||
assert "connected_pin_count" in net
|
||||
assert isinstance(net["connected_pin_count"], int)
|
||||
|
||||
def test_connected_pin_count_is_zero_when_no_pins(self) -> None:
|
||||
handler = self._make_handler()
|
||||
|
||||
label = _make_label("ORPHAN_NET", 50.0, 50.0)
|
||||
mock_sch = MagicMock()
|
||||
mock_sch.wire = []
|
||||
mock_sch.label = [label]
|
||||
del mock_sch.global_label
|
||||
del mock_sch.symbol
|
||||
|
||||
with (
|
||||
patch("kicad_interface.SchematicManager.load_schematic", return_value=mock_sch),
|
||||
patch(
|
||||
"kicad_interface.ConnectionManager.get_net_connections",
|
||||
return_value=[],
|
||||
),
|
||||
):
|
||||
result = handler({"schematicPath": "/tmp/test.kicad_sch"})
|
||||
|
||||
assert result["success"] is True
|
||||
assert result["nets"][0]["connected_pin_count"] == 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TestListFloatingLabelsIntegration
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.integration
|
||||
class TestListFloatingLabelsIntegration:
|
||||
"""Integration tests using a real .kicad_sch file."""
|
||||
|
||||
def _make_sch_with_floating_label(self, tmp_path: Path) -> Path:
|
||||
"""Copy the empty template and append a floating label."""
|
||||
sch_path = tmp_path / "test.kicad_sch"
|
||||
shutil.copy(TEMPLATE_SCH, sch_path)
|
||||
content = sch_path.read_text(encoding="utf-8")
|
||||
floating_label = (
|
||||
' (label "FLOATING_NET" (at 100 100 0)\n'
|
||||
" (effects (font (size 1.27 1.27)))\n"
|
||||
" (uuid 11111111-0000-0000-0000-000000000001)\n"
|
||||
" )"
|
||||
)
|
||||
idx = content.rfind(")")
|
||||
content = content[:idx] + "\n" + floating_label + "\n)"
|
||||
sch_path.write_text(content, encoding="utf-8")
|
||||
return sch_path
|
||||
|
||||
def test_empty_schematic_has_no_floating_labels(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
sch_path = Path(tmp) / "empty.kicad_sch"
|
||||
shutil.copy(TEMPLATE_SCH, sch_path)
|
||||
|
||||
with patch("kicad_interface.USE_IPC_BACKEND", False):
|
||||
from kicad_interface import KiCADInterface
|
||||
|
||||
iface = KiCADInterface.__new__(KiCADInterface)
|
||||
result = iface._handle_list_floating_labels({"schematicPath": str(sch_path)})
|
||||
|
||||
assert result["success"] is True
|
||||
assert result["count"] == 0
|
||||
assert result["floating_labels"] == []
|
||||
|
||||
def test_schematic_with_floating_label_detected(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
sch_path = self._make_sch_with_floating_label(Path(tmp))
|
||||
|
||||
with patch("kicad_interface.USE_IPC_BACKEND", False):
|
||||
from kicad_interface import KiCADInterface
|
||||
|
||||
iface = KiCADInterface.__new__(KiCADInterface)
|
||||
result = iface._handle_list_floating_labels({"schematicPath": str(sch_path)})
|
||||
|
||||
assert result["success"] is True
|
||||
assert result["count"] == 1
|
||||
label = result["floating_labels"][0]
|
||||
assert label["name"] == "FLOATING_NET"
|
||||
assert label["x"] == pytest.approx(100.0)
|
||||
assert label["y"] == pytest.approx(100.0)
|
||||
assert label["type"] == "label"
|
||||
|
||||
def test_list_schematic_nets_has_connected_pin_count(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
sch_path = self._make_sch_with_floating_label(Path(tmp))
|
||||
|
||||
with patch("kicad_interface.USE_IPC_BACKEND", False):
|
||||
from kicad_interface import KiCADInterface
|
||||
|
||||
iface = KiCADInterface.__new__(KiCADInterface)
|
||||
result = iface._handle_list_schematic_nets({"schematicPath": str(sch_path)})
|
||||
|
||||
assert result["success"] is True
|
||||
assert result["count"] == 1
|
||||
net = result["nets"][0]
|
||||
assert net["name"] == "FLOATING_NET"
|
||||
assert "connected_pin_count" in net
|
||||
assert net["connected_pin_count"] == 0
|
||||
Reference in New Issue
Block a user