Spaces:
Sleeping
Sleeping
File size: 6,883 Bytes
75835df | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 | import hashlib
import io
import json
import unittest
import zipfile
from pathlib import Path
from dataclasses import replace
from src.modules.artifact_catalog.java_dependencies import JavaArtifact,JavaDependencyGateway
from src.modules.skill.domain.models import SkillError
from src.tests.runtime.fixtures import workspace
from contextlib import contextmanager
class JavaDependencyTests(unittest.TestCase):
def setUp(self):
self.folder=Path(self.enterContext(workspace()))
self.payload=b'approved binary fixture; never executed'
self.item=JavaArtifact('demo:library:1.0',hashlib.sha512(self.payload).hexdigest(),'Apache-2.0',100)
self.catalog={self.item.coordinate:self.item}
def gateway(self,name='cache',**kw):
return JavaDependencyGateway(self.folder/name,self.catalog,**kw)
@contextmanager
def assertRaisesCode(self,code):
with self.assertRaises(SkillError) as raised:yield
self.assertEqual(raised.exception.code,code)
def test_online_materialize_downloads_fixed_coordinate_once_then_checks_cache(self):
calls=[]
gateway=self.gateway(fetch=lambda url,limit:(calls.append((url,limit)) or self.payload))
lock=gateway.resolve([self.item.coordinate])
gateway.materialize(lock);gateway.materialize(lock)
self.assertEqual(calls,[('https://repo.maven.apache.org/maven2/demo/library/1.0/library-1.0.jar',100)])
self.assertEqual(next(iter(gateway.materialize(lock).values())).read_bytes(),self.payload)
def test_same_lock_moves_to_internal_offline_cache_without_network(self):
online=self.gateway(fetch=lambda *_:self.payload)
lock=online.resolve([self.item.coordinate]);bundle=online.export_bundle(lock)
offline=self.gateway('intranet',repository='https://maven.internal.example/repository/approved',offline=True,
fetch=lambda *_:self.fail('Offline import attempted network'))
self.assertEqual(offline.import_bundle(bundle),lock)
self.assertEqual(offline.resolve([self.item.coordinate]),lock)
self.assertEqual(next(iter(offline.materialize(lock).values())).read_bytes(),self.payload)
def test_tampered_download_and_cached_binary_are_rejected(self):
gateway=self.gateway(fetch=lambda *_:b'tampered')
lock=gateway.resolve([self.item.coordinate])
with self.assertRaisesCode('DEPENDENCY_INTEGRITY_FAILED'):gateway.materialize(lock)
path=gateway.seed(self.item.coordinate,self.payload);path.write_bytes(b'tampered')
with self.assertRaisesCode('DEPENDENCY_INTEGRITY_FAILED'):gateway.materialize(lock)
def test_offline_miss_never_falls_back_to_public_repository(self):
gateway=self.gateway(offline=True,fetch=lambda *_:self.fail('Network fallback'))
with self.assertRaisesCode('DEPENDENCY_NOT_CACHED'):gateway.materialize(gateway.resolve([self.item.coordinate]))
def test_unknown_floating_and_path_coordinates_are_rejected(self):
gateway=self.gateway()
with self.assertRaisesCode('DEPENDENCY_NOT_APPROVED'):gateway.resolve(['other:library:1.0'])
for coordinate in ['demo:library:LATEST','demo:library:1-SNAPSHOT','../demo:library:1.0']:
with self.subTest(coordinate=coordinate),self.assertRaisesCode('DEPENDENCY_DESCRIPTOR_INVALID'):
replace(self.item,coordinate=coordinate).parts()
for roots in [None,'demo:library:1.0',[],[None]]:
with self.subTest(roots=roots),self.assertRaisesCode('DEPENDENCY_REQUEST_INVALID'):gateway.resolve(roots)
def test_complete_closure_detects_version_conflicts_and_cycles(self):
parent=replace(self.item,coordinate='demo:parent:1.0',dependencies=('demo:library:1.0','demo:library:2.0'))
self.catalog.update({parent.coordinate:parent,'demo:library:2.0':replace(self.item,coordinate='demo:library:2.0')})
with self.assertRaisesCode('DEPENDENCY_VERSION_CONFLICT'):self.gateway().resolve([parent.coordinate])
self.catalog={parent.coordinate:replace(parent,dependencies=(parent.coordinate,))}
with self.assertRaisesCode('DEPENDENCY_CYCLE'):self.gateway().resolve([parent.coordinate])
def test_lock_cannot_add_arbitrary_files_or_change_checksums(self):
gateway=self.gateway();lock=gateway.resolve([self.item.coordinate]);lock['artifacts'][0]['sha512']='0'*128
with self.assertRaisesCode('DEPENDENCY_LOCK_INVALID'):gateway.materialize(lock)
def test_malformed_extra_and_corrupted_bundle_are_rejected_before_cache_write(self):
gateway=self.gateway()
for payload in [b'not zip',self.bundle({'dependency-lock.json':b'{}'}),self.bundle({'../escape.jar':b'bad'})]:
with self.subTest(payload=payload[:12]),self.assertRaises(SkillError):gateway.import_bundle(payload)
lock=gateway.resolve([self.item.coordinate])
for entries in [
{'dependency-lock.json':json.dumps(lock).encode(),'artifacts/'+self.item.sha512+'.jar':b'tampered'},
{'dependency-lock.json':json.dumps(lock).encode(),'artifacts/'+self.item.sha512+'.jar':self.payload,'extra':b'bad'}]:
with self.assertRaises(SkillError):gateway.import_bundle(self.bundle(entries))
self.assertEqual(list(gateway.cache.iterdir()),[])
@staticmethod
def bundle(entries):
output=io.BytesIO()
with zipfile.ZipFile(output,'w') as archive:
for path,payload in entries.items():archive.writestr(path,payload)
return output.getvalue()
def test_repositories_and_distribution_paths_are_server_policy(self):
for url in ['http://repo.example','https://user:secret@repo.example','https://repo.example/?token=x']:
with self.assertRaisesCode('DEPENDENCY_REPOSITORY_DENIED'):self.gateway(repository=url)
for path in ['../escape.jar','/absolute.jar','https://elsewhere/x.jar']:
self.catalog={self.item.coordinate:replace(self.item,distribution_path=path)}
gateway=self.gateway(layout='distribution',fetch=lambda *_:self.fail('Unapproved path downloaded'))
with self.assertRaisesCode('DEPENDENCY_SOURCE_NOT_CONFIGURED'):gateway.materialize(gateway.resolve([self.item.coordinate]))
def test_identical_binary_in_two_coordinates_is_exported_once(self):
alias=replace(self.item,coordinate='demo:alias:1.0');self.catalog[alias.coordinate]=alias
gateway=self.gateway(fetch=lambda *_:self.payload);lock=gateway.resolve(list(self.catalog))
bundle=gateway.export_bundle(lock)
with zipfile.ZipFile(io.BytesIO(bundle)) as archive:self.assertEqual(len(archive.namelist()),2)
self.assertEqual(self.gateway('target',offline=True).import_bundle(bundle),lock)
if __name__=='__main__':unittest.main()
|