179 lines
10 KiB
Python
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()
|