Ryan Malloy
ce58454513
Some checks are pending
CI / Lint and Format (push) Waiting to run
CI / Test Python 3.11 on macos-latest (push) Waiting to run
CI / Test Python 3.12 on macos-latest (push) Waiting to run
CI / Test Python 3.13 on macos-latest (push) Waiting to run
CI / Test Python 3.10 on ubuntu-latest (push) Waiting to run
CI / Test Python 3.11 on ubuntu-latest (push) Waiting to run
CI / Test Python 3.12 on ubuntu-latest (push) Waiting to run
CI / Test Python 3.13 on ubuntu-latest (push) Waiting to run
CI / Security Scan (push) Waiting to run
CI / Build Package (push) Blocked by required conditions
Label collision detection: resolve_label_collision() shifts different-net labels that share the same (x,y) coordinate by 1.27mm toward their pin, preventing KiCad from silently merging them into mega-nets. Integrated at both label placement points in apply_batch. Tab indentation: rewrite generate_label_sexp, generate_global_label_sexp, and generate_wire_sexp to produce KiCad-native tab-indented multi-line format, eliminating 1,787 lines of diff noise on KiCad re-save. Intersheetrefs property now uses (at 0 0 0) placeholder. Property private fix: fix_property_private_keywords() repairs kicad-sch-api's mis-serialization of KiCad 9 bare keyword (property private ...) as quoted (property "private" ...), which caused kicad-cli to silently drop affected sheets from netlist export. 243 tests pass, ruff + mypy clean.
430 lines
14 KiB
Python
430 lines
14 KiB
Python
"""Tests for the batch operations tool."""
|
|
|
|
import json
|
|
import os
|
|
|
|
from tests.conftest import requires_sch_api
|
|
|
|
|
|
class TestBatchValidation:
|
|
"""Tests for batch JSON validation (no kicad-sch-api needed for some)."""
|
|
|
|
def test_bad_json_file(self, tmp_output_dir):
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
# Create a schematic file (minimal)
|
|
sch_path = os.path.join(tmp_output_dir, "test.kicad_sch")
|
|
with open(sch_path, "w") as f:
|
|
f.write("(kicad_sch (version 20230121))")
|
|
|
|
# Create a bad JSON file
|
|
bad_json = os.path.join(tmp_output_dir, "bad.json")
|
|
with open(bad_json, "w") as f:
|
|
f.write("{invalid json}")
|
|
|
|
result = apply_batch(
|
|
schematic_path=sch_path,
|
|
batch_file=bad_json,
|
|
)
|
|
|
|
assert result["success"] is False
|
|
assert "json" in result["error"].lower() or "JSON" in result["error"]
|
|
|
|
def test_nonexistent_batch_file(self, tmp_output_dir):
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
sch_path = os.path.join(tmp_output_dir, "test.kicad_sch")
|
|
with open(sch_path, "w") as f:
|
|
f.write("(kicad_sch (version 20230121))")
|
|
|
|
result = apply_batch(
|
|
schematic_path=sch_path,
|
|
batch_file="/nonexistent/batch.json",
|
|
)
|
|
|
|
assert result["success"] is False
|
|
assert "not found" in result["error"].lower()
|
|
|
|
def test_bad_schematic_path(self, batch_json_file):
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
result = apply_batch(
|
|
schematic_path="/nonexistent/path.kicad_sch",
|
|
batch_file=batch_json_file,
|
|
)
|
|
|
|
assert result["success"] is False
|
|
|
|
|
|
@requires_sch_api
|
|
class TestBatchDryRun:
|
|
"""Tests for batch dry_run mode."""
|
|
|
|
def test_dry_run_returns_preview(self, populated_schematic_with_ic, batch_json_file):
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_json_file,
|
|
dry_run=True,
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["dry_run"] is True
|
|
assert "preview" in result
|
|
assert result["preview"]["components"] == 2
|
|
assert result["preview"]["wires"] == 1
|
|
assert result["preview"]["labels"] == 1
|
|
assert result["preview"]["no_connects"] == 1
|
|
assert result["validation"] == "passed"
|
|
|
|
def test_dry_run_catches_missing_fields(self, populated_schematic_with_ic, tmp_output_dir):
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
bad_data = {
|
|
"components": [{"lib_id": "Device:R"}], # missing x, y
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "bad_batch.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(bad_data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
dry_run=True,
|
|
)
|
|
|
|
assert result["success"] is False
|
|
assert "validation_errors" in result
|
|
|
|
def test_empty_batch_rejected(self, populated_schematic_with_ic, tmp_output_dir):
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
batch_path = os.path.join(tmp_output_dir, "empty_batch.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump({}, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
)
|
|
|
|
assert result["success"] is False
|
|
|
|
|
|
@requires_sch_api
|
|
class TestBatchApply:
|
|
"""Integration tests for applying batch operations."""
|
|
|
|
def test_apply_components_and_wires(self, populated_schematic_with_ic, batch_json_file):
|
|
from kicad_sch_api import load_schematic
|
|
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_json_file,
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["components_placed"] == 2
|
|
assert result["wires_placed"] == 1
|
|
assert result["labels_placed"] == 1
|
|
assert result["no_connects_placed"] == 1
|
|
|
|
# Verify components exist in saved schematic
|
|
sch = load_schematic(populated_schematic_with_ic)
|
|
r10 = sch.components.get("R10")
|
|
assert r10 is not None
|
|
assert r10.value == "1k"
|
|
|
|
def test_apply_with_power_symbols(self, populated_schematic_with_ic, tmp_output_dir):
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"components": [
|
|
{"lib_id": "Device:C", "reference": "C20", "value": "100nF", "x": 300, "y": 100},
|
|
],
|
|
"power_symbols": [
|
|
{"net": "GND", "pin_ref": "C20", "pin_number": "2"},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "pwr_batch.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["components_placed"] == 1
|
|
assert result["power_symbols_placed"] == 1
|
|
|
|
def test_mckicad_sidecar_lookup(self, populated_schematic_with_ic, tmp_output_dir):
|
|
"""Test that relative paths resolve to .mckicad/ directory."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
# Create .mckicad/ sidecar next to schematic
|
|
sch_dir = os.path.dirname(populated_schematic_with_ic)
|
|
mckicad_dir = os.path.join(sch_dir, ".mckicad")
|
|
os.makedirs(mckicad_dir, exist_ok=True)
|
|
|
|
data = {
|
|
"labels": [{"text": "SIDECAR_TEST", "x": 100, "y": 100}],
|
|
}
|
|
sidecar_path = os.path.join(mckicad_dir, "sidecar_batch.json")
|
|
with open(sidecar_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
# Use relative path — should find it in .mckicad/
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file="sidecar_batch.json",
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["labels_placed"] == 1
|
|
|
|
def test_batch_labels_persist_in_file(self, populated_schematic_with_ic, tmp_output_dir):
|
|
"""Batch labels (local and global) must appear in the saved file."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"labels": [
|
|
{"text": "BATCH_LOCAL", "x": 150, "y": 100},
|
|
{"text": "BATCH_GLOBAL", "x": 160, "y": 110, "global": True},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "label_persist_batch.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["labels_placed"] == 2
|
|
|
|
with open(populated_schematic_with_ic) as f:
|
|
content = f.read()
|
|
|
|
assert '(label "BATCH_LOCAL"' in content
|
|
assert '(global_label "BATCH_GLOBAL"' in content
|
|
|
|
|
|
@requires_sch_api
|
|
class TestBatchPinRefLabels:
|
|
"""Tests for pin-referenced label placement in batch operations."""
|
|
|
|
def test_pin_ref_label_validation_accepts_valid(
|
|
self, populated_schematic_with_ic, tmp_output_dir,
|
|
):
|
|
"""Pin-ref labels with valid references pass validation."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"labels": [
|
|
{"text": "PIN_REF_NET", "pin_ref": "R1", "pin_number": "1", "global": True},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "pinref_valid.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
dry_run=True,
|
|
)
|
|
|
|
assert result["success"] is True
|
|
|
|
def test_pin_ref_label_validation_rejects_missing_ref(
|
|
self, populated_schematic_with_ic, tmp_output_dir,
|
|
):
|
|
"""Pin-ref labels with unknown references fail validation."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"labels": [
|
|
{"text": "BAD", "pin_ref": "U99", "pin_number": "1"},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "pinref_bad.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
dry_run=True,
|
|
)
|
|
|
|
assert result["success"] is False
|
|
assert any("U99" in e for e in result["validation_errors"])
|
|
|
|
def test_label_requires_coords_or_pin_ref(
|
|
self, populated_schematic_with_ic, tmp_output_dir,
|
|
):
|
|
"""Labels without coords or pin_ref fail validation."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"labels": [
|
|
{"text": "ORPHAN"},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "pinref_orphan.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
dry_run=True,
|
|
)
|
|
|
|
assert result["success"] is False
|
|
assert any("pin-reference" in e or "coordinate" in e for e in result["validation_errors"])
|
|
|
|
def test_pin_ref_label_creates_label_and_wire(
|
|
self, populated_schematic_with_ic, tmp_output_dir,
|
|
):
|
|
"""Pin-referenced label creates both a label and a wire stub in the file."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"labels": [
|
|
{"text": "GPIO_TEST", "pin_ref": "R1", "pin_number": "1", "global": True},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "pinref_apply.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["labels_placed"] == 1
|
|
|
|
with open(populated_schematic_with_ic) as f:
|
|
content = f.read()
|
|
|
|
assert '(global_label "GPIO_TEST"' in content
|
|
assert "(wire\n" in content
|
|
|
|
|
|
@requires_sch_api
|
|
class TestBatchLabelConnections:
|
|
"""Tests for label_connections batch operations."""
|
|
|
|
def test_label_connections_validation_accepts_valid(
|
|
self, populated_schematic_with_ic, tmp_output_dir,
|
|
):
|
|
"""label_connections with valid refs pass validation."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"label_connections": [
|
|
{
|
|
"net": "SHARED_NET",
|
|
"global": True,
|
|
"connections": [
|
|
{"ref": "R1", "pin": "1"},
|
|
{"ref": "C1", "pin": "1"},
|
|
],
|
|
},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "lc_valid.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
dry_run=True,
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["preview"]["label_connections"] == 2
|
|
|
|
def test_label_connections_validation_rejects_bad_ref(
|
|
self, populated_schematic_with_ic, tmp_output_dir,
|
|
):
|
|
"""label_connections with unknown refs fail validation."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"label_connections": [
|
|
{
|
|
"net": "BAD_NET",
|
|
"connections": [
|
|
{"ref": "MISSING_REF", "pin": "1"},
|
|
],
|
|
},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "lc_bad.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
dry_run=True,
|
|
)
|
|
|
|
assert result["success"] is False
|
|
assert any("MISSING_REF" in e for e in result["validation_errors"])
|
|
|
|
def test_label_connections_creates_labels_at_different_positions(
|
|
self, populated_schematic_with_ic, tmp_output_dir,
|
|
):
|
|
"""label_connections places same-named labels at unique pin positions."""
|
|
from mckicad.tools.batch import apply_batch
|
|
|
|
data = {
|
|
"label_connections": [
|
|
{
|
|
"net": "MULTI_PIN_NET",
|
|
"global": True,
|
|
"connections": [
|
|
{"ref": "R1", "pin": "1"},
|
|
{"ref": "C1", "pin": "1"},
|
|
],
|
|
},
|
|
],
|
|
}
|
|
batch_path = os.path.join(tmp_output_dir, "lc_multi.json")
|
|
with open(batch_path, "w") as f:
|
|
json.dump(data, f)
|
|
|
|
result = apply_batch(
|
|
schematic_path=populated_schematic_with_ic,
|
|
batch_file=batch_path,
|
|
)
|
|
|
|
assert result["success"] is True
|
|
assert result["labels_placed"] >= 2
|
|
|
|
with open(populated_schematic_with_ic) as f:
|
|
content = f.read()
|
|
|
|
# Two labels with same text
|
|
import re
|
|
|
|
matches = re.findall(r'\(global_label "MULTI_PIN_NET"', content)
|
|
assert len(matches) == 2
|
|
|
|
# Wire stubs present
|
|
wire_matches = re.findall(r"\(wire\n", content)
|
|
assert len(wire_matches) >= 2
|