138 lines
7.0 KiB
Python
138 lines
7.0 KiB
Python
import json
|
|
import os
|
|
import subprocess
|
|
|
|
import pytest
|
|
|
|
from dx_productivity.trial_task_center import worker_monitor
|
|
from dx_productivity.trial_task_center.logging_setup import configure_logging
|
|
|
|
|
|
def test_phase_timing_records_completed_units_and_failure_without_success(tmp_path, monkeypatch):
|
|
from dx_productivity.trial_task_center import execution_metrics
|
|
|
|
clock = iter((10.0, 12.0, 20.0, 23.0))
|
|
monkeypatch.setattr(execution_metrics.time, 'perf_counter', lambda: next(clock))
|
|
logging = configure_logging(tmp_path)
|
|
with execution_metrics.measure_phase(logging, 'task', 'execute_step', unit='step') as metric:
|
|
metric['completed_units'] = 1
|
|
metric['state'] = 'saved_ok'
|
|
with pytest.raises(RuntimeError, match='worker failed'):
|
|
with execution_metrics.measure_phase(logging, 'task', 'execute_step', unit='step'):
|
|
raise RuntimeError('worker failed')
|
|
events = [json.loads(line) for line in (tmp_path / 'tasks/task/events.jsonl').read_text().splitlines()]
|
|
assert events[0]['details']['elapsed_seconds'] == 2
|
|
assert events[0]['details']['units_per_minute'] == 30
|
|
assert events[0]['details']['state'] == 'saved_ok'
|
|
assert events[1]['details']['elapsed_seconds'] == 3
|
|
assert events[1]['details']['state'] == 'error'
|
|
assert events[1]['details']['completed_units'] == 0
|
|
|
|
|
|
def test_worker_stages_include_repeated_stages_without_double_counting():
|
|
watch = worker_monitor.ProgressWatch('token', 'job', 150, 0)
|
|
def frame(n, stage):
|
|
return f'DX_PROGRESS\ttoken\tjob\t{n}\t{stage}\t0\t1\t1\n'.encode()
|
|
assert watch.accept(frame(1, 'capture'), 2)
|
|
assert watch.accept(frame(2, 'native_replace'), 5)
|
|
assert not watch.accept(frame(2, 'ignored'), 100)
|
|
assert watch.accept(frame(3, 'capture'), 9)
|
|
snapshot = watch.snapshot(now=12)
|
|
assert snapshot['elapsed_seconds'] == 12
|
|
assert snapshot['stage_seconds'] == {'starting': 2, 'capture': 6, 'native_replace': 4}
|
|
assert sum(snapshot['stage_seconds'].values()) == snapshot['elapsed_seconds']
|
|
assert watch.snapshot(now=12) == snapshot
|
|
|
|
|
|
@pytest.mark.skipif(os.name != 'nt', reason='Windows Script Host path compatibility')
|
|
def test_long_evidence_path_remains_visible_to_real_vbs(tmp_path):
|
|
from dx_productivity.trial_task_center.quick_run import _vbs_worker_paths, _resolve_cscript
|
|
|
|
root = tmp_path / ('evidence-' + 'x' * 80) / ('discovery-' + 'y' * 60)
|
|
root.mkdir(parents=True)
|
|
script = root / 'QuickPartReplace.vbs'
|
|
script.write_text("Set f=CreateObject(\"Scripting.FileSystemObject\")\n"
|
|
"WScript.Echo CStr(f.FileExists(f.BuildPath(WScript.Arguments(0), WScript.Arguments(1))))\n")
|
|
marker = 'monitor-' + 'a' * 32 + '.ready'
|
|
(root / marker).write_text('token')
|
|
assert len(str(root / marker)) > 259
|
|
script_arg, root_arg = _vbs_worker_paths(script, root)
|
|
result = subprocess.run((str(_resolve_cscript()), '//nologo', script_arg, root_arg, marker),
|
|
capture_output=True, text=True, timeout=10)
|
|
assert result.returncode == 0 and result.stdout.strip() == 'True'
|
|
|
|
|
|
@pytest.mark.skipif(os.name != 'nt', reason='Windows VBS path compatibility')
|
|
def test_long_evidence_without_83_names_is_readable_and_writable_by_real_vbs(tmp_path, monkeypatch):
|
|
import ctypes
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
from dx_productivity.trial_task_center.quick_run import _vbs_worker_paths, _resolve_cscript
|
|
# Reproduce a Windows volume without usable 8.3 names.
|
|
monkeypatch.setattr(ctypes, 'WinDLL', lambda *args, **kwargs:
|
|
SimpleNamespace(GetShortPathNameW=lambda *args: 0))
|
|
root = tmp_path / ('evidence-' + 'x' * 80) / ('discovery-' + 'y' * 60)
|
|
root.mkdir(parents=True)
|
|
script = root / 'QuickPartReplace.vbs'
|
|
script.write_text('Set f=CreateObject("Scripting.FileSystemObject")\n'
|
|
'WScript.Echo CStr(f.FileExists(f.BuildPath(WScript.Arguments(0), WScript.Arguments(1))))\n'
|
|
'Set s=f.CreateTextFile(f.BuildPath(WScript.Arguments(0), "written-by-vbs.txt"),True)\n'
|
|
's.Write "saved"\ns.Close\n')
|
|
marker = 'monitor-' + 'a' * 32 + '.ready'
|
|
(root / marker).write_text('token')
|
|
assert len(str(root / marker)) > 259
|
|
script_arg, root_arg = _vbs_worker_paths(script, root)
|
|
try:
|
|
assert len(root_arg) + 100 < 260
|
|
assert Path(root_arg).resolve() == root.resolve()
|
|
assert _vbs_worker_paths(script, root) == (script_arg, root_arg)
|
|
result = subprocess.run((str(_resolve_cscript()), '//nologo', script_arg, root_arg, marker),
|
|
capture_output=True, text=True, timeout=10)
|
|
assert result.returncode == 0 and result.stdout.strip() == 'True'
|
|
assert (root / 'written-by-vbs.txt').read_text() == 'saved'
|
|
finally:
|
|
from dx_productivity.trial_task_center.legacy_paths import cleanup_worker_aliases
|
|
cleanup_worker_aliases()
|
|
assert root.is_dir() and (root / marker).read_text() == 'token'
|
|
assert not Path(root_arg).exists()
|
|
|
|
|
|
def test_external_status_append_blocks_next_worker_before_cad_write(tmp_path):
|
|
from pathlib import Path
|
|
from threading import Event
|
|
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer
|
|
from dx_productivity.trial_task_center.service import TaskCenterService
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
from dx_productivity.trial_task_center.errors import TaskCenterError
|
|
|
|
root = tmp_path / 'projects'; root.mkdir()
|
|
(root / 'board.prj').write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
|
|
data = tmp_path / 'data'; calls = []
|
|
def worker(command, timeout):
|
|
calls.append(command[-1])
|
|
with (Path(command[3]) / 'status.tsv').open('a', encoding='utf-8') as stream:
|
|
stream.write(f'{command[-1]}\tno_match\tbatch_closed\tnot found\n')
|
|
return subprocess.CompletedProcess(command, 0, '', '')
|
|
store = TaskStore(tmp_path / 'tasks.db')
|
|
preparer = QuickRunPreparer(data, process_runner=worker, cscript_resolver=lambda: Path('cscript'),
|
|
sheet_discoverer=lambda _: (('MAIN', '1'),))
|
|
service = TaskCenterService(store, configure_logging(data), quick_run_preparer=preparer)
|
|
task = service.create_project_tasks(root)[0]
|
|
service.add_rule(task.task_id, 'A', 'B'); service.add_rule(task.task_id, 'C', 'D')
|
|
child = service.for_project_task(task.task_id)._quick_run_preparer
|
|
original = child.execute_step
|
|
def inject(*args, **kwargs):
|
|
result = original(*args, **kwargs)
|
|
if len(calls) == 1:
|
|
with result.status_path.open('a', encoding='utf-8') as stream:
|
|
stream.write('foreign_job\tno_match\tbatch_closed\tchanged externally\n')
|
|
return result
|
|
child.execute_step = inject
|
|
progress = service.quick_run_progress(task.task_id)
|
|
with pytest.raises(TaskCenterError):
|
|
service.execute_quick_run_queue(task.task_id,
|
|
expected_item=(str(progress.next_project_path), 'A', 'B', 'preserve'), stop_event=Event())
|
|
assert len(calls) == 1
|
|
assert (child._data_root / 'quick-run/uncertain.flag').exists()
|
|
store.close()
|