Files
MeltMind/tests/test_track_b_gino_greif_drive_acl.py
T

179 lines
10 KiB
Python

"""CPU replay of independent local scoring and the complete Drive gate."""
from contextlib import contextmanager, ExitStack
import hashlib
from pathlib import Path
from tempfile import TemporaryDirectory
import unittest
from unittest.mock import patch
import track_b_gino_greif_custody as custody
import track_b_gino_greif_drive_acl as acl
import track_b_gino_greif_entry as entry
from track_b_gino_shapenet_entry import read, save, sha
EVIDENCE = {}
OWNER_EMAIL = 'fixture-owner@example.invalid'
ARCHIVE_ID = 'fixture-archive'
CASE = 'synthetic_part'
PROJECT = dict(private_drive_folder_id=acl.PROJECT_FOLDER)
@contextmanager
def replay():
with TemporaryDirectory() as folder, ExitStack() as stack:
root = Path(folder)
for name in ('contract.json','models-frozen.json','predictions-frozen.json'):
save(root/name,{})
archive = root/'gino-greif-models-and-predictions.zip'
archive.write_bytes(b'synthetic immutable archive')
digest, size = sha(archive), archive.stat().st_size
bundle = dict(path=str(archive),sha256=digest,bytes=size,contract_sha256=sha(root/'contract.json'),
model_index_sha256=sha(root/'models-frozen.json'),prediction_index_sha256=sha(root/'predictions-frozen.json'))
save(root/'drive-upload-index.json',bundle)
compare, reference = root/'comparison.json', root/'reference.json'
save(reference,dict(status='COMPLETE',rows=[dict(case=CASE)]+[
dict(case=f'other-{i}') for i in range(551)]))
save(compare,dict(roster=[dict(case=CASE,fold=0)],h2_score=dict(path=str(reference),sha256=sha(reference))))
pilot, query = root/'pilot.json', root/'query.json'
save(pilot,{})
save(query,dict(rows=[dict(case=CASE,included=True)]))
pins={str(p):sha(p) for p in (pilot,query)}
c=dict(budgets={'score_cpu_seconds':3600},comparison_contract=str(compare),comparison_contract_sha256=sha(compare))
forecasts=[dict(case=CASE,fold=0,seed=s) for s in (0,1)]
owner=dict(id='fixture-owner-id',type='user',role='owner',emailAddress=OWNER_EMAIL)
outside=dict(id='foreign-id',type='user',role='reader',emailAddress='foreign@example.invalid',
permissionDetails=[dict(inherited=True,inheritedFrom=acl.PROJECT_MY_DRIVE_ROOT)])
linked=dict(id='anyone',type='anyone',role='reader',allowFileDiscovery=False)
queried=[]
state=dict(before='project',after='project')
def provider(path, args, token):
assert token=='fixture-token'
queried.append((path,args.get('pageToken')))
after_upload=(root/'drive-readback.json').exists()
mode=state['after' if after_upload else 'before']
if path.endswith('/permissions'):
assert args['includePermissionsForView']=='published'
if mode=='missing-permissions':
return {}
if mode=='anyone-link-page2' and path==ARCHIVE_ID+'/permissions':
if args.get('pageToken')=='page-two':
return dict(permissions=[linked])
return dict(permissions=[owner],nextPageToken='page-two')
if mode=='inherited-outside' and path==acl.PROJECT_MY_DRIVE_ROOT+'/permissions':
return dict(permissions=[owner,outside])
if mode=='domain' and path==ARCHIVE_ID+'/permissions':
return dict(permissions=[owner,dict(id='domain',type='domain',role='reader')])
return dict(permissions=[owner])
item=dict(id=path,ownedByMe=True,trashed=False,version='1',permissionIds=[owner['id']],mimeType=acl.FOLDER_TYPE)
if path==ARCHIVE_ID:
return dict(item,parents=[acl.PROJECT_FOLDER],mimeType='application/zip',size=str(size),sha256Checksum=digest)
if path==acl.PROJECT_FOLDER:
return dict(item,parents=[acl.PROJECT_MY_DRIVE_ROOT])
if path=='root':
return dict(item,id=acl.PROJECT_MY_DRIVE_ROOT)
raise AssertionError('Unexpected item beyond the fixed project chain')
stack.enter_context(patch.dict('os.environ',CUDA_VISIBLE_DEVICES=''))
custody.os.environ.pop(acl.TOKEN_FD,None)
stack.enter_context(patch.object(entry,'ROOT',root))
# No Drive authority field is supplied to the local scoring path.
stack.enter_context(patch.object(entry,'authorize',return_value=({},0.)))
for k,v in dict(PILOT=pilot,QUERY=query,PINS=pins).items():
stack.enter_context(patch.object(custody,k,v))
stack.enter_context(patch.object(custody,'frozen',return_value=([],forecasts)))
stack.enter_context(patch.object(custody.resource,'setrlimit'))
stack.enter_context(patch.object(acl,'PROJECT_OWNER_SHA256',hashlib.sha256(OWNER_EMAIL.encode()).hexdigest()))
stack.enter_context(patch.object(acl,'_get_json',side_effect=provider))
stack.enter_context(patch.object(custody,'summary',return_value={}))
targets=stack.enter_context(patch.object(custody,'target_array',return_value='synthetic target'))
def read_case(*_):
start=read(root/'score/custody-start.json')
assert start['model_manifest_sha256']==sha(root/'models-frozen.json')
assert start['manifest_sha256']==sha(root/'predictions-frozen.json')
targets({},CASE)
return {'case':CASE}
stack.enter_context(patch.object(custody,'one_case',side_effect=read_case))
def mark_uploaded():
# The legacy assertion is intentionally still present and is ignored.
save(root/'drive-readback.json',dict(sha256Checksum=digest,size=str(size),parent_id=acl.PROJECT_FOLDER,
file_id=ARCHIVE_ID,project_private=True,contract_sha256=bundle['contract_sha256']))
yield root,c,state,queried,targets,mark_uploaded
class CustodyACL(unittest.TestCase):
def test_scoring_with_no_drive_capability_or_receipts(self):
with replay() as (root,c,_,queried,targets,_):
self.assertEqual(custody.score(c),0)
targets.assert_called_once()
self.assertEqual(queried,[])
self.assertFalse((root/'drive-preflight.json').exists())
EVIDENCE['score_with_drive_unavailable']=dict(synthetic_target_reads=1,provider_queries=0)
def test_missing_or_external_parent_permission_stops_before_upload(self):
for mode in ('missing-permissions','inherited-outside'):
with self.subTest(mode=mode), replay() as (root,c,state,queried,targets,_):
state['before']=mode
with patch.object(acl,'_credential',return_value='fixture-token'):
self.assertEqual(custody.drive_preflight(c,PROJECT),1)
self.assertEqual(read(root/'drive-preflight.json')['status'],'HOLD_FURTHER_DRIVE_UPLOADS')
self.assertEqual(read(root/'drive-preflight-hold.json')['stage'],'BEFORE_UPLOAD')
self.assertFalse((root/'drive-readback.json').exists())
targets.assert_not_called()
EVIDENCE['before_'+mode]=dict(provider_queries=queried,upload_eligible=False)
def test_missing_archive_evidence_link_only_and_domain_stop_further_uploads(self):
for mode in ('missing-permissions','anyone-link-page2','domain','inherited-outside'):
with self.subTest(mode=mode), replay() as (root,c,state,queried,targets,mark_uploaded):
with patch.object(acl,'_credential',return_value='fixture-token'):
self.assertEqual(custody.drive_preflight(c,PROJECT),0)
state['after']=mode
mark_uploaded()
self.assertEqual(custody.drive_readback(c,PROJECT),1)
count=len(queried)
with self.assertRaises(PermissionError):
custody.drive_preflight(c,PROJECT)
self.assertEqual(len(queried),count)
if mode=='anyone-link-page2':
self.assertIn((ARCHIVE_ID+'/permissions','page-two'),queried)
self.assertTrue((root/'drive-readback.json').exists())
self.assertEqual(read(root/'drive-upload-hold.json')['stage'],'AFTER_UPLOAD')
self.assertFalse((root/'drive-upload-verified.json').exists())
targets.assert_not_called()
EVIDENCE['after_'+mode]=dict(further_uploads_blocked=True,evidence_retained=True,
provider_queries=queried)
def test_complete_private_project_folder_and_archive_acl_pass_both_checks(self):
with replay() as (root,c,_,queried,targets,mark_uploaded):
with patch.object(acl,'_credential',return_value='fixture-token'):
self.assertEqual(custody.drive_preflight(c,PROJECT),0)
before=read(root/'drive-preflight.json')
self.assertTrue(before['does_not_authorize_upload'])
self.assertEqual([row['file_id'] for row in before['drive']['chain']],
[acl.PROJECT_FOLDER,acl.PROJECT_MY_DRIVE_ROOT])
mark_uploaded()
self.assertEqual(custody.drive_readback(c,PROJECT),0)
evidence=read(root/'drive-upload-verified.json')
self.assertEqual(evidence['status'],'PRIVATE_DRIVE_ARCHIVE_VERIFIED')
self.assertEqual([r['file_id'] for r in evidence['chain']],
[ARCHIVE_ID,acl.PROJECT_FOLDER,acl.PROJECT_MY_DRIVE_ROOT])
self.assertEqual(evidence['sha256'],sha(root/'gino-greif-models-and-predictions.zip'))
targets.assert_not_called()
EVIDENCE['normal_private_archive']=dict(provider_queries=queried,verified=True)
def test_no_existing_transport_prevents_any_provider_attempt(self):
with replay() as (root,c,_,queried,targets,_):
self.assertEqual(custody.drive_preflight(c,PROJECT),1)
self.assertEqual(queried,[])
self.assertEqual(read(root/'drive-preflight-hold.json')['stage'],'BEFORE_UPLOAD')
targets.assert_not_called()
EVIDENCE['no_transport']=dict(provider_queries=0,upload_eligible=False)
if __name__=='__main__':
unittest.main()