Files

2639 lines
89 KiB
Python

from __future__ import annotations
import hashlib
import json
import os
from pathlib import Path
import re
import subprocess
from typing import Any
import pytest
from dx_productivity.part_replace.protocol import (
load_snapshot,
load_status,
snapshot_fingerprint,
)
ROOT = Path(__file__).resolve().parents[2]
COMMON = ROOT / "integration" / "dxdesigner795" / "BridgeCommon.vbs"
BRIDGE = ROOT / "integration" / "dxdesigner795" / "PartReplaceBridge.vbs"
_INTERFACES = (
"attributes",
"gates",
"hierarchy",
"logical_identity",
"mirror",
"nets",
"origin_x",
"origin_y",
"part_number",
"pins",
"position_x",
"position_y",
"refdes",
"rotation",
"symbol_identity",
"units",
)
_ROUTES = {
"exact_set_selection": "ActiveView.SelectExactSet",
"native_replace_part": "Application.OpenReplacePartDialog",
"completion_observation": "Application.ReplacePartCompleted",
"undo": "Application.Undo",
"save": "Application.Save",
"open_project": "Application.OpenProject",
"close_project": "Application.CloseProject",
"packager": "Application.RunPackager",
"erc": "Application.RunERC",
"netlist": "Application.RunNetlist",
"ccomp_research": "Application.CComp",
}
def _vbs_string(value: str) -> str:
return '"' + value.replace('"', '""') + '"'
def _project_id(path: Path) -> str:
identity = os.path.normcase(str(path.resolve(strict=False)))
return hashlib.sha256(identity.encode("utf-8")).hexdigest()[:16]
def _route_record(name: str, route: str, *, available: bool = True) -> dict[str, Any]:
error = None
if not available:
error = {
"description": "fixture route unavailable",
"number": 51001,
"operation": f"route.{name}.{route}",
"source": "fixture.route",
}
record = {
"attempted": True,
"available": available,
"manual_fallback": f"manual_{name}",
"route": route,
"attempts": [
{
"attempted": True,
"available": available,
"error": error,
"route": route,
}
],
}
if name == "ccomp_research":
record["production_enabled"] = False
return record
def _profile(*, live_checked: bool = True) -> dict[str, Any]:
return {
"format_version": 1,
"dxdesigner": {"build": "7.9.5.1234", "version": "7.9.5"},
"project": {"active_view": "Sheet1", "dirty": False, "identity": "probe-fixture"},
"enumeration": {
"available": True,
"component_count": 3,
"route": "Application.DesignComponents",
},
"components": [],
"interfaces": {name: {"available": True} for name in _INTERFACES},
"production_replace_route": "native_replace_part",
"routes": {name: _route_record(name, route) for name, route in _ROUTES.items()},
"safety": {
"disposable_project_marker": True,
"mutating_probe_attempted": True,
"mutating_probe_authorized": True,
"operator_confirmation": True,
"request_valid": True,
},
"api_errors": [],
"live_acceptance": {
"checked": live_checked,
**(
{
"evidence_sha256": "a" * 64,
"reason": "live_795_acceptance_completed",
}
if live_checked
else {"reason": "live_795_host_not_exercised"}
),
},
}
def _profile_component() -> dict[str, Any]:
return {
"api_errors": [],
"attributes": [{"name": "Vendor", "value": "Acme"}],
"gates": [{"name": "A", "unit_number": 1}],
"hierarchy": "/MAIN",
"logical_identity": "/MAIN|U1",
"mirror": False,
"nets": ["N1"],
"origin": {"x": 0, "y": 0},
"part_number": "OLD-1",
"pins": [{"name": "IN", "net_identity": "N1", "number": "1", "x": 0, "y": 0}],
"position": {"x": 0, "y": 0},
"refdes": "U1",
"rotation": 0,
"symbol_identity": "IC_A",
"units": 1,
}
def _command(project_path: Path, action: str = "inventory") -> dict[str, Any]:
return {
"action": action,
"command_id": "command-1",
"expected_count": 0,
"expected_fingerprint": "",
"expected_logical_keys": [],
"format_version": 1,
"job_id": "job-1",
"new_part_number": "",
"old_part_number": "",
"project_id": _project_id(project_path),
"scope": "full_project",
}
def _write_json(path: Path, value: object) -> None:
path.write_text(
json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n",
encoding="utf-8",
newline="",
)
def _wrapper_source(root: Path, project_path: Path) -> str:
return fr'''Option Explicit
Dim RouteCalls
Dim FailureOperation
Dim SelectionMode
Dim DialogPartNumber
Dim CaptureModalStatus
Dim ModalStatusText
Dim CollectionAccessCount
Sub FailIfRequested(ByVal Operation, ByVal Number, ByVal Source, ByVal Description)
If FailureOperation = Operation Then Err.Raise Number, Source, Description
End Sub
Class FakeScripting
Public Function GetEnvVariable(ByVal Name)
If Name = "DXTOOLS_HOME" Then
GetEnvVariable = {_vbs_string(str(root))}
Else
GetEnvVariable = ""
End If
End Function
End Class
Class FakeAttribute
Public Name
Public Value
End Class
Class FakeGate
Public Name
Public UnitNumber
End Class
Class FakePin
Public Number
Public Name
Public X
Public Y
Public NetIdentity
End Class
Class FakeComponent
Public ObjectId
Public LogicalIdentity
Public PartNumber
Public RefDes
Public Hierarchy
Public Units
Public Gates
Public SymbolName
Public OriginX
Public OriginY
Public X
Public Y
Public Rotation
Public Mirrored
Public Attributes
Public Pins
Public Nets
End Class
Function NewAttribute(ByVal Name, ByVal Value)
Dim Result
Set Result = New FakeAttribute
Result.Name = Name
Result.Value = Value
Set NewAttribute = Result
End Function
Function NewGate(ByVal Name, ByVal Number)
Dim Result
Set Result = New FakeGate
Result.Name = Name
Result.UnitNumber = Number
Set NewGate = Result
End Function
Function NewPin(ByVal Number, ByVal Name, ByVal X, ByVal Y, ByVal NetIdentity)
Dim Result
Set Result = New FakePin
Result.Number = Number
Result.Name = Name
Result.X = X
Result.Y = Y
Result.NetIdentity = NetIdentity
Set NewPin = Result
End Function
Function NewComponent(ByVal ObjectId, ByVal LogicalIdentity, ByVal PartNumber, _
ByVal RefDes, ByVal UnitId, ByVal UnitNumber, ByVal SymbolName, _
ByVal X, ByVal Y, ByVal Rotation, ByVal Mirrored, ByRef Pins, ByRef Nets)
Dim Result
Dim Gates(0)
Dim Attributes(0)
Set Result = New FakeComponent
Result.ObjectId = ObjectId
Result.LogicalIdentity = LogicalIdentity
Result.PartNumber = PartNumber
Result.RefDes = RefDes
Result.Hierarchy = "/MAIN"
Result.Units = 1
Set Gates(0) = NewGate(UnitId, UnitNumber)
Result.Gates = Gates
Result.SymbolName = SymbolName
Result.OriginX = X - 0.5
Result.OriginY = Y - 0.5
Result.X = X
Result.Y = Y
Result.Rotation = Rotation
Result.Mirrored = Mirrored
Set Attributes(0) = NewAttribute("Vendor", "Acme")
Result.Attributes = Attributes
Result.Pins = Pins
Result.Nets = Nets
Set NewComponent = Result
End Function
Class FakeApplication
Public ProjectPath
Public Modified
Public ComponentItems
Private VersionValue
Private BuildValue
Private Sub Class_Initialize()
VersionValue = "7.9.5"
BuildValue = "7.9.5.1234"
ProjectPath = {_vbs_string(str(project_path))}
Modified = False
End Sub
Public Property Get Version
FailIfRequested "Application.Version", 53008, _
"FakeApplication.Version", "version unavailable"
Version = VersionValue
End Property
Public Property Get Build
FailIfRequested "Application.Build", 53009, _
"FakeApplication.Build", "build unavailable"
Build = BuildValue
End Property
Public Property Get DesignComponents
If FailureOperation = "Application.DesignComponentsChanging" Then
CollectionAccessCount = CollectionAccessCount + 1
If CollectionAccessCount = 1 Then
Err.Raise 54001, "FakeApplication.DesignComponents.first", _
"first collection access failed"
Else
Err.Raise 54002, "FakeApplication.DesignComponents.second", _
"second collection access failed"
End If
End If
FailIfRequested "Application.DesignComponents", 53001, _
"FakeApplication.DesignComponents", "enumeration unavailable"
DesignComponents = ComponentItems
End Property
Public Function OpenReplacePartDialog
Dim Item
RouteCalls = RouteCalls & "native_replace_part|"
FailIfRequested "Application.OpenReplacePartDialog", 53003, _
"FakeApplication.OpenReplacePartDialog", "dialog unavailable"
If CaptureModalStatus Then
ModalStatusText = DxReadUtf8({_vbs_string(str(root / "run" / "status.json"))})
End If
For Each Item In ActiveView.SelectedObjects
Item.PartNumber = DialogPartNumber
Next
Modified = True
OpenReplacePartDialog = True
End Function
Public Property Get ReplacePartCompleted
RouteCalls = RouteCalls & "completion_observation|"
FailIfRequested "Application.ReplacePartCompleted", 53010, _
"FakeApplication.ReplacePartCompleted", "completion unavailable"
ReplacePartCompleted = True
End Property
Public Function Undo
Dim Item
RouteCalls = RouteCalls & "undo|"
FailIfRequested "Application.Undo", 53004, _
"FakeApplication.Undo", "undo unavailable"
For Each Item In ComponentItems
If Item.LogicalIdentity = "/MAIN|U1" Then Item.PartNumber = "OLD-1"
Next
Undo = True
End Function
Public Function Save
RouteCalls = RouteCalls & "save|"
FailIfRequested "Application.Save", 53005, _
"FakeApplication.Save", "save unavailable"
Modified = False
Save = True
End Function
Public Function OpenProject(ByVal Path)
RouteCalls = RouteCalls & "open_project:" & CStr(Path) & "|"
FailIfRequested "Application.OpenProject", 53006, _
"FakeApplication.OpenProject", "open unavailable"
ProjectPath = CStr(Path)
OpenProject = True
End Function
Public Function CloseProject
RouteCalls = RouteCalls & "close_project|"
FailIfRequested "Application.CloseProject", 53007, _
"FakeApplication.CloseProject", "close unavailable"
If FailureOperation <> "Application.CloseProjectLeavesOpen" Then
ProjectPath = ""
End If
CloseProject = True
End Function
Public Function RunPackager
RouteCalls = RouteCalls & "packager|"
FailIfRequested "Application.RunPackager", 53011, _
"FakeApplication.RunPackager", "Packager unavailable"
If FailureOperation = "Application.RunPackagerFailed" Then
RunPackager = False
Else
RunPackager = True
End If
End Function
Public Function RunERC
Dim Items
RouteCalls = RouteCalls & "erc|"
FailIfRequested "Application.RunERC", 53012, _
"FakeApplication.RunERC", "ERC unavailable"
If FailureOperation = "Application.RunERCChangesDesign" Then
Items = ComponentItems
Items(1).PartNumber = "CHANGED-BY-ERC"
Items(2).PartNumber = "CHANGED-BY-ERC"
End If
If FailureOperation = "Application.RunERCFailed" Then
RunERC = False
Else
RunERC = True
End If
End Function
Public Function RunNetlist
RouteCalls = RouteCalls & "netlist|"
FailIfRequested "Application.RunNetlist", 53013, _
"FakeApplication.RunNetlist", "netlist unavailable"
If FailureOperation = "Application.RunNetlistFailed" Then
RunNetlist = False
Else
RunNetlist = True
End If
End Function
End Class
Class FakeActiveView
Public Name
Private CurrentSelection
Private Sub Class_Initialize()
Name = "Sheet1"
CurrentSelection = Array()
End Sub
Public Function SelectExactSet(ByRef Items)
Dim Count
Dim Expanded
RouteCalls = RouteCalls & "exact_set_selection|"
FailIfRequested "ActiveView.SelectExactSet", 53002, _
"FakeActiveView.SelectExactSet", "selection unavailable"
If SelectionMode = "append_extra" Then
Count = UBound(Items) - LBound(Items) + 1
ReDim Expanded(Count)
Dim Index
For Index = 0 To Count - 1
Set Expanded(Index) = Items(Index)
Next
Set Expanded(Count) = Application.ComponentItems(0)
CurrentSelection = Expanded
ElseIf SelectionMode = "scalar_selected" Then
Count = UBound(Items) - LBound(Items) + 1
ReDim Expanded(Count - 1)
Set Expanded(0) = Items(0)
Expanded(1) = "not-a-selected-object"
CurrentSelection = Expanded
Else
CurrentSelection = Items
End If
SelectExactSet = True
End Function
Public Sub SetManualSelection(ByRef Items)
CurrentSelection = Items
End Sub
Public Property Get SelectedObjects
SelectedObjects = CurrentSelection
End Property
End Class
Sub InitializeManualSelection(ByRef View, ByRef Target, ByVal Mode)
Dim Components
Dim ManualItems
Components = Target.ComponentItems
Select Case CStr(Mode)
Case "manual_exact"
ReDim ManualItems(1)
Set ManualItems(0) = Components(1)
Set ManualItems(1) = Components(2)
View.SetManualSelection ManualItems
Case "manual_extra"
ReDim ManualItems(2)
Set ManualItems(0) = Components(1)
Set ManualItems(1) = Components(2)
Set ManualItems(2) = Components(0)
View.SetManualSelection ManualItems
Case "manual_duplicate"
ReDim ManualItems(1)
Set ManualItems(0) = Components(1)
Set ManualItems(1) = Components(1)
View.SetManualSelection ManualItems
End Select
End Sub
Sub InitializeComponents(ByRef Target)
Dim Components(2)
Dim PinsR(0)
Dim NetsR(0)
Dim PinsA(1)
Dim NetsA(1)
Dim PinsB(0)
Dim NetsB(0)
Set PinsR(0) = NewPin("1", "R", 10, 20, "KEEP")
NetsR(0) = "KEEP"
Set Components(0) = NewComponent("R1-A", "/MAIN|R1", "KEEP-1", _
"R1", "A", 1, "RES", 10, 20, 0, False, PinsR, NetsR)
Set PinsA(0) = NewPin("1", "IN", 101, 200, "N1")
Set PinsA(1) = NewPin("2", "OUT", 99, 200, "N2")
NetsA(0) = "N1"
NetsA(1) = "N2"
Set Components(1) = NewComponent("U1-A", "/MAIN|U1", InitialPartNumber, _
"U1", "A", 1, "IC_A", 100, 200, 90, False, PinsA, NetsA)
Set PinsB(0) = NewPin("3", "IO", 111, 210, "N3")
NetsB(0) = "N3"
Set Components(2) = NewComponent("U1-B", "/MAIN|U1", InitialPartNumber, _
"U1", "B", 2, "IC_B", 110, 210, 0, True, PinsB, NetsB)
Target.ComponentItems = Components
End Sub
Sub ApplyDataMode(ByRef Target, ByVal Mode)
Dim Items
Dim FirstTarget
Dim SecondTarget
Dim Gates
Dim Pins
Dim Attributes
Dim Nets
Dim BadValue
Items = Target.ComponentItems
Set FirstTarget = Items(1)
Set SecondTarget = Items(2)
Select Case CStr(Mode)
Case "missing_identity"
FirstTarget.LogicalIdentity = ""
Case "duplicate_unit"
Gates = SecondTarget.Gates
Gates(0).Name = "A"
Case "ambiguous_refdes"
SecondTarget.RefDes = "U2"
Case "missing_pins"
SecondTarget.Pins = Array()
Case "missing_net"
SecondTarget.Nets = Array()
Case "unconnected_pin"
Pins = SecondTarget.Pins
Pins(0).NetIdentity = Null
SecondTarget.Nets = Array()
Case "duplicate_pin"
Pins = FirstTarget.Pins
Pins(1).Number = "1"
Case "non_object_component"
Items(1) = "not-a-component"
Target.ComponentItems = Items
Case "non_object_attribute"
Attributes = FirstTarget.Attributes
Attributes(0) = "not-an-attribute"
FirstTarget.Attributes = Attributes
Case "non_object_gate"
Gates = FirstTarget.Gates
Gates(0) = "not-a-gate"
FirstTarget.Gates = Gates
Case "non_object_pin"
Pins = FirstTarget.Pins
Pins(0) = "not-a-pin"
FirstTarget.Pins = Pins
Case "object_gate_name"
Gates = FirstTarget.Gates
Set BadValue = CreateObject("Scripting.Dictionary")
Set Gates(0).Name = BadValue
Case "object_net"
Nets = FirstTarget.Nets
Set BadValue = CreateObject("Scripting.Dictionary")
Set Nets(0) = BadValue
FirstTarget.Nets = Nets
Case "object_pin_net"
Pins = FirstTarget.Pins
Set BadValue = CreateObject("Scripting.Dictionary")
Set Pins(0).NetIdentity = BadValue
Case "object_project_path"
Set BadValue = CreateObject("Scripting.Dictionary")
Set Target.ProjectPath = BadValue
Case "object_modified"
Set BadValue = CreateObject("Scripting.Dictionary")
Set Target.Modified = BadValue
Case "multiple_object_coordinates"
Set BadValue = CreateObject("Scripting.Dictionary")
Set FirstTarget.OriginX = BadValue
Set FirstTarget.OriginY = BadValue
Case "multiple_object_pin_fields"
Pins = FirstTarget.Pins
Set BadValue = CreateObject("Scripting.Dictionary")
Set Pins(0).Number = BadValue
Set Pins(0).Name = BadValue
End Select
End Sub
Function SelectedCsv()
Dim Item
Dim Result
Result = ""
For Each Item In ActiveView.SelectedObjects
If Len(Result) > 0 Then Result = Result & ","
If IsObject(Item) Then
Result = Result & Item.ObjectId
Else
Result = Result & "<scalar>"
End If
Next
SelectedCsv = Result
End Function
Dim Fso
Dim CommonSource
Dim BridgeSource
Dim Scripting
Dim Application
Dim ActiveView
Dim InitialPartNumber
Set Fso = CreateObject("Scripting.FileSystemObject")
CommonSource = Fso.OpenTextFile({_vbs_string(str(COMMON))}, 1, False, 0).ReadAll
ExecuteGlobal CommonSource
BridgeSource = Fso.OpenTextFile({_vbs_string(str(BRIDGE))}, 1, False, 0).ReadAll
ExecuteGlobal BridgeSource
Set Scripting = New FakeScripting
Set Application = New FakeApplication
Set ActiveView = New FakeActiveView
InitialPartNumber = WScript.Arguments(5)
InitializeComponents Application
Application.Modified = CBool(WScript.Arguments(6))
ApplyDataMode Application, WScript.Arguments(7)
If CBool(WScript.Arguments(9)) Then Application.ProjectPath = ""
RouteCalls = ""
FailureOperation = WScript.Arguments(2)
SelectionMode = WScript.Arguments(3)
DialogPartNumber = WScript.Arguments(4)
CaptureModalStatus = CBool(WScript.Arguments(8))
ModalStatusText = ""
CollectionAccessCount = 0
InitializeManualSelection ActiveView, Application, SelectionMode
DxRunPartReplaceBridge WScript.Arguments(0), "run\profile.json", _
"run\command.json", "run\status.json", "run\snapshot.json", _
WScript.Arguments(1)
Dim CallsFile
Set CallsFile = Fso.CreateTextFile(Fso.BuildPath({_vbs_string(str(root / 'run'))}, _
"route_calls.txt"), True, False)
CallsFile.Write RouteCalls
CallsFile.Close
Dim SelectionFile
Set SelectionFile = Fso.CreateTextFile(Fso.BuildPath({_vbs_string(str(root / 'run'))}, _
"selection.txt"), True, False)
SelectionFile.Write SelectedCsv()
SelectionFile.Close
Dim ModalStatusFile
Set ModalStatusFile = Fso.CreateTextFile(Fso.BuildPath({_vbs_string(str(root / 'run'))}, _
"modal_status.json"), True, False)
ModalStatusFile.Write ModalStatusText
ModalStatusFile.Close
'''
def _run_bridge(
tmp_path: Path,
*,
action: str,
profile: dict[str, Any] | None = None,
command: dict[str, Any] | None = None,
project_path_argument: str = "",
failure_operation: str = "",
selection_mode: str = "exact",
dialog_part_number: str = "NEW-1",
initial_part_number: str = "OLD-1",
initial_modified: bool = False,
data_mode: str = "complete",
capture_modal_status: bool = False,
start_closed: bool = False,
reuse: bool = False,
) -> tuple[Path, subprocess.CompletedProcess[str]]:
project_path = tmp_path / "fixture" / "design.prj"
project_path.parent.mkdir(exist_ok=reuse)
project_path.write_text("fake project\n", encoding="ascii")
run_dir = tmp_path / "run"
run_dir.mkdir(exist_ok=reuse)
if profile is not None or not (run_dir / "profile.json").exists():
_write_json(run_dir / "profile.json", profile or _profile())
if command is not None or not (run_dir / "command.json").exists():
_write_json(run_dir / "command.json", command or _command(project_path, action))
wrapper = tmp_path / "run_bridge.vbs"
wrapper.write_text(_wrapper_source(tmp_path, project_path), encoding="ascii")
completed = subprocess.run(
[
"cscript",
"//nologo",
str(wrapper),
action,
project_path_argument,
failure_operation,
selection_mode,
dialog_part_number,
initial_part_number,
str(initial_modified),
data_mode,
str(capture_modal_status),
str(start_closed),
],
cwd=ROOT,
check=False,
capture_output=True,
text=True,
encoding="utf-8",
errors="replace",
env={**os.environ, "PYTHONPATH": str(ROOT / "src")},
)
return run_dir, completed
def _assert_cscript_ok(completed: subprocess.CompletedProcess[str]) -> None:
output = completed.stdout + completed.stderr
assert completed.returncode == 0, output
assert "Microsoft VBScript" not in output, output
def _snapshot_data(project_path: Path, part_number: str = "OLD-1") -> dict[str, Any]:
return {
"components": [
{
"attributes": [{"name": "Vendor", "value": "Acme"}],
"logical_key": "/MAIN|R1",
"part_number": "KEEP-1",
"refdes": "R1",
"units": [
{
"mirrored": False,
"origin_x": "9.5",
"origin_y": "19.5",
"pins": [{"name": "R", "net": "KEEP", "number": "1", "x": "10", "y": "20"}],
"rotation": 0,
"sheet": "/MAIN",
"symbol": "RES",
"unit_id": "A",
"x": "10",
"y": "20",
}
],
},
{
"attributes": [{"name": "Vendor", "value": "Acme"}],
"logical_key": "/MAIN|U1",
"part_number": part_number,
"refdes": "U1",
"units": [
{
"mirrored": False,
"origin_x": "99.5",
"origin_y": "199.5",
"pins": [
{"name": "IN", "net": "N1", "number": "1", "x": "101", "y": "200"},
{"name": "OUT", "net": "N2", "number": "2", "x": "99", "y": "200"},
],
"rotation": 90,
"sheet": "/MAIN",
"symbol": "IC_A",
"unit_id": "A",
"x": "100",
"y": "200",
},
{
"mirrored": True,
"origin_x": "109.5",
"origin_y": "209.5",
"pins": [{"name": "IO", "net": "N3", "number": "3", "x": "111", "y": "210"}],
"rotation": 0,
"sheet": "/MAIN",
"symbol": "IC_B",
"unit_id": "B",
"x": "110",
"y": "210",
},
],
},
],
"format_version": 2,
"project_id": _project_id(project_path),
"project_path": str(project_path.resolve(strict=False)),
}
def _fingerprint(data: dict[str, Any]) -> str:
canonical = json.dumps(data, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
def _replace_command(project_path: Path) -> dict[str, Any]:
command = _command(project_path, "replace_part")
command.update(
{
"expected_count": 1,
"expected_fingerprint": _fingerprint(_snapshot_data(project_path)),
"expected_logical_keys": ["/MAIN|U1"],
"new_part_number": "NEW-1",
"old_part_number": "OLD-1",
}
)
return command
def _snapshot_command(
project_path: Path,
action: str,
*,
part_number: str = "OLD-1",
) -> dict[str, Any]:
command = _command(project_path, action)
command["expected_fingerprint"] = _fingerprint(
_snapshot_data(project_path, part_number)
)
return command
def test_inventory_exports_complete_multi_unit_protocol_snapshot(tmp_path: Path) -> None:
# Catches inventory dropping units, protected values, unrelated components, or fingerprint evidence.
run_dir, completed = _run_bridge(tmp_path, action="inventory")
_assert_cscript_ok(completed)
snapshot = load_snapshot(run_dir / "snapshot.json")
assert (run_dir / "snapshot.json").read_bytes().startswith(b"{")
assert (run_dir / "snapshot.json").read_bytes().endswith(b"\n")
assert snapshot.project_id == _project_id(tmp_path / "fixture" / "design.prj")
assert Path(snapshot.project_path) == tmp_path / "fixture" / "design.prj"
assert snapshot.fingerprint == snapshot_fingerprint(snapshot)
assert [(component.logical_key, component.refdes, component.part_number) for component in snapshot.components] == [
("/MAIN|R1", "R1", "KEEP-1"),
("/MAIN|U1", "U1", "OLD-1"),
]
target = snapshot.components[1]
assert target.attributes == (("Vendor", "Acme"),)
assert [
(str(unit.origin_x), str(unit.origin_y), str(unit.x), str(unit.y))
for unit in target.units
] == [
("99.5", "199.5", "100", "200"),
("109.5", "209.5", "110", "210"),
]
assert [(unit.unit_id, unit.sheet, unit.symbol, str(unit.x), str(unit.y), unit.rotation, unit.mirrored) for unit in target.units] == [
("A", "/MAIN", "IC_A", "100", "200", 90, False),
("B", "/MAIN", "IC_B", "110", "210", 0, True),
]
assert [(pin.number, pin.name, str(pin.x), str(pin.y), pin.net) for pin in target.units[0].pins] == [
("1", "IN", "101", "200", "N1"),
("2", "OUT", "99", "200", "N2"),
]
status = load_status(run_dir / "status.json")
assert status.state == "inventory_exported"
assert status.snapshot_path == str((run_dir / "snapshot.json").resolve())
assert status.details == (("action", "inventory"), ("expected_count", "0"), ("job_id", "job-1"))
assert (run_dir / "status.json").read_bytes().startswith(b"{")
assert (run_dir / "status.json").read_bytes().endswith(b"\n")
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
@pytest.mark.parametrize(
("data_mode", "expected_code"),
(
("missing_identity", "missing_protected_field"),
("duplicate_unit", "duplicate_unit_identity"),
("ambiguous_refdes", "ambiguous_logical_identity"),
("missing_pins", "missing_pin_data"),
("missing_net", "missing_net_data"),
("duplicate_pin", "duplicate_pin_number"),
),
)
def test_inventory_fails_closed_on_ambiguous_or_incomplete_live_evidence(
tmp_path: Path,
data_mode: str,
expected_code: str,
) -> None:
# Catches incomplete identity, unit, pin, or net data entering a versioned snapshot.
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
data_mode=data_mode,
)
_assert_cscript_ok(completed)
assert not (run_dir / "snapshot.json").exists()
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", expected_code)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
def test_inventory_serializes_an_unconnected_pin_as_protocol_null(tmp_path: Path) -> None:
# Catches VBScript coercing or rejecting the protocol's supported null net identity.
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
data_mode="unconnected_pin",
)
_assert_cscript_ok(completed)
snapshot = load_snapshot(run_dir / "snapshot.json")
target = next(
component for component in snapshot.components if component.logical_key == "/MAIN|U1"
)
unit_b = next(unit for unit in target.units if unit.unit_id == "B")
assert unit_b.pins[0].net is None
assert load_status(run_dir / "status.json").state == "inventory_exported"
@pytest.mark.parametrize(
"malformed_key",
({"logical": "object"}, None, 7, ["nested"]),
)
def test_command_rejects_malformed_expected_keys_without_vbscript_error(
tmp_path: Path,
malformed_key: Any,
) -> None:
# Catches expected-key validation coercing an object/null/number before checking its type.
project_path = tmp_path / "fixture" / "design.prj"
command = _replace_command(project_path)
command["expected_logical_keys"] = [malformed_key]
run_dir, completed = _run_bridge(tmp_path, action="replace_part", command=command)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "invalid_command")
assert dict(status.details)["operation"] == "command.expected_logical_keys"
@pytest.mark.parametrize(
"field_name",
("action", "command_id", "expected_count", "job_id", "project_id"),
)
def test_malformed_command_status_fields_publish_loadable_blocking_status(
tmp_path: Path,
field_name: str,
) -> None:
# Catches command-validation failure publication coercing an untrusted JSON object.
project_path = tmp_path / "fixture" / "design.prj"
command = _command(project_path)
command[field_name] = {"malformed": "object"}
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
command=command,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "invalid_command")
assert isinstance(status.command_id, str)
assert isinstance(status.project_id, str)
@pytest.mark.parametrize(
("data_mode", "expected_operation"),
(
("non_object_component", "Application.DesignComponents"),
("non_object_attribute", "component.Attributes"),
("non_object_gate", "component.Gates"),
("non_object_pin", "component.Pins"),
("object_gate_name", "component.Gates.Name"),
("object_net", "component.Nets"),
("object_pin_net", "component.Pins.NetIdentity"),
),
)
def test_inventory_blocks_malformed_live_values_without_vbscript_error(
tmp_path: Path,
data_mode: str,
expected_operation: str,
) -> None:
# Catches live collection items or gate/net values reaching Set/CStr before type validation.
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
data_mode=data_mode,
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert status.state == "blocked"
assert status.error_code == "missing_protected_field"
assert dict(status.details)["operation"] == expected_operation
@pytest.mark.parametrize(
("data_mode", "expected_operation"),
(
("multiple_object_coordinates", "component.OriginX"),
("multiple_object_pin_fields", "component.Pins.Number"),
),
)
def test_inventory_preserves_first_malformed_field_evidence(
tmp_path: Path,
data_mode: str,
expected_operation: str,
) -> None:
# Catches eager VBScript Or evaluation replacing the first malformed-field failure.
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
data_mode=data_mode,
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"missing_protected_field",
)
assert dict(status.details)["operation"] == expected_operation
def test_inventory_rejects_object_project_path_before_string_conversion(tmp_path: Path) -> None:
# Catches an object-valued live project identity reaching Trim/CStr.
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
data_mode="object_project_path",
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"missing_protected_field",
)
assert dict(status.details)["operation"] == "Application.ProjectPath"
def test_navigation_rejects_object_project_path_before_string_conversion(
tmp_path: Path,
) -> None:
# Catches a malformed active-project identity reaching path comparison or conversion.
next_path = tmp_path / "next" / "next.prj"
next_path.parent.mkdir()
next_path.write_text("next fake project\n", encoding="ascii")
command = _snapshot_command(next_path, "open_project")
run_dir, completed = _run_bridge(
tmp_path,
action="open_project",
command=command,
project_path_argument=str(next_path),
data_mode="object_project_path",
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"missing_protected_field",
)
assert dict(status.details)["operation"] == "Application.ProjectPath.before_open"
def test_automatic_selection_rejects_non_object_selected_value(tmp_path: Path) -> None:
# Catches a scalar selected-object entry reaching Set after the route returns.
project_path = tmp_path / "fixture" / "design.prj"
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
command=_replace_command(project_path),
selection_mode="scalar_selected",
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"missing_protected_field",
)
assert dict(status.details)["operation"] == "ActiveView.SelectedObjects"
def test_apply_rejects_stale_snapshot_before_selection(tmp_path: Path) -> None:
# Catches any selection or dialog side effect occurring before the complete current fingerprint matches.
project_path = tmp_path / "fixture" / "design.prj"
command = _replace_command(project_path)
command["expected_fingerprint"] = "0" * 64
run_dir, completed = _run_bridge(tmp_path, action="replace_part", command=command)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "stale_snapshot")
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
assert (run_dir / "selection.txt").read_text(encoding="ascii") == ""
def test_apply_rejects_wrong_active_project_before_selection(tmp_path: Path) -> None:
# Catches a valid snapshot command being applied to a different active project.
project_path = tmp_path / "fixture" / "design.prj"
command = _replace_command(project_path)
command["project_id"] = "wrong-project"
run_dir, completed = _run_bridge(tmp_path, action="replace_part", command=command)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"project_identity_mismatch",
)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
assert (run_dir / "selection.txt").read_text(encoding="ascii") == ""
def test_apply_selects_every_unit_once_then_publishes_manual_native_fallback(
tmp_path: Path,
) -> None:
# Catches per-unit dialogs, unrelated selection, or an unavailable native route being called anyway.
project_path = tmp_path / "fixture" / "design.prj"
profile = _profile()
profile["routes"]["native_replace_part"] = _route_record(
"native_replace_part", _ROUTES["native_replace_part"], available=False
)
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
profile=profile,
command=_replace_command(project_path),
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == "exact_set_selection|"
assert (run_dir / "selection.txt").read_text(encoding="ascii") == "U1-A,U1-B"
status = load_status(run_dir / "status.json")
assert status.state == "manual_action_required"
assert status.error_code is None
details = dict(status.details)
assert details["manual_route"] == "manual_native_dialog"
assert details["old_part_number"] == "OLD-1"
assert details["new_part_number"] == "NEW-1"
assert details["expected_count"] == "1"
def test_apply_rejects_extra_object_returned_by_exact_selection_route(tmp_path: Path) -> None:
# Catches a route claiming exact selection while retaining an unrelated live object.
project_path = tmp_path / "fixture" / "design.prj"
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
command=_replace_command(project_path),
selection_mode="append_extra",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == "exact_set_selection|"
assert (run_dir / "selection.txt").read_text(encoding="ascii") == "U1-A,U1-B,R1-A"
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "selection_mismatch")
def test_apply_uses_verified_modal_native_route_and_exports_after_return(tmp_path: Path) -> None:
# Catches post-operation export occurring before the verified modal call returns.
project_path = tmp_path / "fixture" / "design.prj"
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
command=_replace_command(project_path),
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == (
"exact_set_selection|native_replace_part|completion_observation|"
)
assert (run_dir / "selection.txt").read_text(encoding="ascii") == "U1-A,U1-B"
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.components[1].part_number == "NEW-1"
assert snapshot.fingerprint == snapshot_fingerprint(snapshot)
status = load_status(run_dir / "status.json")
assert status.state == "applied"
assert status.snapshot_path == str((run_dir / "snapshot.json").resolve())
def test_automatic_modal_requires_completion_observation_before_snapshot(
tmp_path: Path,
) -> None:
# Catches snapshot export immediately after the dialog route without completion evidence.
project_path = tmp_path / "fixture" / "design.prj"
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
command=_replace_command(project_path),
failure_operation="Application.ReplacePartCompleted",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == (
"exact_set_selection|native_replace_part|completion_observation|"
)
assert not (run_dir / "snapshot.json").exists()
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "api_error")
def test_automatic_modal_publishes_correlated_operator_status_before_call(
tmp_path: Path,
) -> None:
# Catches a modal mutation starting before durable old/new/count/Library Wins evidence exists.
project_path = tmp_path / "fixture" / "design.prj"
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
command=_replace_command(project_path),
capture_modal_status=True,
)
_assert_cscript_ok(completed)
during_modal = load_status(run_dir / "modal_status.json")
assert during_modal.state == "native_dialog_opening"
assert during_modal.command_id == "command-1"
assert during_modal.project_id == _project_id(project_path)
assert dict(during_modal.details) == {
"action": "replace_part",
"expected_count": "1",
"instruction": "Confirm the displayed target and choose Library Wins",
"job_id": "job-1",
"library_choice": "Library Wins",
"new_part_number": "NEW-1",
"old_part_number": "OLD-1",
}
assert load_status(run_dir / "status.json").state == "applied"
def test_apply_rejects_a_noncanonical_selection_route_name(tmp_path: Path) -> None:
# Catches a similarly named route being accepted as valid profile evidence.
project_path = tmp_path / "fixture" / "design.prj"
profile = _profile()
profile["routes"]["exact_set_selection"]["route"] = "ActiveView.SelectAlmostExact"
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
profile=profile,
command=_replace_command(project_path),
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
assert (run_dir / "selection.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"compatibility_profile_invalid",
)
assert dict(status.details)["operation"] == (
"profile.routes.exact_set_selection.route"
)
def test_unverified_profile_falls_back_to_manual_selection_without_automatic_routes(
tmp_path: Path,
) -> None:
# Catches unchecked live evidence either blocking the manual path or authorizing automatic routes.
project_path = tmp_path / "fixture" / "design.prj"
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
profile=_profile(live_checked=False),
command=_replace_command(project_path),
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
assert (run_dir / "selection.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert status.state == "manual_action_required"
assert status.error_code is None
assert dict(status.details)["manual_route"] == "manual_exact_selection"
def test_unverified_profile_falls_back_to_manual_project_navigation(tmp_path: Path) -> None:
# Catches unchecked route evidence authorizing automatic project open or blocking its fallback.
next_path = tmp_path / "next" / "next.prj"
next_path.parent.mkdir()
next_path.write_text("next fake project\n", encoding="ascii")
command = _snapshot_command(next_path, "open_project")
run_dir, completed = _run_bridge(
tmp_path,
action="open_project",
profile=_profile(live_checked=False),
command=command,
project_path_argument=str(next_path),
start_closed=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert status.state == "manual_project_open_required"
assert status.error_code is None
assert dict(status.details)["canonical_next_path"] == str(next_path.resolve())
def test_profile_schema_is_fully_validated_before_application_access(tmp_path: Path) -> None:
# Catches a malformed late route record being hidden by an earlier live Application access.
profile = _profile()
profile["routes"]["save"]["attempts"][0]["error"] = []
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
profile=profile,
failure_operation="Application.Version",
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"compatibility_profile_invalid",
)
assert dict(status.details)["operation"] == "profile.routes.save.attempts[0].error"
def test_nested_profile_net_type_is_validated_before_assignment(tmp_path: Path) -> None:
# Catches an object-valued probe pin net escaping through Variant assignment before live access.
profile = _profile()
component = _profile_component()
component["pins"][0]["net_identity"] = {"not": "a net"}
profile["components"] = [component]
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
profile=profile,
failure_operation="Application.Version",
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"compatibility_profile_invalid",
)
assert dict(status.details)["operation"] == "profile.components[0].pins[0].net_identity"
@pytest.mark.parametrize(
("field_path", "malformed_value"),
(
(("format_version",), {}),
(("live_acceptance",), True),
(("live_acceptance", "checked"), {}),
(("live_acceptance", "reason"), {}),
(("dxdesigner",), []),
(("dxdesigner", "version"), {}),
(("project",), []),
(("project", "dirty"), {}),
(("enumeration",), []),
(("enumeration", "available"), {}),
(("enumeration", "route"), {}),
(("enumeration", "component_count"), 1.5),
(("components",), [True]),
(("interfaces",), []),
(("interfaces", "pins"), True),
(("interfaces", "pins", "available"), {}),
(("routes",), []),
(("safety",), []),
(("safety", "request_valid"), {}),
(("api_errors",), [True]),
(("production_replace_route",), {}),
),
)
def test_malformed_profile_types_publish_blocked_status_without_live_access(
tmp_path: Path,
field_path: tuple[str, ...],
malformed_value: Any,
) -> None:
# Catches malformed nested JSON escaping profile validation as a VBScript runtime error.
profile = _profile()
container = profile
for field_name in field_path[:-1]:
container = container[field_name]
container[field_path[-1]] = malformed_value
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
profile=profile,
failure_operation="Application.Version",
)
_assert_cscript_ok(completed)
assert not (run_dir / "snapshot.json").exists()
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
assert (run_dir / "selection.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"compatibility_profile_invalid",
)
@pytest.mark.parametrize(
("field_path", "malformed_value"),
(
(("routes", "exact_set_selection"), True),
(("routes", "exact_set_selection"), []),
(("routes", "exact_set_selection", "route"), {}),
(("routes", "exact_set_selection", "attempts"), [True]),
(("routes", "exact_set_selection", "attempts", 0, "route"), {}),
),
)
def test_malformed_route_evidence_is_blocked_without_live_access(
tmp_path: Path,
field_path: tuple[str | int, ...],
malformed_value: Any,
) -> None:
# Catches malformed route evidence reaching live access or being presented as a usable fallback.
project_path = tmp_path / "fixture" / "design.prj"
profile = _profile()
container = profile
for field_name in field_path[:-1]:
container = container[field_name]
container[field_path[-1]] = malformed_value
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
profile=profile,
command=_replace_command(project_path),
failure_operation="Application.Version",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
assert (run_dir / "selection.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"compatibility_profile_invalid",
)
def _start_manual_dialog_handoff(tmp_path: Path) -> tuple[Path, dict[str, Any]]:
project_path = tmp_path / "fixture" / "design.prj"
profile = _profile()
profile["routes"]["native_replace_part"] = _route_record(
"native_replace_part", _ROUTES["native_replace_part"], available=False
)
command = _replace_command(project_path)
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
profile=profile,
command=command,
)
_assert_cscript_ok(completed)
assert load_status(run_dir / "status.json").state == "manual_action_required"
return run_dir, command
def _start_manual_selection_handoff(
tmp_path: Path,
*,
live_checked: bool = True,
native_available: bool = False,
) -> tuple[Path, dict[str, Any], dict[str, Any]]:
project_path = tmp_path / "fixture" / "design.prj"
profile = _profile(live_checked=live_checked)
profile["routes"]["exact_set_selection"] = _route_record(
"exact_set_selection", _ROUTES["exact_set_selection"], available=False
)
profile["routes"]["native_replace_part"] = _route_record(
"native_replace_part", _ROUTES["native_replace_part"], available=native_available
)
command = _replace_command(project_path)
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
profile=profile,
command=command,
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert status.state == "manual_action_required"
assert dict(status.details)["manual_route"] == "manual_exact_selection"
return run_dir, command, profile
def test_continue_after_manual_selection_verifies_exact_selection_then_hands_off_dialog(
tmp_path: Path,
) -> None:
# Catches a manual selection being trusted without read-only exact-set verification.
run_dir, command, _ = _start_manual_selection_handoff(tmp_path)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_selection",
command=command,
selection_mode="manual_exact",
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
assert (run_dir / "selection.txt").read_text(encoding="ascii") == "U1-A,U1-B"
status = load_status(run_dir / "status.json")
assert status.state == "manual_action_required"
details = dict(status.details)
assert details["manual_route"] == "manual_native_dialog"
assert details["old_part_number"] == "OLD-1"
assert details["new_part_number"] == "NEW-1"
def test_continue_after_manual_selection_rejects_extra_selected_object(tmp_path: Path) -> None:
# Catches a manual selection containing an unrelated object reaching the native dialog path.
run_dir, command, _ = _start_manual_selection_handoff(tmp_path)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_selection",
command=command,
selection_mode="manual_extra",
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "selection_mismatch")
def test_continue_after_manual_selection_rejects_uncorrelated_prior_status(
tmp_path: Path,
) -> None:
# Catches a selection continuation from another command or job being accepted.
run_dir, command, _ = _start_manual_selection_handoff(tmp_path)
prior = json.loads((run_dir / "status.json").read_text(encoding="utf-8"))
prior["command_id"] = "stale-command"
_write_json(run_dir / "status.json", prior)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_selection",
command=command,
selection_mode="manual_exact",
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"manual_continuation_mismatch",
)
def test_continue_after_manual_selection_never_uses_unchecked_automatic_dialog(
tmp_path: Path,
) -> None:
# Catches probe-only route evidence authorizing a modal call after manual selection.
run_dir, command, _ = _start_manual_selection_handoff(
tmp_path,
live_checked=False,
native_available=True,
)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_selection",
command=command,
selection_mode="manual_exact",
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert status.state == "manual_action_required"
assert dict(status.details)["manual_route"] == "manual_native_dialog"
def test_continue_after_manual_selection_uses_live_accepted_automatic_dialog(
tmp_path: Path,
) -> None:
# Catches a verified native dialog route being ignored after exact manual selection.
run_dir, command, _ = _start_manual_selection_handoff(
tmp_path,
native_available=True,
)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_selection",
command=command,
selection_mode="manual_exact",
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == (
"native_replace_part|completion_observation|"
)
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.components[1].part_number == "NEW-1"
assert load_status(run_dir / "status.json").state == "applied"
def test_manual_selection_and_dialog_continuations_remain_separate(tmp_path: Path) -> None:
# Catches selection continuation incorrectly treating an unopened manual dialog as completed Apply.
run_dir, command, _ = _start_manual_selection_handoff(tmp_path)
_, selected = _run_bridge(
tmp_path,
action="continue_after_manual_selection",
command=command,
selection_mode="manual_exact",
reuse=True,
)
_assert_cscript_ok(selected)
assert load_status(run_dir / "status.json").state == "manual_action_required"
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_dialog",
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.components[1].part_number == "NEW-1"
assert load_status(run_dir / "status.json").state == "applied"
def test_unverified_profile_allows_correlated_manual_dialog_continuation(
tmp_path: Path,
) -> None:
# Catches the unchecked live gate blocking a correlated read-only post-dialog export.
run_dir, command, _ = _start_manual_selection_handoff(
tmp_path,
live_checked=False,
)
_, selected = _run_bridge(
tmp_path,
action="continue_after_manual_selection",
command=command,
selection_mode="manual_exact",
reuse=True,
)
_assert_cscript_ok(selected)
assert dict(load_status(run_dir / "status.json").details)["manual_route"] == (
"manual_native_dialog"
)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_dialog",
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.components[1].part_number == "NEW-1"
assert load_status(run_dir / "status.json").state == "applied"
def test_continue_after_manual_dialog_correlates_then_exports_fresh_snapshot(
tmp_path: Path,
) -> None:
# Catches continuation trusting menu timing instead of the durable correlated handoff.
run_dir, command = _start_manual_dialog_handoff(tmp_path)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_dialog",
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.components[1].part_number == "NEW-1"
assert snapshot.fingerprint == snapshot_fingerprint(snapshot)
status = load_status(run_dir / "status.json")
assert status.state == "applied"
assert status.details == (
("action", "replace_part"),
("expected_count", "1"),
("job_id", "job-1"),
)
def _corrupt_prior_status(path: Path, corruption: str) -> None:
data = json.loads(path.read_text(encoding="utf-8"))
if corruption == "command":
data["command_id"] = "stale-command"
elif corruption == "project":
data["project_id"] = "wrong-project"
elif corruption == "state":
data["state"] = "applying"
else:
details = dict(data["details"])
details["job_id" if corruption == "job" else "action"] = "wrong"
data["details"] = [[name, details[name]] for name in ("action", "expected_count", "job_id")]
_write_json(path, data)
@pytest.mark.parametrize("corruption", ("command", "project", "job", "action", "state"))
def test_continue_after_manual_dialog_rejects_uncorrelated_prior_status(
tmp_path: Path,
corruption: str,
) -> None:
# Catches stale or cross-job manual continuation authorizing a snapshot as completed Apply evidence.
run_dir, command = _start_manual_dialog_handoff(tmp_path)
_corrupt_prior_status(run_dir / "status.json", corruption)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_dialog",
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert not (run_dir / "snapshot.json").exists()
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"manual_continuation_mismatch",
)
@pytest.mark.parametrize("malformed_version", (1.0, {"version": 1}))
def test_manual_continuation_rejects_non_integer_status_version_without_vbscript_error(
tmp_path: Path,
malformed_version: Any,
) -> None:
# Catches status validation accepting a numeric double or coercing an object through CLng.
run_dir, command = _start_manual_dialog_handoff(tmp_path)
prior = json.loads((run_dir / "status.json").read_text(encoding="utf-8"))
prior["format_version"] = malformed_version
_write_json(run_dir / "status.json", prior)
_, completed = _run_bridge(
tmp_path,
action="continue_after_manual_dialog",
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"manual_continuation_mismatch",
)
def _start_applied_operation(tmp_path: Path) -> tuple[Path, dict[str, Any], str]:
project_path = tmp_path / "fixture" / "design.prj"
command = _replace_command(project_path)
run_dir, completed = _run_bridge(
tmp_path,
action="replace_part",
command=command,
)
_assert_cscript_ok(completed)
snapshot = load_snapshot(run_dir / "snapshot.json")
assert load_status(run_dir / "status.json").state == "applied"
return run_dir, command, snapshot.fingerprint
def _control_command(
replace_command: dict[str, Any],
action: str,
expected_fingerprint: str,
) -> dict[str, Any]:
command = dict(replace_command)
command["action"] = action
command["expected_fingerprint"] = expected_fingerprint
return command
@pytest.mark.parametrize(
("action", "state", "part_number", "route_call"),
(
("undo", "undo_verified", "OLD-1", "undo|"),
("save", "saved", "NEW-1", "save|"),
),
)
def test_undo_and_save_require_correlated_explicit_commands_and_export(
tmp_path: Path,
action: str,
state: str,
part_number: str,
route_call: str,
) -> None:
# Catches direct menu mutation without a fresh expected fingerprint and applied-status correlation.
run_dir, replace_command, current_fingerprint = _start_applied_operation(tmp_path)
command = _control_command(replace_command, action, current_fingerprint)
_, completed = _run_bridge(
tmp_path,
action=action,
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == route_call
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.components[1].part_number == part_number
assert snapshot.fingerprint == snapshot_fingerprint(snapshot)
status = load_status(run_dir / "status.json")
assert status.state == state
assert dict(status.details)["action"] == "replace_part"
@pytest.mark.parametrize("action", ("undo", "save"))
def test_undo_and_save_reject_stale_current_fingerprint_before_route(
tmp_path: Path,
action: str,
) -> None:
# Catches Undo or Save running against live state other than Python's explicitly expected state.
run_dir, replace_command, _ = _start_applied_operation(tmp_path)
command = _control_command(replace_command, action, "0" * 64)
_, completed = _run_bridge(
tmp_path,
action=action,
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "stale_snapshot")
@pytest.mark.parametrize("action", ("undo", "save"))
def test_undo_and_save_reject_wrong_prior_bridge_status(
tmp_path: Path,
action: str,
) -> None:
# Catches a same-project command being replayed after the correlated applied status was lost.
run_dir, replace_command, current_fingerprint = _start_applied_operation(tmp_path)
prior = json.loads((run_dir / "status.json").read_text(encoding="utf-8"))
prior["state"] = "manual_action_required"
_write_json(run_dir / "status.json", prior)
command = _control_command(replace_command, action, current_fingerprint)
_, completed = _run_bridge(
tmp_path,
action=action,
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"manual_continuation_mismatch",
)
def test_control_rejects_non_integer_prior_status_version(tmp_path: Path) -> None:
# Catches a floating-point status protocol version authorizing Undo.
run_dir, replace_command, current_fingerprint = _start_applied_operation(tmp_path)
prior = json.loads((run_dir / "status.json").read_text(encoding="utf-8"))
prior["format_version"] = 1.0
_write_json(run_dir / "status.json", prior)
command = _control_command(replace_command, "undo", current_fingerprint)
_, completed = _run_bridge(
tmp_path,
action="undo",
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"control_status_mismatch",
)
@pytest.mark.parametrize(
"malformed_snapshot_path",
(None, 7, {"path": "snapshot.json"}),
)
def test_control_rejects_malformed_applied_snapshot_path_before_route(
tmp_path: Path,
malformed_snapshot_path: Any,
) -> None:
# Catches a structurally invalid prior applied status authorizing native Undo.
run_dir, replace_command, current_fingerprint = _start_applied_operation(tmp_path)
prior = json.loads((run_dir / "status.json").read_text(encoding="utf-8"))
prior["snapshot_path"] = malformed_snapshot_path
_write_json(run_dir / "status.json", prior)
command = _control_command(replace_command, "undo", current_fingerprint)
_, completed = _run_bridge(
tmp_path,
action="undo",
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"control_status_mismatch",
)
@pytest.mark.parametrize(
("action", "manual_route"),
(("undo", "manual_native_undo"), ("save", "manual_native_save")),
)
def test_undo_and_save_use_manual_status_when_exact_route_is_unverified(
tmp_path: Path,
action: str,
manual_route: str,
) -> None:
# Catches an unavailable profile flag being ignored for a mutating route.
run_dir, replace_command, current_fingerprint = _start_applied_operation(tmp_path)
profile = _profile()
profile["routes"][action] = _route_record(action, _ROUTES[action], available=False)
command = _control_command(replace_command, action, current_fingerprint)
_, completed = _run_bridge(
tmp_path,
action=action,
profile=profile,
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert status.state == "manual_action_required"
assert dict(status.details)["manual_route"] == manual_route
@pytest.mark.parametrize(
("action", "manual_route"),
(("undo", "manual_native_undo"), ("save", "manual_native_save")),
)
def test_unverified_profile_never_authorizes_automatic_control_route(
tmp_path: Path,
action: str,
manual_route: str,
) -> None:
# Catches unchecked probe evidence authorizing Undo/Save or implying automatic verification.
run_dir, replace_command, current_fingerprint = _start_applied_operation(tmp_path)
command = _control_command(replace_command, action, current_fingerprint)
_, completed = _run_bridge(
tmp_path,
action=action,
profile=_profile(live_checked=False),
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert status.state == "manual_action_required"
details = dict(status.details)
assert details["manual_route"] == manual_route
assert details["instruction"] == (
f"Use native {action} manually; completion is not automatically verified"
)
@pytest.mark.parametrize(
("action", "observed_part", "observed_modified", "final_state"),
(
("undo", "OLD-1", True, "undo_verified"),
("save", "NEW-1", False, "saved"),
),
)
def test_manual_control_continuation_observes_live_result_without_route_replay(
tmp_path: Path,
action: str,
observed_part: str,
observed_modified: bool,
final_state: str,
) -> None:
# Catches the manual Undo/Save fallback replacing applied status with a permanent dead end.
run_dir, replace_command, current_fingerprint = _start_applied_operation(tmp_path)
command = _control_command(replace_command, action, current_fingerprint)
profile = _profile()
profile["routes"][action] = _route_record(action, _ROUTES[action], available=False)
_, first = _run_bridge(
tmp_path,
action=action,
profile=profile,
command=command,
initial_part_number="NEW-1",
initial_modified=True,
reuse=True,
)
_assert_cscript_ok(first)
assert load_status(run_dir / "status.json").state == "manual_action_required"
_, second = _run_bridge(
tmp_path,
action=action,
profile=profile,
command=command,
initial_part_number=observed_part,
initial_modified=observed_modified,
reuse=True,
)
_assert_cscript_ok(second)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.components[1].part_number == observed_part
assert load_status(run_dir / "status.json").state == final_state
def test_clean_close_publishes_complete_snapshot_and_proves_project_closed(
tmp_path: Path,
) -> None:
# Catches backup authorization from a close call without correlated live-state evidence.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "close_project")
run_dir, completed = _run_bridge(
tmp_path,
action="close_project",
command=command,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == "close_project|"
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.fingerprint == command["expected_fingerprint"]
status = load_status(run_dir / "status.json")
assert status.state == "project_closed"
assert status.snapshot_path == str((run_dir / "snapshot.json").resolve())
def test_clean_close_rejects_dirty_project_before_route(tmp_path: Path) -> None:
# Catches a dirty in-memory project being treated as safe input for the backup boundary.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "close_project")
run_dir, completed = _run_bridge(
tmp_path,
action="close_project",
command=command,
initial_modified=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "dirty_project")
def test_close_without_save_exports_discarded_state_even_when_fingerprint_differs(
tmp_path: Path,
) -> None:
# Catches fail-safe discard being blocked because the uncertain live state differs from baseline.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "close_without_save")
command["expected_fingerprint"] = "0" * 64
run_dir, completed = _run_bridge(
tmp_path,
action="close_without_save",
command=command,
initial_part_number="NEW-1",
initial_modified=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == "close_project|"
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.components[1].part_number == "NEW-1"
assert snapshot.fingerprint != command["expected_fingerprint"]
assert load_status(run_dir / "status.json").state == "project_closed"
def test_close_blocks_when_route_returns_without_closing_project(tmp_path: Path) -> None:
# Catches trusting a successful API return without observing that the active project disappeared.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "close_project")
run_dir, completed = _run_bridge(
tmp_path,
action="close_project",
command=command,
failure_operation="Application.CloseProjectLeavesOpen",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == "close_project|"
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "project_close_incomplete")
def test_manual_close_continuation_uses_preclose_snapshot_after_project_disappears(
tmp_path: Path,
) -> None:
# Catches manual Close overwriting its evidence status with no route to confirm closure.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "close_project")
profile = _profile()
profile["routes"]["close_project"] = _route_record(
"close_project",
_ROUTES["close_project"],
available=False,
)
run_dir, first = _run_bridge(
tmp_path,
action="close_project",
profile=profile,
command=command,
)
_assert_cscript_ok(first)
assert load_status(run_dir / "status.json").state == "manual_action_required"
assert load_snapshot(run_dir / "snapshot.json").fingerprint == command["expected_fingerprint"]
_, second = _run_bridge(
tmp_path,
action="close_project",
profile=profile,
command=command,
start_closed=True,
reuse=True,
)
_assert_cscript_ok(second)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert status.state == "project_closed"
assert status.snapshot_path == str((run_dir / "snapshot.json").resolve())
def test_project_navigation_rejects_a_noncanonical_route_name(tmp_path: Path) -> None:
# Catches a similarly named navigation route being accepted as profile evidence.
current_path = tmp_path / "fixture" / "design.prj"
next_path = tmp_path / "next" / "next.prj"
next_path.parent.mkdir()
next_path.write_text("next fake project\n", encoding="ascii")
command = _snapshot_command(next_path, "open_project")
profile = _profile()
profile["routes"]["close_project"]["route"] = "Application.CloseAnything"
run_dir, completed = _run_bridge(
tmp_path,
action="open_project",
profile=profile,
command=command,
project_path_argument=str(next_path),
)
_assert_cscript_ok(completed)
assert current_path.exists()
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"compatibility_profile_invalid",
)
assert dict(status.details)["operation"] == "profile.routes.close_project.route"
def test_project_open_requires_closed_host_and_publishes_verified_snapshot(
tmp_path: Path,
) -> None:
# Catches an open result without a complete target-bound snapshot and stale-state check.
next_path = tmp_path / "next" / "next.prj"
next_path.parent.mkdir()
next_path.write_text("next fake project\n", encoding="ascii")
command = _snapshot_command(next_path, "open_project")
run_dir, completed = _run_bridge(
tmp_path,
action="open_project",
command=command,
project_path_argument=str(next_path),
start_closed=True,
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == (
f"open_project:{next_path.resolve()}|"
)
snapshot = load_snapshot(run_dir / "snapshot.json")
assert Path(snapshot.project_path) == next_path.resolve()
assert snapshot.fingerprint == command["expected_fingerprint"]
status = load_status(run_dir / "status.json")
assert status.state == "project_opened"
assert status.project_id == _project_id(next_path)
assert status.snapshot_path == str((run_dir / "snapshot.json").resolve())
def test_project_open_blocks_before_route_when_a_project_is_already_active(
tmp_path: Path,
) -> None:
# Catches open implicitly closing or replacing an active project outside the close/backup gate.
next_path = tmp_path / "next" / "next.prj"
next_path.parent.mkdir()
next_path.write_text("next fake project\n", encoding="ascii")
command = _snapshot_command(next_path, "open_project")
run_dir, completed = _run_bridge(
tmp_path,
action="open_project",
command=command,
project_path_argument=str(next_path),
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "project_already_open")
def test_manual_open_continuation_verifies_operator_opened_project(tmp_path: Path) -> None:
# Catches manual Open status becoming a dead end instead of observing target identity and contents.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "open_project")
profile = _profile()
profile["routes"]["open_project"] = _route_record(
"open_project",
_ROUTES["open_project"],
available=False,
)
run_dir, first = _run_bridge(
tmp_path,
action="open_project",
profile=profile,
command=command,
project_path_argument=str(project_path),
start_closed=True,
)
_assert_cscript_ok(first)
assert load_status(run_dir / "status.json").state == "manual_project_open_required"
_, second = _run_bridge(
tmp_path,
action="open_project",
profile=profile,
command=command,
project_path_argument=str(project_path),
reuse=True,
)
_assert_cscript_ok(second)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.fingerprint == command["expected_fingerprint"]
assert load_status(run_dir / "status.json").state == "project_opened"
@pytest.mark.parametrize(
("action", "route_call"),
(("packager", "packager|"), ("erc", "erc|"), ("netlist", "netlist|")),
)
def test_external_check_requires_true_result_and_unchanged_complete_snapshot(
tmp_path: Path,
action: str,
route_call: str,
) -> None:
# Catches a check being accepted without exact route success and post-check design evidence.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, action, part_number="NEW-1")
run_dir, completed = _run_bridge(
tmp_path,
action=action,
command=command,
initial_part_number="NEW-1",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == route_call
snapshot = load_snapshot(run_dir / "snapshot.json")
assert snapshot.fingerprint == command["expected_fingerprint"]
status = load_status(run_dir / "status.json")
assert status.state == "external_check_passed"
assert status.snapshot_path == str((run_dir / "snapshot.json").resolve())
def test_external_check_blocks_when_verified_route_returns_false(tmp_path: Path) -> None:
# Catches a non-throwing but explicitly failed native check being treated as success.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "packager", part_number="NEW-1")
run_dir, completed = _run_bridge(
tmp_path,
action="packager",
command=command,
initial_part_number="NEW-1",
failure_operation="Application.RunPackagerFailed",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == "packager|"
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "external_check_failed")
def test_external_check_blocks_when_erc_changes_the_design(tmp_path: Path) -> None:
# Catches a successful diagnostic route legitimizing a modified saved design.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "erc", part_number="NEW-1")
run_dir, completed = _run_bridge(
tmp_path,
action="erc",
command=command,
initial_part_number="NEW-1",
failure_operation="Application.RunERCChangesDesign",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == "erc|"
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"external_check_modified_design",
)
def test_external_check_without_live_accepted_route_cannot_be_confirmed_manually(
tmp_path: Path,
) -> None:
# Catches a human Boolean replacing executable Packager/ERC/netlist evidence.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, "packager", part_number="NEW-1")
profile = _profile()
profile["routes"]["packager"] = _route_record(
"packager",
_ROUTES["packager"],
available=False,
)
run_dir, completed = _run_bridge(
tmp_path,
action="packager",
profile=profile,
command=command,
initial_part_number="NEW-1",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == (
"blocked",
"external_check_unverified",
)
@pytest.mark.parametrize(
"action",
("close_project", "close_without_save", "open_project", "packager", "erc", "netlist"),
)
def test_snapshot_only_actions_reject_component_selection_fields(
tmp_path: Path,
action: str,
) -> None:
# Catches unrelated component-selection authority leaking into navigation/check commands.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, action)
command.update(
{
"expected_count": 1,
"expected_logical_keys": ["/MAIN|U1"],
"old_part_number": "OLD-1",
"new_part_number": "NEW-1",
}
)
run_dir, completed = _run_bridge(
tmp_path,
action=action,
command=command,
project_path_argument=str(project_path),
start_closed=action == "open_project",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "invalid_command")
@pytest.mark.parametrize(
"action",
("close_project", "close_without_save", "open_project", "packager", "erc", "netlist"),
)
def test_snapshot_only_actions_require_complete_fingerprint(
tmp_path: Path,
action: str,
) -> None:
# Catches an unbound project state crossing close/open/check trust boundaries.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, action)
command["expected_fingerprint"] = ""
run_dir, completed = _run_bridge(
tmp_path,
action=action,
command=command,
project_path_argument=str(project_path),
start_closed=action == "open_project",
)
_assert_cscript_ok(completed)
assert (run_dir / "route_calls.txt").read_text(encoding="ascii") == ""
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "invalid_command")
@pytest.mark.parametrize(
("action", "operation", "number", "source", "start_closed", "part_number"),
(
(
"close_project",
"Application.CloseProject",
53007,
"FakeApplication.CloseProject",
False,
"OLD-1",
),
(
"open_project",
"Application.OpenProject",
53006,
"FakeApplication.OpenProject",
True,
"OLD-1",
),
(
"packager",
"Application.RunPackager",
53011,
"FakeApplication.RunPackager",
False,
"NEW-1",
),
),
)
def test_snapshot_only_actions_preserve_exact_api_error_evidence(
tmp_path: Path,
action: str,
operation: str,
number: int,
source: str,
start_closed: bool,
part_number: str,
) -> None:
# Catches status publication replacing the first exact navigation/check API error.
project_path = tmp_path / "fixture" / "design.prj"
command = _snapshot_command(project_path, action, part_number=part_number)
run_dir, completed = _run_bridge(
tmp_path,
action=action,
command=command,
project_path_argument=str(project_path),
failure_operation=operation,
initial_part_number=part_number,
start_closed=start_closed,
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "api_error")
details = dict(status.details)
assert details["error_number"] == str(number)
assert details["error_source"] == source
@pytest.mark.parametrize(
("operation", "action", "number", "source", "description"),
(
(
"Application.DesignComponents",
"inventory",
53001,
"FakeApplication.DesignComponents",
"enumeration unavailable",
),
(
"ActiveView.SelectExactSet",
"replace_part",
53002,
"FakeActiveView.SelectExactSet",
"selection unavailable",
),
(
"Application.OpenReplacePartDialog",
"replace_part",
53003,
"FakeApplication.OpenReplacePartDialog",
"dialog unavailable",
),
("Application.Undo", "undo", 53004, "FakeApplication.Undo", "undo unavailable"),
("Application.Save", "save", 53005, "FakeApplication.Save", "save unavailable"),
),
)
def test_bridge_preserves_exact_api_error_evidence(
tmp_path: Path,
operation: str,
action: str,
number: int,
source: str,
description: str,
) -> None:
# Catches a later error scope overwriting number/source/description from the failed API call.
project_path = tmp_path / "fixture" / "design.prj"
if action == "inventory":
command = _command(project_path, action)
reuse = False
elif action == "replace_part":
command = _replace_command(project_path)
reuse = False
else:
run_dir, replace_command, current_fingerprint = _start_applied_operation(tmp_path)
command = _control_command(replace_command, action, current_fingerprint)
reuse = True
run_dir, completed = _run_bridge(
tmp_path,
action=action,
command=command,
failure_operation=operation,
initial_part_number="NEW-1" if action in {"undo", "save"} else "OLD-1",
initial_modified=action in {"undo", "save"},
reuse=reuse,
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "api_error")
details = dict(status.details)
assert details["error_number"] == str(number)
assert details["error_source"] == source
assert details["error_description"] == description
def test_collection_access_preserves_the_first_exact_api_error(tmp_path: Path) -> None:
# Catches the variant retry overwriting the original collection property failure.
run_dir, completed = _run_bridge(
tmp_path,
action="inventory",
failure_operation="Application.DesignComponentsChanging",
)
_assert_cscript_ok(completed)
status = load_status(run_dir / "status.json")
assert (status.state, status.error_code) == ("blocked", "api_error")
details = dict(status.details)
assert details["error_number"] == "54001"
assert details["error_source"] == "FakeApplication.DesignComponents.first"
assert details["error_description"] == "first collection access failed"
def test_bridge_source_is_ascii_and_contains_no_prohibited_production_route() -> None:
# Safety lint only. Functional behavior is covered by the cscript tests above.
source = BRIDGE.read_bytes()
text = source.decode("ascii")
casefolded = text.casefold()
assert all(byte <= 0x7F for byte in source)
for prohibited in (
"ChangeComponentPreserveRefdes",
".ChangeComponent ",
"ViewDraw.Application",
"GetObject",
"SendKeys",
"WScript.Sleep",
"AppActivate",
"DoEvents",
):
assert prohibited.casefold() not in casefolded
executable_text = re.sub(r'"(?:[^"]|"")*"', '""', casefolded)
assert "ccomp" not in executable_text