Chromium Code Reviews| 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 |