149 lines
7.1 KiB
Python
149 lines
7.1 KiB
Python
"""Discovery orchestration uses injected workers and validates their evidence."""
|
|
from pathlib import Path
|
|
import json
|
|
import subprocess
|
|
from threading import Event
|
|
|
|
import pytest
|
|
|
|
from dx_productivity.trial_task_center import quick_run
|
|
from dx_productivity.trial_task_center.errors import TaskCenterError
|
|
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer
|
|
|
|
|
|
@pytest.fixture
|
|
def discovery(tmp_path, monkeypatch):
|
|
project = tmp_path / 'board.prj'
|
|
project.write_text('project')
|
|
source = tmp_path / 'runtime.vbs'
|
|
source.write_text('runtime sentinel')
|
|
roots = []
|
|
def worker_paths(script, root):
|
|
assert script.read_text() == 'runtime sentinel'
|
|
roots.append(root)
|
|
return 'short-script.vbs', 'short-root'
|
|
monkeypatch.setattr(quick_run, '_vbs_worker_paths', worker_paths)
|
|
monkeypatch.setattr(quick_run, '_native_helper_launch_arguments', lambda: ('helper.vbs', 'bridge.ps1'))
|
|
def prepare(runner):
|
|
return QuickRunPreparer(tmp_path / 'data', script_source=source,
|
|
process_runner=runner, cscript_resolver=lambda: Path('injected-cscript.exe'))
|
|
return project, roots, prepare
|
|
|
|
|
|
def write_evidence(root, project, *, corrupt=False):
|
|
evidence_project = root / 'foreign.prj' if corrupt else project
|
|
(root / 'sheets.tsv').write_text(
|
|
'project_path\tschematic_name\tsheet_number\n' + f'{evidence_project}\tMAIN\t1\n')
|
|
(root / 'inventory.tsv').write_text(
|
|
'project_path\tschematic_name\tsheet_number\told_part\n' + f'{project}\tMAIN\t1\tOLD\n')
|
|
(root / 'components.tsv').write_text(
|
|
'project_path\tschematic_name\tsheet_number\tuid\trefdes\told_part\told_value\n'
|
|
+ f'{project}\tMAIN\t1\tu1\tR1\tOLD\t10k\n')
|
|
|
|
|
|
def test_discovery_preserves_worker_paths_protocol_and_component_inventory(discovery):
|
|
project, roots, prepare = discovery
|
|
def worker(command, timeout):
|
|
assert command[:6] == ('injected-cscript.exe', '//nologo', 'short-script.vbs',
|
|
'short-root', 'helper.vbs', 'bridge.ps1')
|
|
assert timeout == quick_run.IDLE_PROGRESS_TIMEOUT_SECONDS
|
|
root = roots[-1]
|
|
job = command[-1]
|
|
assert job.startswith('discover_')
|
|
for marker in ('batch.request', 'sheet-discovery.request', 'component-inventory.request'):
|
|
assert (root / marker).read_text() == job
|
|
assert (root / 'inventory-request.tsv').read_text().splitlines() == ['old_part', 'OLD', 'A%0009B']
|
|
assert (root / 'command.tsv').read_text().splitlines()[1].split('\t')[2] == str(project)
|
|
write_evidence(root, project)
|
|
return subprocess.CompletedProcess(command, 0, 'worker stdout', 'worker stderr')
|
|
result = prepare(worker)._discover_project_sheets(project, ('OLD', 'old', 'A\tB'), collect_components=True)
|
|
assert result.sheets == (('MAIN', '1'),)
|
|
assert result.matched_old_parts == {('MAIN', '1'): frozenset({'old'})}
|
|
assert len(result.components) == 1 and result.components[0].refdes == 'R1'
|
|
assert (roots[0] / 'worker-output.txt').read_text() == 'worker stdout\nworker stderr'
|
|
|
|
|
|
def test_discovery_without_components_never_requests_or_requires_component_file(discovery):
|
|
project, roots, prepare = discovery
|
|
def worker(command, timeout):
|
|
root = roots[-1]
|
|
assert not (root / 'component-inventory.request').exists()
|
|
write_evidence(root, project)
|
|
(root / 'components.tsv').unlink()
|
|
return subprocess.CompletedProcess(command, 0, '', '')
|
|
result = prepare(worker)._discover_project_sheets(project, ('OLD',))
|
|
assert result.components == ()
|
|
|
|
|
|
def test_discovery_reuses_explicit_runtime_on_built_in_process_path(discovery, monkeypatch):
|
|
project, roots, prepare = discovery
|
|
shared = object()
|
|
seen = []
|
|
def process(command, timeout, *, runtime=None, **options):
|
|
seen.append(runtime)
|
|
write_evidence(roots[-1], project)
|
|
return subprocess.CompletedProcess(command, 0, '', '')
|
|
monkeypatch.setattr(quick_run, '_run_process', process)
|
|
result = prepare(process).discover_project(project, ('OLD',), runtime=shared)
|
|
assert result.sheets == (('MAIN', '1'),)
|
|
assert seen == [shared]
|
|
|
|
|
|
@pytest.mark.parametrize('failure', [OSError('launch failed'), subprocess.TimeoutExpired('worker', 150)])
|
|
def test_discovery_worker_failures_keep_stable_error_code(discovery, failure):
|
|
project, roots, prepare = discovery
|
|
def worker(command, timeout):
|
|
raise failure
|
|
with pytest.raises(TaskCenterError) as raised:
|
|
prepare(worker)._discover_project_sheets(project, ('OLD',))
|
|
assert raised.value.code == 'quick_run_sheet_discovery'
|
|
assert raised.value.__cause__ is failure
|
|
|
|
|
|
def test_discovery_nonzero_exit_keeps_operator_diagnostic_and_output(discovery):
|
|
project, roots, prepare = discovery
|
|
def worker(command, timeout):
|
|
return subprocess.CompletedProcess(command, 1, 'stdout', 'another project is already open')
|
|
with pytest.raises(TaskCenterError) as raised:
|
|
prepare(worker)._discover_project_sheets(project, ('OLD',))
|
|
assert raised.value.code == 'quick_run_sheet_discovery'
|
|
assert 'another project is already open' in str(raised.value)
|
|
assert '保存并关闭' in str(raised.value)
|
|
assert (roots[0] / 'worker-output.txt').read_text().endswith('another project is already open')
|
|
|
|
|
|
def test_discovery_rejects_foreign_sheet_evidence(discovery):
|
|
project, roots, prepare = discovery
|
|
def worker(command, timeout):
|
|
write_evidence(roots[-1], project, corrupt=True)
|
|
return subprocess.CompletedProcess(command, 0, '', '')
|
|
with pytest.raises(TaskCenterError, match='another project'):
|
|
prepare(worker)._discover_project_sheets(project, ('OLD',))
|
|
|
|
|
|
@pytest.mark.parametrize('release', ['confirmed', 'missing', 'uncertain', 'malformed'])
|
|
@pytest.mark.parametrize('cancelled', [False, True])
|
|
def test_only_positive_release_evidence_certifies_failed_reader(discovery, release, cancelled):
|
|
from dx_productivity.trial_task_center.project_discovery import ReleasedProjectReadError
|
|
project, roots, prepare = discovery
|
|
stop = Event()
|
|
def worker(command, timeout):
|
|
if release != 'missing':
|
|
record = {'state': 'released' if release == 'confirmed' else 'uncertain',
|
|
'clean': True, 'cad_exit_code': 0, 'quit_helper_exit_code': 0,
|
|
'desktop_cleanup': {'desktop_handle_closed': True, 'errors': [],
|
|
'desktop_confirmation': {'released': True}}}
|
|
(roots[-1] / 'private-desktop.json').write_text(
|
|
'{' if release == 'malformed' else json.dumps(record))
|
|
# No uncertain.flag exists, including when its write would have failed.
|
|
if cancelled:
|
|
stop.set()
|
|
raise PermissionError('uncertain.flag cannot be written')
|
|
with pytest.raises(TaskCenterError) as caught:
|
|
prepare(worker)._discover_project_sheets(project, ('OLD',), stop_event=stop)
|
|
if cancelled and release == 'confirmed':
|
|
assert caught.value.code == 'operation_cancelled'
|
|
else:
|
|
assert caught.value.code == 'quick_run_sheet_discovery'
|
|
assert isinstance(caught.value, ReleasedProjectReadError) == (release == 'confirmed')
|