233 lines
15 KiB
Python
233 lines
15 KiB
Python
"""Actual Windows EXE: batch import, native run, report, restart, rerun, report.
|
|
|
|
Use saved test copies. Expectations must be supplied before launch. This tool
|
|
never creates replacement receipts or changes task state directly in SQLite.
|
|
"""
|
|
import argparse
|
|
from contextlib import contextmanager
|
|
import json
|
|
import os
|
|
import shutil
|
|
from pathlib import Path
|
|
import sqlite3
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'src'))
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
from dx_productivity.trial_task_center.verification.service import VerificationService
|
|
from dx_productivity.trial_task_center.native_netlist import _hash
|
|
from verification_closed_loop import freeze_inputs, verify_closed_loop, require
|
|
|
|
|
|
def main(argv=None):
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
for name in ('exe', 'before-root', 'after-root', 'output'):
|
|
parser.add_argument('--'+name, type=Path, required=True)
|
|
parser.add_argument('--expected-items', nargs='+', required=True, help='Exact relative paths, e.g. A/input.prj B/input.prj')
|
|
parser.add_argument('--expect-verdict', choices=('CONSISTENT', 'WARNING', 'DIFFERENT'), required=True)
|
|
parser.add_argument('--fault-batch', action='store_true', help='Use private copies and prepend one deliberately invalid database fixture')
|
|
args = parser.parse_args(argv)
|
|
output = args.output.resolve(); exe = args.exe.resolve()
|
|
before, after = args.before_root.resolve(), args.after_root.resolve()
|
|
if output.exists(): parser.error('output must be a new directory')
|
|
if output.is_relative_to(before) or output.is_relative_to(after): parser.error('output must be outside input roots')
|
|
if len(set(args.expected_items))!=len(args.expected_items): parser.error('expected-items must be unique')
|
|
output.mkdir(parents=True)
|
|
# Import UI automation only for the EXE path; service acceptance remains portable.
|
|
import win32con
|
|
import win32gui
|
|
from packaged_window_driver import WindowDriver, window_image
|
|
from accept_packaged_ui import wait
|
|
data = output/'data'
|
|
report = {'standard': 'verification-closed-loop-v1', 'validation_scope': 'independent-native:C01-C07',
|
|
'evidence_kind': 'native-packaged-ui', 'executable': str(exe), 'executable_sha256': _hash(exe),
|
|
'expected_items': args.expected_items, 'expected_verdict': args.expect_verdict, 'checks': [],
|
|
'not_run': ['C08:packaged-fault-cases', 'actual-successful-replacement-handoff', 'continuous-full-regression']}
|
|
original = {str(p): _hash(p) for root in (before, after) for p in root.rglob('*') if p.is_file()}
|
|
failed_name = '00-invalid/input.prj' if args.fault_batch else None
|
|
if args.fault_batch:
|
|
for phase, source in (('before', before), ('after', after)):
|
|
destination = output/'inputs'/phase
|
|
shutil.copytree(source, destination)
|
|
fixture = destination/'00-invalid'; (fixture/'database').mkdir(parents=True)
|
|
(fixture/'input.prj').write_text('KEY RootBlock "board"\nKEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n', encoding='utf-8')
|
|
(fixture/'database/icdb.dat').write_bytes(b'deliberately-invalid-acceptance-fixture')
|
|
before, after = output/'inputs/before', output/'inputs/after'
|
|
original.update((str(p), _hash(p)) for root in (before, after) for p in root.rglob('*') if p.is_file())
|
|
report.update(evidence_kind='native-real-copies-and-invalid-database-fixture', expected_failed_items=[failed_name])
|
|
expected_names = sorted(args.expected_items + ([failed_name] if failed_name else []))
|
|
process = driver = main_window = None
|
|
|
|
def sql(query, params=()):
|
|
with sqlite3.connect(data/'task-center.db') as db:
|
|
db.row_factory = sqlite3.Row
|
|
return [dict(row) for row in db.execute(query, params)]
|
|
|
|
@contextmanager
|
|
def reader():
|
|
store = TaskStore(data/'task-center.db')
|
|
try: yield VerificationService(store, data)
|
|
finally: store.close()
|
|
|
|
def launch():
|
|
nonlocal process, driver, main_window
|
|
environment = dict(os.environ)
|
|
for name in ('PYTHONPATH', 'PYTHONHOME', 'DX_TASK_CENTER_HOME', 'QT_QPA_PLATFORM'): environment.pop(name, None)
|
|
p = subprocess.Popen([str(exe), '--data-root', str(data)], cwd=exe.parent, env=environment,
|
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, creationflags=subprocess.CREATE_NO_WINDOW)
|
|
process = p
|
|
d = WindowDriver(p.pid, output); driver = d
|
|
def ready():
|
|
try: return d.main()
|
|
except TimeoutError:
|
|
require(p.poll() is None, 'Application exited before its main window appeared')
|
|
return None
|
|
window = wait(ready, timeout=90); main_window = window
|
|
d.click(d.find(automation_id='verification_navigation'))
|
|
return p, d, window
|
|
|
|
def close():
|
|
for window in driver.windows():
|
|
if win32gui.GetClassName(window.handle)=='#32770':
|
|
cancel = next((c for c in window.descendants(control_type='Button') if c.element_info.automation_id=='2'), None)
|
|
if cancel: win32gui.PostMessage(cancel.handle, win32con.BM_CLICK, 0, 0)
|
|
win32gui.PostMessage(main_window.handle, win32con.WM_CLOSE, 0, 0)
|
|
require(process.wait(45)==0, 'Application did not exit normally')
|
|
|
|
def run_record(run_id):
|
|
row = sql('SELECT * FROM verification_runs WHERE run_id=?', (run_id,))[0]
|
|
require(row['state']=='completed', 'Run stopped, blocked or interrupted')
|
|
return {'run_id': run_id, 'members': json.loads(row['members_json'])}
|
|
|
|
def finished(run_id):
|
|
rows = sql('SELECT state FROM verification_runs WHERE run_id=?', (run_id,))
|
|
return rows and rows[0]['state'] not in ('queued', 'running', 'stopping')
|
|
|
|
def export_report():
|
|
destination = output/'reports'; destination.mkdir(exist_ok=True)
|
|
previous = set(destination.glob('verification-*'))
|
|
driver.click(driver.find('导出报告', kind='Button'))
|
|
dialog = wait(lambda: next((w for w in driver.windows() if win32gui.GetClassName(w.handle)=='#32770'), None), timeout=15)
|
|
# The native folder picker has FolderName edit 1152, unlike file picker 1001.
|
|
field = next(c for c in dialog.descendants(control_type='Edit') if c.element_info.automation_id=='1152')
|
|
field.iface_value.SetValue(str(destination))
|
|
require(field.get_value()==str(destination), 'Folder picker path differs from the requested destination')
|
|
confirm = next(c for c in dialog.descendants(control_type='Button') if c.element_info.automation_id=='1')
|
|
win32gui.PostMessage(confirm.handle, win32con.BM_CLICK, 0, 0)
|
|
wait(lambda: not win32gui.IsWindow(dialog.handle), timeout=20)
|
|
return wait(lambda: next((p for p in destination.glob('verification-*') if p not in previous and (p/'task.json').is_file()), None), timeout=60)
|
|
|
|
def selected_cell(name):
|
|
tables = [w for kind in ('Table', 'DataGrid') for w in main_window.descendants(control_type=kind) if w.is_visible()]
|
|
table = min(tables, key=lambda w: w.rectangle().left)
|
|
return next((c for c in table.children() if c.window_text()==name), None)
|
|
|
|
def verify_report(scope, run, directory, label, *, selected_only=False):
|
|
with reader() as service:
|
|
validation = verify_closed_loop(service, task, scope, run, directory,
|
|
expected_verdicts={row['item_id']: args.expect_verdict for row in scope['items']}, selected_only=selected_only)
|
|
(output/(label+'.json')).write_text(json.dumps(validation, ensure_ascii=False, indent=2), encoding='utf-8')
|
|
report['checks'].extend(validation['checks'])
|
|
require(validation['passed'], label+' failed: '+json.dumps(validation['checks'], ensure_ascii=False))
|
|
|
|
try:
|
|
process, driver, main_window = launch()
|
|
reduce = driver.find('减少透明度', kind='Button', optional=True)
|
|
if reduce: driver.click(reduce)
|
|
driver.click(wait(lambda: driver.find(automation_id='verificationNew')))
|
|
dialog = wait(lambda: next((w for w in driver.windows() if w.window_text()=='新建校验'), None))
|
|
ok = next(b for b in dialog.descendants(control_type='Button') if b.window_text().replace('&', '') in ('OK', '确定'))
|
|
driver.click(ok)
|
|
button = wait(lambda: driver.find(automation_id='verificationBatchImport'))
|
|
wait(lambda: button.is_enabled()); driver.click(button)
|
|
dialog = wait(lambda: next((w for w in driver.windows() if w.window_text()=='批量添加工程对'), None))
|
|
driver.type_text(driver.find(automation_id='verificationBeforeRoot', window=dialog), str(before))
|
|
driver.type_text(driver.find(automation_id='verificationAfterRoot', window=dialog), str(after))
|
|
driver.click(driver.find(automation_id='verificationScanPairs', window=dialog))
|
|
button = driver.find(automation_id='verificationImportPairs', window=dialog)
|
|
wait(lambda: button.is_enabled()); window_image(dialog.handle).save(output/'01-pairs.png')
|
|
driver.click(button)
|
|
wait(lambda: driver.find(f'本批导入完成:已导入 {len(expected_names)} 对,失败 0 对;尚未开始校验。', kind='Text', window=dialog), timeout=120)
|
|
driver.click(driver.find('关闭', kind='Button', window=dialog))
|
|
imported = sql('SELECT * FROM verification_items ORDER BY display_name')
|
|
require([r['display_name'] for r in imported]==expected_names, 'Imported names differ from the predeclared scope')
|
|
require(not sql('SELECT attempt_id FROM verification_attempts'), 'Import started verification automatically')
|
|
task = imported[0]['task_id']
|
|
with reader() as service: scope = freeze_inputs(service, task, expected_count=len(expected_names))
|
|
(output/'frozen-scope.json').write_text(json.dumps(dict(scope, expected_verdict=args.expect_verdict,
|
|
expected_failed_items=[failed_name] if failed_name else []), ensure_ascii=False, indent=2), encoding='utf-8')
|
|
driver.click(driver.find('开始全部', kind='Button'))
|
|
run_id = wait(lambda: next((r['run_id'] for r in sql('SELECT run_id FROM verification_runs')), None))
|
|
wait(lambda: finished(run_id), timeout=900)
|
|
run = run_record(run_id)
|
|
if failed_name:
|
|
failed_item = next(r['item_id'] for r in imported if r['display_name']==failed_name)
|
|
with reader() as service:
|
|
failure = service.read_item(failed_item)
|
|
require(run['members'][0]['item_id']==failed_item, 'Fault fixture did not run before the healthy projects')
|
|
require(failure['attempt_state']=='failed' and failure['verdict']=='INCOMPLETE'
|
|
and failure['attempt']['result']['resource_state']=='released', 'Invalid database did not fail and release resources as expected')
|
|
report['checks'].append({'check_id': 'C08:failed-native-item-continues', 'state': 'passed',
|
|
'item_id': failed_item, 'observed_state': failure['attempt_state'], 'observed_verdict': failure['verdict']})
|
|
report['not_run'][0] = 'C08:packaged-stop-and-uncertain-resources'
|
|
scope = dict(scope, items=[row for row in scope['items'] if row['item_id']!=failed_item])
|
|
run = dict(run, members=[row for row in run['members'] if row['item_id']!=failed_item])
|
|
name = sorted(args.expected_items)[0]
|
|
driver.click(wait(lambda: selected_cell(name)))
|
|
label = {'CONSISTENT': '一致', 'WARNING': '需关注', 'DIFFERENT': '异常'}[args.expect_verdict]
|
|
wait(lambda: driver.find(name+' · '+label, kind='Text'), timeout=60)
|
|
window_image(main_window.handle).save(output/'02-result.png')
|
|
directory = export_report(); verify_report(scope, run, directory, 'first-run', selected_only=bool(failed_name))
|
|
first_report_hashes = {str(p): _hash(p) for p in directory.iterdir() if p.is_file()}
|
|
attempts = sql('SELECT attempt_id,input_version,generation,state,result_json FROM verification_attempts ORDER BY attempt_id')
|
|
report['first_report'] = str(directory)
|
|
close(); process, driver, main_window = launch()
|
|
driver.click(wait(lambda: selected_cell(name)))
|
|
wait(lambda: driver.find(name+' · '+label, kind='Text'), timeout=60)
|
|
# Wait for startup recovery and at least one normal workspace polling interval.
|
|
time.sleep(2)
|
|
require(sql('SELECT attempt_id,input_version,generation,state,result_json FROM verification_attempts ORDER BY attempt_id')==attempts, 'Restart changed attempts or started another run')
|
|
verify_report(scope, run, directory, 'restart-readback', selected_only=bool(failed_name))
|
|
report['checks'].append({'check_id': 'C06:restart', 'state': 'passed'})
|
|
window_image(main_window.handle).save(output/'03-restart.png')
|
|
old_ids = {r['run_id'] for r in sql('SELECT run_id FROM verification_runs')}
|
|
driver.click(driver.find('重校验', kind='Button'))
|
|
rerun_id = wait(lambda: next((r['run_id'] for r in sql('SELECT run_id FROM verification_runs') if r['run_id'] not in old_ids), None))
|
|
wait(lambda: finished(rerun_id), timeout=900)
|
|
rerun = run_record(rerun_id)
|
|
subset = dict(scope, items=[r for r in scope['items'] if r['display_name']==name])
|
|
member = rerun['members'][0]
|
|
previous = next(r for r in attempts if r['attempt_id']==next(m['attempt_id'] for m in run['members'] if m['item_id']==member['item_id']))
|
|
latest = sql('SELECT * FROM verification_attempts WHERE attempt_id=?', (member['attempt_id'],))[0]
|
|
require(latest['generation']==previous['generation']+1 and latest['input_version']==previous['input_version'], 'Rerun did not create the next attempt on the same input')
|
|
require(all(_hash(Path(p))==sha for p, sha in first_report_hashes.items()), 'Rerun overwrote the first report')
|
|
require(sql('SELECT result_json FROM verification_attempts WHERE attempt_id=?', (previous['attempt_id'],))[0]['result_json']==previous['result_json'], 'Rerun changed the old result')
|
|
second_report = export_report()
|
|
verify_report(subset, rerun, second_report, 'rerun', selected_only=True)
|
|
report['checks'].append({'check_id': 'C07:rerun', 'state': 'passed'})
|
|
report['rerun_report'] = str(second_report)
|
|
require(all(_hash(Path(p))==sha for p, sha in original.items()), 'Input files changed during the loop')
|
|
require(sql('SELECT COUNT(*) total FROM execution_operations')[0]['total']==0, 'Replacement operations occurred')
|
|
close(); report['passed'] = True
|
|
except Exception as error:
|
|
report.update(passed=False, reason=str(error), error=type(error).__name__)
|
|
if driver:
|
|
for n, window in enumerate(driver.windows()):
|
|
try: window_image(window.handle).save(output/f'failure-{n}.png')
|
|
except Exception: pass
|
|
if process and process.poll() is None and main_window:
|
|
try: close()
|
|
except Exception: report['process_left_running'] = process.pid
|
|
elif process and process.poll() is None:
|
|
report['process_left_running'] = process.pid
|
|
finally:
|
|
report['input_sha256'] = original
|
|
(output/'acceptance.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
|
|
print(json.dumps(report, ensure_ascii=False))
|
|
return 0 if report.get('passed') else 1
|
|
|
|
|
|
if __name__=='__main__': raise SystemExit(main())
|