202 lines
12 KiB
Python
202 lines
12 KiB
Python
"""Replay an issue BOM through inspect_batch using only captured native reports.
|
|
|
|
All fixtures and the copied task database are created under --output. This tool
|
|
never opens CAD and refuses to create a desktop or persist a target plan.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
from collections import defaultdict
|
|
from dataclasses import asdict
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import sqlite3
|
|
import subprocess
|
|
import sys
|
|
from unittest.mock import patch
|
|
import zipfile
|
|
|
|
|
|
def digest(path):
|
|
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
|
|
|
|
|
|
def save(path, value):
|
|
Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2, default=str), encoding='utf-8')
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument('--issue-root', type=Path, required=True)
|
|
parser.add_argument('--output', type=Path, required=True)
|
|
parser.add_argument('--repo', type=Path, default=Path(__file__).resolve().parents[1])
|
|
args = parser.parse_args()
|
|
issue, output, repo = args.issue_root.resolve(), args.output.resolve(), args.repo.resolve()
|
|
assert not output.is_relative_to(issue), 'Original evidence is read-only'
|
|
assert 'build' in output.parts, 'Replay output must stay inside a build directory'
|
|
output.mkdir(parents=True, exist_ok=False)
|
|
sys.path.insert(0, str(repo / 'src'))
|
|
|
|
from openpyxl import load_workbook
|
|
from dx_productivity.trial_task_center import isolated_cad, isolated_desktop, native_inventory
|
|
from dx_productivity.trial_task_center.batch_runtime import BatchCadRuntime
|
|
from dx_productivity.trial_task_center.bom_import_report import inspect_batch
|
|
from dx_productivity.trial_task_center.logging_setup import configure_logging
|
|
from dx_productivity.trial_task_center.native_inventory_protocol import read_ascii_discovery
|
|
from dx_productivity.trial_task_center.service import TaskCenterService
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
from dx_productivity.trial_task_center.target_plan import ProjectIdentityResolver
|
|
|
|
identities = ProjectIdentityResolver()
|
|
expected = json.loads((issue / 'reported-row-replay.json').read_text(encoding='utf-8'))
|
|
replayed_rows = {row['excel_row'] for row in expected}
|
|
replayed_projects = {row['project'] for row in expected}
|
|
baseline_native = json.loads((issue / 'native-replay-report.json').read_text(encoding='utf-8'))
|
|
native_names = {row['evidence'] for row in baseline_native if row['status'] == 'ready'}
|
|
captured = defaultdict(list)
|
|
original_files = [issue / name for name in (
|
|
'reported-app.zip', 'reported-bom.xlsx', 'reported-row-replay.json', 'native-replay-report.json')]
|
|
for evidence in (issue / 'evidence/tasks').glob('*/quick-run-history/native-inventory-*'):
|
|
if evidence.name not in native_names:
|
|
continue
|
|
metadata = json.loads((evidence / 'native-inventory.json').read_text(encoding='utf-8'))
|
|
project = Path(metadata['project'])
|
|
if project.name not in replayed_projects:
|
|
continue
|
|
scope, effective = evidence / 'output/scope.txt', evidence / 'output/effective.txt'
|
|
assert scope.is_file() and effective.is_file()
|
|
captured[identities.project(project)].append(evidence)
|
|
original_files.extend((evidence / 'native-inventory.json', scope, effective))
|
|
assert len(captured) == len(replayed_projects) == 6
|
|
before_sources = {str(path): digest(path) for path in original_files}
|
|
|
|
database = output / 'app-copy/task-center.db'
|
|
database.parent.mkdir()
|
|
with zipfile.ZipFile(issue / 'reported-app.zip') as archive:
|
|
names = [name for name in archive.namelist() if name.endswith('/data/task-center.db')]
|
|
assert len(names) == 1
|
|
database.write_bytes(archive.read(names[0]))
|
|
connection = sqlite3.connect(database)
|
|
connection.row_factory = sqlite3.Row
|
|
source_counts = {'tasks': connection.execute('SELECT count(*) FROM tasks').fetchone()[0],
|
|
'target_plan': connection.execute('SELECT count(*) FROM target_plan').fetchone()[0]}
|
|
assert source_counts == {'tasks': 428, 'target_plan': 0}
|
|
project_rows = list(connection.execute('SELECT project_id,task_id,path FROM projects'))
|
|
remap, source_by_local, task_by_source = {}, {}, {}
|
|
for project_row in project_rows:
|
|
source = Path(project_row['path'])
|
|
local = output / 'projects' / project_row['project_id'] / source.name
|
|
local.parent.mkdir(parents=True)
|
|
local.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n', encoding='utf-8')
|
|
(local.parent / 'database').mkdir()
|
|
(local.parent / 'database/icdb.dat').write_bytes(b'captured read-only replay fixture')
|
|
source_key, local_key = identities.project(source), identities.project(local)
|
|
remap[source_key] = local
|
|
source_by_local[local_key] = source_key
|
|
task_by_source[source_key] = project_row['task_id']
|
|
connection.execute('UPDATE projects SET path=?,path_identity=?,discovery_root=? WHERE project_id=?',
|
|
(str(local), local_key, str(output / 'projects'), project_row['project_id']))
|
|
connection.execute('UPDATE tasks SET discovery_root=?', (str(output / 'projects'),))
|
|
connection.commit()
|
|
connection.close()
|
|
|
|
workbook = load_workbook(issue / 'reported-bom.xlsx', data_only=False)
|
|
sheet = workbook.active
|
|
assert len(workbook.worksheets) == 1
|
|
assert tuple(cell.value for cell in sheet[1]) == (
|
|
'project_name', 'project_path', 'old_part_number', 'new_part_number', 'refdes',
|
|
'schematic_name', 'sheet_number', 'uid', 'enabled', 'custom_value', 'sync_nc')
|
|
original_rows, replacement_rows, replacement_projects = sheet.max_row - 1, [], set()
|
|
for excel_row in range(2, sheet.max_row + 1):
|
|
source_path = sheet.cell(excel_row, 2).value
|
|
key = identities.project(source_path)
|
|
assert key in remap
|
|
sheet.cell(excel_row, 2, str(remap[key]))
|
|
has_replacement = any(sheet.cell(excel_row, column).value not in (None, '') for column in (3, 4, 5))
|
|
if has_replacement:
|
|
replacement_rows.append(excel_row)
|
|
replacement_projects.add(key)
|
|
if excel_row not in replayed_rows:
|
|
# Preserve row positions, routing columns, header and original cell
|
|
# styles. Uncaptured replacements are explicitly outside this replay.
|
|
for column in (3, 4, 5, 6, 7, 8, 10):
|
|
sheet.cell(excel_row, column).value = None
|
|
else:
|
|
assert key in captured and has_replacement
|
|
assert (original_rows, len(replacement_rows), len(replacement_projects)) == (763, 437, 102)
|
|
replay_file = output / 'captured-scope-original-format.xlsx'
|
|
workbook.save(replay_file)
|
|
workbook.close()
|
|
|
|
store = TaskStore(database)
|
|
service = TaskCenterService(store, configure_logging(output / 'data'))
|
|
loads, phases, forbidden_calls = [], [], []
|
|
def forbidden(name):
|
|
def fail(*args, **kwargs):
|
|
forbidden_calls.append(name)
|
|
raise AssertionError(f'Read-only replay attempted {name}')
|
|
return fail
|
|
for source_key, evidence_paths in captured.items():
|
|
child = service.for_project_task(task_by_source[source_key])
|
|
def captured_loader(project, parts, *, collect_components=False, _key=source_key,
|
|
_evidence=tuple(evidence_paths), **controls):
|
|
assert source_by_local[identities.project(project)] == _key
|
|
assert collect_components and controls.get('runtime') is not None
|
|
reads = [read_ascii_discovery(project, evidence / 'output/scope.txt', parts,
|
|
effective_report_path=evidence / 'output/effective.txt') for evidence in _evidence]
|
|
assert all(read == reads[0] for read in reads), 'Repeated native captures disagree'
|
|
loads.append({'project': str(project), 'original_project': _key, 'requested_parts': parts,
|
|
'components': len(reads[0].components), 'evidence': list(_evidence)})
|
|
return reads[0]
|
|
child._quick_run_preparer._discover_project_sheets = captured_loader
|
|
initial_dump = tuple(store._connection.iterdump())
|
|
with (patch.object(BatchCadRuntime, '_ensure_desktop', forbidden('batch desktop')),
|
|
patch.object(isolated_desktop.PrivateDesktop, '__enter__', forbidden('private desktop')),
|
|
patch.object(isolated_cad.IsolatedCadSession, '__enter__', forbidden('CAD')),
|
|
patch.object(native_inventory.NativeInventoryReader, 'read', forbidden('native process')),
|
|
patch.object(subprocess, 'Popen', forbidden('process launch')),
|
|
patch.object(store, 'record_target_inventory', forbidden('inventory persistence')),
|
|
patch.object(store, 'replace_target_plan', forbidden('target-plan persistence'))):
|
|
report = inspect_batch(service, task_by_source[next(iter(captured))], replay_file,
|
|
on_phase=lambda phase, message: phases.append({'phase': phase.value, 'message': message}))
|
|
assert tuple(store._connection.iterdump()) == initial_dump, 'Replay changed the copied task database'
|
|
assert not forbidden_calls
|
|
assert report.preview is None
|
|
assert len(loads) == len(captured) == 6
|
|
current = [{'excel_row': row.excel_row, 'project': Path(row.project_path).name,
|
|
'status': row.status, 'reason': row.reason} for row in report.rows]
|
|
expected_outcomes = [(row['excel_row'], row['project'], row['status']) for row in expected]
|
|
current_outcomes = [(row['excel_row'], row['project'], row['status']) for row in current]
|
|
assert current_outcomes == expected_outcomes
|
|
assert (report.total_rows, report.passed_rows, report.failed_rows, report.unchecked_rows) == (31, 20, 11, 0)
|
|
assert [row.excel_row for row in report.rows if row.status == 'failed'] == [3, 4, 6, 7, 11, 12, 13, 16, 17, 18, 19]
|
|
assert {str(path): digest(path) for path in original_files} == before_sources
|
|
save(output / 'report.json', asdict(report))
|
|
save(output / 'row-comparison.json', [{'original': old, 'current': new,
|
|
'row_project_status_equal': True, 'reason_text_equal': old['reason'] == new['reason']}
|
|
for old, new in zip(expected, current)])
|
|
save(output / 'captured-loads.json', loads)
|
|
save(output / 'source-hashes.json', before_sources)
|
|
save(output / 'phases.json', phases)
|
|
summary = {'source_repo': str(repo), 'source_commit': subprocess.check_output(
|
|
['git', 'rev-parse', 'HEAD'], cwd=repo, text=True).strip(),
|
|
'application_tasks': 428, 'original_bom_rows': original_rows,
|
|
'original_replacement_rows': len(replacement_rows), 'original_replacement_projects': 102,
|
|
'captured_projects': 6, 'captured_report_files': sum(map(len, captured.values())),
|
|
'replayed_rows': report.total_rows, 'passed_rows': report.passed_rows,
|
|
'failed_rows': report.failed_rows, 'unchecked_rows': report.unchecked_rows,
|
|
'unreplayed_replacement_rows': len(replacement_rows) - report.total_rows,
|
|
'unreplayed_projects': 96, 'row_project_status_equal': True,
|
|
'cad_desktop_or_process_creations': 0, 'target_plan_writes': 0,
|
|
'copied_database_unchanged_during_inspection': True, 'original_evidence_hashes_unchanged': True,
|
|
'limitations': 'Only the 31 rows covered by six captured project inventories were replayed. '
|
|
'Original and current reason wording can differ; Excel row/project/status match exactly.'}
|
|
save(output / 'summary.json', summary)
|
|
store.close()
|
|
print(json.dumps(summary, ensure_ascii=False, indent=2))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|