517 lines
18 KiB
Python
517 lines
18 KiB
Python
"""
|
|
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
|