"""Native backup entry: user owns version choice, restoration and confirmation.""" import json from pathlib import Path from types import SimpleNamespace import pytest import win32con import win32file def project_fixture(tmp_path): from cbb_refresh_verify.verify_runner import VerifyRequest library = tmp_path/'library/library.lmc'; library.parent.mkdir(); library.touch() work = library.parent/'ReusableBlocksLP/Block/Work'; work.mkdir(parents=True) project = work/'Block.prj'; project.write_text('KEY iCDBDir "database"\n') return VerifyRequest(library, 'Block', tmp_path/'evidence'), project def test_backup_entry_can_open_project_without_layout_data(tmp_path, monkeypatch): from cbb_refresh_verify import native_backup as native request, project = project_fixture(tmp_path) executable = tmp_path/'iCDBProjectBackup.exe'; executable.touch() monkeypatch.setattr(native, 'native_backup_executable', lambda *_: executable) calls = [] monkeypatch.setattr(native.subprocess, 'Popen', lambda command, **kw: (calls.append(command) or SimpleNamespace(pid=123, poll=lambda: None))) session = native.launch_native_backup(request) record = json.loads(session.job.read_text('utf-8')) assert record['project'] == str(project) assert calls[0][-2] == '--native-backup-worker' assert calls[0][-1] == str(session.job) assert session.library == request.lmc_file and session.block == 'Block' def test_native_session_closure_does_not_claim_restore_success(tmp_path, monkeypatch): from cbb_refresh_verify import native_backup as native from cbb_refresh_verify.library_lock import LibraryLock request, project = project_fixture(tmp_path) executable = tmp_path/'iCDBProjectBackup.exe'; executable.touch() monkeypatch.setattr(native, 'native_backup_executable', lambda *_: executable) job = request.evidence_dir/'request.json'; job.parent.mkdir() job.write_text(json.dumps({'library': str(request.lmc_file), 'block': 'Block', 'project': str(project), 'mentor_bin': ''})) calls = [] class NativeProcess: pid = 456 def __init__(self, command, cwd): calls.append(command) lock = LibraryLock(request.lmc_file) with pytest.raises(Exception): win32file.CreateFile(str(lock.path), win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None, win32con.OPEN_ALWAYS, 0, None) def poll(self): return 0 def session_pids(self): return [] def close(self): pass assert native.native_backup_worker_main(job, process_factory=NativeProcess) == 0 assert calls == [[str(executable), '-p', str(project)]] result = json.loads(job.with_name('result.json').read_text('utf-8')) assert result['status'] == 'CLOSED' and result['restore_confirmed'] is False assert result['native_exit_code'] == 0 and result['safe_to_continue'] is True with LibraryLock(request.lmc_file): pass def test_changed_project_identity_is_rejected_before_native_launch(tmp_path, monkeypatch): from cbb_refresh_verify import native_backup as native request, project = project_fixture(tmp_path) job = request.evidence_dir/'request.json'; job.parent.mkdir() job.write_text(json.dumps({'library': str(request.lmc_file), 'block': 'Block', 'project': str(project.parent/'Other.prj'), 'mentor_bin': ''})) assert native.native_backup_worker_main(job, process_factory=lambda *a, **k: pytest.fail('native launch on mismatched project')) == 1 assert json.loads(job.with_name('result.json').read_text('utf-8'))['status'] == 'FAILED' @pytest.mark.parametrize('all_evidence_failed', [False, True]) def test_state_log_failure_does_not_abandon_live_native_session(tmp_path, monkeypatch, all_evidence_failed): from cbb_refresh_verify import native_backup as native, management request, project = project_fixture(tmp_path) executable = tmp_path/'iCDBProjectBackup.exe'; executable.touch() monkeypatch.setattr(native, 'native_backup_executable', lambda *_: executable) job = request.evidence_dir/'request.json'; job.parent.mkdir() job.write_text(json.dumps({'library': str(request.lmc_file), 'block': 'Block', 'project': str(project), 'mentor_bin': ''})) write = management._write_json def broken_state(path, value): if all_evidence_failed or Path(path).name == 'state.json': raise OSError('state log unavailable') write(path, value) monkeypatch.setattr(management, '_write_json', broken_state) observations = [] class NativeProcess: pid = 456 def __init__(self, *a): pass def poll(self): return 0 def session_pids(self): observations.append(True) return [456] if len(observations) == 1 else [] def close(self): pass assert native.native_backup_worker_main(job, process_factory=NativeProcess) == 0 assert len(observations) >= 2 if not all_evidence_failed: assert json.loads(job.with_name('result.json').read_text('utf-8'))['status'] == 'CLOSED' def test_native_backup_ui_keeps_catalog_interactive_and_refreshes_after_close(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window requests, refreshes = [], [] result = tmp_path/'native/result.json'; result.parent.mkdir() job = result.with_name('request.json'); job.write_text('{}') session = SimpleNamespace(library=Path('test.lmc'), block='Beta', job=job, process=SimpleNamespace(poll=lambda: None)) window = load_window(qtbot, tmp_path, monkeypatch, native_backup_launcher=lambda req: (requests.append(req) or session), verifier=lambda _: pytest.fail('native backup must not run Verify'), status_refresher=lambda names, _: (refreshes.append(names) or {n: 'PENDING' for n in names})) window.search_edit.setText('Beta'); window.select_visible_button.click() assert window.native_backup_button.isEnabled() window.native_backup_button.click(); qtbot.waitUntil(lambda: not window.busy) assert len(requests) == 1 and requests[0].block_name == 'Beta' assert window.search_edit.isEnabled() and window.section_tabs.isEnabled() window.section_tabs.setCurrentIndex(2) window.search_edit.setText('Gamma') assert not window.busy result.write_text(json.dumps({'status': 'CLOSED', 'safe_to_continue': True, 'library': str(session.library), 'block': session.block, 'native_exit_code': 0, 'restore_confirmed': False})) session.process.poll = lambda: 0 window._poll_native_backup() qtbot.waitUntil(lambda: not window.busy) assert refreshes == [('Beta',)] assert window.search_edit.text() == 'Gamma' assert 'PASS' not in window.cbb_table.item(window._row_by_name['Beta'], 3).text() def test_native_backup_selection_requires_one_visible_non_ready_item(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window window = load_window(qtbot, tmp_path, monkeypatch, native_backup_launcher=lambda _: pytest.fail('unexpected launch')) assert not window.native_backup_button.isEnabled() def test_native_backup_can_use_current_non_ready_row_without_checkbox(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window window = load_window(qtbot, tmp_path, monkeypatch, native_backup_launcher=lambda _: pytest.fail('unexpected launch')) row = window._row_by_name['Beta'] window.cbb_table.setCurrentCell(row, 0) window._update() assert window.native_backup_button.isEnabled() window.search_edit.setText('Alpha'); window.select_visible_button.click() assert not window.native_backup_button.isEnabled() window.search_edit.clear(); window.select_visible_button.click() assert not window.native_backup_button.isEnabled() def test_closing_app_keeps_manual_native_window_and_mapping(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window window = load_window(qtbot, tmp_path, monkeypatch) retained = [] lease = SimpleNamespace(retain_for_recovery=lambda: retained.append(True), close=lambda: pytest.fail('mapping released before native session ends')) session = SimpleNamespace(library=Path('test.lmc'), block='Beta', path_lease=lease, process=SimpleNamespace(poll=lambda: None, terminate=lambda: pytest.fail('native UI terminated'))) window.library_lease = lease window._native_backup_session = session window.show(); window.close() qtbot.waitUntil(lambda: not window.isVisible()) assert retained == [True] and session.process.poll() is None def test_native_launch_failure_does_not_poison_other_features(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window def missing(_): raise ValueError('未找到 iCDB Project Backup') window = load_window(qtbot, tmp_path, monkeypatch, native_backup_launcher=missing) window.search_edit.setText('Beta'); window.select_visible_button.click() window.native_backup_button.click(); qtbot.waitUntil(lambda: not window.busy) assert '未找到' in window.status_label.text() assert window.selected_batch_button.isEnabled() and window.native_backup_button.isEnabled() assert not window._management_unsafe @pytest.mark.parametrize('evidence', ['unconfirmed', 'missing', 'malformed', 'wrong_identity']) def test_unconfirmed_supervisor_exit_keeps_session_conflict_and_mapping(qtbot, tmp_path, monkeypatch, evidence): from test_ui_filters import load_window window = load_window(qtbot, tmp_path, monkeypatch) job = tmp_path/'native/request.json'; job.parent.mkdir(); job.write_text('{}') if evidence != 'missing': job.with_name('result.json').write_text('invalid' if evidence == 'malformed' else json.dumps({ 'status': 'FAILED', 'safe_to_continue': evidence == 'wrong_identity', 'library': 'other.lmc' if evidence == 'wrong_identity' else 'test.lmc', 'block': 'Beta', 'detail': 'unconfirmed'})) session = SimpleNamespace(library=Path('test.lmc'), block='Beta', job=job, path_lease=window.library_lease, process=SimpleNamespace(poll=lambda: 1)) window._native_backup_session = session window._poll_native_backup(); qtbot.waitUntil(lambda: not window.busy) assert window._native_backup_session is session assert not window.batch_button.isEnabled() and window.search_edit.isEnabled() assert not window.native_backup_timer.isActive() def test_confirmed_native_close_transfers_mapping_to_current_library(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window from test_network_path import FakeWNet from cbb_refresh_verify.network_path import LibraryPathLease window = load_window(qtbot, tmp_path, monkeypatch) backend = FakeWNet() old = LibraryPathLease.acquire(r'\\server\share\A\library.lmc', backend=backend) current = LibraryPathLease.acquire(r'\\server\share\B\library.lmc', backend=backend) window.library_lease = current job = tmp_path/'request.json' job.with_name('result.json').write_text(json.dumps({'status': 'CLOSED', 'safe_to_continue': True, 'library': str(old.mentor_path), 'block': 'Beta'})) window._native_backup_session = SimpleNamespace(library=old.mentor_path, block='Beta', job=job, path_lease=old, process=SimpleNamespace(poll=lambda: 0)) window._poll_native_backup(); qtbot.waitUntil(lambda: not window.busy) assert window._native_backup_session is None assert backend.cancelled == [] and current.created window.close() qtbot.waitUntil(lambda: backend.cancelled == [current.drive]) def test_native_mapping_ownership_transfers_to_new_library_on_same_share(): from test_network_path import FakeWNet from cbb_refresh_verify.network_path import LibraryPathLease backend = FakeWNet() old = LibraryPathLease.acquire(r'\\server\share\A\library.lmc', backend=backend) current = LibraryPathLease.acquire(r'\\server\share\B\library.lmc', backend=backend) assert old.created and not current.created old.transfer_ownership(current) old.close() assert backend.cancelled == [] and current.created current.close() assert backend.cancelled == [current.drive] def test_native_process_job_waits_for_its_children_without_killing_them(tmp_path): import sys, time from cbb_refresh_verify.native_backup import _NativeBackupProcess pythonw = Path(sys.executable).with_name('pythonw.exe') child = tmp_path/'child.pid' script = tmp_path/'parent.py' script.write_text('import subprocess,sys,time\nfrom pathlib import Path\n' 'p=subprocess.Popen([sys.executable,"-c","import time;time.sleep(1)"])\n' f'Path({str(child)!r}).write_text(str(p.pid))\n' 'time.sleep(.2)\n', encoding='utf-8') native = _NativeBackupProcess([str(pythonw), str(script)], tmp_path) try: deadline = time.monotonic()+10 seen_child = False seen_parent_exit_before_child = False while time.monotonic() < deadline: pids = native.session_pids() assert isinstance(pids, (list, tuple)) if child.exists(): pid = int(child.read_text()) seen_child = seen_child or pid in pids seen_parent_exit_before_child = seen_parent_exit_before_child or native.poll() == 0 and pid in pids if native.poll() == 0 and not pids: break time.sleep(.05) assert seen_child and seen_parent_exit_before_child assert not native.session_pids() finally: native.close()