400 lines
17 KiB
Python
400 lines
17 KiB
Python
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer, _ProjectDiscovery
|
|
from dx_productivity.trial_task_center.errors import TaskCenterError
|
|
from dx_productivity.trial_task_center.target_plan import ComponentTarget
|
|
|
|
|
|
def prepared(tmp_path):
|
|
root = tmp_path / 'project'
|
|
root.mkdir()
|
|
project = root / 'board.prj'
|
|
project.write_text('project')
|
|
(root / 'sch').mkdir()
|
|
(root / 'sch' / 'MAIN.1').write_text('sheet')
|
|
preparer = QuickRunPreparer(tmp_path / 'data')
|
|
calls = []
|
|
def discover(path, parts, *, collect_components=False):
|
|
calls.append((parts, collect_components))
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset({'old'})}, (ComponentTarget(path, 'MAIN', '1', 'uid', 'R1', 'old', 'value'),) if collect_components else ())
|
|
preparer._discover_project_sheets = discover
|
|
return project, preparer, calls
|
|
|
|
|
|
def test_inventory_discovery_reused_by_sheet_discovery(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
assert preparer.collect_inventory(project, ('old',))[0].refdes == 'R1'
|
|
assert preparer.discover_project(project, ('OLD',)).sheets == (('MAIN', '1'),)
|
|
assert len(calls) == 1
|
|
|
|
|
|
@pytest.mark.parametrize('change', ['edit', 'add', 'delete', 'replace'])
|
|
def test_project_content_changes_invalidate_cache(tmp_path, change):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
preparer.discover_project(project, ('old',))
|
|
sheet = project.parent / 'sch' / 'MAIN.1'
|
|
if change == 'edit':
|
|
sheet.write_text('changed sheet')
|
|
elif change == 'add':
|
|
sheet.with_name('MAIN.2').write_text('new sheet')
|
|
elif change == 'delete':
|
|
sheet.unlink()
|
|
else:
|
|
replacement = sheet.with_suffix('.new')
|
|
replacement.write_text('sheet')
|
|
replacement.replace(sheet)
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 2
|
|
|
|
|
|
def test_expanded_parts_and_component_request_need_new_discovery(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
preparer.discover_project(project, ('old',))
|
|
preparer.discover_project(project, ('old', 'other'))
|
|
preparer.collect_inventory(project, ('old', 'other'))
|
|
assert len(calls) == 3
|
|
|
|
|
|
def test_changed_during_discovery_is_not_cached(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
original = preparer._discover_project_sheets
|
|
def changing(*args, **kwargs):
|
|
result = original(*args, **kwargs)
|
|
(project.parent / 'sch' / 'MAIN.1').write_text(str(len(calls)))
|
|
return result
|
|
preparer._discover_project_sheets = changing
|
|
with pytest.raises(TaskCenterError, match='changed'):
|
|
preparer.discover_project(project, ('old',))
|
|
with pytest.raises(TaskCenterError, match='changed'):
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 4
|
|
|
|
|
|
def test_clone_has_independent_cache_and_configuration(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
preparer.discover_project(project, ('old',))
|
|
clone = preparer.for_data_root(tmp_path / 'task-two')
|
|
assert clone.data_root == tmp_path / 'task-two'
|
|
clone._discover_project_sheets = preparer._discover_project_sheets
|
|
clone.discover_project(project, ('old',))
|
|
assert len(calls) == 2
|
|
|
|
|
|
def test_explicit_invalidation_discards_discovery(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
preparer.discover_project(project, ('old',))
|
|
preparer.invalidate_discovery(project)
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 2
|
|
|
|
|
|
def queue_records(project):
|
|
from dx_productivity.trial_task_center.models import ProjectRecord, ProjectStatus, RuleRecord
|
|
return ((ProjectRecord('p', 't', 'board', project, project.parent, True, True,
|
|
ProjectStatus.PENDING, 0),),
|
|
(RuleRecord('r', 't', 0, 'old', 'new', True),))
|
|
|
|
|
|
def test_handoff_reuses_collected_inventory_without_second_cad_open(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
projects, rules = queue_records(project)
|
|
preparer.collect_inventory(project, ('old',))
|
|
handoff = preparer.ensure_batch_handoff('t', projects, rules)
|
|
assert 'MAIN' in handoff.command_path.read_text(encoding='utf-8')
|
|
assert len(calls) == 1
|
|
|
|
|
|
def test_failed_worker_invalidates_before_it_runs(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
projects, rules = queue_records(project)
|
|
preparer.collect_inventory(project, ('old',))
|
|
preparer.ensure_batch_handoff('t', projects, rules)
|
|
preparer._cscript_resolver = lambda: Path('cscript.exe')
|
|
def fail(command, timeout):
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 2
|
|
raise OSError('cannot launch')
|
|
preparer._process_runner = fail
|
|
with pytest.raises(TaskCenterError):
|
|
preparer.execute_step('t', projects, rules, batch_mode=True)
|
|
assert len(calls) == 2
|
|
|
|
|
|
def test_failed_or_incomplete_discovery_never_cached(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
def incomplete(path, parts):
|
|
calls.append(parts)
|
|
return _ProjectDiscovery((('MAIN', '1'),), {})
|
|
preparer._discover_project_sheets = incomplete
|
|
preparer.discover_project(project, ('old',))
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 2
|
|
def fail(path, parts):
|
|
calls.append(parts)
|
|
raise TaskCenterError('discovery', 'failed')
|
|
preparer._discover_project_sheets = fail
|
|
for _ in range(2):
|
|
with pytest.raises(TaskCenterError):
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 4
|
|
|
|
|
|
def test_cached_results_cannot_be_poisoned_by_callers(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
result = preparer.discover_project(project, ('old',))
|
|
result.matched_old_parts.clear()
|
|
result = preparer.discover_project(project, ('old',))
|
|
assert result.matched_old_parts == {('MAIN', '1'): frozenset({'old'})}
|
|
assert len(calls) == 1
|
|
|
|
|
|
def test_generated_logs_and_tool_evidence_do_not_invalidate(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
preparer.discover_project(project, ('old',))
|
|
(project.parent / 'designer.log').write_text('generated log')
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 1
|
|
|
|
|
|
def test_component_collection_filters_cached_superset_to_requested_parts(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
def discover(path, parts, *, collect_components=False):
|
|
calls.append(parts)
|
|
rows = tuple(ComponentTarget(path, 'MAIN', '1', part, part, part, '') for part in parts)
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset(parts)}, rows)
|
|
preparer._discover_project_sheets = discover
|
|
preparer.collect_inventory(project, ('old', 'other'))
|
|
rows = preparer.collect_inventory(project, ('OLD',))
|
|
assert [row.old_part_number for row in rows] == ['old']
|
|
assert len(calls) == 1
|
|
|
|
|
|
def test_tool_evidence_inside_project_tree_is_excluded(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
preparer = preparer.for_data_root(project.parent / '.tool-data')
|
|
def discover(path, parts):
|
|
calls.append(parts)
|
|
preparer.data_root.mkdir(exist_ok=True)
|
|
(preparer.data_root / 'generated.tsv').write_text(str(len(calls)))
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset({'old'})})
|
|
preparer._discover_project_sheets = discover
|
|
preparer.discover_project(project, ('old',))
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 1
|
|
|
|
|
|
def test_same_size_schematic_edit_with_restored_mtime_rechecks_negative_matches(tmp_path):
|
|
import os
|
|
project, preparer, calls = prepared(tmp_path)
|
|
sheet = project.parent / 'sch' / 'MAIN.1'
|
|
sheet.write_text('nohit', encoding='ascii')
|
|
def discover(path, parts):
|
|
calls.append(parts)
|
|
matches = frozenset({'old'}) if sheet.read_text(encoding='ascii') == 'oldxx' else frozenset()
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): matches})
|
|
preparer._discover_project_sheets = discover
|
|
assert preparer.discover_project(project, ('old',)).matched_old_parts[('MAIN', '1')] == frozenset()
|
|
original = sheet.stat()
|
|
sheet.write_text('oldxx', encoding='ascii')
|
|
os.utime(sheet, ns=(original.st_atime_ns, original.st_mtime_ns))
|
|
assert sheet.stat().st_size == original.st_size
|
|
assert sheet.stat().st_mtime_ns == original.st_mtime_ns
|
|
assert preparer.discover_project(project, ('old',)).matched_old_parts[('MAIN', '1')] == frozenset({'old'})
|
|
assert len(calls) == 2
|
|
|
|
|
|
def test_file_changed_during_hashing_has_no_reusable_fingerprint(tmp_path, monkeypatch):
|
|
import hashlib
|
|
from dx_productivity.trial_task_center.discovery_cache import project_fingerprint
|
|
project, preparer, _ = prepared(tmp_path)
|
|
sheet = project.parent / 'sch' / 'MAIN.1'
|
|
digest = hashlib.file_digest
|
|
def changing(stream, algorithm):
|
|
result = digest(stream, algorithm)
|
|
if Path(stream.name) == sheet:
|
|
sheet.write_bytes(b'changed while hashing')
|
|
return result
|
|
monkeypatch.setattr(hashlib, 'file_digest', changing)
|
|
assert project_fingerprint(project, preparer.data_root) is None
|
|
|
|
|
|
def test_first_open_normalization_retries_and_caches_only_stable_second_pass(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
database = project.parent / 'database'
|
|
database.mkdir()
|
|
icdb = database / 'icdb.dat'
|
|
icdb.write_text('old database')
|
|
ole = project.parent / 'OLE' / 'sch'
|
|
ole.mkdir(parents=True)
|
|
ole_sheet = ole / 'MAIN.1'
|
|
ole_sheet.write_text('old normalized data')
|
|
def normalize_once(path, parts, *, collect_components=False):
|
|
calls.append(parts)
|
|
if len(calls) == 1:
|
|
icdb.write_text('normalized database')
|
|
ole_sheet.write_text('normalized schematic')
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset()})
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset({'old'})})
|
|
preparer._discover_project_sheets = normalize_once
|
|
assert preparer.discover_project(project, ('old',)).matched_old_parts[('MAIN', '1')] == frozenset({'old'})
|
|
assert len(calls) == 2
|
|
assert preparer.discover_project(project, ('old',)).matched_old_parts[('MAIN', '1')] == frozenset({'old'})
|
|
assert len(calls) == 2
|
|
|
|
|
|
@pytest.mark.parametrize('directory', ['log', 'plog', 'events'])
|
|
def test_cdbsvr_audit_churn_does_not_rediscover(tmp_path, directory):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
audit = project.parent / 'database' / 'cdbsvr' / directory
|
|
audit.mkdir(parents=True)
|
|
audit_file = audit / '000001.dat'
|
|
audit_file.write_text('audit')
|
|
original = preparer._discover_project_sheets
|
|
def audit_during_discovery(*args, **kwargs):
|
|
result = original(*args, **kwargs)
|
|
audit_file.write_text('audit grew during native open')
|
|
return result
|
|
preparer._discover_project_sheets = audit_during_discovery
|
|
preparer.discover_project(project, ('old',))
|
|
audit_file.write_text('audit changed again after native close')
|
|
(audit / '000002.dat').write_text('new audit')
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 1
|
|
|
|
|
|
@pytest.mark.parametrize('relative', ['database/icdb.dat', 'OLE/sch/MAIN.1', 'sch/MAIN.1'])
|
|
def test_authoritative_same_size_content_changes_are_hashed_despite_restored_timestamps(tmp_path, relative):
|
|
import os
|
|
project, preparer, calls = prepared(tmp_path)
|
|
authoritative = project.parent / relative
|
|
authoritative.parent.mkdir(parents=True, exist_ok=True)
|
|
authoritative.write_bytes(b'nohit')
|
|
def discover(path, parts):
|
|
calls.append(parts)
|
|
matches = frozenset({'old'}) if authoritative.read_bytes() == b'oldxx' else frozenset()
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): matches})
|
|
preparer._discover_project_sheets = discover
|
|
assert not preparer.discover_project(project, ('old',)).matched_old_parts[('MAIN', '1')]
|
|
stamp = authoritative.stat()
|
|
authoritative.write_bytes(b'oldxx')
|
|
os.utime(authoritative, ns=(stamp.st_atime_ns, stamp.st_mtime_ns))
|
|
assert preparer.discover_project(project, ('old',)).matched_old_parts[('MAIN', '1')] == frozenset({'old'})
|
|
assert len(calls) == 2
|
|
|
|
|
|
def test_unstable_rediscovery_never_falls_back_to_cached_negative_matches(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
sheet = project.parent / 'sch' / 'MAIN.1'
|
|
def negative(path, parts):
|
|
calls.append(parts)
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset()})
|
|
preparer._discover_project_sheets = negative
|
|
assert not preparer.discover_project(project, ('old',)).matched_old_parts[('MAIN', '1')]
|
|
sheet.write_text('externally changed')
|
|
def unstable(path, parts):
|
|
calls.append(parts)
|
|
sheet.write_text('changed during pass ' + str(len(calls)))
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset({'old'})})
|
|
preparer._discover_project_sheets = unstable
|
|
with pytest.raises(TaskCenterError, match='changed'):
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 3
|
|
def stable(path, parts):
|
|
calls.append(parts)
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset({'old'})})
|
|
preparer._discover_project_sheets = stable
|
|
assert preparer.discover_project(project, ('old',)).matched_old_parts[('MAIN', '1')] == frozenset({'old'})
|
|
assert len(calls) == 4
|
|
|
|
|
|
def test_initially_unverifiable_project_uses_fresh_discovery_without_cache(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
# A project within the explicit evidence root has no reusable fingerprint.
|
|
clone = preparer.for_data_root(project.parent)
|
|
clone._discover_project_sheets = preparer._discover_project_sheets
|
|
assert clone.discover_project(project, ('old',)).sheets == (('MAIN', '1'),)
|
|
assert len(calls) == 1
|
|
assert clone.discover_project(project, ('old',)).sheets == (('MAIN', '1'),)
|
|
assert len(calls) == 2
|
|
|
|
|
|
def test_projectbackup_audit_updates_do_not_rediscover(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
original = preparer._discover_project_sheets
|
|
def discover(*args, **kwargs):
|
|
log = project.parent / 'Log Files' / 'ProjectBackupLog.txt'
|
|
log.parent.mkdir(exist_ok=True)
|
|
log.write_text('automatic backup audit')
|
|
backup = project.parent / 'ProjectBackup' / 'backups' / 'auto.zip'
|
|
backup.parent.mkdir(parents=True, exist_ok=True)
|
|
backup.write_bytes(b'generated backup')
|
|
return original(*args, **kwargs)
|
|
preparer._discover_project_sheets = discover
|
|
preparer.discover_project(project, ('old',))
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 1
|
|
|
|
|
|
def test_native_database_runtime_updates_require_repeated_equal_inventory(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
database = project.parent / 'database' / 'icdb.dat'
|
|
database.parent.mkdir()
|
|
database.write_text('initial database')
|
|
original = preparer._discover_project_sheets
|
|
def discover(*args, **kwargs):
|
|
result = original(*args, **kwargs)
|
|
database.write_text('native session metadata ' + str(len(calls)))
|
|
return result
|
|
preparer._discover_project_sheets = discover
|
|
assert preparer.collect_inventory(project, ('old',))[0].refdes == 'R1'
|
|
assert len(calls) == 2
|
|
preparer.collect_inventory(project, ('old',))
|
|
assert len(calls) == 2
|
|
database.write_text('external database edit')
|
|
preparer.collect_inventory(project, ('old',))
|
|
assert len(calls) == 4 # Database content remains part of cache invalidation.
|
|
|
|
|
|
def test_native_database_runtime_updates_reject_different_inventories(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
database = project.parent / 'database' / 'icdb.dat'
|
|
database.parent.mkdir()
|
|
database.write_text('initial database')
|
|
def discover(path, parts, *, collect_components=False):
|
|
calls.append(parts)
|
|
database.write_text('native session metadata ' + str(len(calls)))
|
|
row = ComponentTarget(path, 'MAIN', '1', 'uid', 'R1', 'old', str(len(calls)))
|
|
return _ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset({'old'})}, (row,))
|
|
preparer._discover_project_sheets = discover
|
|
with pytest.raises(TaskCenterError, match='changed'):
|
|
preparer.collect_inventory(project, ('old',))
|
|
|
|
|
|
def test_first_open_normalization_then_runtime_updates_need_two_equal_reads(tmp_path):
|
|
project, preparer, calls = prepared(tmp_path)
|
|
database = project.parent / 'database' / 'icdb.dat'
|
|
database.parent.mkdir()
|
|
database.write_text('initial database')
|
|
original = preparer._discover_project_sheets
|
|
def discover(*args, **kwargs):
|
|
result = original(*args, **kwargs)
|
|
if len(calls) == 1:
|
|
project.write_text('normalized project')
|
|
database.write_text('native session metadata ' + str(len(calls)))
|
|
return result
|
|
preparer._discover_project_sheets = discover
|
|
assert preparer.collect_inventory(project, ('old',))[0].refdes == 'R1'
|
|
assert len(calls) == 3
|
|
|
|
|
|
def test_unverifiable_retry_after_known_churn_still_fails_closed(tmp_path, monkeypatch):
|
|
from dx_productivity.trial_task_center import discovery_cache as module
|
|
project, preparer, calls = prepared(tmp_path)
|
|
fingerprints = iter([('before',), ('changed',), None, None])
|
|
monkeypatch.setattr(module, 'project_fingerprint', lambda *args: next(fingerprints))
|
|
with pytest.raises(TaskCenterError, match='changed'):
|
|
preparer.discover_project(project, ('old',))
|
|
assert len(calls) == 2
|