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