350 lines
24 KiB
Python
350 lines
24 KiB
Python
#!/usr/bin/env python3
|
|
"""Pure acceptance-harness guards; no VM, credentials, API mutations or approval."""
|
|
import ast
|
|
import copy
|
|
import datetime as dt
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import ssl
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import patch
|
|
from types import SimpleNamespace
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'deploy'))
|
|
import vm_mvp_acceptance as m
|
|
import vm_mvp_adapters as advanced
|
|
import vm_mvp_runtime as native
|
|
import vm_runtime_upgrade as upgrade
|
|
|
|
|
|
class Guards(unittest.TestCase):
|
|
def settings(self):
|
|
return m.config(dict(profile='dev/test', origin=m.ORIGIN, connect_address='127.0.0.1:18443', ca_file=str(m.CA),
|
|
tenant_id='11111111-1111-4111-8111-111111111111', asset_id='22222222-2222-4222-8222-222222222222',
|
|
agent_id='33333333-3333-4333-8333-333333333333', agent_uid=993))
|
|
|
|
def artifact(self):
|
|
return dict(profile='dev/test', **{k:v for k,v in self.settings().items() if k in ('tenant_id','asset_id','agent_id')},
|
|
approved_cases=['hello'], expires_at=(m.now()+dt.timedelta(minutes=5)).isoformat(),
|
|
permission_origin='explicit_chat_user_permission',chat_date='2026-11-12',testsimulation=True,
|
|
expected_principal='simulated-testprincipal-a')
|
|
|
|
def test_only_exact_loopback_tls_origin_and_nonroot_network_identity(self):
|
|
for field, value in [('profile','production'), ('origin','https://127.0.0.1:18443'),
|
|
('origin','https://user:secret@rmm-dev.internal:18443'),
|
|
('connect_address','0.0.0.0:18443'), ('ca_file','/not/trusted.pem'), ('agent_uid',0)]:
|
|
with self.assertRaises(m.GuardError): m.config(dict(self.settings(), **{field:value}))
|
|
|
|
def test_protected_files_duplicate_fields_modes_and_symlinks(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
path=Path(folder)/'input.json'; path.write_text('{"a":1,"a":2}'); path.chmod(0o600)
|
|
with self.assertRaises(m.GuardError): m.protected_json(path)
|
|
path.write_text('{}'); self.assertEqual(m.protected_json(path), {})
|
|
path.chmod(0o644)
|
|
with self.assertRaises(m.GuardError): m.protected_json(path)
|
|
link=Path(folder)/'link'; link.symlink_to(path)
|
|
with self.assertRaises(m.GuardError): m.protected_json(link)
|
|
|
|
def test_invalid_ca_cannot_establish_a_trust_context(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
path=Path(folder)/'invalid-ca.pem'; path.write_text('NOT A CERTIFICATE')
|
|
with self.assertRaises(ssl.SSLError): ssl.create_default_context(cafile=str(path))
|
|
|
|
def test_fixed_hello_bytes_identity_and_deadline(self):
|
|
case=m.case_input('hello',self.settings())
|
|
self.assertEqual(case['parameters']['variants'][0]['script_utf8'], "printf '%s\\n' 'Hello World'\n")
|
|
self.assertEqual(case['parameters']['expected_stdout'],'Hello World\n')
|
|
self.assertEqual(case['targets']['asset_ids'],[self.settings()['asset_id']])
|
|
self.assertEqual(case['parameters']['execution_identity'],'agent_service')
|
|
self.assertEqual(m.timestamp(case['schedule']['start_before'])-m.timestamp(case['schedule']['not_before']),dt.timedelta(minutes=15))
|
|
|
|
def test_bounded_logs_and_exact_service_unit_only(self):
|
|
logs=m.case_input('query_logs',self.settings())['parameters']
|
|
self.assertEqual(logs['unit'],'rmm-mvp-test.service');self.assertEqual(logs['max_lines'],50)
|
|
self.assertEqual(m.timestamp(logs['until'])-m.timestamp(logs['since']),dt.timedelta(minutes=5))
|
|
for name,state in [('service_start','running'),('service_stop','stopped')]:
|
|
case=m.case_input(name,self.settings())['parameters']
|
|
self.assertEqual((case['unit'],case['state'],case['execution_identity'],case['timeout_seconds']),
|
|
('rmm-mvp-test.service',state,'root',180))
|
|
setup=m.case_input('service_setup',self.settings())['parameters']
|
|
self.assertEqual(setup['execution_identity'],'root')
|
|
self.assertEqual(hashlib.sha256(setup['variants'][0]['script_utf8'].encode()).hexdigest(),
|
|
'3e299e84021beaa4cbdce6fa63eda193f6f123aba86368890fe20684c43e78ae')
|
|
# The browser independently pins the reviewed bytes at the UI boundary.
|
|
# Check that pin locally as well; do not wait for a live approval run to
|
|
# discover drift between the two acceptance paths.
|
|
browser=(m.ROOT/'tests/browser/mvp-actions.spec.ts').read_text()
|
|
self.assertIn("update(text(action.script_utf8)).digest('hex')).toBe('" +
|
|
hashlib.sha256(setup['variants'][0]['script_utf8'].encode()).hexdigest() + "')", browser)
|
|
artifact=dict(self.artifact(),approved_cases=['service_setup','service_start','service_stop'])
|
|
m.validate_run_artifact(artifact,self.settings(),['service_setup','service_start','service_stop'])
|
|
with self.assertRaises(m.GuardError):m.validate_run_artifact(artifact,self.settings(),['service_start','service_setup','service_stop'])
|
|
|
|
def test_expired_or_unbounded_schedules_rejected(self):
|
|
for start,end in [(m.now()-dt.timedelta(minutes=2),m.now()-dt.timedelta(minutes=1)),
|
|
(m.now(),m.now()+dt.timedelta(hours=2))]:
|
|
with self.assertRaises(m.GuardError):m.schedule(start,end)
|
|
|
|
def test_explicit_scoped_artifact_no_pending_adapter_can_be_opted_in(self):
|
|
m.validate_run_artifact(self.artifact(),self.settings(),['hello'])
|
|
for changes,cases in [(dict(testsimulation=False),['hello']), (dict(profile='production'),['hello']),
|
|
(dict(expected_principal='real-person'),['hello']), ({},[]), ({},['hello','hello']),
|
|
(dict(approved_cases=['reboot_last','hello']),['reboot_last','hello']),
|
|
(dict(expires_at=(m.now()-dt.timedelta(seconds=1)).isoformat()),['hello'])]:
|
|
with self.assertRaises(m.GuardError):m.validate_run_artifact(dict(self.artifact(),**changes),self.settings(),cases)
|
|
|
|
def test_outstanding_unknown_or_replay_does_not_create_new_attempt(self):
|
|
m.safe_states(['succeeded','failed'])
|
|
for state in ('queued','accepted','running','verifying','unknown','awaiting_reboot'):
|
|
with self.assertRaises(m.GuardError):m.safe_states([state])
|
|
self.assertEqual(len(m.EXECUTABLE),15)
|
|
for name in ('duplicate_offer','lost_result_ack'):
|
|
with self.assertRaises(m.GuardError):m.case_input(name,self.settings())
|
|
|
|
def manifest(self):
|
|
pin='74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867'
|
|
transaction=dict(schema_version=1, recipe_id='rmm-apt-fixture-install-1.0',recipe_version='1',platform='ubuntu-24.04-amd64',
|
|
resolver_config_version='rmm-apt-local-v1',no_reboot=True,status_fingerprint='a'*64,baseline_sha256='b'*64,
|
|
packages=[dict(name='rmm-mvp-test',architecture='all',old_version=None,new_version='1.0',origin='rmm-test',sha256=pin,
|
|
size=20672,archive_path='/var/lib/rmm-apt-transaction/archives/'+pin+'.deb')])
|
|
raw=json.dumps(transaction,separators=(',',':')).encode()
|
|
return dict(type='rmm.apt.helper-action',schema_version=2,action='apt-native-acceptance',execution_profile='dev-test',
|
|
transaction_sha256=hashlib.sha256(raw).hexdigest(),resolved_apt_transaction=transaction,transaction_bytes=list(raw),
|
|
provider_sha256='c'*64,hook_sha256='d'*64,apt_config_sha256='e'*64,runtime_sha256='f'*64,test_result_id='fixture-only')
|
|
|
|
def test_complete_apt_fixture_format_is_not_execution_or_acceptance(self):
|
|
value=self.manifest();self.assertEqual(m.validate_apt_manifest(value)['packages'][0]['name'],'rmm-mvp-test')
|
|
for field,bad in [('schema_version',1),('transaction_bytes',[True]),('runtime_sha256','missing'),('extra','unsigned')]:
|
|
with self.assertRaises(m.GuardError):m.validate_apt_manifest(dict(value,**{field:bad}))
|
|
changed=copy.deepcopy(value);changed['resolved_apt_transaction']['no_reboot']=False
|
|
with self.assertRaises(m.GuardError):m.validate_apt_manifest(changed)
|
|
|
|
def test_reboot_same_boot_or_exit_code_is_not_success(self):
|
|
ids=[str(__import__('uuid').uuid4()) for _ in range(7)]
|
|
checkpoint=dict(zip(('tenant_id','agent_id','asset_id','operation_id','job_id','attempt_id','old_boot_id'),ids),plan_hash='a'*64)
|
|
job=dict(job_id=checkpoint['job_id'],attempt_id=checkpoint['attempt_id'],state='succeeded',result=dict(exit_code=0,evidence={}))
|
|
with self.assertRaises(m.GuardError):m.validate_reboot_checkpoint(checkpoint,checkpoint['old_boot_id'],job)
|
|
with self.assertRaises(m.GuardError):m.validate_reboot_checkpoint(checkpoint,str(__import__('uuid').uuid4()),job)
|
|
|
|
def test_no_direct_approval_or_database_mutation_in_harness(self):
|
|
source=Path(m.__file__).read_text();tree=ast.parse(source)
|
|
for call in ast.walk(tree):
|
|
if isinstance(call,ast.Call) and isinstance(call.func,ast.Attribute) and call.func.attr=='request':
|
|
self.assertIsInstance(call.args[0],ast.Constant)
|
|
self.assertIn(call.args[0].value,('/mcp','/auth/config'))
|
|
for value in ast.walk(tree):
|
|
if isinstance(value,ast.Constant) and isinstance(value.value,str):
|
|
self.assertFalse(value.value.upper().startswith(('INSERT INTO ','UPDATE ','DELETE FROM ','DROP TABLE ')))
|
|
browser=(m.ROOT/'tests/browser/mvp-actions.spec.ts').read_text()
|
|
self.assertNotRegex(browser,r'page\.request|request\.(post|put)\(|evaluate\(')
|
|
|
|
def test_readonly_preflight_calls_only_read_tools(self):
|
|
settings=self.settings()
|
|
class Fake:
|
|
def __init__(self):self.calls=[]
|
|
def request(self,path):return 200,{},dict(dev_login_enabled=True)
|
|
def outstanding_guard(self,settings):pass
|
|
def call(self,name,args):
|
|
self.calls.append(name)
|
|
if name=='tenants.list':return dict(items=[dict(tenant_id=settings['tenant_id'])])
|
|
if name=='inventory.list_devices':return dict(truncated=True)
|
|
return dict(agent_id=settings['agent_id'],asset_id=settings['asset_id'],presence='unreachable',capabilities=[])
|
|
fake=Fake();_,report=m.preflight(fake,settings)
|
|
self.assertEqual(fake.calls,['tenants.list','inventory.list_devices','inventory.get_device','monitoring.get_health'])
|
|
self.assertFalse(report['effects_performed'])
|
|
|
|
def planning(self,upgrade=False):
|
|
baseline={} if not upgrade else {'rmm-mvp-test:all':dict(version='1.0',status='install ok installed')}
|
|
runtime=dict(apt_config_sha256='e'*64)
|
|
return dict(fixture_package=baseline.get('rmm-mvp-test:all'),baseline=baseline,baseline_sha256=advanced.digest(advanced.canonical(baseline)),
|
|
sealed_baseline_sha256=advanced.digest(advanced.canonical(baseline)),status_records={},status_fingerprint=advanced.digest(b'{}'),
|
|
dpkg_updates_empty=True,pending_triggers_empty=True,host_reboot_required=False,runtime=runtime,runtime_sha256=advanced.digest(advanced.canonical(runtime)),
|
|
provider_sha256='c'*64,hook_sha256='d'*64,apt_config_sha256='e'*64,
|
|
prefetch={pin:dict(schema_version=1,sha256=pin,size=20672,sealed_at_ms=1) for pin in advanced.PINS.values()})
|
|
|
|
def test_all_four_apt_adapters_preserve_complete_typed_manifests(self):
|
|
for name in advanced.APT_CASES:
|
|
data=self.planning(name in ('apt_native_update','apply_updates','ensure_package'))
|
|
case=m.case_input(name,self.settings(),planning=data)
|
|
value=case['parameters']['apt_manifest'];m.validate_apt_manifest(value)
|
|
self.assertEqual(value['resolved_apt_transaction'],json.loads(bytes(value['transaction_bytes'])))
|
|
self.assertEqual(case['parameters']['execution_identity'],'root')
|
|
self.assertEqual(value['action'],'apt-native-acceptance' if name.startswith('apt_native_') else 'apt-execute')
|
|
self.assertEqual(case['parameters']['timeout_seconds'],300)
|
|
|
|
def test_no_live_ssh_planning_fallback_when_passive_data_missing_or_dirty(self):
|
|
with self.assertRaisesRegex(m.GuardError,'stored_linux.apt.planning'):advanced.planning_from_device(dict(inventory={}))
|
|
data=self.planning()
|
|
observation=dict(scope='linux.apt.planning',quality='valid',completeness='complete',truncated=False,observed_at=m.now().isoformat(),data=data)
|
|
self.assertEqual(advanced.planning_from_device(dict(inventory=dict(observations=[observation]))),data)
|
|
for changes in (dict(dpkg_updates_empty=False),dict(sealed_baseline_sha256='0'*64),dict(runtime_sha256='0'*64)):
|
|
with self.assertRaises(m.GuardError):advanced.planning_from_device(dict(inventory=dict(observations=[dict(observation,data=dict(data,**changes))])))
|
|
|
|
def test_no_fake_baseline_or_implicit_fixture_removal_to_repeat_acceptance(self):
|
|
data=self.planning();data['fixture_package']=dict(version='1.0',status='install ok installed')
|
|
with self.assertRaisesRegex(m.GuardError,'no_approved_removal'):m.case_input('apt_native_install',self.settings(),planning=data)
|
|
data=self.planning(True);data['fixture_package']=dict(version='1.1',status='install ok installed')
|
|
data['baseline']['rmm-mvp-test:all']=data['fixture_package']
|
|
data['baseline_sha256']=advanced.digest(advanced.canonical(data['baseline']))
|
|
data['sealed_baseline_sha256']=data['baseline_sha256']
|
|
self.assertEqual(m.case_input('apply_updates',self.settings(),planning=data)['parameters']['apt_manifest']['resolved_apt_transaction']['packages'][0]['new_version'],'1.1')
|
|
self.assertEqual(m.case_input('ensure_package',self.settings(),planning=data)['parameters']['version'],'1.1')
|
|
|
|
def test_final_upgrade_generated_program_has_real_dependencies_and_sanitized_errors(self):
|
|
import io
|
|
from contextlib import redirect_stdout
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
path=Path(folder);(path/'identity').write_text('PRIVATE-UPGRADE-CANARY')
|
|
code=upgrade.program('(sha(b"known"),manifest(Path('+repr(folder)+')))')
|
|
output=io.StringIO()
|
|
with redirect_stdout(output):exec(compile(code,'<final-upgrade>','exec'),{})
|
|
result=json.loads(output.getvalue())
|
|
self.assertEqual(result['result'],[upgrade.sha(b'known'),upgrade.previous.manifest(path)])
|
|
self.assertNotIn('PRIVATE-UPGRADE-CANARY',output.getvalue())
|
|
output=io.StringIO()
|
|
with redirect_stdout(output):exec(compile(upgrade.program("(_ for _ in ()).throw(ValueError('PRIVATE-UPGRADE-ERROR'))"),'<final-upgrade>','exec'),{})
|
|
result=json.loads(output.getvalue());self.assertEqual(result['error']['exception_class'],'ValueError')
|
|
self.assertNotIn('PRIVATE-UPGRADE-ERROR',output.getvalue())
|
|
|
|
def test_real_cancel_expiry_and_reboot_plans_have_fixed_noop_or_explicit_root(self):
|
|
start=m.now()
|
|
cancel=m.case_input('cancel_queued',self.settings(),start)
|
|
self.assertEqual(m.timestamp(cancel['schedule']['not_before'])-start,dt.timedelta(minutes=3))
|
|
expiry=m.case_input('expired_offline',self.settings(),start)
|
|
self.assertEqual(m.timestamp(expiry['schedule']['start_before'])-start,dt.timedelta(seconds=60))
|
|
reboot=m.case_input('reboot_last',self.settings(),start)
|
|
self.assertEqual(reboot['action'],'reboot');self.assertEqual(reboot['parameters']['execution_identity'],'root')
|
|
self.assertEqual(reboot['parameters']['reconnect_timeout_seconds'],180)
|
|
|
|
def test_no_native_actor_or_server_restart_from_readonly_default(self):
|
|
with patch.object(sys,'argv',['vm_mvp_acceptance.py']),patch.object(m,'default_config',return_value=self.settings()), \
|
|
patch.object(m,'Backend') as backend,patch.object(m,'preflight',return_value=({},{})), \
|
|
patch.object(native,'OwnedRuntime') as actor:
|
|
m.main();actor.assert_not_called();backend.assert_called_once()
|
|
|
|
def test_native_action_requires_independent_helper_policy_no_capability_override(self):
|
|
actor=object.__new__(native.OwnedRuntime);actor.settings=self.settings()
|
|
request=m.case_input('reboot_last',self.settings())
|
|
capabilities=['reboot','rmm.sync.v1','helper.root.v1','root:reboot','helper.policy.sha256:'+'a'*64]
|
|
actor.backend=SimpleNamespace(call=lambda *args:dict(capabilities=capabilities))
|
|
actor.wait_sync=lambda:dict(helper_ready=True)
|
|
actor.control_probe=lambda *args:dict(policy_sha256='a'*64,policy=dict(allow_reboot=False))
|
|
with self.assertRaisesRegex(m.GuardError,'allow_reboot_false'):actor.require_action(request)
|
|
|
|
def test_cancel_adapter_orders_pause_approve_cancel_resume_without_new_attempt(self):
|
|
events=[];checkpoint=dict(job_id='44444444-4444-4444-8444-444444444444',operation_id='55555555-5555-4555-8555-555555555555',
|
|
attempt_id='66666666-6666-4666-8666-666666666666',plan_hash='a'*64)
|
|
class Backend:
|
|
def outstanding_guard(self,settings):events.append('guard')
|
|
def call(self,name,args):
|
|
events.append(name)
|
|
return {} if name=='inventory.get_device' else dict(state='cancelled')
|
|
def counts(self,*args):return [1,1,0]
|
|
actor=SimpleNamespace(require_action=lambda request:events.append('require_action'),server_state=lambda:dict(boot_id='old'),
|
|
pause_idle=lambda:events.append('pause'),resume_after_offline=lambda job:events.append('resume'))
|
|
with tempfile.TemporaryDirectory() as folder,patch.object(advanced,'authorize',side_effect=lambda *a,**k:events.append('ui_approve') or checkpoint), \
|
|
patch.object(advanced,'wait_job',return_value=dict(state='cancelled')),patch.object(advanced,'audit',return_value={}):
|
|
advanced.execute_advanced(Backend(),self.settings(),self.artifact(),'cancel_queued',Path(folder),actor)
|
|
self.assertLess(events.index('pause'),events.index('ui_approve'))
|
|
self.assertLess(events.index('ui_approve'),events.index('jobs.cancel'))
|
|
self.assertLess(events.index('jobs.cancel'),events.index('resume'))
|
|
|
|
def test_fault_cases_never_create_an_extra_plan_or_claim_injection_passed(self):
|
|
backend=SimpleNamespace(outstanding_guard=lambda settings:None,call=lambda *args:(_ for _ in ()).throw(AssertionError('no new MCP plan')))
|
|
actor=SimpleNamespace(replay_original_result=lambda checkpoint:dict(regression_verified=True))
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
folder=Path(folder);m.write_private(folder/'hello-result.json',dict(job_id='test'))
|
|
advanced.execute_advanced(backend,self.settings(),self.artifact(),'lost_result_ack',folder,actor)
|
|
result=m.protected_json(folder/'lost_result_ack-result.json')
|
|
self.assertFalse(result['native_fault_test_passed'])
|
|
self.assertEqual(result['fault_injection'],'unsupported_native_fault_injection')
|
|
|
|
def test_chat_permission_is_never_a_native_readiness_boolean(self):
|
|
artifact=self.artifact()
|
|
self.assertNotIn('wiring_verified',artifact)
|
|
with self.assertRaises(m.GuardError):m.validate_run_artifact(dict(artifact,wiring_verified=True),self.settings(),['hello'])
|
|
with self.assertRaises(m.GuardError):native.OwnedRuntime(self.settings(),None,dict(agent_id=self.settings()['agent_id'],ready=True))
|
|
|
|
def test_bootstrap_cannot_start_foreign_units_or_sample_business_baseline(self):
|
|
actor=object.__new__(native.OwnedRuntime)
|
|
actor.verdict=dict(helper_units={'sshd.service':'a'*64})
|
|
actor.remote=lambda code:(_ for _ in ()).throw(AssertionError('must not dispatch'))
|
|
with self.assertRaises(m.GuardError):actor.start_helpers()
|
|
source=Path(native.__file__).read_text()
|
|
self.assertNotIn('prepare-baseline',source)
|
|
self.assertNotIn('provision-fixture-store',source)
|
|
self.assertNotIn('dpkg-query',source)
|
|
self.assertNotIn('os.kill(',source)
|
|
|
|
def test_planning_projection_fits_bounded_observation_without_raw_inventory(self):
|
|
data=self.planning();data.pop('baseline');data.pop('status_records')
|
|
observation=dict(scope='linux.apt.planning',quality='valid',completeness='complete',truncated=False,observed_at=m.now().isoformat(),data=data)
|
|
self.assertLess(len(advanced.canonical(data)),32768)
|
|
self.assertEqual(advanced.planning_from_device(dict(inventory=dict(observations=[observation]))),data)
|
|
|
|
def test_native_replay_program_compiles_and_keeps_same_result_attempt_and_grant(self):
|
|
actor=object.__new__(native.OwnedRuntime);actor.settings=self.settings()
|
|
checkpoint=dict(job_id='44444444-4444-4444-8444-444444444444',attempt_id='55555555-5555-4555-8555-555555555555')
|
|
actor.backend=SimpleNamespace(call=lambda *a:dict(state='succeeded'),counts=lambda *a:[1,1,1],sql=lambda *a:'1')
|
|
actor.server_state=lambda:dict(fingerprint='a'*64)
|
|
def capture(body):
|
|
compile(body,'<native-original-result-replay>','exec')
|
|
self.assertIn('SELECT envelope FROM reconcile_results',body)
|
|
self.assertIn('result=fields(outer[25][0])',body)
|
|
self.assertIn("server_hostname='rmm-dev.internal'",body)
|
|
self.assertNotIn('UPDATE ',body)
|
|
return dict(message_id='66666666-6666-4666-8666-666666666666')
|
|
actor.remote=capture
|
|
result=actor.replay_original_result(checkpoint)
|
|
self.assertTrue(result['regression_verified']);self.assertEqual(result['server_receipts'],1)
|
|
|
|
def test_runtime_readiness_script_is_effect_free_until_explicit_acquire(self):
|
|
actor=object.__new__(native.OwnedRuntime)
|
|
def capture(body):
|
|
compile(body,'<native-technical-inspect>','exec')
|
|
self.assertNotIn('prepare-baseline',body);self.assertNotIn('dpkg-query',body)
|
|
self.assertNotIn('systemctl\',\'start',body)
|
|
return dict(pid=0)
|
|
actor.remote=capture
|
|
self.assertEqual(actor.inspect(),dict(pid=0))
|
|
|
|
def test_root_requester_uses_human_UI_preparation_not_automation_scope_override(self):
|
|
settings=self.settings();job='44444444-4444-4444-8444-444444444444';attempt='55555555-5555-4555-8555-555555555555'
|
|
operation='66666666-6666-4666-8666-666666666666';raw=b'{"fixture":true}';hash_value=hashlib.sha256(raw).hexdigest()
|
|
plan=dict(plan_hash=hash_value,plan_payload_bytes=list(raw),jobs=[dict(job_id=job,attempt_id=attempt,
|
|
agent_id=settings['agent_id'],asset_id=settings['asset_id'],job_payload_hash='a'*64,payload=dict(execution_identity='root'))])
|
|
pending=dict(operation_id=operation,approval_state='pending_approval',job_count=0,execution_state=None)
|
|
calls=[]
|
|
def call(name,args):
|
|
calls.append(name);self.assertEqual(name,'jobs.get')
|
|
return dict(plan_hash=hash_value,approval_state='pending_approval')
|
|
backend=SimpleNamespace(call=call,counts=lambda *a:[0,0,0])
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
folder=Path(folder)
|
|
def browser(argv,**kwargs):
|
|
if '--prepare-only' in argv:
|
|
m.write_private(folder/'service_start-prepared.json',dict(plan=plan,operation=pending))
|
|
else:
|
|
checkpoint=m.protected_json(folder/'service_start-checkpoint.json')
|
|
self.assertEqual(checkpoint['job_id'],job)
|
|
return SimpleNamespace(returncode=0)
|
|
with patch.object(advanced.subprocess,'run',side_effect=browser):
|
|
result=advanced.authorize(backend,settings,self.artifact(),'service_start',folder,m.case_input('service_start',settings))
|
|
self.assertEqual(result['operation_id'],operation)
|
|
self.assertEqual(calls,['jobs.get'])
|
|
|
|
def test_apt_profile_cannot_hide_consumption_in_a_private_ledger_copy(self):
|
|
actor=object.__new__(native.OwnedRuntime)
|
|
common=dict(ledger_device=1,ledger_inode=2,lock_device=1,lock_inode=3)
|
|
actor.control_probe=lambda profile:dict(common,ledger_inode=4) if profile=='apt_only' else common
|
|
with self.assertRaisesRegex(m.GuardError,'exact_ledger'):actor.apt_probe()
|
|
actor.control_probe=lambda profile:common
|
|
self.assertEqual(actor.apt_probe(),common)
|
|
|
|
|
|
if __name__=='__main__':unittest.main()
|