Files
cbb-refresh-verify-795/tests/test_residual_sessions.py

372 lines
22 KiB
Python

from pathlib import Path
from types import SimpleNamespace
import pytest
def test_registered_save_is_not_treated_as_an_idle_hung_client():
from cbb_refresh_verify.residual_sessions import force_block_reason
assert '保存' in force_block_reason({'runtime_phase': 'NATIVE_CALL'})
OWNERSHIP = {"owner_sid": "S-1-current", "session_id": 1, "force_user_confirmed": True}
def api():
from cbb_refresh_verify import library_lock
inspect = getattr(library_lock, 'inspect_residual_sessions', None)
release = getattr(library_lock, 'release_residual_sessions', None)
assert callable(inspect) and callable(release), 'Missing confirmed residual-session release workflow'
return inspect, release
def row(pid, project, *, name='iCDBProjectBackup.exe'):
return {'pid': pid, 'name': name, 'parent': 1, 'created': f'created-{pid}',
'executable': 'C:/Mentor/'+name, 'command': f'{name} -p "{project}"'}
def test_preview_limits_to_selected_projects_and_keeps_process_identity(tmp_path, monkeypatch):
inspect, _ = api()
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
a = library.parent/'ReusableBlocksLP/A/Work/A.prj'
b = library.parent/'ReusableBlocksLP/B/Work/B.prj'
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [row(10, a), row(20, b)])
monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': r['created'], 'image': r['executable']})
monkeypatch.setattr(sessions, '_process_windows', lambda pids: {p: [] for p in pids})
result = inspect(library, block_names=('A',))
assert [r['pid'] for r in result['sessions']] == [10]
assert result['sessions'][0]['created'] == 'created-10'
def test_unknown_scope_is_visible_but_never_closed_even_with_force(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
process = row(10, ''); process['command'] = 'LibraryManager.exe'
process['name'] = 'LibraryManager.exe'
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process])
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']})
plan = sessions.inspect_residual_sessions(library)
assert plan['sessions'] and plan['sessions'][0]['scope_confirmed'] is False
monkeypatch.setattr(sessions, '_request_close', lambda *a, **kw: pytest.fail('closed unknown scope'))
monkeypatch.setattr(sessions, '_force_close', lambda *a, **kw: pytest.fail('ended unknown scope'))
for force in (False, True):
result = sessions.release_residual_sessions(plan, tmp_path.parent/'release-evidence'/tmp_path.name, force=force)
assert result['status'] == 'RELEASE_CONFIRMED'
assert result['sessions'][0]['release_status'] == 'OBSERVED'
# A request file becoming readable must not expand the user's consent list.
monkeypatch.setattr('cbb_refresh_verify.library_lock._owner_matches_scope', lambda *a: True)
result = sessions.release_residual_sessions(plan, tmp_path.parent/'release-evidence'/tmp_path.name, force=True)
assert result['status'] == 'PARTIAL'
@pytest.mark.parametrize('name,title,children,expected', [
('iCDBProjectBackup.exe', 'iCDB Project Backup - test', [], True),
('ExpeditionPCB.exe', 'Expedition PCB - Reusable Block', [], True),
('ExpeditionPCB.exe', 'Design.pcb - Expedition PCB', [], True),
('iCDBProjectBackup.exe', 'iCDB Project Backup - test', [{'class': 'msctls_progress32', 'text': ''}], False),
])
def test_only_idle_supported_native_windows_are_offered_for_close(name, title, children, expected):
api()
from cbb_refresh_verify.residual_sessions import close_target
windows = [{'hwnd': 100, 'class': 'Afx:main', 'title': title, 'enabled': True,
'children': children, 'documents': [], 'output': 'Backup information loaded correctly.'}]
target, reason = close_target(name, windows)
assert bool(target) is expected
if not expected: assert reason
def test_confirmation_rechecks_pid_reuse_and_never_posts_to_replacement(tmp_path, monkeypatch):
inspect, release = api()
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj')
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()])
monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']})
monkeypatch.setattr(sessions, '_process_windows', lambda _: {10: []})
plan = inspect(library)
process['created'] = 'replacement'
monkeypatch.setattr(sessions, '_request_close', lambda *_: pytest.fail('closed replacement PID'))
monkeypatch.setattr(sessions, '_finish_library_release', lambda *_: {'status': 'RELEASE_CONFIRMED'})
result = release(plan, tmp_path.parent/'release-evidence'/tmp_path.name)
assert result['sessions'][0]['release_status'] == 'IDENTITY_CHANGED'
assert result['status'] == 'PARTIAL'
def test_close_requests_cover_whole_preview_and_failures_remain_per_item(tmp_path, monkeypatch):
inspect, release = api()
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
rows = [row(p, tmp_path/f'ReusableBlocksLP/{p}/Work/{p}.prj') for p in (10, 20)]
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: rows)
monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': r['created'], 'image': r['executable']})
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
calls = []
monkeypatch.setattr(sessions, '_request_close', lambda r, *_, **kw: calls.append(r['pid']) or
{'release_status': 'RELEASED' if r['pid'] == 10 else 'WAITING', 'detail': 'native window pending'})
monkeypatch.setattr(sessions, '_finish_library_release', lambda *_: pytest.fail('partial release cleared library marker'))
result = release(inspect(library), tmp_path.parent/'release-evidence'/tmp_path.name)
assert calls == [10, 20]
assert result['status'] == 'PARTIAL'
assert [r['release_status'] for r in result['sessions']] == ['RELEASED', 'WAITING']
def test_no_remaining_processes_rechecks_and_clears_old_metadata(tmp_path, monkeypatch):
inspect, release = api()
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [])
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
proof = {'status': 'RELEASE_CONFIRMED', 'library': str(library), 'evidence_path': 'proof.json'}
monkeypatch.setattr(sessions, '_finish_library_release', lambda *_: proof)
result = release(inspect(library), tmp_path.parent/'release-evidence'/tmp_path.name)
assert result['status'] == 'RELEASE_CONFIRMED' and result['proof'] == proof
def test_empty_session_scan_still_exposes_historical_operation_record(tmp_path, monkeypatch):
import json
from cbb_refresh_verify import residual_sessions as sessions
from cbb_refresh_verify.library_lock import blocker_path
library = tmp_path/'lib.lmc'; library.touch()
marker = blocker_path(library)
marker.write_text(json.dumps({'protocol': 'cbb-refresh-verify-library-lease', 'version': 1,
'library': str(library), 'lease_id': 'a'*32, 'pid': 57076,
'status': 'OWNER_RELEASE_UNCONFIRMED', 'time': '2026-11-04T09:43:50+00:00'}))
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [])
result = sessions.inspect_residual_sessions(library)
assert result['sessions'] == []
assert result['previous_records'][0]['path'] == str(marker)
assert result['previous_records'][0]['time'].startswith('2026-11-04')
assert marker.exists()
@pytest.mark.parametrize('output', [None, 'Repairing project\nRepair backup created successfully.',
'Repairing project\nBackup information loaded correctly.\nRestoring project'])
def test_backup_intermediate_success_does_not_allow_cooperative_close(output):
from cbb_refresh_verify.residual_sessions import close_target
window = {'hwnd': 10, 'class': 'Afx:main', 'title': 'iCDB Project Backup - test',
'children': [], 'enabled': True, 'output': output}
assert close_target('iCDBProjectBackup.exe', [window])[0] is None
def test_force_requires_separate_explicit_argument_and_rechecks_identity(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj', name='ExpeditionPCB.exe')
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()])
monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']})
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
monkeypatch.setattr(sessions, '_request_close', lambda *a, **k: {'release_status': 'WAITING', 'detail': 'hung'})
forced = []
monkeypatch.setattr(sessions, '_force_close', lambda r, **kw: forced.append(r['pid']) or
{'release_status': 'WAITING', 'detail': 'exiting'})
plan = sessions.inspect_residual_sessions(library)
evidence = tmp_path.parent/'release-evidence'/tmp_path.name
sessions.release_residual_sessions(plan, evidence)
assert not forced
sessions.release_residual_sessions(plan, evidence, force=True)
assert forced == [10]
process['created'] = 'reused'
sessions.release_residual_sessions(plan, evidence, force=True)
assert forced == [10]
@pytest.mark.parametrize('name', ['icdbnetserver.exe', 'icdbserver.exe',
'ReuseBlockImporter.exe', 'wscript.exe'])
def test_force_preserves_servers_and_unsupported_processes_even_with_confirmed_scope(tmp_path, monkeypatch, name):
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj', name=name)
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()])
monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']})
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
monkeypatch.setattr(sessions, '_force_close', lambda *a, **kw: pytest.fail('protected process was force terminated'))
plan = sessions.inspect_residual_sessions(library)
assert plan['sessions'][0]['scope_confirmed']
result = sessions.release_residual_sessions(plan, tmp_path.parent/'release-evidence'/tmp_path.name, force=True)
assert result['status'] == 'PARTIAL'
assert result['sessions'][0]['release_status'] == 'WAITING'
assert result['sessions'][0]['force_allowed'] is False
@pytest.mark.parametrize('name', ['icdbserver.exe', 'cdbsvr.exe', 'python.exe'])
def test_direct_force_cannot_request_a_terminate_handle_for_database_server(monkeypatch, name):
from cbb_refresh_verify import residual_sessions as sessions
process = {'pid': 10, 'name': name, 'scope_confirmed': True,
'image': 'C:/Mentor/'+name, 'created_handle': 'creation'}
monkeypatch.setattr(sessions, '_process_handle', lambda *a, **kw: pytest.fail('opened terminate-capable server handle'))
assert sessions._force_close(process)['release_status'] == 'WAITING'
def test_force_writes_exact_consent_before_any_native_action(tmp_path, monkeypatch):
import json
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj', name='ExpeditionPCB.exe')
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()])
monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']})
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
evidence = tmp_path.parent/'release-evidence'/tmp_path.name
def force(actual, **kwargs):
consent = json.loads(next(evidence.glob('sessions-*/consent.json')).read_text(encoding='utf-8'))
assert consent['library'] == str(library.resolve())
assert consent['mode'] == 'force_document_clients'
assert consent['sessions'][0]['pid'] == actual['pid']
assert consent['sessions'][0]['created_handle'] == actual['created_handle']
return {'release_status': 'WAITING', 'detail': 'not exited'}
monkeypatch.setattr(sessions, '_force_close', force)
plan = sessions.inspect_residual_sessions(library)
result = sessions.release_residual_sessions(plan, evidence, force=True)
assert Path(result['consent_path']).is_file()
assert result['status'] == 'PARTIAL'
def test_unwritable_force_consent_prevents_all_native_actions(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'lib.lmc'; library.touch()
process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj', name='ExpeditionPCB.exe')
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()])
monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']})
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
plan = sessions.inspect_residual_sessions(library)
original = Path.open
def deny(path, *args, **kwargs):
if path.name == 'consent.json': raise PermissionError('cannot record consent')
return original(path, *args, **kwargs)
monkeypatch.setattr(Path, 'open', deny)
monkeypatch.setattr(sessions, '_force_close', lambda *a, **kw: pytest.fail('termination preceded durable consent'))
with pytest.raises(PermissionError, match='cannot record consent'):
sessions.release_residual_sessions(plan, tmp_path.parent/'release-evidence'/tmp_path.name, force=True)
def test_current_process_handle_identity_uses_real_windows_api():
import os
from cbb_refresh_verify.residual_sessions import _process_identity
identity = _process_identity({'pid': os.getpid()})
assert identity['created_handle'] and Path(identity['image']).is_file()
assert identity['owner_sid'].startswith('S-1-')
assert isinstance(identity['session_id'], int)
assert identity['force_user_confirmed'] is True
@pytest.mark.parametrize('ownership', [{}, {'owner_sid': 'S-1-other', 'session_id': 1,
'force_user_confirmed': False}])
def test_force_never_opens_terminate_handle_without_current_user_and_session(monkeypatch, ownership):
from cbb_refresh_verify import residual_sessions as sessions
process = {'pid': 10, 'name': 'ExpeditionPCB.exe', 'scope_confirmed': True,
'created_handle': 'creation', 'image': 'C:/Mentor/ExpeditionPCB.exe', **ownership}
monkeypatch.setattr(sessions, '_process_handle', lambda *a, **kw: pytest.fail('opened unowned process'))
assert sessions._force_close(process)['release_status'] == 'WAITING'
@pytest.mark.parametrize('other_user,other_session', [(True, False), (False, True), (False, False)])
def test_force_ownership_checks_user_sid_and_windows_session(monkeypatch, other_user, other_session):
import os
import win32api, win32process, win32security, win32ts
from cbb_refresh_verify import residual_sessions as sessions
closed = []
monkeypatch.setattr(win32process, 'GetProcessId', lambda _: 10)
monkeypatch.setattr(win32api, 'GetCurrentProcess', lambda: 999)
monkeypatch.setattr(win32security, 'OpenProcessToken', lambda process, access:
SimpleNamespace(process=process, Close=lambda: closed.append(process)))
monkeypatch.setattr(win32security, 'GetTokenInformation', lambda token, kind:
('other' if other_user and token.process == 123 else 'current', 0))
monkeypatch.setattr(win32security, 'ConvertSidToStringSid', lambda sid: 'S-1-'+sid)
monkeypatch.setattr(win32ts, 'ProcessIdToSessionId', lambda pid:
2 if other_session and pid != os.getpid() else 1)
assert sessions._force_ownership(123, 10)['force_user_confirmed'] is (not other_user and not other_session)
assert closed == [123, 999]
def test_unreadable_force_ownership_does_not_hide_cooperative_identity(monkeypatch):
from contextlib import nullcontext
from cbb_refresh_verify import residual_sessions as sessions
monkeypatch.setattr(sessions, '_process_handle', lambda _: nullcontext(123))
monkeypatch.setattr(sessions, '_handle_identity', lambda _: {'created_handle': 'creation', 'image': 'pcb.exe'})
def denied(*args): raise PermissionError('token inaccessible')
monkeypatch.setattr(sessions, '_force_ownership', denied)
identity = sessions._process_identity({'pid': 10})
assert identity['created_handle'] == 'creation' and identity['force_user_confirmed'] is False
def test_force_refuses_actual_unsupported_test_helper():
import subprocess
import sys
from cbb_refresh_verify.residual_sessions import _process_identity, _force_close
child = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(30)'],
creationflags=subprocess.CREATE_NO_WINDOW)
try:
process = {'pid': child.pid, **_process_identity({'pid': child.pid})}
assert _force_close(process)['release_status'] == 'WAITING'
assert child.poll() is None
finally:
if child.poll() is None:
child.terminate(); child.wait(3) # This test's sleep-only helper.
def test_supported_force_revalidates_exact_handle_before_termination(monkeypatch):
from contextlib import nullcontext
import win32api, win32con, win32event
from cbb_refresh_verify import residual_sessions as sessions
process = {'pid': 10, 'name': 'ExpeditionPCB.exe', 'scope_confirmed': True,
'created_handle': 'creation', 'image': 'C:/Mentor/ExpeditionPCB.exe', **OWNERSHIP}
monkeypatch.setattr(sessions, '_process_handle', lambda *a, **kw: nullcontext(123))
monkeypatch.setattr(sessions, '_handle_identity', lambda _: {
'created_handle': 'creation', 'image': 'C:/Mentor/ExpeditionPCB.exe'})
monkeypatch.setattr(win32event, 'WaitForSingleObject', lambda handle, timeout:
win32con.WAIT_OBJECT_0 if timeout else win32con.WAIT_TIMEOUT)
monkeypatch.setattr(sessions, '_force_ownership', lambda *args: dict(OWNERSHIP))
monkeypatch.setattr(sessions, '_process_windows', lambda _: {10: []})
calls = []
monkeypatch.setattr(win32api, 'TerminateProcess', lambda handle, code: calls.append((handle, code)))
assert sessions._force_close({**process, 'created_handle': 'reused'})['release_status'] == 'IDENTITY_CHANGED'
assert not calls
assert sessions._force_close({**process, 'session_id': 2})['release_status'] == 'IDENTITY_CHANGED'
assert sessions._force_close({**process, 'owner_sid': 'S-1-other'})['release_status'] == 'IDENTITY_CHANGED'
assert not calls
assert sessions._force_close(process)['release_status'] == 'RELEASED'
assert calls == [(123, 1)]
def test_partial_desktop_enumeration_never_offers_normal_close(monkeypatch):
import win32gui, win32service
from cbb_refresh_verify.residual_sessions import _process_windows, close_target
def failed(*_): raise OSError('desktop disappeared')
monkeypatch.setattr(win32gui, 'EnumWindows', failed)
monkeypatch.setattr(win32service, 'GetProcessWindowStation', lambda: SimpleNamespace(EnumDesktops=lambda: []))
snapshot = _process_windows({10})
windows = snapshot[10]
assert snapshot.incomplete[10]
windows.append({'hwnd': 100, 'class': 'Afx:main', 'title': 'Design - Expedition PCB',
'children': [], 'enabled': True})
assert close_target('ExpeditionPCB.exe', windows, incomplete=snapshot.incomplete[10])[0] is None
@pytest.mark.parametrize('choice', [6, 7, 2])
def test_save_answers_require_current_exact_prompt_and_process(monkeypatch, choice):
import win32con, win32gui, win32process
from contextlib import nullcontext
from cbb_refresh_verify import residual_sessions as sessions
process = row(10, 'C:/Lib/ReusableBlocksLP/A/Work/A.prj')
process.update(created_handle='creation', image='pcb.exe')
dialog = {'hwnd': 100, 'class': '#32770', 'title': 'Expedition PCB', 'children': [
{'class': 'Static', 'text': 'Save changes to the modified design?'},
*[{'class': 'Button', 'text': text, 'enabled': True, 'id': code, 'hwnd': code}
for code, text in ((6, 'Yes'), (7, 'No'), (2, 'Cancel'))]]}
windows = [dialog]
process['prompt'] = sessions._save_question(windows)
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process])
monkeypatch.setattr(sessions, '_process_handle', lambda _: nullcontext(123))
monkeypatch.setattr(sessions, '_handle_identity', lambda _: {'created_handle': 'creation', 'image': 'pcb.exe'})
monkeypatch.setattr(sessions, '_process_windows', lambda _: {10: windows})
monkeypatch.setattr(win32process, 'GetWindowThreadProcessId', lambda _: (1, 10))
clicked = []
monkeypatch.setattr(win32gui, 'PostMessage', lambda *a: clicked.append(a))
sessions._answer_save_question(process, choice)
assert clicked == [(choice, win32con.BM_CLICK, 0, 0)]
dialog['children'][0]['text'] = 'Save changes to another modified design?'
with pytest.raises(ValueError, match='提示已变化'):
sessions._answer_save_question(process, choice)
assert len(clicked) == 1