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()