OLD | NEW |
---|---|
(Empty) | |
1 # Copyright 2014 The Chromium Authors. All rights reserved. | |
2 # Use of this source code is governed by a BSD-style license that can be | |
3 # found in the LICENSE file. | |
4 | |
5 import datetime | |
6 | |
7 from testing_utils import testing | |
8 | |
9 from components import auth | |
10 from components import auth_testing | |
11 from components import utils | |
12 | |
13 from cipd import api | |
14 from cipd import impl | |
15 | |
16 | |
17 class TestSerialization(testing.AppengineTestCase): | |
18 def test_metadata_from_entity(self): | |
19 ent = impl.PackageInstanceMetadata( | |
20 date='Jan 1 2014', | |
21 hostname='hostname', | |
22 user='user', | |
23 registered_by=auth.Identity.from_bytes('user:abc@example.com'), | |
24 registered_ts=datetime.datetime(2014, 1, 1)) | |
25 msg = api.metadata_from_entity(ent) | |
26 self.assertEqual('Jan 1 2014', msg.date) | |
27 self.assertEqual('hostname', msg.hostname) | |
28 self.assertEqual('user', msg.user) | |
29 self.assertEqual('user:abc@example.com', msg.registered_by) | |
30 self.assertEqual(1388534400000000, msg.registered_ts) | |
31 | |
32 def test_metadata_to_entity(self): | |
33 msg = api.InstanceMetadata( | |
34 date='Jan 1 2014', | |
35 hostname='hostname', | |
36 user='user', | |
37 registered_by='user:abc@example.com', | |
38 registered_ts=1388534400000000) | |
39 ent = api.metadata_to_entity(msg) | |
40 # Ignores registered_* fields, they are output only. | |
41 expected = { | |
42 'date': 'Jan 1 2014', | |
43 'hostname': 'hostname', | |
44 'user': 'user', | |
45 'registered_by': None, | |
46 'registered_ts': None, | |
47 } | |
48 self.assertEqual(expected, ent.to_dict()) | |
49 | |
50 def test_signature_from_entity(self): | |
51 ent = impl.PackageInstanceSignature( | |
52 hash_algo='SHA1', | |
53 digest='\x00\x01\x02\x03\x04\x05', | |
54 signature_algo='sig algo', | |
55 signature_key='sig key', | |
56 signature='signature \x00\x01\x02\x03\x04\x05', | |
57 added_by=auth.Identity.from_bytes('user:abc@example.com'), | |
58 added_ts=datetime.datetime(2014, 1, 1)) | |
59 msg = api.signature_from_entity(ent) | |
60 self.assertEqual('SHA1', msg.hash_algo) | |
61 self.assertEqual('\x00\x01\x02\x03\x04\x05', msg.digest) | |
62 self.assertEqual('sig algo', msg.signature_algo) | |
63 self.assertEqual('sig key', msg.signature_key) | |
64 self.assertEqual('signature \x00\x01\x02\x03\x04\x05', msg.signature) | |
65 self.assertEqual('user:abc@example.com', msg.added_by) | |
66 self.assertEqual(1388534400000000, msg.added_ts) | |
67 | |
68 def test_signature_to_entity(self): | |
69 msg = api.Signature( | |
70 hash_algo='SHA1', | |
71 digest='\x00\x01\x02\x03\x04\x05', | |
72 signature_algo='sig algo', | |
73 signature_key='sig key', | |
74 signature='signature \x00\x01\x02\x03\x04\x05', | |
75 added_by='user:abc@example.com', | |
76 added_ts=1388534400000000) | |
77 ent = api.signature_to_entity(msg) | |
78 # Ignores added_* fields, they are output only. | |
79 expected = { | |
80 'hash_algo': 'SHA1', | |
81 'digest': '\x00\x01\x02\x03\x04\x05', | |
82 'signature_algo': 'sig algo', | |
83 'signature_key': 'sig key', | |
84 'signature': 'signature \x00\x01\x02\x03\x04\x05', | |
85 'added_by': None, | |
86 'added_ts': None, | |
87 } | |
88 self.assertEqual(expected, ent.to_dict()) | |
89 | |
90 | |
91 class PackageRepositoryApiTest(testing.EndpointsTestCase): | |
92 """Tests for API layer ONLY.""" | |
93 | |
94 api_service_cls = api.PackageRepositoryApi | |
95 | |
96 fake_metadata = { | |
97 'date': 'Jan 1 2014', | |
98 'hostname': 'hostname', | |
99 'user': 'user', | |
100 } | |
101 | |
102 def setUp(self): | |
103 super(PackageRepositoryApiTest, self).setUp() | |
104 auth_testing.mock_get_current_identity(self) | |
105 auth_testing.mock_is_admin(self) | |
106 self.repo_service = MockedRepoService() | |
107 def mocked_get_repo_service(): | |
108 return self.repo_service | |
109 self.mock(impl, 'get_repo_service', mocked_get_repo_service) | |
nodir
2014/12/30 22:54:01
lambda: self.repo_service
would fit
Vadim Sh.
2014/12/31 01:27:36
Done.
| |
110 | |
111 def test_register_new_package_flow(self): | |
112 self.mock(utils, 'utcnow', lambda: datetime.datetime(2014, 1, 1)) | |
113 request = { | |
114 'package_name': 'good/name', | |
115 'instance_id': 'a'*40, | |
116 'metadata': self.fake_metadata, | |
117 'signatures': [ | |
118 { | |
119 'hash_algo': 'SHA1', | |
120 'digest': 'AAECAwQ=', | |
121 'signature_algo': 'sig algo', | |
122 'signature_key': 'sig key 1', | |
123 'signature': 'c2lnbmF0dXJlIAABAgME', | |
124 }, | |
125 { | |
126 'hash_algo': 'SHA1', | |
127 'digest': 'AAECAwQ=', | |
128 'signature_algo': 'sig algo', | |
129 'signature_key': 'sig key 2', | |
130 'signature': 'c2lnbmF0dXJlIAABAgME', | |
131 }, | |
132 ], | |
133 } | |
134 | |
135 # Package is not uploaded yet. Should ask to upload. | |
136 resp = self.call_api('register_package', request) | |
137 self.assertEqual(200, resp.status_code) | |
138 self.assertEqual({ | |
139 'status': 'UPLOAD_FIRST', | |
140 'upload_session_id': 'upload_session_id', | |
141 'upload_url': 'http://upload_url', | |
142 }, resp.json_body) | |
143 | |
144 # Pretend it is upload now. | |
145 self.repo_service.uploaded.add('a'*40) | |
146 | |
147 # Should register the package. | |
148 resp = self.call_api('register_package', request) | |
149 self.assertEqual(200, resp.status_code) | |
150 self.assertEqual({ | |
151 'status': 'REGISTERED', | |
152 'metadata': { | |
153 'date': 'Jan 1 2014', | |
154 'hostname': 'hostname', | |
155 'user': 'user', | |
156 'registered_by': 'user:mocked@example.com', | |
157 'registered_ts': '1388534400000000', | |
158 }, | |
159 }, resp.json_body) | |
160 | |
161 # Check that it is indeed there. | |
162 pkg = self.repo_service.get_instance('good/name', 'a'*40) | |
163 self.assertTrue(pkg) | |
164 expected = { | |
165 'metadata': { | |
166 'date': 'Jan 1 2014', | |
167 'hostname': 'hostname', | |
168 'user': 'user', | |
169 'registered_by': auth.Identity(kind='user', name='mocked@example.com'), | |
170 'registered_ts': datetime.datetime(2014, 1, 1, 0, 0), | |
171 }, | |
172 'signature_ids': ['SHA1:sig algo:sig key 1', 'SHA1:sig algo:sig key 2'], | |
173 'signatures': [ | |
174 { | |
175 'added_by': auth.Identity(kind='user', name='mocked@example.com'), | |
176 'added_ts': datetime.datetime(2014, 1, 1, 0, 0), | |
177 'digest': '\x00\x01\x02\x03\x04', | |
178 'hash_algo': 'SHA1', | |
179 'signature': 'signature \x00\x01\x02\x03\x04', | |
180 'signature_algo': 'sig algo', | |
181 'signature_key': 'sig key 1', | |
182 }, | |
183 { | |
184 'added_by': auth.Identity(kind='user', name='mocked@example.com'), | |
185 'added_ts': datetime.datetime(2014, 1, 1, 0, 0), | |
186 'digest': '\x00\x01\x02\x03\x04', | |
187 'hash_algo': 'SHA1', | |
188 'signature': 'signature \x00\x01\x02\x03\x04', | |
189 'signature_algo': 'sig algo', | |
190 'signature_key': 'sig key 2', | |
191 }, | |
192 ], | |
193 } | |
194 self.assertEqual(expected, pkg.to_dict()) | |
195 | |
196 # Attempt to register it again, with additional signature. | |
197 request['signatures'].append({ | |
198 'hash_algo': 'SHA1', | |
199 'digest': 'AAECAwQ=', | |
200 'signature_algo': 'sig algo', | |
201 'signature_key': 'sig key 3', | |
202 'signature': 'c2lnbmF0dXJlIAABAgME', | |
203 }) | |
204 resp = self.call_api('register_package', request) | |
205 self.assertEqual(200, resp.status_code) | |
206 self.assertEqual({ | |
207 'status': 'ALREADY_REGISTERED', | |
208 'metadata': { | |
209 'date': 'Jan 1 2014', | |
210 'hostname': 'hostname', | |
211 'user': 'user', | |
212 'registered_by': 'user:mocked@example.com', | |
213 'registered_ts': '1388534400000000', | |
214 }, | |
215 }, resp.json_body) | |
216 | |
217 # The signature is added to the list. | |
218 pkg = self.repo_service.get_instance('good/name', 'a'*40) | |
219 self.assertTrue(pkg) | |
220 self.assertEqual(3, len(pkg.signatures)) | |
221 | |
222 def test_register_package_bad_name(self): | |
223 with self.call_should_fail(400): | |
224 self.call_api('register_package', { | |
225 'package_name': 'bad name', | |
226 'instance_id': 'a'*40, | |
227 'metadata': self.fake_metadata, | |
228 }) | |
229 | |
230 def test_register_package_bad_instance_id(self): | |
231 with self.call_should_fail(400): | |
232 self.call_api('register_package', { | |
233 'package_name': 'good/name', | |
234 'instance_id': 'bad instance id', | |
235 'metadata': self.fake_metadata, | |
236 }) | |
237 | |
238 def test_register_package_no_access(self): | |
239 self.mock(api.acl, 'can_register_package', lambda *_: False) | |
240 with self.call_should_fail(403): | |
241 self.call_api('register_package', { | |
242 'package_name': 'good/name', | |
243 'instance_id': 'a'*40, | |
244 'metadata': self.fake_metadata, | |
245 }) | |
246 | |
247 def test_register_package_no_service(self): | |
248 self.repo_service = None | |
249 with self.call_should_fail(500): | |
250 self.call_api('register_package', { | |
251 'package_name': 'good/name', | |
252 'instance_id': 'a'*40, | |
253 'metadata': self.fake_metadata, | |
254 }) | |
255 | |
256 | |
257 class MockedRepoService(impl.RepoService): | |
258 """Almost like a real one, except CAS part is stubbed.""" | |
259 | |
260 def __init__(self): | |
261 super(MockedRepoService, self).__init__(None) | |
262 self.uploaded = set() | |
263 | |
264 def is_data_uploaded(self, package_name, instance_id): | |
265 return instance_id in self.uploaded | |
266 | |
267 def create_upload_session(self, package_name, instance_id, caller): | |
268 return 'http://upload_url', 'upload_session_id' | |
OLD | NEW |