blob: 9f1e2648c0684b64f55bb40bbe2f5abde52c92d2 [file] [log] [blame]
Alex Kleineb77ffa2019-05-28 14:47:44 -06001# -*- coding: utf-8 -*-
2# Copyright 2019 The Chromium OS Authors. All rights reserved.
3# Use of this source code is governed by a BSD-style license that can be
4# found in the LICENSE file.
5
6"""Packages service tests."""
7
8from __future__ import print_function
9
Andrew Lamb2bde9e42019-11-04 13:24:09 -070010import json
11import os
Michael Mortensen009cb662019-10-21 11:38:43 -060012import re
13
Andrew Lamb2bde9e42019-11-04 13:24:09 -070014from google.protobuf import json_format
15from google.protobuf.field_mask_pb2 import FieldMask
16
17from chromite.api.gen.config.replication_config_pb2 import (
18 ReplicationConfig, FileReplicationRule, FILE_TYPE_JSON,
19 REPLICATION_TYPE_FILTER
20)
Michael Mortensen009cb662019-10-21 11:38:43 -060021from chromite.cbuildbot import manifest_version
Alex Kleineb77ffa2019-05-28 14:47:44 -060022from chromite.lib import build_target_util
Andrew Lamb2bde9e42019-11-04 13:24:09 -070023from chromite.lib import constants
Michael Mortensene0f4b542019-10-24 15:30:23 -060024from chromite.lib import cros_build_lib
Alex Kleineb77ffa2019-05-28 14:47:44 -060025from chromite.lib import cros_test_lib
Michael Mortensenb70e8a82019-10-10 18:43:41 -060026from chromite.lib import osutils
Alex Klein87531182019-08-12 15:23:37 -060027from chromite.lib import portage_util
28from chromite.lib.chroot_lib import Chroot
Andrew Lamb2bde9e42019-11-04 13:24:09 -070029from chromite.lib.uprev_lib import GitRef
Alex Kleineb77ffa2019-05-28 14:47:44 -060030from chromite.service import packages
31
Andrew Lamb2bde9e42019-11-04 13:24:09 -070032D = cros_test_lib.Directory
33
Alex Kleineb77ffa2019-05-28 14:47:44 -060034
Alex Klein4de25e82019-08-05 15:58:39 -060035class UprevAndroidTest(cros_test_lib.RunCommandTestCase):
36 """Uprev android tests."""
37
38 def test_success(self):
39 """Test successful run handling."""
40 self.PatchObject(packages, '_parse_android_atom',
41 return_value='ANDROID_ATOM=android/android-1.0')
42
43 build_targets = [build_target_util.BuildTarget(t) for t in ['foo', 'bar']]
44
45 packages.uprev_android('refs/tracking-branch', 'android/package',
46 'refs/android-build-branch', Chroot(),
47 build_targets=build_targets)
48 self.assertCommandContains(['cros_mark_android_as_stable',
49 '--boards=foo:bar'])
50 self.assertCommandContains(['emerge-foo'])
51 self.assertCommandContains(['emerge-bar'])
52
53 def test_no_uprev(self):
54 """Test no uprev handling."""
55 self.PatchObject(packages, '_parse_android_atom', return_value=None)
56 build_targets = [build_target_util.BuildTarget(t) for t in ['foo', 'bar']]
57 packages.uprev_android('refs/tracking-branch', 'android/package',
58 'refs/android-build-branch', Chroot(),
59 build_targets=build_targets)
60
61 self.assertCommandContains(['cros_mark_android_as_stable',
62 '--boards=foo:bar'])
63 self.assertCommandContains(['emerge-foo'], expected=False)
64 self.assertCommandContains(['emerge-bar'], expected=False)
65
66
Alex Kleineb77ffa2019-05-28 14:47:44 -060067class UprevBuildTargetsTest(cros_test_lib.RunCommandTestCase):
68 """uprev_build_targets tests."""
69
70 def test_invalid_type_fails(self):
71 """Test invalid type fails."""
72 with self.assertRaises(AssertionError):
73 packages.uprev_build_targets([build_target_util.BuildTarget('foo')],
74 'invalid')
75
76 def test_none_type_fails(self):
77 """Test None type fails."""
78 with self.assertRaises(AssertionError):
79 packages.uprev_build_targets([build_target_util.BuildTarget('foo')],
80 None)
81
82
Alex Klein87531182019-08-12 15:23:37 -060083class UprevsVersionedPackageTest(cros_test_lib.MockTestCase):
84 """uprevs_versioned_package decorator test."""
85
86 @packages.uprevs_versioned_package('category/package')
87 def uprev_category_package(self, *args, **kwargs):
88 """Registered function for testing."""
89
90 def test_calls_function(self):
91 """Test calling a registered function."""
92 patch = self.PatchObject(self, 'uprev_category_package')
93
94 cpv = portage_util.SplitCPV('category/package', strict=False)
95 packages.uprev_versioned_package(cpv, [], [], Chroot())
96
97 patch.assert_called()
98
99 def test_unregistered_package(self):
100 """Test calling with an unregistered package."""
101 cpv = portage_util.SplitCPV('does-not/exist', strict=False)
102
103 with self.assertRaises(packages.UnknownPackageError):
104 packages.uprev_versioned_package(cpv, [], [], Chroot())
105
106
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700107class ReplicatePrivateConfigTest(cros_test_lib.MockTempDirTestCase):
108 """replicate_private_config tests."""
109
110 def setUp(self):
111 # Set up fake public and private chromeos-config overlays.
112 private_package_root = (
113 'overlay-coral-private/chromeos-base/chromeos-config-bsp-coral-private')
114 self.public_package_root = (
115 'overlay-coral/chromeos-base/chromeos-config-bsp-coral')
116 file_layout = (
117 D(os.path.join(private_package_root, 'files'), ['build_config.json']),
118 D(private_package_root, ['replication_config.jsonpb']),
119 D(
120 os.path.join(self.public_package_root, 'files'),
121 ['build_config.json']),
122 )
123
124 cros_test_lib.CreateOnDiskHierarchy(self.tempdir, file_layout)
125
126 # Private config contains 'a' and 'b' fields.
Andrew Lambca1f35b2019-12-04 09:37:11 -0700127 private_config_path = os.path.join(private_package_root, 'files',
128 'build_config.json')
129 self.WriteTempFile(
130 private_config_path,
131 json.dumps({'chromeos': {
132 'configs': [{
133 'a': 3,
134 'b': 2
135 }]
136 }}))
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700137
138 # Public config only contains the 'a' field. Note that the value of 'a' is
139 # 1 in the public config; it will get updated to 3 when the private config
140 # is replicated.
Andrew Lambca1f35b2019-12-04 09:37:11 -0700141 self.public_config_path = os.path.join(self.public_package_root, 'files',
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700142 'build_config.json')
Andrew Lambca1f35b2019-12-04 09:37:11 -0700143 self.WriteTempFile(self.public_config_path,
144 json.dumps({'chromeos': {
145 'configs': [{
146 'a': 1
147 }]
148 }}))
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700149
150 # Put a ReplicationConfig JSONPB in the private package. Note that it
151 # specifies only the 'a' field is replicated.
152 self.replication_config_path = os.path.join(self.tempdir,
153 private_package_root,
154 'replication_config.jsonpb')
155 replication_config = ReplicationConfig(file_replication_rules=[
156 FileReplicationRule(
157 source_path=private_config_path,
158 destination_path=self.public_config_path,
159 file_type=FILE_TYPE_JSON,
160 replication_type=REPLICATION_TYPE_FILTER,
161 destination_fields=FieldMask(paths=['a']))
162 ])
163
164 osutils.WriteFile(self.replication_config_path,
165 json_format.MessageToJson(replication_config))
166 self.PatchObject(constants, 'SOURCE_ROOT', new=self.tempdir)
167
168 def test_replicate_private_config(self):
169 """Basic replication test."""
170 refs = [GitRef(path='overlay-coral-private', ref='master', revision='123')]
171 result = packages.replicate_private_config(
172 _build_targets=None, refs=refs, _chroot=None)
173
174 self.assertEqual(len(result.modified), 1)
175 # The public build_config.json was modified.
176 self.assertEqual(result.modified[0].files, [self.public_config_path])
177 self.assertEqual(result.modified[0].new_version, '123')
178
179 # The update from the private build_config.json was copied to the public.
180 # Note that only the 'a' field is present, as per destination_fields.
Andrew Lambca1f35b2019-12-04 09:37:11 -0700181 self.assertEqual(
182 json.loads(self.ReadTempFile(self.public_config_path)),
183 {'chromeos': {
184 'configs': [{
185 'a': 3
186 }]
187 }})
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700188
189 def test_replicate_private_config_wrong_number_of_refs(self):
190 """An error is thrown if there is not exactly one ref."""
191 with self.assertRaisesRegex(ValueError, 'Expected exactly one ref'):
192 packages.replicate_private_config(
193 _build_targets=None, refs=[], _chroot=None)
194
195 with self.assertRaisesRegex(ValueError, 'Expected exactly one ref'):
196 refs = [
197 GitRef(path='a', ref='master', revision='1'),
198 GitRef(path='a', ref='master', revision='2')
199 ]
200 packages.replicate_private_config(
201 _build_targets=None, refs=refs, _chroot=None)
202
203 def test_replicate_private_config_replication_config_missing(self):
204 """An error is thrown if there is not a replication config."""
205 os.remove(self.replication_config_path)
206 with self.assertRaisesRegex(
207 ValueError, 'Expected ReplicationConfig missing at %s' %
208 self.replication_config_path):
209 refs = [
210 GitRef(path='overlay-coral-private', ref='master', revision='123')
211 ]
212 packages.replicate_private_config(
213 _build_targets=None, refs=refs, _chroot=None)
214
215
Alex Kleinda39c6d2019-09-16 14:36:36 -0600216class GetBestVisibleTest(cros_test_lib.TestCase):
David Burger1e0fe232019-07-01 14:52:07 -0600217 """get_best_visible tests."""
218
219 def test_empty_atom_fails(self):
220 with self.assertRaises(AssertionError):
221 packages.get_best_visible('')
Alex Kleinda39c6d2019-09-16 14:36:36 -0600222
223
224class HasPrebuiltTest(cros_test_lib.TestCase):
225 """has_prebuilt tests."""
226
227 def test_empty_atom_fails(self):
228 with self.assertRaises(AssertionError):
229 packages.has_prebuilt('')
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600230
231
232class AndroidVersionsTest(cros_test_lib.MockTestCase):
233 """Tests getting android versions."""
Michael Mortensen14960d02019-10-18 07:53:59 -0600234
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600235 def setUp(self):
236 package_result = [
237 'chromeos-base/android-container-nyc-4717008-r1',
238 'chromeos-base/update_engine-0.0.3-r3408']
239 self.PatchObject(portage_util, 'GetPackageDependencies',
240 return_value=package_result)
241 self.board = 'board'
242 self.PatchObject(portage_util, 'FindEbuildForBoardPackage',
243 return_value='chromeos-base/android-container-nyc')
244 FakeEnvironment = {
245 'ARM_TARGET': '3-linux-target'
246 }
247 self.PatchObject(osutils, 'SourceEnvironment',
248 return_value=FakeEnvironment)
249
250 def test_determine_android_version(self):
Michael Mortensen14960d02019-10-18 07:53:59 -0600251 """Tests that a valid android version is returned."""
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600252 version = packages.determine_android_version(self.board)
253 self.assertEqual(version, '4717008')
254
Michael Mortensenedf76532019-10-16 14:22:37 -0600255 def test_determine_android_version_when_not_present(self):
Michael Mortensen14960d02019-10-18 07:53:59 -0600256 """Tests that a None is returned for version when android is not present."""
Michael Mortensenedf76532019-10-16 14:22:37 -0600257 package_result = ['chromeos-base/update_engine-0.0.3-r3408']
258 self.PatchObject(portage_util, 'GetPackageDependencies',
259 return_value=package_result)
260 version = packages.determine_android_version(self.board)
261 self.assertEqual(version, None)
262
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600263 def test_determine_android_branch(self):
Michael Mortensen14960d02019-10-18 07:53:59 -0600264 """Tests that a valid android branch is returned."""
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600265 branch = packages.determine_android_branch(self.board)
266 self.assertEqual(branch, '3')
267
Michael Mortensenedf76532019-10-16 14:22:37 -0600268 def test_determine_android_branch_when_not_present(self):
Michael Mortensen14960d02019-10-18 07:53:59 -0600269 """Tests that a None is returned for branch when android is not present."""
Michael Mortensenedf76532019-10-16 14:22:37 -0600270 package_result = ['chromeos-base/update_engine-0.0.3-r3408']
271 self.PatchObject(portage_util, 'GetPackageDependencies',
272 return_value=package_result)
273 branch = packages.determine_android_branch(self.board)
274 self.assertEqual(branch, None)
275
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600276 def test_determine_android_target(self):
Michael Mortensen14960d02019-10-18 07:53:59 -0600277 """Tests that a valid android target is returned."""
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600278 target = packages.determine_android_target(self.board)
279 self.assertEqual(target, 'cheets')
Michael Mortensenc2615b72019-10-15 08:12:24 -0600280
Michael Mortensenedf76532019-10-16 14:22:37 -0600281 def test_determine_android_target_when_not_present(self):
Michael Mortensen14960d02019-10-18 07:53:59 -0600282 """Tests that a None is returned for target when android is not present."""
Michael Mortensenedf76532019-10-16 14:22:37 -0600283 package_result = ['chromeos-base/update_engine-0.0.3-r3408']
284 self.PatchObject(portage_util, 'GetPackageDependencies',
285 return_value=package_result)
286 target = packages.determine_android_target(self.board)
287 self.assertEqual(target, None)
288
Michael Mortensene0f4b542019-10-24 15:30:23 -0600289 def test_determine_android_version_handle_exception(self):
290 """Tests handling RunCommandError inside determine_android_version."""
291 # Mock what happens when portage returns that bubbles up (via RunCommand)
292 # inside portage_util.GetPackageDependencies.
293 self.PatchObject(portage_util, 'GetPackageDependencies',
294 side_effect=cros_build_lib.RunCommandError('error'))
295 target = packages.determine_android_version(self.board)
296 self.assertEqual(target, None)
297
298 def test_determine_android_package_handle_exception(self):
299 """Tests handling RunCommandError inside determine_android_package."""
300 # Mock what happens when portage returns that bubbles up (via RunCommand)
301 # inside portage_util.GetPackageDependencies.
302 self.PatchObject(portage_util, 'GetPackageDependencies',
303 side_effect=cros_build_lib.RunCommandError('error'))
304 target = packages.determine_android_package(self.board)
305 self.assertEqual(target, None)
306
Michael Mortensen9fe740c2019-10-29 14:42:48 -0600307 def test_determine_android_package_callers_handle_exception(self):
308 """Tests handling RunCommandError by determine_android_package callers."""
309 # Mock what happens when portage returns that bubbles up (via RunCommand)
310 # inside portage_util.GetPackageDependencies.
311 self.PatchObject(portage_util, 'GetPackageDependencies',
312 side_effect=cros_build_lib.RunCommandError('error'))
313 # Verify that target is None, as expected.
314 target = packages.determine_android_package(self.board)
315 self.assertEqual(target, None)
316 # determine_android_branch calls determine_android_package
317 branch = packages.determine_android_branch(self.board)
318 self.assertEqual(branch, None)
319 # determine_android_target calls determine_android_package
320 target = packages.determine_android_target(self.board)
321 self.assertEqual(target, None)
322
Michael Mortensene0f4b542019-10-24 15:30:23 -0600323
Michael Mortensenc2615b72019-10-15 08:12:24 -0600324class ChromeVersionsTest(cros_test_lib.MockTestCase):
325 """Tests getting chrome version."""
Michael Mortensen14960d02019-10-18 07:53:59 -0600326
Michael Mortensenc2615b72019-10-15 08:12:24 -0600327 def setUp(self):
Michael Mortensenb51a1f02019-10-16 13:28:20 -0600328 self.build_target = build_target_util.BuildTarget('board')
Michael Mortensenc2615b72019-10-15 08:12:24 -0600329
330 def test_determine_chrome_version(self):
Michael Mortensen14960d02019-10-18 07:53:59 -0600331 """Tests that a valid chrome version is returned."""
Michael Mortensenc2615b72019-10-15 08:12:24 -0600332 # Mock PortageqBestVisible to return a valid chrome version string.
333 r1_cpf = 'chromeos-base/chromeos-chrome-78.0.3900.0_rc-r1'
334 r1_cpv = portage_util.SplitCPV(r1_cpf)
335 self.PatchObject(portage_util, 'PortageqBestVisible',
336 return_value=r1_cpv)
337
Michael Mortensenb51a1f02019-10-16 13:28:20 -0600338 chrome_version = packages.determine_chrome_version(self.build_target)
Michael Mortensenc2615b72019-10-15 08:12:24 -0600339 version_numbers = chrome_version.split('.')
340 self.assertEqual(len(version_numbers), 4)
341 self.assertEqual(int(version_numbers[0]), 78)
Michael Mortensen9fdb14b2019-10-17 11:17:30 -0600342
Michael Mortensen9fe740c2019-10-29 14:42:48 -0600343 def test_determine_chrome_version_handle_exception(self):
344 # Mock what happens when portage throws an exception that bubbles up (via
345 # RunCommand)inside portage_util.PortageqBestVisible.
346 self.PatchObject(portage_util, 'PortageqBestVisible',
347 side_effect=cros_build_lib.RunCommandError('error'))
348 target = packages.determine_chrome_version(self.build_target)
349 self.assertEqual(target, None)
350
Michael Mortensen9fdb14b2019-10-17 11:17:30 -0600351
352class PlatformVersionsTest(cros_test_lib.MockTestCase):
353 """Tests getting platform version."""
354
355 def test_determine_platform_version(self):
356 """Test checking that a valid platform version is returned."""
357 platform_version = packages.determine_platform_version()
358 # The returned platform version is something like 12603.0.0.
359 version_string_list = platform_version.split('.')
360 self.assertEqual(len(version_string_list), 3)
361 # We don't want to check an exact version, but the first number should be
362 # non-zero.
363 self.assertGreaterEqual(int(version_string_list[0]), 1)
Michael Mortensen009cb662019-10-21 11:38:43 -0600364
365 def test_determine_milestone_version(self):
366 """Test checking that a valid milestone version is returned."""
367 milestone_version = packages.determine_milestone_version()
368 # Milestone version should be non-zero
369 self.assertGreaterEqual(int(milestone_version), 1)
370
371 def test_determine_full_version(self):
372 """Test checking that a valid full version is returned."""
373 full_version = packages.determine_full_version()
374 pattern = r'^R(\d+)-(\d+.\d+.\d+(-rc\d+)*)'
375 m = re.match(pattern, full_version)
376 self.assertTrue(m)
377 milestone_version = m.group(1)
378 self.assertGreaterEqual(int(milestone_version), 1)
379
380 def test_versions_based_on_mock(self):
381 # Create a test version_info object, and than mock VersionInfo.from_repo
382 # return it.
383 test_platform_version = '12575.0.0'
384 test_chrome_branch = '75'
385 version_info_mock = manifest_version.VersionInfo(test_platform_version)
386 version_info_mock.chrome_branch = test_chrome_branch
387 self.PatchObject(manifest_version.VersionInfo, 'from_repo',
388 return_value=version_info_mock)
389 test_full_version = 'R' + test_chrome_branch + '-' + test_platform_version
390 platform_version = packages.determine_platform_version()
391 milestone_version = packages.determine_milestone_version()
392 full_version = packages.determine_full_version()
393 self.assertEqual(platform_version, test_platform_version)
394 self.assertEqual(milestone_version, test_chrome_branch)
395 self.assertEqual(full_version, test_full_version)