ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.
Python ai-agentsamdcomfyuidockerllama-cppllmlocal-ain8nnvidiaopen-webuiragself-hostedspeech-to-textstrix-halotext-to-speechworkflow-automation
"""Source-only retained-hold proof contracts; no Mac or deployment qualification."""
import ast
import asyncio
import copy
from contextlib import contextmanager
import importlib.util
import io
import json
import os
from pathlib import Path
import sys
from types import SimpleNamespace
import pytest
ROOT = Path(__file__).resolve().parents[1]
LIB = ROOT / 'installers/macos/lib'
def load(name, path):
spec = importlib.util.spec_from_file_location(name, path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
base = load('held_proof_repair_fixture', ROOT / 'tests/test_macos_pixel_controller_repair.py')
repair = base.repair
pure = load('held_proof', LIB / 'pixel-controller-held-proof.py')
live = load('held_proof_live', LIB / 'pixel-controller-held-proof-live.py')
child = load('held_proof_child', LIB / 'pixel-controller-proof-child.py')
def fixture():
_, _, snapshots, repaired, _ = base.fixture()
repaired['phase'] = 'repaired'
authority = dict(current=base.CURRENT, candidate=base.CANDIDATE, owner=base.OWNER,
snapshots=snapshots, repair_body=base.encoded(repaired), settings_hash='f' * 64,
mode='sandboxed')
value = pure.make_intent(repair, identities=repaired['identities'], **authority)
return authority, value
def proof(value):
return dict(mode=value['mode'], pid=value['identities']['gateway'][0],
config_sha256='1' * 64, executed=True, at='2026-09-23T12:00:00.000Z')
def sample(value, *, held=False, ready=False):
return dict(native=dict(available=True, phase='held' if held else 'idle', active=0,
pid=value['identities']['gateway'][0], revision='2' * 64,
proof=proof(value) if ready else None, runtime_version='2026.6.33', probe_failure=None),
owned=held, ready=ready)
class FaultAdapter:
def __init__(self, failure=None, after=False):
self.authority, self.value = fixture()
self.observed = sample(self.value)
self.failure, self.after, self.events = failure, after, []
self.edge_held, self.locked = True, True
def event(self, name, action=lambda: None):
assert self.locked
self.events.append(name)
fail = self.failure == len(self.events) - 1
if fail and not self.after: raise OSError('interrupted before effect')
result = action()
if fail: raise OSError('interrupted after effect')
return result
def verify(self, value):
def check():
assert value == self.value
pure.validate(repair, value, **self.authority)
if not self.edge_held:
assert value['phase'] in ('releasing-edge', 'complete')
self.event('verify:' + value['phase'], check)
def persist(self, before, after):
assert before == self.value
def write():
pure.validate(repair, after, **self.authority)
self.value = copy.deepcopy(after)
self.event('persist:' + after['phase'], write)
def snapshot(self, value):
return self.event('snapshot:' + value['phase'], lambda: copy.deepcopy(self.observed))
def native(self, value, operation):
def effect():
assert self.edge_held
if operation == 'acquire':
assert value['phase'] == 'acquiring-native'
self.observed = sample(value, held=True)
elif operation == 'probe':
assert value['phase'] == 'probing'
self.observed = sample(value, held=True, ready=True)
else:
assert value['phase'] == 'releasing-native'
self.observed = sample(value, ready=True)
self.observed['native']['revision'] = '3' * 64
return copy.deepcopy(self.observed)
return self.event('native:' + operation, effect)
def release_edge(self, value):
def effect():
assert value['phase'] == 'releasing-edge'
pure.check_native(self.observed, value, held=False, ready=True, exact=True)
self.edge_held = False
held = repair._hold(self.authority['snapshots']['hold'])
self.authority['snapshots']['hold'] = json.dumps(dict(held, phase='released')).encode()
self.event('edge:release', effect)
def verify_released(self, value):
self.event('edge:released', lambda: None)
assert not self.edge_held
def test_effect_order_retains_original_hold_through_real_proof_and_native_release():
adapter = FaultAdapter()
originals = copy.deepcopy(adapter.authority)
assert pure.execute(adapter.value, adapter)['phase'] == 'complete'
effects = [event for event in adapter.events if event.startswith(('persist:', 'native:', 'edge:release'))]
assert effects == ['persist:acquiring-native', 'native:acquire', 'persist:probing', 'native:probe',
'persist:verified', 'persist:releasing-native', 'native:release', 'persist:native-released',
'persist:releasing-edge', 'edge:release', 'persist:complete', 'edge:released']
assert all(adapter.authority['snapshots'][key] == originals['snapshots'][key]
for key in ('archive', 'context', 'service'))
assert adapter.authority['repair_body'] == originals['repair_body']
previous = len(adapter.events)
assert pure.execute(adapter.value, adapter)['phase'] == 'complete'
assert not any(event.startswith(('persist:', 'native:')) for event in adapter.events[previous:])
@pytest.mark.parametrize('after', [False, True])
def test_interruption_at_every_durable_write_observation_and_effect_resumes_exactly(after):
reference = FaultAdapter()
pure.execute(reference.value, reference)
for index in range(len(reference.events)):
adapter = FaultAdapter(index, after)
with pytest.raises(OSError): pure.execute(adapter.value, adapter)
if not adapter.edge_held:
assert adapter.value['phase'] in ('releasing-edge', 'complete')
assert adapter.observed['ready'] and adapter.observed['native']['proof'] == adapter.value['proof']
adapter.failure = None
assert pure.execute(adapter.value, adapter)['phase'] == 'complete'
assert adapter.events.count('native:probe') <= 2
@pytest.mark.parametrize('field', ['archive', 'context', 'service', 'hold'])
def test_authority_byte_drift_is_not_adopted(field):
authority, value = fixture()
authority['snapshots'][field] += b' '
with pytest.raises((pure.ProofError, repair.RepairError)):
pure.validate(repair, value, **authority)
@pytest.mark.parametrize('change', [
lambda a: a.update(repair_body=a['repair_body'] + b' '),
lambda a: a.update(settings_hash='0' * 64), lambda a: a.update(mode='full-access'),
lambda a: a.update(candidate='0' * 64), lambda a: a['owner'].update(uid=502),
])
def test_repair_settings_owner_and_selection_are_exact(change):
authority, value = fixture()
authority = copy.deepcopy(authority)
change(authority)
with pytest.raises((pure.ProofError, repair.RepairError)):
pure.validate(repair, value, **authority)
@pytest.mark.parametrize('change', [
lambda v: v.update(extra=True), lambda v: v.update(schemaVersion=True),
lambda v: v.update(phase='ready'), lambda v: v.update(leaseRevision='1' * 64),
lambda v: v.update(proof={}), lambda v: v['identities']['gateway'].pop(),
lambda v: v['identities']['access'].__setitem__(2, 1000000),
])
def test_closed_journal_schema_and_phase_contract(change):
authority, value = fixture()
change(value)
with pytest.raises((pure.ProofError, repair.RepairError)):
pure.validate(repair, value, **authority)
@pytest.mark.parametrize('phase', ['acquiring-native', 'probing', 'verified', 'releasing-native',
'native-released', 'releasing-edge'])
@pytest.mark.parametrize('fault', ['other-token', 'process', 'busy', 'proof', 'revision', 'version'])
def test_unknown_native_state_never_releases_edge(phase, fault):
adapter = FaultAdapter()
original = adapter.persist
def stop(before, after):
original(before, after)
if after['phase'] == phase: raise OSError('checkpoint')
adapter.persist = stop
with pytest.raises(OSError): pure.execute(adapter.value, adapter)
adapter.persist = original
native = adapter.observed['native']
if fault == 'other-token':
native['phase'] = 'held'
adapter.observed['owned'] = False
elif fault == 'process': native['pid'] += 1
elif fault == 'busy': native['active'] = 1
elif fault == 'proof':
# Before acquiring, arbitrary old proof is not authority; acquisition
# deliberately clears it. All subsequent phases reject unknown proof.
if phase == 'acquiring-native':
native['phase'] = 'held'
adapter.observed['owned'] = True
native['proof'] = {'executed': True}
adapter.observed['ready'] = True
elif fault == 'revision':
native['revision'] = 'invalid'
else: native['runtime_version'] = 'other'
with pytest.raises(pure.ProofError): pure.execute(adapter.value, adapter)
assert adapter.edge_held and 'edge:release' not in adapter.events
def request():
_, value = fixture()
hashes = {name: 'a' * 64 for name in child.MODULES}
hashes['pixel_access_bridge.py'] = repair.AFTER
return dict(action='snapshot', owner=value['owner'], settingsSha256='f' * 64,
modules=hashes, token='d' * 64, mode='sandboxed', gatewayIdentity=value['identities']['gateway'])
def child_namespace():
namespace = {'__name__': 'proof_child_test'}
exec(compile(child.PROGRAM, '<actual fixed child>', 'exec'), namespace)
return namespace
def test_fixed_child_command_and_actual_closed_protocol():
assert child.command() == ['/usr/bin/python3', '-I', '-B', '-c', child.PROGRAM]
for action in ('snapshot', 'acquire', 'probe', 'release'):
value = dict(request(), action=action)
assert json.loads(child.request_bytes(value)) == value
tree = ast.parse((LIB / 'pixel-macos-access-install.py').read_text())
constants = {}
for node in tree.body:
if isinstance(node, ast.Assign) and any(isinstance(t, ast.Name) and t.id in
('HOST_FILES', 'SETTINGS_FILES', 'PROVIDER_FILES') for t in node.targets):
constants[node.targets[0].id] = ast.literal_eval(node.value)
assert set(child.MODULES) == set(constants['HOST_FILES']) | {
'pixel_settings/' + name for name in constants['SETTINGS_FILES']} | {
'pixel_provider/' + name for name in constants['PROVIDER_FILES']}
run = [n for n in ast.walk(ast.parse(child.PROGRAM)) if isinstance(n, ast.FunctionDef) and n.name == 'run'][0]
forbidden = {'locked', 'recovery_locked', 'change', 'reconcile', 'create_connection'}
assert not any(isinstance(n, ast.Attribute) and n.attr in forbidden for n in ast.walk(run))
@pytest.mark.parametrize('change', [
lambda v: v.update(action='change'), lambda v: v.update(command='/bin/sh'),
lambda v: v.update(path='/tmp/import'), lambda v: v.update(token='x' * 64),
lambda v: v.update(token='d' * 65), lambda v: v.update(mode='off'),
lambda v: v.update(settingsSha256='x' * 64), lambda v: v['modules'].update(extra='a' * 64),
lambda v: v['modules'].update({'pixel_access_bridge.py': repair.BEFORE}),
lambda v: v['owner'].update(uid=0), lambda v: v['owner'].update(uid=True),
lambda v: v['owner'].update(name='../owner'), lambda v: v['gatewayIdentity'].__setitem__(0, 0),
lambda v: v['gatewayIdentity'].__setitem__(3, 0), lambda v: v['gatewayIdentity'].__setitem__(2, 1000000),
])
def test_actual_child_builder_rejects_command_path_owner_and_scope_injection(change):
value = request()
change(value)
with pytest.raises(ValueError): child.request_bytes(value)
@pytest.mark.parametrize('body', [b'{}', b'[]', b'{"action":"probe","action":"snapshot"}', b'x' * 16385])
def test_actual_child_parser_rejects_missing_duplicate_and_oversized_input(body):
with pytest.raises(ValueError): child_namespace()['decode'](body)
def child_runtime(monkeypatch, *, action='snapshot', fault=None):
"""Execute the actual fixed child, mocking only OS custody and installed IO."""
ns = child_namespace()
value = request()
value['action'] = action
_, intent = fixture()
observed = sample(intent, held=action in ('acquire', 'probe'), ready=action != 'acquire')
events = []
settings = dict(install_dir='/fixed-install', gateway_target='fixed-target', gateway_plist='fixed-plist',
gateway_process='node', gateway_binding={}, openclaw_bin='fixed-binary', gateway_policy={})
owner = SimpleNamespace(pw_name='fixture', pw_uid=501, pw_gid=20)
ns['sys'] = SimpleNamespace(platform='darwin', path=[])
ns['os'] = SimpleNamespace(geteuid=lambda: 0)
ns['bootstrap_custody'] = lambda r: events.append('bootstrap')
def authority(*args):
events.append('authority')
if fault == 'authority' and events.count('authority') == 2: raise ValueError('private')
if fault == 'late-proof' and events.count('authority') == 2:
observed['native']['proof'] = None
observed['ready'] = False
return settings
ns['authority'] = authority
ns['key_bytes'] = lambda *a: events.append('key') or 'private-fixture-key'
def identity():
events.append('identity')
result = list(value['gatewayIdentity'])
if fault == 'late-process' and events.count('identity') > 1: result[1] += 1
return result
@contextmanager
def bounded(seconds):
assert seconds == 140
events.append('bound')
yield
def native(operation=None, token=None, **kwargs):
events.append('native:' + str(operation))
if operation: assert token == value['token']
if fault == 'late-sample' and events.count('native:None') == 2:
observed['native']['revision'] = '0' * 64
return copy.deepcopy(observed['native'])
def status():
events.append('status')
return dict(available=True, scope='owner-host', surface='darwin', configured_mode='sandboxed',
effective_mode='sandboxed', runtime_verified=observed['ready'], busy=False, pending=False, reason=None)
def probe(token, mode):
assert token == value['token'] and mode == value['mode']
events.append('probe')
bridge = SimpleNamespace(bounded=bounded, discover=lambda: events.append('discover'),
gateway_service=SimpleNamespace(process_identity=identity), _policy_state=lambda: {'activeMode': 'sandboxed'},
verify_held_mode=probe, native=native, status=status,
owns_native_hold=lambda *a: events.append('owns') or observed['owned'])
monkeypatch.setitem(sys.modules, 'pwd', SimpleNamespace(getpwnam=lambda name: owner))
monkeypatch.setitem(sys.modules, 'pixel_access_bridge', SimpleNamespace(LaunchdAccessBridge=lambda *a, **k: bridge))
return ns, value, events
@pytest.mark.parametrize('action', ['snapshot', 'acquire', 'probe', 'release'])
def test_actual_child_uses_direct_installed_primitive_without_controller_recursion(monkeypatch, action):
ns, value, events = child_runtime(monkeypatch, action=action)
result = ns['run'](value)
assert result['ready'] is (action != 'acquire')
assert events[-7:] == ['authority', 'key', 'native:None', 'status', 'native:None', 'owns', 'identity']
assert events.count('probe') == (action == 'probe')
assert events.count('native:' + action) == (action in ('acquire', 'release'))
@pytest.mark.parametrize('fault', ['authority', 'late-process', 'late-sample', 'late-proof'])
def test_actual_child_never_returns_stale_ready_observation(monkeypatch, fault):
ns, value, events = child_runtime(monkeypatch, fault=fault)
if fault == 'late-proof':
result = ns['run'](value)
assert result['ready'] is False and result['native']['proof'] is None
else:
with pytest.raises(ValueError): ns['run'](value)
@pytest.mark.parametrize('fault', [None, 'wrong-config', 'wrong-module', 'pending', 'wrong-path'])
def test_actual_child_authority_checks_every_fixed_module_and_settings(monkeypatch, fault):
ns, value = child_namespace(), request()
bodies = {name: name.encode() for name in child.MODULES}
value['modules'] = {name: repair.sha(body) for name, body in bodies.items()}
settings = dict(owner='fixture', state_dir=str(ns['STATE']), gateway_target='system/com.ods.pixel-native-gateway',
gateway_plist='/Library/LaunchDaemons/com.ods.pixel-native-gateway.plist',
openclaw_bin=str(ns['ROOT'] / 'openclaw-gateway-launcher'), edge_owner_key_sha256='f' * 64)
config = json.dumps(settings).encode()
value['settingsSha256'] = repair.sha(config)
reads = []
def read(path, **kwargs):
reads.append(path)
if path == ns['CONFIG']: return config + (b' ' if fault == 'wrong-config' else b'')
name = path.relative_to(ns['ROOT']).as_posix()
return bodies[name] + (b' ' if fault == 'wrong-module' and name == child.MODULES[-1] else b'')
ns['private_metadata'] = lambda path, mode: None
ns['os'] = SimpleNamespace(path=SimpleNamespace(lexists=lambda path: fault == 'pending'))
if fault == 'wrong-path':
settings['openclaw_bin'] = '/tmp/arbitrary'
config = json.dumps(settings).encode()
value['settingsSha256'] = repair.sha(config)
custody = SimpleNamespace(protected_tree_metadata=lambda p: None, protected_bytes=read)
if fault:
with pytest.raises(ValueError): ns['authority'](custody, value)
else:
assert ns['authority'](custody, value) == settings
assert len(reads) == len(child.MODULES) + 1
def source(name, namespace):
return base.source_function('installers/macos/lib/pixel-macos-access-install.py', name, namespace)
@pytest.mark.parametrize('phase', ['held', 'releasing', 'released'])
@pytest.mark.parametrize('fault', [None, 'late-proof', 'late-process'])
def test_real_adapter_and_hold_helper_resample_after_slow_checks_before_release(monkeypatch, phase, fault):
authority, value = fixture()
value.update(phase='releasing-edge', leaseRevision='2' * 64, proof=proof(value))
hold = repair._hold(authority['snapshots']['hold'])
hold['phase'] = phase
disk = [copy.deepcopy(hold)]
events = []
observed = sample(value, ready=True)
def acquire_release(plan, container, operation, binding):
events.append(operation)
if operation == 'acquire':
if fault == 'late-proof': observed['ready'] = False
if fault == 'late-process': observed['native']['pid'] += 1
return hold['status']
assert events[-2] == 'fresh-child'
return {'capability': 'available', 'phase': 'idle', 'streams': 0, 'admission_blocked': False}
def write(path, record):
events.append('journal:' + record['phase'])
disk[0] = record
monkeypatch.setitem(sys.modules, 'pixel_access_bridge', SimpleNamespace(
private_json=lambda *a: disk[0], atomic_json=write))
finish = source('_finish_migration_hold', {'_edge_hold_journal': lambda p: 'hold',
'_migration_edge_request': acquire_release, 'InstallError': ValueError})
adapter = object.__new__(live.Adapter)
adapter.i = SimpleNamespace(_finish_migration_hold=finish, _migration_edge_request=acquire_release, InstallError=ValueError)
adapter.pure, adapter.plan = pure, {}
def verify(value):
events.append('slow-verify')
if phase != 'held':
if fault == 'late-proof': observed['ready'] = False
if fault == 'late-process': observed['native']['pid'] += 1
adapter.verify = verify
adapter.edge = lambda v: events.append('slow-edge') or hold
adapter.budget = lambda: 1
adapter.child_sample = lambda *a: events.append('fresh-child') or copy.deepcopy(observed)
if fault:
with pytest.raises(pure.ProofError): adapter.release_edge(value)
assert 'release' not in events
assert disk[0]['phase'] != 'released' or phase == 'released'
else:
adapter.release_edge(value)
assert events.index('release') > events.index('fresh-child') > events.index('slow-edge')
assert disk[0]['phase'] == 'released'
@pytest.mark.parametrize('fault', [None, 'timeout', 'exit', 'large', 'duplicate', 'shape'])
def test_real_adapter_child_transport_is_fixed_bounded_and_private(monkeypatch, fault):
authority, value = fixture()
events = []
adapter = object.__new__(live.Adapter)
adapter.i, adapter.repair, adapter.child = SimpleNamespace(InstallError=ValueError), repair, child
adapter.settings_hash, adapter.mode = authority['settings_hash'], authority['mode']
adapter.modules = request()['modules']
adapter.authority = lambda: authority
adapter.budget = lambda: 42
adapter.verify = lambda v: events.append('authority')
def run(command, **kwargs):
events.append('child')
assert command == child.command()
assert kwargs['env'] == {'PATH': '/usr/bin:/bin'} and kwargs['cwd'] == '/'
assert kwargs['timeout'] == 42 and kwargs['stderr'] == live.subprocess.DEVNULL
assert set(json.loads(kwargs['input'])) == set(request())
assert b'credential' not in kwargs['input'] and b'private-fixture-key' not in kwargs['input']
if fault == 'timeout': raise live.subprocess.TimeoutExpired(command, 42)
output = base.encoded(sample(value))
if fault == 'large': output = b'x' * 8193
if fault == 'duplicate': output = b'{"ready":true,"ready":false}'
if fault == 'shape': output = b'{"error":"private"}'
return SimpleNamespace(returncode=1 if fault == 'exit' else 0, stdout=output)
monkeypatch.setattr(live.subprocess, 'run', run)
if fault:
with pytest.raises((ValueError, live.subprocess.TimeoutExpired)): adapter.invoke(value, 'snapshot')
else:
assert adapter.invoke(value, 'snapshot') == sample(value)
assert events == ['authority', 'child', 'authority']
@pytest.mark.parametrize('reproved', [False, True])
def test_cli_only_skips_startup_reconcile_after_completed_retained_hold_proof(monkeypatch, capsys, reproved):
import argparse
events = []
monkeypatch.setitem(sys.modules, 'pixel_access_bridge', SimpleNamespace(AccessError=RuntimeError))
def recover(*a, **kwargs):
events.append('recover')
if reproved: kwargs['on_reproved']()
return 'active'
namespace = dict(argparse=argparse, json=json, subprocess=live.subprocess,
sys=SimpleNamespace(platform='darwin', stderr=sys.stderr), os=SimpleNamespace(geteuid=lambda: 0),
InstallError=type('Error', (ValueError,), {}),
_upgrade=SimpleNamespace(UpgradeError=RuntimeError), _recovery_bridge=lambda **k: None,
recover_install=recover, _reprove_recovered_access=lambda owner: events.append('startup-reconcile'))
main = source('_recovery_main', namespace)
assert main(['--owner', 'fixture', '--current-bundle-digest', 'a' * 64, '--bundle-digest', 'b' * 64]) == 0
assert events == (['recover'] if reproved else ['recover', 'startup-reconcile'])
assert json.loads(capsys.readouterr().out)['status'] == 'active'
@pytest.mark.parametrize('interference', [None, 'new-turn', 'different-token'])
def test_actual_transition_gate_lost_release_reply_retries_only_original_receipt(monkeypatch, interference):
gate_module = load('held_proof_actual_transition_gate', ROOT / 'extensions/services/pixel-edge/transition_gate.py')
gate = object.__new__(gate_module.TransitionGate)
gate.mutex, gate.active, gate.closing = asyncio.Lock(), set(), False
gate.path, gate.failure = 'in-memory-custody-fixture', None
gate.state = gate_module._empty_state()
# Only persistence/custody IO is replaced; all admission/lease transitions,
# token comparisons, revision changes and release receipts are actual code.
gate._check = lambda: None
gate._write = lambda state: setattr(gate, 'state', state)
token, revision = 'd' * 64, gate.state['revision']
status = asyncio.run(gate.acquire(token, revision))
_, value = fixture()
value.update(phase='releasing-edge', leaseRevision='2' * 64, proof=proof(value))
disk = [dict(schemaVersion=1, phase='held', container='c' * 64,
binding=dict(token=token, revision=revision), status=status)]
events, lose = [], [True]
def request_edge(plan, container, operation, binding):
events.append(operation)
result = asyncio.run(getattr(gate, operation)(binding['token'], binding['revision']))
if operation == 'release' and lose and lose.pop():
raise TimeoutError('lost successful release reply')
return result
monkeypatch.setitem(sys.modules, 'pixel_access_bridge', SimpleNamespace(
private_json=lambda *a: disk[0], atomic_json=lambda path, value: disk.__setitem__(0, value)))
finish = source('_finish_migration_hold', dict(_edge_hold_journal=lambda p: 'hold',
_migration_edge_request=request_edge, InstallError=ValueError))
adapter = object.__new__(live.Adapter)
adapter.i = SimpleNamespace(_finish_migration_hold=finish, _migration_edge_request=request_edge, InstallError=ValueError)
adapter.pure, adapter.plan, adapter.budget = pure, {}, lambda: 1
adapter.verify = lambda v: None
adapter.edge = lambda v: disk[0]
adapter.child_sample = lambda *a: sample(value, ready=True)
with pytest.raises(TimeoutError): adapter.release_edge(value)
assert gate.state['phase'] == 'idle' and disk[0]['phase'] == 'releasing'
assert gate.state['revision'] != revision and gate.state['released']['revision'] == revision
if interference == 'new-turn':
asyncio.run(gate.admit('turn'))
asyncio.run(gate.finish('turn'))
elif interference == 'different-token':
asyncio.run(gate.acquire('f' * 64, gate.state['revision']))
before = copy.deepcopy(gate.state)
if interference:
with pytest.raises(gate_module.GateError): adapter.release_edge(value)
assert gate.state == before and disk[0]['phase'] == 'releasing'
else:
adapter.release_edge(value)
assert disk[0]['phase'] == 'released' and gate.state == before
assert events == ['acquire', 'release', 'release']
@pytest.mark.parametrize('kind', ['legacy', 'repaired', 'rolled-back', 'incomplete-proof', 'failed-proof'])
@pytest.mark.parametrize('loading', ['portable-function', 'native-module'])
def test_archived_repaired_route_holds_lock_through_proof_and_skips_legacy_release(monkeypatch, tmp_path, kind, loading):
if loading == 'native-module' and os.name == 'nt':
pytest.skip('Full POSIX installer import runs in Linux/macOS CI')
_, _, snapshots, repaired, _ = base.fixture()
repaired['phase'] = 'rolled-back' if kind == 'rolled-back' else 'repaired'
hold = repair._hold(snapshots['hold'])
events, held = [], []
plan = dict(access_settings={'gateway_port': 18789})
journal, records = SimpleNamespace(value={'phase': 'active'}), []
services = {name: name for name in repaired['identities']}
hold_path, repair_path = tmp_path / 'hold', tmp_path / 'repair'
hold_path.touch()
if kind != 'legacy': repair_path.touch()
@contextmanager
def locked(**kwargs):
assert kwargs == {'completed_digest': base.CANDIDATE}
held.append(True)
events.append('lock')
try: yield
finally:
held.pop()
events.append('unlock')
def run_locked(installer, **kwargs):
assert held and kwargs['services'] == services and kwargs['records'] == records
assert kwargs['selection'] == dict(current_digest=base.CURRENT, candidate_digest=base.CANDIDATE, owner_name='fixture')
events.append('retained-proof')
if kind == 'failed-proof': raise ValueError('proof failed')
return {'phase': 'verified' if kind == 'incomplete-proof' else 'complete'}
namespace = dict(os=os, json=json, re=base.re, HERE=LIB, _repair=repair, InstallError=ValueError,
ACCESS_FILES={'config': '/fixed-config'}, _destination=lambda p: p,
_load_upgrade_recovery=lambda **k: (plan, journal, records),
_verify_recovery_bindings=lambda *a: None, _upgrade_services=lambda *a: (services, services),
_verify_bundle_selection=lambda p: events.append('selection'),
_upgrade_service_identity=lambda s: (1, 2, 3), _policy=SimpleNamespace(policy_state=lambda p: {}),
_ready_gateway=lambda *a: None, _ready_access=lambda *a: None, _ready_access_relay=lambda *a: None,
_clear_candidate_stop_witnesses=lambda p: None, _edge_hold_journal=lambda p: hold_path,
_controller_repair_path=lambda d: repair_path, _controller_private_bytes=lambda *a: base.encoded(repaired),
_finish_migration_hold=lambda *a: events.append('legacy-release'))
monkeypatch.setitem(sys.modules, 'pixel_access_bridge', SimpleNamespace(private_json=lambda *a: hold))
monkeypatch.setitem(sys.modules, 'pixel_macos_custody', SimpleNamespace(protected_inspection_bytes=lambda *a, **k: b'{"gateway_policy":{}}'))
if loading == 'native-module':
# The shared native installer fixture already owns its POSIX imports.
test_module = load('held_proof_native_installer_fixture', ROOT / 'tests/test_macos_pixel_access_install.py')
installer = test_module.installer
for name, item in namespace.items(): monkeypatch.setattr(installer, name, item, raising=False)
function = installer._finish_archived_upgrade
else:
function = source('_finish_archived_upgrade', namespace)
fake_util = SimpleNamespace(spec_from_file_location=lambda *a: SimpleNamespace(loader=SimpleNamespace(exec_module=lambda m: None)),
module_from_spec=lambda s: SimpleNamespace(run_locked=run_locked))
if loading == 'native-module': monkeypatch.setattr(installer, 'importlib', SimpleNamespace(util=fake_util))
else: namespace['importlib'] = SimpleNamespace(util=fake_util)
invoke = lambda: function(SimpleNamespace(recovery_locked=locked), current_digest=base.CURRENT,
candidate_digest=base.CANDIDATE, owner_name='fixture', on_reproved=lambda: events.append('proved-callback'))
if kind in ('incomplete-proof', 'failed-proof'):
with pytest.raises(ValueError): invoke()
assert 'proved-callback' not in events and 'legacy-release' not in events
else:
assert invoke() == 'active'
if kind == 'repaired': assert events[-3:] == ['retained-proof', 'proved-callback', 'unlock']
else: assert events[-2:] == ['legacy-release', 'unlock'] and 'retained-proof' not in events
assert not held
@pytest.mark.parametrize('fault', [None, 'mode', 'owner', 'gid', 'hardlink', 'symlink'])
def test_actual_child_private_metadata_denies_unsafe_file(fault):
import stat
ns = child_namespace()
info = dict(st_mode=stat.S_IFREG | 0o644, st_uid=0, st_gid=0, st_nlink=1)
if fault == 'mode': info['st_mode'] |= 0o022
if fault == 'owner': info['st_uid'] = 501
if fault == 'gid': info['st_gid'] = 20
if fault == 'hardlink': info['st_nlink'] = 2
if fault == 'symlink': info['st_mode'] = stat.S_IFLNK | 0o644
path = SimpleNamespace(lstat=lambda: SimpleNamespace(**info))
if fault:
with pytest.raises(ValueError): ns['private_metadata'](path, 0o644)
else: ns['private_metadata'](path, 0o644)
@pytest.mark.parametrize('fault', ['private-error', 'large-result', 'oversized-input'])
def test_actual_child_main_keeps_errors_private_and_output_bounded(capsys, fault):
ns = child_namespace()
raw = b' ' * 16385 if fault == 'oversized-input' else child.request_bytes(request())
ns['sys'] = SimpleNamespace(stdin=SimpleNamespace(buffer=io.BytesIO(raw)))
def run(value):
if fault == 'private-error': raise RuntimeError('SECRET-PRIVATE-PATH-CREDENTIAL')
return {'value': 'x' * 9000}
ns['run'] = run
assert ns['main']() == 1
output = capsys.readouterr()
assert output.out == '{"error":"controller-held-proof-child-failed"}\n'
assert not output.err