"""Native single-step and saved-recovery regression on a new disposable copy.""" import argparse from dataclasses import asdict import json from pathlib import Path import re import shutil import sys import time import traceback sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src')) from dx_productivity.trial_task_center.quick_run import QuickRunPreparer, _write_uncertain_flag from dx_productivity.trial_task_center.service import TaskCenterService from dx_productivity.trial_task_center.store import TaskStore from dx_productivity.trial_task_center.logging_setup import configure_logging from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow from private_desktop_observer import PrivateDesktopObserver def main(): parser = argparse.ArgumentParser() parser.add_argument('--source', type=Path, required=True) parser.add_argument('--inventory', type=Path, required=True) parser.add_argument('--library', type=Path, required=True) parser.add_argument('--output', type=Path, required=True) parser.add_argument('--refdes', default='RL06') parser.add_argument('--new', default='4100-CA3300-2200') args = parser.parse_args() output, source = args.output.resolve(), args.source.resolve() assert not output.is_relative_to(source.parent) assert args.library.is_file() output.mkdir(parents=True, exist_ok=False) shutil.copytree(source.parent, output / 'project') project = output / 'project' / source.name text, count = re.subn(r'(?m)^KEY CentralLibrary .*$', lambda _: f'KEY CentralLibrary "{args.library.resolve().as_posix()}"', project.read_text(encoding='utf-8-sig')) assert count == 1 project.write_text(text, encoding='utf-8') source_inventory = json.loads(args.inventory.read_text(encoding='utf-8')) sheets = tuple(tuple(row) for row in source_inventory['sheets']) inventory = tuple(ComponentTarget(project, row['schematic_name'], row['sheet_number'], row['uid'], row['refdes'], row['old_part_number'], row['old_value']) for row in source_inventory['components']) assert sum(row.refdes == args.refdes for row in inventory) == 1 target = next(row for row in inventory if row.refdes == args.refdes) store = TaskStore(output / 'tasks.db') service = TaskCenterService(store, configure_logging(output / 'data'), quick_run_preparer=QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets)) report = {'project': str(project), 'refdes': args.refdes} try: with PrivateDesktopObserver(output): task = service.create_project_tasks(project.parent)[0] report['task_id'] = task.task_id service.add_rule(task.task_id, target.old_part_number, args.new) store.record_target_inventory(task.task_id, inventory) service.replace_target_plan(task.task_id, tuple(TargetPlanRow(row, row.refdes == args.refdes, args.new) for row in inventory)) progress = service.quick_run_progress(task.task_id) started = time.perf_counter() result = service.execute_quick_run(task.task_id, expected_item=(str(project), progress.next_old_part_number, progress.next_new_part_number, 'preserve')) report['single_step_seconds'] = time.perf_counter() - started report['single_step'] = asdict(result) assert result.state == 'saved_ok' root = result.status_path.parent assert tuple(root.parent.glob('quick-run-history/batch-*/.dxpartreplace-backup.json')) report['single_step_session'] = json.loads((root / 'private-desktop.json').read_text(encoding='utf-8')) assert report['single_step_session']['clean'] print('SINGLE_STEP_SAVED_AND_RELEASED', flush=True) # Fault injection is limited to this disposable task's status file. # Keep the immutable snapshot/native transaction evidence intact. status = result.status_path.read_text(encoding='utf-8-sig').splitlines() (output / 'status-before-injected-interruption.tsv').write_text('\n'.join(status) + '\n', encoding='utf-8') fields = status[-1].split('\t') fields[1:] = ['batch_saved_unverified', 'regression_injected', 'simulate interruption after disk save'] status[-1] = '\t'.join(fields) result.status_path.write_text('\n'.join(status) + '\n', encoding='utf-8') _write_uncertain_flag(root / 'uncertain.flag', 'regression_injected_after_save') started = time.perf_counter() recovered = service.recover_quick_run(task.task_id, confirmed=True) report['recovery_seconds'] = time.perf_counter() - started report['recovery'] = asdict(recovered) assert recovered.state == 'restored_ok' and not (root / 'uncertain.flag').exists() report['recovery_session'] = json.loads((recovered.log_path.parent / 'worker/private-desktop.json').read_text(encoding='utf-8')) assert report['recovery_session']['clean'] print('RECOVERY_SAVED_AND_RELEASED', flush=True) actual = QuickRunPreparer(output / 'independent-read')._discover_project_sheets(project, (target.old_part_number, args.new), collect_components=True) by_uid = {row.uid: row for row in actual.components} report['comparisons'] = [] for before in inventory: after = by_uid[before.uid] expected = args.new if before.refdes == args.refdes else before.old_part_number report['comparisons'].append({'refdes': before.refdes, 'expected': expected, 'actual': after.old_part_number}) assert after.refdes == before.refdes and after.old_part_number == expected observation = json.loads((output / 'desktop-observation.json').read_text(encoding='utf-8')) assert observation['input_desktop_before'] == observation['input_desktop_after'] assert not observation['owned_cad_became_foreground'] and not observation['owned_cad_on_input_desktop'] assert all(observation['cad_exit_confirmed'].values()) and all(observation['desktop_absent'].values()) assert not observation['observer_errors'] report['verified'] = True except Exception as error: report['error'] = str(error) traceback.print_exc() finally: store.close() (output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2, default=str), encoding='utf-8') print(json.dumps({key: report[key] for key in ('verified', 'error') if key in report}), flush=True) return 0 if report.get('verified') else 1 if __name__ == '__main__': raise SystemExit(main())