blob: 99fb3754fc673eab23c19bd9efbd3afd02ff9825 [file] [log] [blame]
Mike Frysingerf1ba7ad2022-09-12 05:42:57 -04001# Copyright 2019 The ChromiumOS Authors
Alex Kleineb77ffa2019-05-28 14:47:44 -06002# Use of this source code is governed by a BSD-style license that can be
3# found in the LICENSE file.
4
5"""Packages service tests."""
6
Madeleine Hardt8ae7f102022-03-24 20:26:11 +00007import io
Andrew Lamb2bde9e42019-11-04 13:24:09 -07008import json
9import os
Michael Mortensen009cb662019-10-21 11:38:43 -060010import re
Madeleine Hardt8ae7f102022-03-24 20:26:11 +000011from unittest import mock
Michael Mortensen009cb662019-10-21 11:38:43 -060012
Mike Frysinger2c024062021-05-22 15:43:22 -040013from chromite.third_party.google.protobuf import json_format
14from chromite.third_party.google.protobuf.field_mask_pb2 import FieldMask
Mike Frysinger68796b52019-08-25 00:04:27 -040015import pytest
Andrew Lamb2bde9e42019-11-04 13:24:09 -070016
Chris McDonaldea0312c2020-05-04 23:33:15 -060017import chromite as cr
Andrew Lamb2bde9e42019-11-04 13:24:09 -070018from chromite.api.gen.config.replication_config_pb2 import (
Mike Frysinger68796b52019-08-25 00:04:27 -040019 FILE_TYPE_JSON,
20 FileReplicationRule,
21 REPLICATION_TYPE_FILTER,
22 ReplicationConfig,
23)
Alex Klein2960c752020-03-09 13:43:38 -060024from chromite.lib import build_target_lib
Ram Chandrasekar60f69f32022-06-03 22:49:30 +000025from chromite.lib import chromeos_version
Andrew Lamb2bde9e42019-11-04 13:24:09 -070026from chromite.lib import constants
Michael Mortensene0f4b542019-10-24 15:30:23 -060027from chromite.lib import cros_build_lib
Alex Kleineb77ffa2019-05-28 14:47:44 -060028from chromite.lib import cros_test_lib
Alex Klein6becabc2020-09-11 14:03:05 -060029from chromite.lib import dependency_graph
Mike Frysinger68796b52019-08-25 00:04:27 -040030from chromite.lib import depgraph
Michael Mortensenb70e8a82019-10-10 18:43:41 -060031from chromite.lib import osutils
Mike Frysinger88d96362020-02-14 19:05:45 -050032from chromite.lib import partial_mock
Alex Klein87531182019-08-12 15:23:37 -060033from chromite.lib import portage_util
Chris McDonaldea0312c2020-05-04 23:33:15 -060034from chromite.lib import uprev_lib
Alex Klein87531182019-08-12 15:23:37 -060035from chromite.lib.chroot_lib import Chroot
Alex Klein18a60af2020-06-11 12:08:47 -060036from chromite.lib.parser import package_info
Andrew Lamb2bde9e42019-11-04 13:24:09 -070037from chromite.lib.uprev_lib import GitRef
Shao-Chuan Lee05e51142021-11-24 12:27:37 +090038from chromite.service import android
Alex Kleineb77ffa2019-05-28 14:47:44 -060039from chromite.service import packages
40
Mike Frysinger68796b52019-08-25 00:04:27 -040041
Andrew Lamb2bde9e42019-11-04 13:24:09 -070042D = cros_test_lib.Directory
43
Alex Kleineb77ffa2019-05-28 14:47:44 -060044
Alex Klein4de25e82019-08-05 15:58:39 -060045class UprevAndroidTest(cros_test_lib.RunCommandTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -060046 """Uprev android tests."""
Alex Klein4de25e82019-08-05 15:58:39 -060047
Alex Klein1699fab2022-09-08 08:46:06 -060048 def _mock_successful_uprev(self):
49 self.rc.AddCmdResult(
50 partial_mock.In("cros_mark_android_as_stable"),
51 stdout=(
52 '{"revved": true,'
53 ' "android_atom": "android/android-1.0",'
54 ' "modified_files": ["file1", "file2"]}'
55 ),
56 )
Shao-Chuan Lee84bf9a22021-11-19 17:42:11 +090057
Alex Klein1699fab2022-09-08 08:46:06 -060058 def test_success(self):
59 """Test successful run handling."""
60 self._mock_successful_uprev()
61 build_targets = [
62 build_target_lib.BuildTarget(t) for t in ["foo", "bar"]
63 ]
Alex Klein4de25e82019-08-05 15:58:39 -060064
Alex Klein1699fab2022-09-08 08:46:06 -060065 result = packages.uprev_android(
66 "android/package", Chroot(), build_targets=build_targets
67 )
68 self.assertCommandContains(
69 [
70 "cros_mark_android_as_stable",
71 "--android_package=android/package",
72 "--boards=foo:bar",
73 ]
74 )
75 self.assertCommandContains(["emerge-foo"])
76 self.assertCommandContains(["emerge-bar"])
Alex Klein4de25e82019-08-05 15:58:39 -060077
Alex Klein1699fab2022-09-08 08:46:06 -060078 self.assertTrue(result.revved)
79 self.assertEqual(result.android_atom, "android/android-1.0")
80 self.assertListEqual(result.modified_files, ["file1", "file2"])
Shao-Chuan Lee84bf9a22021-11-19 17:42:11 +090081
Alex Klein1699fab2022-09-08 08:46:06 -060082 def test_android_build_branch(self):
83 """Test specifying android_build_branch option."""
84 self._mock_successful_uprev()
Shao-Chuan Leea4b4f302021-05-12 14:40:20 +090085
Alex Klein1699fab2022-09-08 08:46:06 -060086 packages.uprev_android(
87 "android/package",
88 Chroot(),
89 android_build_branch="android-build-branch",
90 )
91 self.assertCommandContains(
92 [
93 "cros_mark_android_as_stable",
94 "--android_package=android/package",
95 "--android_build_branch=android-build-branch",
96 ]
97 )
Shao-Chuan Leea4b4f302021-05-12 14:40:20 +090098
Alex Klein1699fab2022-09-08 08:46:06 -060099 def test_android_version(self):
100 """Test specifying android_version option."""
101 self._mock_successful_uprev()
Shao-Chuan Leea4b4f302021-05-12 14:40:20 +0900102
Alex Klein1699fab2022-09-08 08:46:06 -0600103 packages.uprev_android(
104 "android/package", Chroot(), android_version="7123456"
105 )
106 self.assertCommandContains(
107 [
108 "cros_mark_android_as_stable",
109 "--android_package=android/package",
110 "--force_version=7123456",
111 ]
112 )
Shao-Chuan Leea4b4f302021-05-12 14:40:20 +0900113
Alex Klein1699fab2022-09-08 08:46:06 -0600114 def test_skip_commit(self):
115 """Test specifying skip_commit option."""
116 self._mock_successful_uprev()
Shao-Chuan Lee85ba7ce2021-02-09 13:50:11 +0900117
Alex Klein1699fab2022-09-08 08:46:06 -0600118 packages.uprev_android("android/package", Chroot(), skip_commit=True)
119 self.assertCommandContains(
120 [
121 "cros_mark_android_as_stable",
122 "--android_package=android/package",
123 "--skip_commit",
124 ]
125 )
Shao-Chuan Lee85ba7ce2021-02-09 13:50:11 +0900126
Alex Klein1699fab2022-09-08 08:46:06 -0600127 def test_no_uprev(self):
128 """Test no uprev handling."""
129 self.rc.AddCmdResult(
130 partial_mock.In("cros_mark_android_as_stable"),
131 stdout='{"revved": false}',
132 )
133 build_targets = [
134 build_target_lib.BuildTarget(t) for t in ["foo", "bar"]
135 ]
136 result = packages.uprev_android(
137 "android/package", Chroot(), build_targets=build_targets
138 )
Alex Klein4de25e82019-08-05 15:58:39 -0600139
Alex Klein1699fab2022-09-08 08:46:06 -0600140 self.assertCommandContains(
141 ["cros_mark_android_as_stable", "--boards=foo:bar"]
142 )
143 self.assertCommandContains(["emerge-foo"], expected=False)
144 self.assertCommandContains(["emerge-bar"], expected=False)
Alex Klein4de25e82019-08-05 15:58:39 -0600145
Alex Klein1699fab2022-09-08 08:46:06 -0600146 self.assertFalse(result.revved)
Shao-Chuan Lee84bf9a22021-11-19 17:42:11 +0900147
Alex Klein1699fab2022-09-08 08:46:06 -0600148 def test_ignore_junk_in_stdout(self):
149 """Test when stdout contains junk messages."""
150 self.rc.AddCmdResult(
151 partial_mock.In("cros_mark_android_as_stable"),
152 stdout='foo\nbar\n{"revved": false}\n',
153 )
154 result = packages.uprev_android("android/package", Chroot())
Shao-Chuan Leedea458f2021-11-25 23:46:53 +0900155
Alex Klein1699fab2022-09-08 08:46:06 -0600156 self.assertFalse(result.revved)
Shao-Chuan Leedea458f2021-11-25 23:46:53 +0900157
Alex Klein4de25e82019-08-05 15:58:39 -0600158
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900159class UprevAndroidLKGBTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600160 """Tests for uprevving Android with LKGB."""
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900161
Alex Klein1699fab2022-09-08 08:46:06 -0600162 def test_registered_handlers(self):
163 """Test that each Android package has an uprev handler registered."""
164 mock_handler = self.PatchObject(packages, "uprev_android_lkgb")
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900165
Shao-Chuan Leeca2cbcc2022-11-02 08:28:31 +0900166 for android_package in android.GetAllAndroidPackages():
Alex Klein1699fab2022-09-08 08:46:06 -0600167 cpv = package_info.SplitCPV(
168 "chromeos-base/" + android_package, strict=False
169 )
170 build_targets = [build_target_lib.BuildTarget("foo")]
171 chroot = Chroot()
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900172
Alex Klein1699fab2022-09-08 08:46:06 -0600173 packages.uprev_versioned_package(cpv, build_targets, [], chroot)
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900174
Alex Klein1699fab2022-09-08 08:46:06 -0600175 mock_handler.assert_called_once_with(
176 android_package, build_targets, chroot
177 )
178 mock_handler.reset_mock()
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900179
Alex Klein1699fab2022-09-08 08:46:06 -0600180 def test_success(self):
181 """Test a successful uprev."""
182 self.PatchObject(android, "OVERLAY_DIR", new="overlay-dir")
Shao-Chuan Leee0b9ba92023-01-18 19:35:36 +0900183 self.PatchObject(
184 android, "ReadLKGB", return_value=dict(build_id="android-lkgb")
185 )
Alex Klein1699fab2022-09-08 08:46:06 -0600186 self.PatchObject(
187 packages,
188 "uprev_android",
189 return_value=packages.UprevAndroidResult(
190 revved=True,
191 android_atom="android-atom",
192 modified_files=["file1", "file2"],
193 ),
194 )
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900195
Alex Klein1699fab2022-09-08 08:46:06 -0600196 result = packages.uprev_android_lkgb("android-package", [], Chroot())
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900197
Alex Klein1699fab2022-09-08 08:46:06 -0600198 self.assertListEqual(
199 result.modified,
200 [
201 uprev_lib.UprevVersionedPackageModifications(
202 "android-lkgb",
203 [
204 os.path.join("overlay-dir", "file1"),
205 os.path.join("overlay-dir", "file2"),
206 ],
207 )
208 ],
209 )
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900210
Alex Klein1699fab2022-09-08 08:46:06 -0600211 def test_no_rev(self):
212 """Test when nothing revved."""
Shao-Chuan Leee0b9ba92023-01-18 19:35:36 +0900213 self.PatchObject(
214 android, "ReadLKGB", return_value=dict(build_id="android-lkgb")
215 )
Alex Klein1699fab2022-09-08 08:46:06 -0600216 self.PatchObject(
217 packages,
218 "uprev_android",
219 return_value=packages.UprevAndroidResult(revved=False),
220 )
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900221
Alex Klein1699fab2022-09-08 08:46:06 -0600222 result = packages.uprev_android_lkgb("android-package", [], Chroot())
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900223
Alex Klein1699fab2022-09-08 08:46:06 -0600224 self.assertListEqual(result.modified, [])
Shao-Chuan Lee05e51142021-11-24 12:27:37 +0900225
226
Jeremy Bettisaf96afb2023-01-11 16:09:58 -0700227class UprevECUtilsTest(cros_test_lib.MockTestCase):
228 """Tests for upreving ecutils."""
229
230 def test_success(self):
231 """Test a successful uprev."""
232
233 def fakeRunTasks(func, inputs):
234 results = []
235 for args in inputs:
236 results.append(func(*args))
237 return results
238
239 self.PatchObject(
240 packages.uprev_lib.parallel,
241 "RunTasksInProcessPool",
242 side_effect=fakeRunTasks,
243 )
244 mock_devutils = mock.MagicMock(name="dev-utils")
245 mock_ecutils = mock.MagicMock(name="ec-utils")
246 mock_ecutilstest = mock.MagicMock(name="ec-utils-test")
247 self.PatchObject(
248 packages.uprev_lib.portage_util,
249 "GetOverlayEBuilds",
250 return_value=[
251 mock_devutils,
252 mock_ecutils,
253 mock_ecutilstest,
254 ],
255 )
256 mock_overlay_mgr = mock.MagicMock(name="overlay-manager")
257 mock_overlay_mgr.modified_ebuilds = ["file1", "file2"]
258 self.PatchObject(
259 packages.uprev_lib,
260 "UprevOverlayManager",
261 return_value=mock_overlay_mgr,
262 )
Jeremy Bettis0186d252023-01-19 14:47:46 -0700263
264 for package in [
265 "chromeos-base/ec-devutils",
266 "chromeos-base/ec-utils",
267 "chromeos-base/ec-utils-test",
268 ]:
269 cpv = package_info.SplitCPV(package, strict=False)
270 assert cpv is not None
271 build_targets = [build_target_lib.BuildTarget("foo")]
272 refs = [
273 GitRef(
274 path="/platform/ec",
275 ref="main",
276 revision="123",
277 )
278 ]
279 chroot = Chroot()
280
281 result = packages.uprev_versioned_package(
282 cpv, build_targets, refs, chroot
Jeremy Bettisaf96afb2023-01-11 16:09:58 -0700283 )
Jeremy Bettisaf96afb2023-01-11 16:09:58 -0700284
Jeremy Bettis0186d252023-01-19 14:47:46 -0700285 self.assertEqual(1, len(result.modified))
286 self.assertEqual("123", result.modified[0].new_version)
287 self.assertListEqual(result.modified[0].files, ["file1", "file2"])
Jeremy Bettisaf96afb2023-01-11 16:09:58 -0700288
Jeremy Bettis0186d252023-01-19 14:47:46 -0700289 mock_overlay_mgr.uprev.assert_called_with(
290 package_list=[
291 package,
292 ],
293 force=True,
294 )
Jeremy Bettisaf96afb2023-01-11 16:09:58 -0700295
296
Alex Kleineb77ffa2019-05-28 14:47:44 -0600297class UprevBuildTargetsTest(cros_test_lib.RunCommandTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600298 """uprev_build_targets tests."""
Alex Kleineb77ffa2019-05-28 14:47:44 -0600299
Alex Klein1699fab2022-09-08 08:46:06 -0600300 def test_invalid_type_fails(self):
301 """Test invalid type fails."""
302 with self.assertRaises(AssertionError):
303 packages.uprev_build_targets(
304 [build_target_lib.BuildTarget("foo")], "invalid"
305 )
Alex Kleineb77ffa2019-05-28 14:47:44 -0600306
Alex Klein1699fab2022-09-08 08:46:06 -0600307 def test_none_type_fails(self):
308 """Test None type fails."""
309 with self.assertRaises(AssertionError):
310 packages.uprev_build_targets(
311 [build_target_lib.BuildTarget("foo")], None
312 )
Alex Kleineb77ffa2019-05-28 14:47:44 -0600313
314
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000315class PatchEbuildVarsTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600316 """patch_ebuild_vars test."""
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000317
Alex Klein1699fab2022-09-08 08:46:06 -0600318 def setUp(self):
319 self.mock_input = self.PatchObject(packages.fileinput, "input")
320 self.mock_stdout_write = self.PatchObject(packages.sys.stdout, "write")
321 self.ebuild_path = "/path/to/ebuild"
322 self.old_var_value = "R100-5678.0.123456789"
323 self.new_var_value = "R102-5678.0.234566789"
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000324
Alex Klein1699fab2022-09-08 08:46:06 -0600325 def test_patch_ebuild_vars_var_only(self):
326 """patch_ebuild_vars changes ^var=value$."""
327 ebuild_contents = (
328 "This line does not change.\n"
329 'AFDO_PROFILE_VERSION="{var_value}"\n'
330 "\n"
331 "# The line with AFDO_PROFILE_VERSION is also unchanged."
332 )
333 # Ebuild contains old_var_value.
334 self.mock_input.return_value = io.StringIO(
335 ebuild_contents.format(var_value=self.old_var_value)
336 )
337 expected_calls = []
338 # Expect the line with new_var_value.
339 for line in io.StringIO(
340 ebuild_contents.format(var_value=self.new_var_value)
341 ):
342 expected_calls.append(mock.call(line))
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000343
Alex Klein1699fab2022-09-08 08:46:06 -0600344 packages.patch_ebuild_vars(
345 self.ebuild_path, {"AFDO_PROFILE_VERSION": self.new_var_value}
346 )
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000347
Alex Klein1699fab2022-09-08 08:46:06 -0600348 self.mock_stdout_write.assert_has_calls(expected_calls)
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000349
Alex Klein1699fab2022-09-08 08:46:06 -0600350 def test_patch_ebuild_vars_ignore_export(self):
351 """patch_ebuild_vars changes ^export var=value$ and keeps export."""
352 ebuild_contents = (
353 "This line does not change.\n"
354 'export AFDO_PROFILE_VERSION="{var_value}"\n'
355 "# This line is also unchanged."
356 )
357 # Ebuild contains old_var_value.
358 self.mock_input.return_value = io.StringIO(
359 ebuild_contents.format(var_value=self.old_var_value)
360 )
361 expected_calls = []
362 # Expect the line with new_var_value.
363 for line in io.StringIO(
364 ebuild_contents.format(var_value=self.new_var_value)
365 ):
366 expected_calls.append(mock.call(line))
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000367
Alex Klein1699fab2022-09-08 08:46:06 -0600368 packages.patch_ebuild_vars(
369 self.ebuild_path, {"AFDO_PROFILE_VERSION": self.new_var_value}
370 )
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000371
Alex Klein1699fab2022-09-08 08:46:06 -0600372 self.mock_stdout_write.assert_has_calls(expected_calls)
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000373
Alex Klein1699fab2022-09-08 08:46:06 -0600374 def test_patch_ebuild_vars_partial_match(self):
375 """patch_ebuild_vars ignores ^{prefix}var=value$."""
376 ebuild_contents = (
Alex Kleina53bd282022-09-09 12:42:55 -0600377 'This and the line below do not change.\nNEW_AFDO="{var_value}"'
Alex Klein1699fab2022-09-08 08:46:06 -0600378 )
379 # Ebuild contains old_var_value.
380 self.mock_input.return_value = io.StringIO(
381 ebuild_contents.format(var_value=self.old_var_value)
382 )
383 expected_calls = []
384 # Expect the line with UNCHANGED old_var_value.
385 for line in io.StringIO(
386 ebuild_contents.format(var_value=self.old_var_value)
387 ):
388 expected_calls.append(mock.call(line))
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000389
Alex Klein1699fab2022-09-08 08:46:06 -0600390 # Note that the var name partially matches the ebuild var and hence it has
391 # to be ignored.
392 packages.patch_ebuild_vars(
393 self.ebuild_path, {"AFDO": self.new_var_value}
394 )
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000395
Alex Klein1699fab2022-09-08 08:46:06 -0600396 self.mock_stdout_write.assert_has_calls(expected_calls)
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000397
Alex Klein1699fab2022-09-08 08:46:06 -0600398 def test_patch_ebuild_vars_no_vars(self):
399 """patch_ebuild_vars keeps ebuild intact if there are no vars."""
400 ebuild_contents = (
401 "This line does not change.\n"
402 "The line with AFDO_PROFILE_VERSION is also unchanged."
403 )
404 self.mock_input.return_value = io.StringIO(ebuild_contents)
405 expected_calls = []
406 for line in io.StringIO(ebuild_contents):
407 expected_calls.append(mock.call(line))
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000408
Alex Klein1699fab2022-09-08 08:46:06 -0600409 packages.patch_ebuild_vars(
410 self.ebuild_path, {"AFDO_PROFILE_VERSION": self.new_var_value}
411 )
412
413 self.mock_stdout_write.assert_has_calls(expected_calls)
Madeleine Hardt8ae7f102022-03-24 20:26:11 +0000414
415
Alex Klein87531182019-08-12 15:23:37 -0600416class UprevsVersionedPackageTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600417 """uprevs_versioned_package decorator test."""
Alex Klein87531182019-08-12 15:23:37 -0600418
Alex Klein1699fab2022-09-08 08:46:06 -0600419 @packages.uprevs_versioned_package("category/package")
420 def uprev_category_package(self, *args, **kwargs):
421 """Registered function for testing."""
Alex Klein87531182019-08-12 15:23:37 -0600422
Alex Klein1699fab2022-09-08 08:46:06 -0600423 def test_calls_function(self):
424 """Test calling a registered function."""
425 self.PatchObject(self, "uprev_category_package")
Alex Klein87531182019-08-12 15:23:37 -0600426
Alex Klein1699fab2022-09-08 08:46:06 -0600427 cpv = package_info.SplitCPV("category/package", strict=False)
428 packages.uprev_versioned_package(cpv, [], [], Chroot())
Alex Klein87531182019-08-12 15:23:37 -0600429
Alex Klein1699fab2022-09-08 08:46:06 -0600430 # TODO(crbug/1065172): Invalid assertion that had previously been mocked.
431 # patch.assert_called()
Alex Klein87531182019-08-12 15:23:37 -0600432
Alex Klein1699fab2022-09-08 08:46:06 -0600433 def test_unregistered_package(self):
434 """Test calling with an unregistered package."""
435 cpv = package_info.SplitCPV("does-not/exist", strict=False)
Alex Klein87531182019-08-12 15:23:37 -0600436
Alex Klein1699fab2022-09-08 08:46:06 -0600437 with self.assertRaises(packages.UnknownPackageError):
438 packages.uprev_versioned_package(cpv, [], [], Chroot())
Alex Klein87531182019-08-12 15:23:37 -0600439
440
Trent Begin6daa8702020-01-29 14:58:12 -0700441class UprevEbuildFromPinTest(cros_test_lib.RunCommandTempDirTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600442 """Tests uprev_ebuild_from_pin function"""
Trent Begin315d9d92019-12-03 21:55:53 -0700443
Alex Klein1699fab2022-09-08 08:46:06 -0600444 package = "category/package"
445 version = "1.2.3"
446 new_version = "1.2.4"
447 ebuild_template = "package-%s-r1.ebuild"
448 ebuild = ebuild_template % version
449 unstable_ebuild = "package-9999.ebuild"
450 manifest = "Manifest"
Trent Begin315d9d92019-12-03 21:55:53 -0700451
Alex Klein1699fab2022-09-08 08:46:06 -0600452 def test_uprev_ebuild(self):
453 """Tests uprev of ebuild with version path"""
454 file_layout = (
455 D(self.package, [self.ebuild, self.unstable_ebuild, self.manifest]),
456 )
457 cros_test_lib.CreateOnDiskHierarchy(self.tempdir, file_layout)
Trent Begin315d9d92019-12-03 21:55:53 -0700458
Alex Klein1699fab2022-09-08 08:46:06 -0600459 package_path = os.path.join(self.tempdir, self.package)
Trent Begin315d9d92019-12-03 21:55:53 -0700460
Alex Klein1699fab2022-09-08 08:46:06 -0600461 ebuild_path = os.path.join(package_path, self.ebuild)
462 self.WriteTempFile(ebuild_path, 'KEYWORDS="*"\n')
Fergus Dall2209d0b2020-08-06 11:51:43 +1000463
Alex Klein1699fab2022-09-08 08:46:06 -0600464 result = uprev_lib.uprev_ebuild_from_pin(
465 package_path, self.new_version, chroot=Chroot()
466 )
467 self.assertEqual(
468 len(result.modified),
469 1,
470 "unexpected number of results: %s" % len(result.modified),
471 )
Trent Begin315d9d92019-12-03 21:55:53 -0700472
Alex Klein1699fab2022-09-08 08:46:06 -0600473 mod = result.modified[0]
474 self.assertEqual(
475 mod.new_version,
476 self.new_version + "-r1",
477 "unexpected version number: %s" % mod.new_version,
478 )
Trent Begin315d9d92019-12-03 21:55:53 -0700479
Alex Klein1699fab2022-09-08 08:46:06 -0600480 old_ebuild_path = os.path.join(
481 package_path, self.ebuild_template % self.version
482 )
483 new_ebuild_path = os.path.join(
484 package_path, self.ebuild_template % self.new_version
485 )
486 manifest_path = os.path.join(package_path, "Manifest")
Trent Begin2e5344f2020-03-02 10:46:55 -0700487
Alex Klein1699fab2022-09-08 08:46:06 -0600488 expected_modified_files = [
489 old_ebuild_path,
490 new_ebuild_path,
491 manifest_path,
492 ]
493 self.assertCountEqual(mod.files, expected_modified_files)
Trent Begin4a11a632020-02-28 12:59:58 -0700494
Alex Klein1699fab2022-09-08 08:46:06 -0600495 self.assertCommandContains(["ebuild", "manifest"])
Trent Begin6daa8702020-01-29 14:58:12 -0700496
Alex Klein1699fab2022-09-08 08:46:06 -0600497 def test_uprev_ebuild_same_version(self):
498 """Tests uprev of ebuild with version path when the version has not changed.
Fergus Dall2209d0b2020-08-06 11:51:43 +1000499
Alex Klein1699fab2022-09-08 08:46:06 -0600500 This should result in bumping the revision number.
501 """
502 file_layout = (
503 D(self.package, [self.ebuild, self.unstable_ebuild, self.manifest]),
504 )
505 cros_test_lib.CreateOnDiskHierarchy(self.tempdir, file_layout)
Fergus Dall2209d0b2020-08-06 11:51:43 +1000506
Alex Klein1699fab2022-09-08 08:46:06 -0600507 package_path = os.path.join(self.tempdir, self.package)
Fergus Dall2209d0b2020-08-06 11:51:43 +1000508
Alex Klein1699fab2022-09-08 08:46:06 -0600509 ebuild_path = os.path.join(package_path, self.ebuild)
510 self.WriteTempFile(ebuild_path, 'KEYWORDS="*"\n')
Fergus Dall2209d0b2020-08-06 11:51:43 +1000511
Alex Klein1699fab2022-09-08 08:46:06 -0600512 result = uprev_lib.uprev_ebuild_from_pin(
513 package_path, self.version, chroot=Chroot()
514 )
515 self.assertEqual(
516 len(result.modified),
517 1,
518 "unexpected number of results: %s" % len(result.modified),
519 )
Fergus Dall2209d0b2020-08-06 11:51:43 +1000520
Alex Klein1699fab2022-09-08 08:46:06 -0600521 mod = result.modified[0]
522 self.assertEqual(
523 mod.new_version,
524 self.version + "-r2",
525 "unexpected version number: %s" % mod.new_version,
526 )
Fergus Dall2209d0b2020-08-06 11:51:43 +1000527
Alex Klein1699fab2022-09-08 08:46:06 -0600528 old_ebuild_path = os.path.join(
529 package_path, self.ebuild_template % self.version
530 )
531 new_ebuild_path = os.path.join(
532 package_path, "package-%s-r2.ebuild" % self.version
533 )
534 manifest_path = os.path.join(package_path, "Manifest")
Fergus Dall2209d0b2020-08-06 11:51:43 +1000535
Alex Klein1699fab2022-09-08 08:46:06 -0600536 expected_modified_files = [
537 old_ebuild_path,
538 new_ebuild_path,
539 manifest_path,
540 ]
541 self.assertCountEqual(mod.files, expected_modified_files)
Fergus Dall2209d0b2020-08-06 11:51:43 +1000542
Alex Klein1699fab2022-09-08 08:46:06 -0600543 self.assertCommandContains(["ebuild", "manifest"])
Fergus Dall2209d0b2020-08-06 11:51:43 +1000544
Alex Klein1699fab2022-09-08 08:46:06 -0600545 def test_no_ebuild(self):
546 """Tests assertion is raised if package has no ebuilds"""
547 file_layout = (D(self.package, [self.manifest]),)
548 cros_test_lib.CreateOnDiskHierarchy(self.tempdir, file_layout)
Trent Begin315d9d92019-12-03 21:55:53 -0700549
Alex Klein1699fab2022-09-08 08:46:06 -0600550 package_path = os.path.join(self.tempdir, self.package)
Trent Begin315d9d92019-12-03 21:55:53 -0700551
Alex Klein1699fab2022-09-08 08:46:06 -0600552 with self.assertRaises(uprev_lib.EbuildUprevError):
553 uprev_lib.uprev_ebuild_from_pin(
554 package_path, self.new_version, chroot=Chroot()
555 )
Trent Begin315d9d92019-12-03 21:55:53 -0700556
Alex Klein1699fab2022-09-08 08:46:06 -0600557 def test_multiple_stable_ebuilds(self):
558 """Tests assertion is raised if multiple stable ebuilds are present"""
559 file_layout = (
560 D(
561 self.package,
562 [self.ebuild, self.ebuild_template % "1.2.1", self.manifest],
563 ),
564 )
565 cros_test_lib.CreateOnDiskHierarchy(self.tempdir, file_layout)
Fergus Dall2209d0b2020-08-06 11:51:43 +1000566
Alex Klein1699fab2022-09-08 08:46:06 -0600567 package_path = os.path.join(self.tempdir, self.package)
Fergus Dall2209d0b2020-08-06 11:51:43 +1000568
Alex Klein1699fab2022-09-08 08:46:06 -0600569 ebuild_path = os.path.join(package_path, self.ebuild)
570 self.WriteTempFile(ebuild_path, 'KEYWORDS="*"\n')
Fergus Dall2209d0b2020-08-06 11:51:43 +1000571
Alex Klein1699fab2022-09-08 08:46:06 -0600572 ebuild_path = os.path.join(package_path, self.ebuild_template % "1.2.1")
573 self.WriteTempFile(ebuild_path, 'KEYWORDS="*"\n')
Fergus Dall2209d0b2020-08-06 11:51:43 +1000574
Alex Klein1699fab2022-09-08 08:46:06 -0600575 with self.assertRaises(uprev_lib.EbuildUprevError):
576 uprev_lib.uprev_ebuild_from_pin(
577 package_path, self.new_version, chroot=Chroot()
578 )
Fergus Dall2209d0b2020-08-06 11:51:43 +1000579
Alex Klein1699fab2022-09-08 08:46:06 -0600580 def test_multiple_unstable_ebuilds(self):
581 """Tests assertion is raised if multiple unstable ebuilds are present"""
582 file_layout = (
583 D(
584 self.package,
585 [self.ebuild, self.ebuild_template % "1.2.1", self.manifest],
586 ),
587 )
588 cros_test_lib.CreateOnDiskHierarchy(self.tempdir, file_layout)
Trent Begin315d9d92019-12-03 21:55:53 -0700589
Alex Klein1699fab2022-09-08 08:46:06 -0600590 package_path = os.path.join(self.tempdir, self.package)
Trent Begin315d9d92019-12-03 21:55:53 -0700591
Alex Klein1699fab2022-09-08 08:46:06 -0600592 with self.assertRaises(uprev_lib.EbuildUprevError):
593 uprev_lib.uprev_ebuild_from_pin(
594 package_path, self.new_version, chroot=Chroot()
595 )
Trent Begin315d9d92019-12-03 21:55:53 -0700596
597
Andrew Lamb9563a152019-12-04 11:42:18 -0700598class ReplicatePrivateConfigTest(cros_test_lib.RunCommandTempDirTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600599 """replicate_private_config tests."""
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700600
Alex Klein1699fab2022-09-08 08:46:06 -0600601 def setUp(self):
602 # Set up fake public and private chromeos-config overlays.
603 private_package_root = (
604 "src/private-overlays/overlay-coral-private/chromeos-base/"
605 "chromeos-config-bsp"
606 )
607 self.public_package_root = (
608 "src/overlays/overlay-coral/chromeos-base/chromeos-config-bsp"
609 )
610 file_layout = (
611 D(
612 os.path.join(private_package_root, "files"),
613 ["build_config.json"],
614 ),
615 D(private_package_root, ["replication_config.jsonpb"]),
616 D(
617 os.path.join(self.public_package_root, "files"),
618 ["build_config.json"],
619 ),
620 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700621
Alex Klein1699fab2022-09-08 08:46:06 -0600622 cros_test_lib.CreateOnDiskHierarchy(self.tempdir, file_layout)
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700623
Alex Klein1699fab2022-09-08 08:46:06 -0600624 # Private config contains 'a' and 'b' fields.
625 self.private_config_path = os.path.join(
626 private_package_root, "files", "build_config.json"
627 )
628 self.WriteTempFile(
629 self.private_config_path,
630 json.dumps({"chromeos": {"configs": [{"a": 3, "b": 2}]}}),
631 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700632
Alex Klein1699fab2022-09-08 08:46:06 -0600633 # Public config only contains the 'a' field. Note that the value of 'a' is
634 # 1 in the public config; it will get updated to 3 when the private config
635 # is replicated.
636 self.public_config_path = os.path.join(
637 self.public_package_root, "files", "build_config.json"
638 )
639 self.WriteTempFile(
640 self.public_config_path,
641 json.dumps({"chromeos": {"configs": [{"a": 1}]}}),
642 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700643
Alex Klein1699fab2022-09-08 08:46:06 -0600644 # Put a ReplicationConfig JSONPB in the private package. Note that it
645 # specifies only the 'a' field is replicated.
646 self.replication_config_path = os.path.join(
647 self.tempdir, private_package_root, "replication_config.jsonpb"
648 )
649 replication_config = ReplicationConfig(
650 file_replication_rules=[
651 FileReplicationRule(
652 source_path=self.private_config_path,
653 destination_path=self.public_config_path,
654 file_type=FILE_TYPE_JSON,
655 replication_type=REPLICATION_TYPE_FILTER,
656 destination_fields=FieldMask(paths=["a"]),
657 )
658 ]
659 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700660
Alex Klein1699fab2022-09-08 08:46:06 -0600661 osutils.WriteFile(
662 self.replication_config_path,
663 json_format.MessageToJson(replication_config),
664 )
665 self.PatchObject(constants, "SOURCE_ROOT", new=self.tempdir)
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700666
Alex Klein1699fab2022-09-08 08:46:06 -0600667 self.rc.SetDefaultCmdResult(side_effect=self._write_generated_c_files)
Andrew Lamb9563a152019-12-04 11:42:18 -0700668
Alex Klein1699fab2022-09-08 08:46:06 -0600669 def _write_generated_c_files(self, *_args, **_kwargs):
670 """Write fake generated C files to the public output dir.
Andrew Lamb9563a152019-12-04 11:42:18 -0700671
Alex Klein1699fab2022-09-08 08:46:06 -0600672 Note that this function accepts args and kwargs so it can be used as a side
673 effect.
674 """
675 output_dir = os.path.join(self.public_package_root, "files")
676 self.WriteTempFile(os.path.join(output_dir, "config.c"), "")
677 self.WriteTempFile(os.path.join(output_dir, "ec_config.c"), "")
678 self.WriteTempFile(os.path.join(output_dir, "ec_config.h"), "")
Andrew Lamb9563a152019-12-04 11:42:18 -0700679
Alex Klein1699fab2022-09-08 08:46:06 -0600680 def _write_incorrect_generated_c_files(self, *_args, **_kwargs):
681 """Similar to _write_generated_c_files, with an expected file missing.
Andrew Lamb9563a152019-12-04 11:42:18 -0700682
Alex Klein1699fab2022-09-08 08:46:06 -0600683 Note that this function accepts args and kwargs so it can be used as a side
684 effect.
685 """
686 output_dir = os.path.join(self.public_package_root, "files")
687 self.WriteTempFile(os.path.join(output_dir, "config.c"), "")
688 self.WriteTempFile(os.path.join(output_dir, "ec_config.c"), "")
Andrew Lamb9563a152019-12-04 11:42:18 -0700689
Alex Klein1699fab2022-09-08 08:46:06 -0600690 def test_replicate_private_config(self):
691 """Basic replication test."""
692 refs = [
693 GitRef(
694 path="/chromeos/overlays/overlay-coral-private",
695 ref="main",
696 revision="123",
697 )
698 ]
699 chroot = Chroot()
700 result = packages.replicate_private_config(
701 _build_targets=None, refs=refs, chroot=chroot
702 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700703
Alex Klein1699fab2022-09-08 08:46:06 -0600704 self.assertCommandContains(
705 [
706 "cros_config_schema",
707 "-m",
708 os.path.join(
709 constants.CHROOT_SOURCE_ROOT, self.public_config_path
710 ),
711 "-g",
712 os.path.join(
713 constants.CHROOT_SOURCE_ROOT,
714 self.public_package_root,
715 "files",
716 ),
717 "-f",
718 '"TRUE"',
719 ],
720 enter_chroot=True,
721 chroot_args=chroot.get_enter_args(),
722 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700723
Alex Klein1699fab2022-09-08 08:46:06 -0600724 self.assertEqual(len(result.modified), 1)
725 # The public build_config.json and generated C files were modified.
726 expected_modified_files = [
727 os.path.join(self.tempdir, self.public_config_path),
728 os.path.join(
729 self.tempdir, self.public_package_root, "files", "config.c"
730 ),
731 os.path.join(
732 self.tempdir, self.public_package_root, "files", "ec_config.c"
733 ),
734 os.path.join(
735 self.tempdir, self.public_package_root, "files", "ec_config.h"
736 ),
737 ]
738 self.assertEqual(result.modified[0].files, expected_modified_files)
739 self.assertEqual(result.modified[0].new_version, "123")
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700740
Alex Klein1699fab2022-09-08 08:46:06 -0600741 # The update from the private build_config.json was copied to the public.
742 # Note that only the 'a' field is present, as per destination_fields.
743 self.assertEqual(
744 json.loads(self.ReadTempFile(self.public_config_path)),
745 {"chromeos": {"configs": [{"a": 3}]}},
746 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700747
Alex Klein1699fab2022-09-08 08:46:06 -0600748 def test_replicate_private_config_no_build_config(self):
749 """If there is no build config, don't generate C files."""
750 # Modify the replication config to write to "other_config.json" instead of
751 # "build_config.json"
752 modified_destination_path = self.public_config_path.replace(
753 "build_config", "other_config"
754 )
755 replication_config = ReplicationConfig(
756 file_replication_rules=[
757 FileReplicationRule(
758 source_path=self.private_config_path,
759 destination_path=modified_destination_path,
760 file_type=FILE_TYPE_JSON,
761 replication_type=REPLICATION_TYPE_FILTER,
762 destination_fields=FieldMask(paths=["a"]),
763 )
764 ]
765 )
766 osutils.WriteFile(
767 self.replication_config_path,
768 json_format.MessageToJson(replication_config),
769 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700770
Alex Klein1699fab2022-09-08 08:46:06 -0600771 refs = [
772 GitRef(
773 path="/chromeos/overlays/overlay-coral-private",
774 ref="main",
775 revision="123",
776 )
777 ]
778 result = packages.replicate_private_config(
779 _build_targets=None, refs=refs, chroot=Chroot()
780 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700781
Alex Klein1699fab2022-09-08 08:46:06 -0600782 self.assertEqual(len(result.modified), 1)
783 self.assertEqual(
784 result.modified[0].files,
785 [os.path.join(self.tempdir, modified_destination_path)],
786 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700787
Alex Klein1699fab2022-09-08 08:46:06 -0600788 def test_replicate_private_config_multiple_build_configs(self):
789 """An error is thrown if there is more than one build config."""
790 replication_config = ReplicationConfig(
791 file_replication_rules=[
792 FileReplicationRule(
793 source_path=self.private_config_path,
794 destination_path=self.public_config_path,
795 file_type=FILE_TYPE_JSON,
796 replication_type=REPLICATION_TYPE_FILTER,
797 destination_fields=FieldMask(paths=["a"]),
798 ),
799 FileReplicationRule(
800 source_path=self.private_config_path,
801 destination_path=self.public_config_path,
802 file_type=FILE_TYPE_JSON,
803 replication_type=REPLICATION_TYPE_FILTER,
804 destination_fields=FieldMask(paths=["a"]),
805 ),
806 ]
807 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700808
Alex Klein1699fab2022-09-08 08:46:06 -0600809 osutils.WriteFile(
810 self.replication_config_path,
811 json_format.MessageToJson(replication_config),
812 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700813
Alex Klein1699fab2022-09-08 08:46:06 -0600814 refs = [
815 GitRef(
816 path="/chromeos/overlays/overlay-coral-private",
817 ref="main",
818 revision="123",
819 )
820 ]
821 with self.assertRaisesRegex(
822 ValueError,
823 "Expected at most one build_config.json destination path.",
824 ):
825 packages.replicate_private_config(
826 _build_targets=None, refs=refs, chroot=Chroot()
827 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700828
Alex Klein1699fab2022-09-08 08:46:06 -0600829 def test_replicate_private_config_generated_files_incorrect(self):
830 """An error is thrown if generated C files are missing."""
831 self.rc.SetDefaultCmdResult(
832 side_effect=self._write_incorrect_generated_c_files
833 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700834
Alex Klein1699fab2022-09-08 08:46:06 -0600835 refs = [
836 GitRef(
837 path="/chromeos/overlays/overlay-coral-private",
838 ref="main",
839 revision="123",
840 )
841 ]
842 chroot = Chroot()
Andrew Lamb9563a152019-12-04 11:42:18 -0700843
Alex Klein1699fab2022-09-08 08:46:06 -0600844 with self.assertRaisesRegex(
845 packages.GeneratedCrosConfigFilesError,
846 "Expected to find generated C files",
847 ):
848 packages.replicate_private_config(
849 _build_targets=None, refs=refs, chroot=chroot
850 )
Andrew Lamb9563a152019-12-04 11:42:18 -0700851
Alex Klein1699fab2022-09-08 08:46:06 -0600852 def test_replicate_private_config_wrong_number_of_refs(self):
853 """An error is thrown if there is not exactly one ref."""
854 with self.assertRaisesRegex(ValueError, "Expected exactly one ref"):
855 packages.replicate_private_config(
856 _build_targets=None, refs=[], chroot=None
857 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700858
Alex Klein1699fab2022-09-08 08:46:06 -0600859 with self.assertRaisesRegex(ValueError, "Expected exactly one ref"):
860 refs = [
861 GitRef(path="a", ref="main", revision="1"),
862 GitRef(path="a", ref="main", revision="2"),
863 ]
864 packages.replicate_private_config(
865 _build_targets=None, refs=refs, chroot=None
866 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700867
Alex Klein1699fab2022-09-08 08:46:06 -0600868 def test_replicate_private_config_replication_config_missing(self):
869 """An error is thrown if there is not a replication config."""
870 os.remove(self.replication_config_path)
871 with self.assertRaisesRegex(
872 ValueError,
873 "Expected ReplicationConfig missing at %s"
874 % self.replication_config_path,
875 ):
876 refs = [
877 GitRef(
878 path="/chromeos/overlays/overlay-coral-private",
879 ref="main",
880 revision="123",
881 )
882 ]
883 packages.replicate_private_config(
884 _build_targets=None, refs=refs, chroot=None
885 )
Andrew Lambe836f222019-12-09 12:27:38 -0700886
Alex Klein1699fab2022-09-08 08:46:06 -0600887 def test_replicate_private_config_wrong_git_ref_path(self):
888 """An error is thrown if the git ref doesn't point to a private overlay."""
889 with self.assertRaisesRegex(
890 ValueError, "ref.path must match the pattern"
891 ):
892 refs = [GitRef(path="a/b/c", ref="main", revision="123")]
893 packages.replicate_private_config(
894 _build_targets=None, refs=refs, chroot=None
895 )
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700896
897
Alex Klein5caab872021-09-10 11:44:37 -0600898class GetBestVisibleTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600899 """get_best_visible tests."""
David Burger1e0fe232019-07-01 14:52:07 -0600900
Alex Klein1699fab2022-09-08 08:46:06 -0600901 def test_empty_atom_fails(self):
902 """Test empty atom raises an error."""
903 with self.assertRaises(AssertionError):
904 packages.get_best_visible("")
Alex Kleinda39c6d2019-09-16 14:36:36 -0600905
906
Alex Klein149fd3b2019-12-16 16:01:05 -0700907class HasPrebuiltTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600908 """has_prebuilt tests."""
Alex Kleinda39c6d2019-09-16 14:36:36 -0600909
Alex Klein1699fab2022-09-08 08:46:06 -0600910 def test_empty_atom_fails(self):
911 """Test an empty atom results in an error."""
912 with self.assertRaises(AssertionError):
913 packages.has_prebuilt("")
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600914
Alex Klein1699fab2022-09-08 08:46:06 -0600915 def test_use_flags(self):
916 """Test use flags get propagated correctly."""
917 # We don't really care about the result, just the env handling.
918 patch = self.PatchObject(portage_util, "HasPrebuilt", return_value=True)
919 # Ignore any flags that may be in the environment.
920 self.PatchObject(os.environ, "get", return_value="")
Alex Klein149fd3b2019-12-16 16:01:05 -0700921
Alex Klein1699fab2022-09-08 08:46:06 -0600922 packages.has_prebuilt("cat/pkg-1.2.3", useflags="useflag")
923 patch.assert_called_with(
924 "cat/pkg-1.2.3", board=None, extra_env={"USE": "useflag"}
925 )
Alex Klein149fd3b2019-12-16 16:01:05 -0700926
Alex Klein1699fab2022-09-08 08:46:06 -0600927 def test_env_use_flags(self):
928 """Test env use flags get propagated correctly with passed useflags."""
929 # We don't really care about the result, just the env handling.
930 patch = self.PatchObject(portage_util, "HasPrebuilt", return_value=True)
931 # Add some flags to the environment.
932 existing_flags = "already set flags"
933 self.PatchObject(os.environ, "get", return_value=existing_flags)
Alex Klein149fd3b2019-12-16 16:01:05 -0700934
Alex Klein1699fab2022-09-08 08:46:06 -0600935 new_flags = "useflag"
936 packages.has_prebuilt("cat/pkg-1.2.3", useflags=new_flags)
937 expected = "%s %s" % (existing_flags, new_flags)
938 patch.assert_called_with(
939 "cat/pkg-1.2.3", board=None, extra_env={"USE": expected}
940 )
Alex Klein149fd3b2019-12-16 16:01:05 -0700941
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600942
943class AndroidVersionsTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -0600944 """Tests getting android versions."""
Michael Mortensen14960d02019-10-18 07:53:59 -0600945
Alex Klein1699fab2022-09-08 08:46:06 -0600946 def setUp(self):
947 package_result = [
948 "chromeos-base/android-container-nyc-4717008-r1",
949 "chromeos-base/update_engine-0.0.3-r3408",
950 ]
951 self.PatchObject(
952 portage_util, "GetPackageDependencies", return_value=package_result
953 )
954 self.board = "board"
955 self.PatchObject(
956 portage_util,
957 "FindEbuildForBoardPackage",
958 return_value="chromeos-base/android-container-nyc",
959 )
960 FakeEnvironment = {
961 "ARM_TARGET": "3-linux-target",
962 }
963 self.PatchObject(
964 osutils, "SourceEnvironment", return_value=FakeEnvironment
965 )
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600966
Alex Klein1699fab2022-09-08 08:46:06 -0600967 # Clear the LRU cache for the function. We mock the function that provides
968 # the data this function processes to produce its result, so we need to
969 # clear it manually.
970 packages.determine_android_package.cache_clear()
Alex Klein68a28712021-11-08 11:08:30 -0700971
Alex Klein1699fab2022-09-08 08:46:06 -0600972 def test_determine_android_version(self):
973 """Tests that a valid android version is returned."""
974 version = packages.determine_android_version(self.board)
975 self.assertEqual(version, "4717008")
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600976
Alex Klein1699fab2022-09-08 08:46:06 -0600977 def test_determine_android_version_when_not_present(self):
978 """Tests that a None is returned for version when android is not present."""
979 package_result = ["chromeos-base/update_engine-0.0.3-r3408"]
980 self.PatchObject(
981 portage_util, "GetPackageDependencies", return_value=package_result
982 )
983 version = packages.determine_android_version(self.board)
984 self.assertEqual(version, None)
Michael Mortensenedf76532019-10-16 14:22:37 -0600985
Alex Klein1699fab2022-09-08 08:46:06 -0600986 def test_determine_android_branch(self):
987 """Tests that a valid android branch is returned."""
988 branch = packages.determine_android_branch(self.board)
989 self.assertEqual(branch, "3")
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600990
Alex Klein1699fab2022-09-08 08:46:06 -0600991 def test_determine_android_branch_64bit_targets(self):
992 """Tests that a valid android branch is returned with only 64bit targets."""
993 self.PatchObject(
994 osutils,
995 "SourceEnvironment",
996 return_value={"ARM64_TARGET": "3-linux-target"},
997 )
998 branch = packages.determine_android_branch(self.board)
999 self.assertEqual(branch, "3")
Federico 'Morg' Pareschicd9165a2020-05-29 09:45:55 +09001000
Alex Klein1699fab2022-09-08 08:46:06 -06001001 def test_determine_android_branch_when_not_present(self):
1002 """Tests that a None is returned for branch when android is not present."""
1003 package_result = ["chromeos-base/update_engine-0.0.3-r3408"]
1004 self.PatchObject(
1005 portage_util, "GetPackageDependencies", return_value=package_result
1006 )
1007 branch = packages.determine_android_branch(self.board)
1008 self.assertEqual(branch, None)
Michael Mortensenedf76532019-10-16 14:22:37 -06001009
Alex Klein1699fab2022-09-08 08:46:06 -06001010 def test_determine_android_target(self):
1011 """Tests that a valid android target is returned."""
1012 target = packages.determine_android_target(self.board)
1013 self.assertEqual(target, "cheets")
Michael Mortensenc2615b72019-10-15 08:12:24 -06001014
Alex Klein1699fab2022-09-08 08:46:06 -06001015 def test_determine_android_target_when_not_present(self):
1016 """Tests that a None is returned for target when android is not present."""
1017 package_result = ["chromeos-base/update_engine-0.0.3-r3408"]
1018 self.PatchObject(
1019 portage_util, "GetPackageDependencies", return_value=package_result
1020 )
1021 target = packages.determine_android_target(self.board)
1022 self.assertEqual(target, None)
Michael Mortensenedf76532019-10-16 14:22:37 -06001023
Alex Klein1699fab2022-09-08 08:46:06 -06001024 def test_determine_android_version_handle_exception(self):
1025 """Tests handling RunCommandError inside determine_android_version."""
1026 # Mock what happens when portage returns that bubbles up (via RunCommand)
1027 # inside portage_util.GetPackageDependencies.
1028 self.PatchObject(
1029 portage_util,
1030 "GetPackageDependencies",
1031 side_effect=cros_build_lib.RunCommandError("error"),
1032 )
1033 target = packages.determine_android_version(self.board)
1034 self.assertEqual(target, None)
Michael Mortensene0f4b542019-10-24 15:30:23 -06001035
Alex Klein1699fab2022-09-08 08:46:06 -06001036 def test_determine_android_package_handle_exception(self):
1037 """Tests handling RunCommandError inside determine_android_package."""
1038 # Mock what happens when portage returns that bubbles up (via RunCommand)
1039 # inside portage_util.GetPackageDependencies.
1040 self.PatchObject(
1041 portage_util,
1042 "GetPackageDependencies",
1043 side_effect=cros_build_lib.RunCommandError("error"),
1044 )
1045 target = packages.determine_android_package(self.board)
1046 self.assertEqual(target, None)
Michael Mortensene0f4b542019-10-24 15:30:23 -06001047
Alex Klein1699fab2022-09-08 08:46:06 -06001048 def test_determine_android_package_callers_handle_exception(self):
1049 """Tests handling RunCommandError by determine_android_package callers."""
1050 # Mock what happens when portage returns that bubbles up (via RunCommand)
1051 # inside portage_util.GetPackageDependencies.
1052 self.PatchObject(
1053 portage_util,
1054 "GetPackageDependencies",
1055 side_effect=cros_build_lib.RunCommandError("error"),
1056 )
1057 # Verify that target is None, as expected.
1058 target = packages.determine_android_package(self.board)
1059 self.assertEqual(target, None)
1060 # determine_android_branch calls determine_android_package
1061 branch = packages.determine_android_branch(self.board)
1062 self.assertEqual(branch, None)
1063 # determine_android_target calls determine_android_package
1064 target = packages.determine_android_target(self.board)
1065 self.assertEqual(target, None)
Michael Mortensen9fe740c2019-10-29 14:42:48 -06001066
Michael Mortensene0f4b542019-10-24 15:30:23 -06001067
Alex Klein1699fab2022-09-08 08:46:06 -06001068@pytest.mark.usefixtures("testcase_caplog", "testcase_monkeypatch")
Michael Mortensende716a12020-05-15 11:27:00 -06001069class FindFingerprintsTest(cros_test_lib.RunCommandTempDirTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001070 """Tests for find_fingerprints."""
Michael Mortensende716a12020-05-15 11:27:00 -06001071
Alex Klein1699fab2022-09-08 08:46:06 -06001072 def setUp(self):
1073 self.board = "test-board"
1074 # Create cheets-fingerprints.txt based on tempdir/src...
1075 self.fingerprint_contents = (
1076 "google/test-board/test-board_cheets"
1077 ":9/R99-12345.0.9999/123456:user/release-keys"
1078 )
1079 fingerprint_path = os.path.join(
1080 self.tempdir,
1081 "src/build/images/test-board/latest/cheets-fingerprint.txt",
1082 )
1083 self.chroot = Chroot(self.tempdir)
1084 osutils.WriteFile(
1085 fingerprint_path, self.fingerprint_contents, makedirs=True
1086 )
Michael Mortensende716a12020-05-15 11:27:00 -06001087
Alex Klein1699fab2022-09-08 08:46:06 -06001088 def test_find_fingerprints_with_test_path(self):
1089 """Tests get_firmware_versions with mocked output."""
1090 self.monkeypatch.setattr(constants, "SOURCE_ROOT", self.tempdir)
1091 build_target = build_target_lib.BuildTarget(self.board)
1092 result = packages.find_fingerprints(build_target)
1093 self.assertEqual(result, [self.fingerprint_contents])
1094 self.assertIn("Reading fingerprint file", self.caplog.text)
Michael Mortensende716a12020-05-15 11:27:00 -06001095
Alex Klein1699fab2022-09-08 08:46:06 -06001096 def test_find_fingerprints(self):
1097 """Tests get_firmware_versions with mocked output."""
1098 # Use board name whose path for fingerprint file does not exist.
1099 # Verify that fingerprint file is not found and None is returned.
1100 build_target = build_target_lib.BuildTarget("wrong-boardname")
1101 self.monkeypatch.setattr(constants, "SOURCE_ROOT", self.tempdir)
1102 result = packages.find_fingerprints(build_target)
1103 self.assertEqual(result, [])
1104 self.assertIn("Fingerprint file not found", self.caplog.text)
Michael Mortensende716a12020-05-15 11:27:00 -06001105
1106
Michael Mortensen59e30872020-05-18 14:12:49 -06001107class GetAllFirmwareVersionsTest(cros_test_lib.RunCommandTempDirTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001108 """Tests for get_firmware_versions."""
Michael Mortensen59e30872020-05-18 14:12:49 -06001109
Alex Klein1699fab2022-09-08 08:46:06 -06001110 def setUp(self):
1111 self.board = "test-board"
1112 self.rc.SetDefaultCmdResult(
1113 stdout="""
Michael Mortensen59e30872020-05-18 14:12:49 -06001114
1115flashrom(8): 68935ee2fcfcffa47af81b966269cd2b */build/reef/usr/sbin/flashrom
1116 ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=e102cc98d45300b50088999d53775acbeff407dc, stripped
1117 0.9.9 : bbb2d6a : Jul 28 2017 15:12:34 UTC
1118
1119Model: reef
1120BIOS image: 1b535280fe688ac284d95276492b06f6 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/reef/image.bin
1121BIOS version: Google_Reef.9042.87.1
1122BIOS (RW) image: 0ef265eb8f2d228c09f75b011adbdcbb */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/reef/image.binrw
1123BIOS (RW) version: Google_Reef.9042.110.0
1124EC image: 2e8b4b5fa73cc5dbca4496de97a917a9 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/reef/ec.bin
1125EC version: reef_v1.1.5900-ab1ee51
1126EC (RW) version: reef_v1.1.5909-bd1f0c9
1127
1128Model: pyro
1129BIOS image: 9e62447ebf22a724a4a835018ab6234e */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/pyro/image.bin
1130BIOS version: Google_Pyro.9042.87.1
1131BIOS (RW) image: 1897457303c85de99f3e98b2eaa0eccc */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/pyro/image.binrw
1132BIOS (RW) version: Google_Pyro.9042.110.0
1133EC image: 44b93ed591733519e752e05aa0529eb5 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/pyro/ec.bin
1134EC version: pyro_v1.1.5900-ab1ee51
1135EC (RW) version: pyro_v1.1.5909-bd1f0c9
1136
1137Model: snappy
1138BIOS image: 3ab63ff080596bd7de4e7619f003bb64 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/snappy/image.bin
1139BIOS version: Google_Snappy.9042.110.0
1140EC image: c4db159e84428391d2ee25368c5fe5b6 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/snappy/ec.bin
1141EC version: snappy_v1.1.5909-bd1f0c9
1142
1143Model: sand
1144BIOS image: 387da034a4f0a3f53e278ebfdcc2a412 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/sand/image.bin
1145BIOS version: Google_Sand.9042.110.0
1146EC image: 411562e0589dacec131f5fdfbe95a561 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/sand/ec.bin
1147EC version: sand_v1.1.5909-bd1f0c9
1148
1149Model: electro
1150BIOS image: 1b535280fe688ac284d95276492b06f6 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/reef/image.bin
1151BIOS version: Google_Reef.9042.87.1
1152BIOS (RW) image: 0ef265eb8f2d228c09f75b011adbdcbb */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/reef/image.binrw
1153BIOS (RW) version: Google_Reef.9042.110.0
1154EC image: 2e8b4b5fa73cc5dbca4496de97a917a9 */build/reef/tmp/portage/chromeos-base/chromeos-firmware-reef-0.0.1-r79/temp/tmp7rHApL.pack_firmware-99001/models/reef/ec.bin
1155EC version: reef_v1.1.5900-ab1ee51
1156EC (RW) version: reef_v1.1.5909-bd1f0c9
1157
1158Package Content:
1159612e7bb6ed1fb0a05abf2ebdc834c18b *./updater4.sh
11600eafbee07282315829d0f42135ec7c0c *./gbb_utility
11616074e3ca424cb30a67c378c1d9681f9c *./mosys
116268935ee2fcfcffa47af81b966269cd2b *./flashrom
11630eafbee07282315829d0f42135ec7c0c *./dump_fmap
1164490c95d6123c208d20d84d7c16857c7c *./crosfw.sh
116560899148600b8673ddb711faa55aee40 *./common.sh
11663c3a99346d1ca1273cbcd86c104851ff *./shflags
1167de7ce035e1f82a89f8909d888ee402c0 *./crosutil.sh
1168f9334372bdb9036ba09a6fd9bf30e7a2 *./crossystem
116922257a8d5f0adc1f50a1916c3a4a35dd *./models/reef/ec.bin
1170faf12dbb7cdaf21ce153bdffb67841fd *./models/reef/bios.bin
1171c9bbb417b7921b85a7ed999ee42f550e *./models/reef/setvars.sh
117229823d46f1ec1491ecacd7b830fd2686 *./models/pyro/ec.bin
11732320463aba8b22eb5ea836f094d281b3 *./models/pyro/bios.bin
117481614833ad77c9cd093360ba7bea76b8 *./models/pyro/setvars.sh
1175411562e0589dacec131f5fdfbe95a561 *./models/sand/ec.bin
1176387da034a4f0a3f53e278ebfdcc2a412 *./models/sand/bios.bin
1177fcd8cb0ac0e2ed6be220aaae435d43ff *./models/sand/setvars.sh
1178c4db159e84428391d2ee25368c5fe5b6 *./models/snappy/ec.bin
11793ab63ff080596bd7de4e7619f003bb64 *./models/snappy/bios.bin
1180fe5d699f2e9e4a7de031497953313dbd *./models/snappy/setvars.sh
118179aabd7cd8a215a54234c53d7bb2e6fb *./vpd
Alex Klein1699fab2022-09-08 08:46:06 -06001182"""
1183 )
Michael Mortensen59e30872020-05-18 14:12:49 -06001184
Alex Klein1699fab2022-09-08 08:46:06 -06001185 def test_get_firmware_versions(self):
1186 """Tests get_firmware_versions with mocked output."""
1187 build_target = build_target_lib.BuildTarget(self.board)
1188 result = packages.get_all_firmware_versions(build_target)
1189 self.assertEqual(len(result), 5)
1190 self.assertEqual(
1191 result["reef"],
1192 packages.FirmwareVersions(
1193 "reef",
1194 "Google_Reef.9042.87.1",
1195 "Google_Reef.9042.110.0",
1196 "reef_v1.1.5900-ab1ee51",
1197 "reef_v1.1.5909-bd1f0c9",
1198 ),
1199 )
1200 self.assertEqual(
1201 result["pyro"],
1202 packages.FirmwareVersions(
1203 "pyro",
1204 "Google_Pyro.9042.87.1",
1205 "Google_Pyro.9042.110.0",
1206 "pyro_v1.1.5900-ab1ee51",
1207 "pyro_v1.1.5909-bd1f0c9",
1208 ),
1209 )
1210 self.assertEqual(
1211 result["snappy"],
1212 packages.FirmwareVersions(
1213 "snappy",
1214 "Google_Snappy.9042.110.0",
1215 None,
1216 "snappy_v1.1.5909-bd1f0c9",
1217 None,
1218 ),
1219 )
1220 self.assertEqual(
1221 result["sand"],
1222 packages.FirmwareVersions(
1223 "sand",
1224 "Google_Sand.9042.110.0",
1225 None,
1226 "sand_v1.1.5909-bd1f0c9",
1227 None,
1228 ),
1229 )
1230 self.assertEqual(
1231 result["electro"],
1232 packages.FirmwareVersions(
1233 "electro",
1234 "Google_Reef.9042.87.1",
1235 "Google_Reef.9042.110.0",
1236 "reef_v1.1.5900-ab1ee51",
1237 "reef_v1.1.5909-bd1f0c9",
1238 ),
1239 )
Michael Mortensen59e30872020-05-18 14:12:49 -06001240
Alex Klein1699fab2022-09-08 08:46:06 -06001241 def test_get_firmware_versions_error(self):
1242 """Tests get_firmware_versions with no output."""
1243 # Throw an exception when running the command.
1244 self.PatchObject(
1245 cros_build_lib,
1246 "run",
1247 side_effect=cros_build_lib.RunCommandError("error"),
1248 )
1249 build_target = build_target_lib.BuildTarget(self.board)
1250 result = packages.get_all_firmware_versions(build_target)
1251 self.assertEqual(result, {})
Benjamin Shai12c767e2022-01-12 15:17:44 +00001252
Michael Mortensen59e30872020-05-18 14:12:49 -06001253
Michael Mortensen71ef5682020-05-07 14:29:24 -06001254class GetFirmwareVersionsTest(cros_test_lib.RunCommandTempDirTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001255 """Tests for get_firmware_versions."""
Michael Mortensen71ef5682020-05-07 14:29:24 -06001256
Alex Klein1699fab2022-09-08 08:46:06 -06001257 def setUp(self):
1258 self.board = "test-board"
1259 self.rc.SetDefaultCmdResult(
1260 stdout="""
Michael Mortensen71ef5682020-05-07 14:29:24 -06001261
1262flashrom(8): a8f99c2e61e7dc09c4b25ef5a76ef692 */build/kevin/usr/sbin/flashrom
1263 ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, for GNU/Linux 2.d
1264 0.9.4 : 860875a : Apr 10 2017 23:54:29 UTC
1265
1266BIOS image: 6b5b855a0b8fd1657546d1402c15b206 *chromeos-firmware-kevin-0.0.1/.dist/kevin_fw_8785.178.0.n
1267BIOS version: Google_Kevin.8785.178.0
1268EC image: 1ebfa9518e6cac0558a80b7ab2f5b489 *chromeos-firmware-kevin-0.0.1/.dist/kevin_ec_8785.178.0.n
1269EC version:kevin_v1.10.184-459421c
1270
1271Package Content:
1272a8f99c2e61e7dc09c4b25ef5a76ef692 *./flashrom
12733c3a99346d1ca1273cbcd86c104851ff *./shflags
1274457a8dc8546764affc9700f8da328d23 *./dump_fmap
1275c392980ddb542639edf44a965a59361a *./updater5.sh
1276490c95d6123c208d20d84d7c16857c7c *./crosfw.sh
12776b5b855a0b8fd1657546d1402c15b206 *./bios.bin
12787b5bef0d2da90c23ff2e157250edf0fa *./crosutil.sh
1279d78722e4f1a0dc2d8c3d6b0bc7010ae3 *./crossystem
1280457a8dc8546764affc9700f8da328d23 *./gbb_utility
12811ebfa9518e6cac0558a80b7ab2f5b489 *./ec.bin
1282c98ca54db130886142ad582a58e90ddc *./common.sh
12835ba978bdec0f696f47f0f0de90936880 *./mosys
1284312e8ee6122057f2a246d7bcf1572f49 *./vpd
Alex Klein1699fab2022-09-08 08:46:06 -06001285"""
1286 )
Michael Mortensen71ef5682020-05-07 14:29:24 -06001287
Alex Klein1699fab2022-09-08 08:46:06 -06001288 def test_get_firmware_versions(self):
1289 """Tests get_firmware_versions with mocked output."""
1290 build_target = build_target_lib.BuildTarget(self.board)
1291 result = packages.get_firmware_versions(build_target)
1292 versions = packages.FirmwareVersions(
1293 None,
1294 "Google_Kevin.8785.178.0",
1295 None,
1296 "kevin_v1.10.184-459421c",
1297 None,
1298 )
1299 self.assertEqual(result, versions)
Michael Mortensen71ef5682020-05-07 14:29:24 -06001300
1301
Michael Mortensenfbf2b2d2020-05-14 16:33:06 -06001302class DetermineKernelVersionTest(cros_test_lib.RunCommandTempDirTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001303 """Tests for determine_kernel_version."""
Michael Mortensenfbf2b2d2020-05-14 16:33:06 -06001304
Alex Klein1699fab2022-09-08 08:46:06 -06001305 def setUp(self):
1306 self.board = "test-board"
1307 self.build_target = build_target_lib.BuildTarget(self.board)
Michael Mortensenfbf2b2d2020-05-14 16:33:06 -06001308
Alex Klein1699fab2022-09-08 08:46:06 -06001309 def test_determine_kernel_version(self):
1310 """Tests that a valid kernel version is returned."""
Lizzy Presland0b978e62022-09-09 16:55:29 +00001311 kernel_candidates = [
1312 "sys-kernel/chromeos-kernel-experimental-4.18_rc2-r23",
Alex Klein1699fab2022-09-08 08:46:06 -06001313 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
Lizzy Presland0b978e62022-09-09 16:55:29 +00001314 "sys-kernel/chromeos-kernel-5_15-5.15.65-r869",
1315 "sys-kernel/upstream-kernel-next-9999",
1316 "sys-kernel/socfpga-kernel-4.20-r34",
Alex Klein1699fab2022-09-08 08:46:06 -06001317 ]
1318 self.PatchObject(
Lizzy Presland0b978e62022-09-09 16:55:29 +00001319 portage_util,
1320 "GetFlattenedDepsForPackage",
1321 return_value=kernel_candidates,
1322 )
1323
1324 installed_pkgs = [
1325 "sys-kernel/linux-firmware-0.0.1-r594",
1326 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1327 "virtual/linux-sources-1-r30",
1328 ]
1329 self.PatchObject(
1330 portage_util,
1331 "GetPackageDependencies",
1332 return_value=installed_pkgs,
Alex Klein1699fab2022-09-08 08:46:06 -06001333 )
Michael Mortensenfbf2b2d2020-05-14 16:33:06 -06001334
Alex Klein1699fab2022-09-08 08:46:06 -06001335 result = packages.determine_kernel_version(self.build_target)
1336 self.assertEqual(result, "4.4.223-r2209")
Michael Mortensenfbf2b2d2020-05-14 16:33:06 -06001337
Lizzy Presland0b978e62022-09-09 16:55:29 +00001338 def test_determine_kernel_version_ignores_exact_duplicates(self):
1339 """Tests that multiple results for candidates is ignored."""
1340 # Depgraph is evaluated for version as well as revision, so graph will
1341 # return all results twice.
1342 kernel_candidates = [
1343 "sys-kernel/chromeos-kernel-experimental-4.18_rc2-r23",
1344 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1345 "sys-kernel/chromeos-kernel-5_15-5.15.65-r869",
1346 "sys-kernel/upstream-kernel-next-9999",
1347 "sys-kernel/socfpga-kernel-4.20-r34",
1348 "sys-kernel/chromeos-kernel-experimental-4.18_rc2-r23",
1349 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1350 "sys-kernel/chromeos-kernel-5_15-5.15.65-r869",
1351 "sys-kernel/upstream-kernel-next-9999",
1352 "sys-kernel/socfpga-kernel-4.20-r34",
1353 ]
1354 self.PatchObject(
1355 portage_util,
1356 "GetFlattenedDepsForPackage",
1357 return_value=kernel_candidates,
1358 )
1359
1360 installed_pkgs = [
1361 "sys-kernel/linux-firmware-0.0.1-r594",
1362 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1363 "virtual/linux-sources-1-r30",
1364 ]
Alex Klein1699fab2022-09-08 08:46:06 -06001365 self.PatchObject(
1366 portage_util,
1367 "GetPackageDependencies",
Lizzy Presland0b978e62022-09-09 16:55:29 +00001368 return_value=installed_pkgs,
1369 )
1370
1371 result = packages.determine_kernel_version(self.build_target)
1372 self.assertEqual(result, "4.4.223-r2209")
1373
1374 def test_determine_kernel_version_ignores_virtual_package(self):
1375 """Tests that top-level package is ignored as potential kernel pkg."""
1376 # Depgraph results include the named package at level 0 as well as its
1377 # first-order dependencies, so verify that the virtual package is not
1378 # included as a kernel package.
1379 kernel_candidates = [
1380 "virtual/linux-sources-1",
1381 "sys-kernel/chromeos-kernel-experimental-4.18_rc2-r23",
1382 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1383 "sys-kernel/chromeos-kernel-5_15-5.15.65-r869",
1384 "sys-kernel/upstream-kernel-next-9999",
1385 "sys-kernel/socfpga-kernel-4.20-r34",
1386 "virtual/linux-sources-1-r30",
1387 "sys-kernel/chromeos-kernel-experimental-4.18_rc2-r23",
1388 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1389 "sys-kernel/chromeos-kernel-5_15-5.15.65-r869",
1390 "sys-kernel/upstream-kernel-next-9999",
1391 "sys-kernel/socfpga-kernel-4.20-r34",
1392 ]
1393 self.PatchObject(
1394 portage_util,
1395 "GetFlattenedDepsForPackage",
1396 return_value=kernel_candidates,
1397 )
1398
1399 installed_pkgs = [
1400 "sys-kernel/linux-firmware-0.0.1-r594",
1401 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1402 "virtual/linux-sources-1-r30",
1403 ]
1404 self.PatchObject(
1405 portage_util,
1406 "GetPackageDependencies",
1407 return_value=installed_pkgs,
1408 )
1409
1410 result = packages.determine_kernel_version(self.build_target)
1411 self.assertEqual(result, "4.4.223-r2209")
1412
1413 def test_determine_kernel_version_too_many(self):
1414 """Tests that an exception is thrown with too many matching packages."""
1415 package_result = [
1416 "sys-kernel/chromeos-kernel-experimental-4.18_rc2-r23",
1417 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1418 "sys-kernel/chromeos-kernel-5_15-5.15.65-r869",
1419 "sys-kernel/upstream-kernel-next-9999",
1420 "sys-kernel/socfpga-kernel-4.20-r34",
1421 ]
1422 self.PatchObject(
1423 portage_util,
1424 "GetFlattenedDepsForPackage",
1425 return_value=package_result,
1426 )
1427
1428 installed_pkgs = [
1429 "sys-kernel/linux-firmware-0.0.1-r594",
1430 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1431 "sys-kernel/chromeos-kernel-5_15-5.15.65-r869",
1432 "virtual/linux-sources-1-r30",
1433 ]
1434 self.PatchObject(
1435 portage_util,
1436 "GetPackageDependencies",
1437 return_value=installed_pkgs,
1438 )
1439
1440 with self.assertRaises(packages.KernelVersionError):
1441 packages.determine_kernel_version(self.build_target)
1442
1443 def test_determine_kernel_version_no_kernel_match(self):
1444 """Tests that an exception is thrown with 0-sized intersection."""
1445 package_result = [
1446 "sys-kernel/chromeos-kernel-experimental-4.18_rc2-r23",
1447 "sys-kernel/chromeos-kernel-4_4-4.4.223-r2209",
1448 "sys-kernel/chromeos-kernel-5_15-5.15.65-r869",
1449 "sys-kernel/upstream-kernel-next-9999",
1450 ]
1451 self.PatchObject(
1452 portage_util,
1453 "GetFlattenedDepsForPackage",
1454 return_value=package_result,
1455 )
1456
1457 installed_pkgs = [
1458 "sys-kernel/linux-firmware-0.0.1-r594",
1459 "sys-kernel/socfpga-kernel-4.20-r34",
1460 "virtual/linux-sources-1-r30",
1461 ]
1462 self.PatchObject(
1463 portage_util,
1464 "GetPackageDependencies",
1465 return_value=installed_pkgs,
1466 )
1467
1468 with self.assertRaises(packages.KernelVersionError):
1469 packages.determine_kernel_version(self.build_target)
1470
1471 def test_determine_kernel_version_exception(self):
1472 """Tests that portage_util exceptions result in returning empty str."""
1473 self.PatchObject(
1474 portage_util,
1475 "GetFlattenedDepsForPackage",
Alex Klein1699fab2022-09-08 08:46:06 -06001476 side_effect=cros_build_lib.RunCommandError("error"),
1477 )
1478 result = packages.determine_kernel_version(self.build_target)
Lizzy Presland0b978e62022-09-09 16:55:29 +00001479 self.assertEqual(result, "")
Michael Mortensenfbf2b2d2020-05-14 16:33:06 -06001480
Alex Klein627e04c2021-11-10 15:56:47 -07001481
Michael Mortensenc2615b72019-10-15 08:12:24 -06001482class ChromeVersionsTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001483 """Tests getting chrome version."""
Michael Mortensen14960d02019-10-18 07:53:59 -06001484
Alex Klein1699fab2022-09-08 08:46:06 -06001485 def setUp(self):
1486 self.build_target = build_target_lib.BuildTarget("board")
Michael Mortensenc2615b72019-10-15 08:12:24 -06001487
Alex Klein1699fab2022-09-08 08:46:06 -06001488 def test_determine_chrome_version(self):
1489 """Tests that a valid chrome version is returned."""
1490 # Mock PortageqBestVisible to return a valid chrome version string.
1491 r1_cpf = "chromeos-base/chromeos-chrome-78.0.3900.0_rc-r1"
1492 r1_cpv = package_info.SplitCPV(r1_cpf)
1493 self.PatchObject(
1494 portage_util, "PortageqBestVisible", return_value=r1_cpv
1495 )
Michael Mortensenc2615b72019-10-15 08:12:24 -06001496
Alex Klein1699fab2022-09-08 08:46:06 -06001497 chrome_version = packages.determine_chrome_version(self.build_target)
1498 version_numbers = chrome_version.split(".")
1499 self.assertEqual(len(version_numbers), 4)
1500 self.assertEqual(int(version_numbers[0]), 78)
Michael Mortensen9fdb14b2019-10-17 11:17:30 -06001501
Alex Klein1699fab2022-09-08 08:46:06 -06001502 def test_determine_chrome_version_handle_exception(self):
1503 # Mock what happens when portage throws an exception that bubbles up (via
1504 # RunCommand)inside portage_util.PortageqBestVisible.
1505 self.PatchObject(
1506 portage_util,
1507 "PortageqBestVisible",
1508 side_effect=cros_build_lib.RunCommandError("error"),
1509 )
1510 target = packages.determine_chrome_version(self.build_target)
1511 self.assertEqual(target, None)
Michael Mortensen9fe740c2019-10-29 14:42:48 -06001512
Michael Mortensen9fdb14b2019-10-17 11:17:30 -06001513
1514class PlatformVersionsTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001515 """Tests getting platform version."""
Michael Mortensen9fdb14b2019-10-17 11:17:30 -06001516
Alex Klein1699fab2022-09-08 08:46:06 -06001517 def test_determine_platform_version(self):
1518 """Test checking that a valid platform version is returned."""
1519 platform_version = packages.determine_platform_version()
1520 # The returned platform version is something like 12603.0.0.
1521 version_string_list = platform_version.split(".")
1522 self.assertEqual(len(version_string_list), 3)
1523 # We don't want to check an exact version, but the first number should be
1524 # non-zero.
1525 self.assertGreaterEqual(int(version_string_list[0]), 1)
Michael Mortensen009cb662019-10-21 11:38:43 -06001526
Alex Klein1699fab2022-09-08 08:46:06 -06001527 def test_determine_milestone_version(self):
1528 """Test checking that a valid milestone version is returned."""
1529 milestone_version = packages.determine_milestone_version()
1530 # Milestone version should be non-zero
1531 self.assertGreaterEqual(int(milestone_version), 1)
Michael Mortensen009cb662019-10-21 11:38:43 -06001532
Alex Klein1699fab2022-09-08 08:46:06 -06001533 def test_determine_full_version(self):
1534 """Test checking that a valid full version is returned."""
1535 full_version = packages.determine_full_version()
1536 pattern = r"^R(\d+)-(\d+.\d+.\d+(-rc\d+)*)"
1537 m = re.match(pattern, full_version)
1538 self.assertTrue(m)
1539 milestone_version = m.group(1)
1540 self.assertGreaterEqual(int(milestone_version), 1)
Michael Mortensen009cb662019-10-21 11:38:43 -06001541
Alex Klein1699fab2022-09-08 08:46:06 -06001542 def test_versions_based_on_mock(self):
1543 # Create a test version_info object, and than mock VersionInfo.from_repo
1544 # return it.
1545 test_platform_version = "12575.0.0"
1546 test_chrome_branch = "75"
1547 version_info_mock = chromeos_version.VersionInfo(test_platform_version)
1548 version_info_mock.chrome_branch = test_chrome_branch
1549 self.PatchObject(
1550 chromeos_version.VersionInfo,
1551 "from_repo",
1552 return_value=version_info_mock,
1553 )
1554 test_full_version = (
1555 "R" + test_chrome_branch + "-" + test_platform_version
1556 )
1557 platform_version = packages.determine_platform_version()
1558 milestone_version = packages.determine_milestone_version()
1559 full_version = packages.determine_full_version()
1560 self.assertEqual(platform_version, test_platform_version)
1561 self.assertEqual(milestone_version, test_chrome_branch)
1562 self.assertEqual(full_version, test_full_version)
Chris McDonaldea0312c2020-05-04 23:33:15 -06001563
1564
1565# Each of the columns in the following table is a separate dimension along
1566# which Chrome uprev test cases can vary in behavior. The full test space would
1567# be the Cartesian product of the possible values of each column.
1568# 'CHROME_EBUILD' refers to the relationship between the version of the existing
1569# Chrome ebuild vs. the requested uprev version. 'FOLLOWER_EBUILDS' refers to
1570# the same relationship but for the packages defined in OTHER_CHROME_PACKAGES.
1571# 'EBUILDS MODIFIED' refers to whether any of the existing 9999 ebuilds have
1572# modified contents relative to their corresponding stable ebuilds.
1573#
1574# CHROME_EBUILD FOLLOWER_EBUILDS EBUILDS_MODIFIED
1575#
1576# HIGHER HIGHER YES
1577# SAME SAME NO
1578# LOWER LOWER
1579# DOESN'T EXIST YET
1580
1581# These test cases cover both CHROME & FOLLOWER ebuilds being identically
1582# higher, lower, or the same versions, with no modified ebuilds.
1583UPREV_VERSION_CASES = (
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001584 # Uprev.
Chris McDonaldea0312c2020-05-04 23:33:15 -06001585 pytest.param(
Alex Klein1699fab2022-09-08 08:46:06 -06001586 "80.0.8080.0",
1587 "81.0.8181.0",
Chris McDonaldea0312c2020-05-04 23:33:15 -06001588 # One added and one deleted for chrome and each "other" package.
1589 2 * (1 + len(constants.OTHER_CHROME_PACKAGES)),
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001590 False,
Alex Klein1699fab2022-09-08 08:46:06 -06001591 id="newer_chrome_version",
Chris McDonaldea0312c2020-05-04 23:33:15 -06001592 ),
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001593 # Revbump.
1594 pytest.param(
Alex Klein1699fab2022-09-08 08:46:06 -06001595 "80.0.8080.0",
1596 "80.0.8080.0",
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001597 2,
1598 True,
Alex Klein1699fab2022-09-08 08:46:06 -06001599 id="chrome_revbump",
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001600 ),
Chris McDonaldea0312c2020-05-04 23:33:15 -06001601 # No files should be changed in these cases.
1602 pytest.param(
Alex Klein1699fab2022-09-08 08:46:06 -06001603 "80.0.8080.0",
1604 "80.0.8080.0",
Chris McDonaldea0312c2020-05-04 23:33:15 -06001605 0,
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001606 False,
Alex Klein1699fab2022-09-08 08:46:06 -06001607 id="same_chrome_version",
Chris McDonaldea0312c2020-05-04 23:33:15 -06001608 ),
1609 pytest.param(
Alex Klein1699fab2022-09-08 08:46:06 -06001610 "80.0.8080.0",
1611 "79.0.7979.0",
Chris McDonaldea0312c2020-05-04 23:33:15 -06001612 0,
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001613 False,
Alex Klein1699fab2022-09-08 08:46:06 -06001614 id="older_chrome_version",
Chris McDonaldea0312c2020-05-04 23:33:15 -06001615 ),
1616)
1617
1618
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001619@pytest.mark.parametrize(
Alex Klein1699fab2022-09-08 08:46:06 -06001620 "old_version, new_version, expected_count, modify_unstable",
1621 UPREV_VERSION_CASES,
1622)
1623def test_uprev_chrome_all_files_already_exist(
1624 old_version,
1625 new_version,
1626 expected_count,
1627 modify_unstable,
1628 monkeypatch,
1629 overlay_stack,
1630):
1631 """Test Chrome uprevs work as expected when all packages already exist."""
1632 (overlay,) = overlay_stack(1)
1633 monkeypatch.setattr(uprev_lib, "_CHROME_OVERLAY_PATH", overlay.path)
Chris McDonaldea0312c2020-05-04 23:33:15 -06001634
Alex Klein1699fab2022-09-08 08:46:06 -06001635 unstable_chrome = cr.test.Package(
1636 "chromeos-base", "chromeos-chrome", version="9999", keywords="~*"
1637 )
1638 if modify_unstable:
1639 # Add some field not set in stable.
1640 unstable_chrome.depend = "foo/bar"
Alex Klein0b2ec2d2021-06-23 15:56:45 -06001641
Alex Klein1699fab2022-09-08 08:46:06 -06001642 stable_chrome = cr.test.Package(
1643 "chromeos-base", "chromeos-chrome", version=f"{old_version}_rc-r1"
1644 )
Chris McDonaldea0312c2020-05-04 23:33:15 -06001645
Alex Klein1699fab2022-09-08 08:46:06 -06001646 overlay.add_package(unstable_chrome)
1647 overlay.add_package(stable_chrome)
Chris McDonaldea0312c2020-05-04 23:33:15 -06001648
Alex Klein1699fab2022-09-08 08:46:06 -06001649 for pkg_str in constants.OTHER_CHROME_PACKAGES:
1650 category, pkg_name = pkg_str.split("/")
1651 unstable_pkg = cr.test.Package(
1652 category, pkg_name, version="9999", keywords="~*"
1653 )
1654 stable_pkg = cr.test.Package(
1655 category, pkg_name, version=f"{old_version}_rc-r1"
1656 )
Chris McDonaldea0312c2020-05-04 23:33:15 -06001657
Alex Klein1699fab2022-09-08 08:46:06 -06001658 overlay.add_package(unstable_pkg)
1659 overlay.add_package(stable_pkg)
Chris McDonaldea0312c2020-05-04 23:33:15 -06001660
Alex Klein1699fab2022-09-08 08:46:06 -06001661 git_refs = [
1662 GitRef(
1663 path="/foo", ref=f"refs/tags/{new_version}", revision="stubcommit"
1664 )
1665 ]
1666 res = packages.uprev_chrome_from_ref(None, git_refs, None)
Chris McDonaldea0312c2020-05-04 23:33:15 -06001667
Alex Klein1699fab2022-09-08 08:46:06 -06001668 modified_file_count = sum(len(m.files) for m in res.modified)
1669 assert modified_file_count == expected_count
Michael Mortensen125bb012020-05-21 14:02:10 -06001670
1671
Alex Klein1699fab2022-09-08 08:46:06 -06001672@pytest.mark.usefixtures("testcase_monkeypatch")
Michael Mortensen125bb012020-05-21 14:02:10 -06001673class GetModelsTest(cros_test_lib.RunCommandTempDirTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001674 """Tests for get_models."""
Michael Mortensen125bb012020-05-21 14:02:10 -06001675
Alex Klein1699fab2022-09-08 08:46:06 -06001676 def setUp(self):
1677 self.board = "test-board"
1678 self.rc.SetDefaultCmdResult(stdout="pyro\nreef\nsnappy\n")
1679 self.monkeypatch.setattr(constants, "SOURCE_ROOT", self.tempdir)
1680 build_bin = os.path.join(
1681 self.tempdir, constants.DEFAULT_CHROOT_DIR, "usr", "bin"
1682 )
1683 osutils.Touch(
1684 os.path.join(build_bin, "cros_config_host"), makedirs=True
1685 )
Michael Mortensen125bb012020-05-21 14:02:10 -06001686
Alex Klein1699fab2022-09-08 08:46:06 -06001687 def testGetModels(self):
1688 """Test get_models."""
1689 build_target = build_target_lib.BuildTarget(self.board)
1690 result = packages.get_models(build_target)
1691 self.assertEqual(result, ["pyro", "reef", "snappy"])
Michael Mortensen359c1f32020-05-28 19:35:42 -06001692
1693
1694class GetKeyIdTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001695 """Tests for get_key_id."""
Michael Mortensen359c1f32020-05-28 19:35:42 -06001696
Alex Klein1699fab2022-09-08 08:46:06 -06001697 def setUp(self):
1698 self.board = "test-board"
1699 self.build_target = build_target_lib.BuildTarget(self.board)
Michael Mortensen359c1f32020-05-28 19:35:42 -06001700
Alex Klein1699fab2022-09-08 08:46:06 -06001701 def testGetKeyId(self):
1702 """Test get_key_id when _run_cros_config_host returns a key."""
1703 self.PatchObject(
1704 packages, "_run_cros_config_host", return_value=["key"]
1705 )
1706 result = packages.get_key_id(self.build_target, "model")
1707 self.assertEqual(result, "key")
Michael Mortensen359c1f32020-05-28 19:35:42 -06001708
Alex Klein1699fab2022-09-08 08:46:06 -06001709 def testGetKeyIdNoKey(self):
1710 """Test get_key_id when None should be returned."""
1711 self.PatchObject(
1712 packages, "_run_cros_config_host", return_value=["key1", "key2"]
1713 )
1714 result = packages.get_key_id(self.build_target, "model")
1715 self.assertEqual(result, None)
Ben Reiche779cf42020-12-15 03:21:31 +00001716
1717
Harvey Yang3eee06c2021-03-18 15:47:56 +08001718class GetLatestVersionTest(cros_test_lib.TestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001719 """Tests for get_latest_version_from_refs."""
Ben Reiche779cf42020-12-15 03:21:31 +00001720
Alex Klein1699fab2022-09-08 08:46:06 -06001721 def setUp(self):
1722 self.prefix = "refs/tags/drivefs_"
1723 # The tag ref template.
1724 ref_tpl = self.prefix + "%s"
Ben Reiche779cf42020-12-15 03:21:31 +00001725
Alex Klein1699fab2022-09-08 08:46:06 -06001726 self.latest = "44.0.20"
1727 self.versions = ["42.0.1", self.latest, "44.0.19", "39.0.15"]
1728 self.latest_ref = uprev_lib.GitRef(
1729 "/path", ref_tpl % self.latest, "abc123"
1730 )
1731 self.refs = [
1732 uprev_lib.GitRef("/path", ref_tpl % v, "abc123")
1733 for v in self.versions
1734 ]
Ben Reiche779cf42020-12-15 03:21:31 +00001735
Alex Klein1699fab2022-09-08 08:46:06 -06001736 def test_single_ref(self):
1737 """Test a single ref is supplied."""
1738 # pylint: disable=protected-access
1739 self.assertEqual(
1740 self.latest,
1741 packages._get_latest_version_from_refs(
1742 self.prefix, [self.latest_ref]
1743 ),
1744 )
Ben Reiche779cf42020-12-15 03:21:31 +00001745
Alex Klein1699fab2022-09-08 08:46:06 -06001746 def test_multiple_ref_versions(self):
1747 """Test multiple refs supplied."""
1748 # pylint: disable=protected-access
1749 self.assertEqual(
1750 self.latest,
1751 packages._get_latest_version_from_refs(self.prefix, self.refs),
1752 )
Ben Reiche779cf42020-12-15 03:21:31 +00001753
Alex Klein1699fab2022-09-08 08:46:06 -06001754 def test_no_refs_returns_none(self):
1755 """Test no refs supplied."""
1756 # pylint: disable=protected-access
1757 self.assertEqual(
1758 packages._get_latest_version_from_refs(self.prefix, []), None
1759 )
Harvey Yang9c61e9c2021-03-02 16:32:43 +08001760
Chinglin Yu84818732022-10-03 12:03:43 +08001761 def test_ref_prefix(self):
1762 """Test refs with a different prefix isn't used"""
1763 # pylint: disable=protected-access
1764 # Add refs/tags/foo_100.0.0 to the refs, which should be ignored in
1765 # _get_latest_version_from_refs because the prefix doesn't match, even
1766 # if its version number is larger.
1767 refs = self.refs + [
1768 uprev_lib.GitRef("/path", "refs/tags/foo_100.0.0", "abc123")
1769 ]
1770 self.assertEqual(
1771 self.latest,
1772 packages._get_latest_version_from_refs(self.prefix, refs),
1773 )
1774
Harvey Yang9c61e9c2021-03-02 16:32:43 +08001775
Alex Klein6becabc2020-09-11 14:03:05 -06001776class NeedsChromeSourceTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001777 """Tests for needs_chrome_source."""
Alex Klein6becabc2020-09-11 14:03:05 -06001778
Alex Klein1699fab2022-09-08 08:46:06 -06001779 def _build_graph(self, with_chrome: bool, with_followers: bool):
1780 root = "/build/build_target"
1781 foo_bar = package_info.parse("foo/bar-1")
1782 chrome = package_info.parse(f"{constants.CHROME_CP}-1.2.3.4")
1783 followers = [
1784 package_info.parse(f"{pkg}-1.2.3.4")
1785 for pkg in constants.OTHER_CHROME_PACKAGES
1786 ]
1787 nodes = [dependency_graph.PackageNode(foo_bar, root)]
1788 root_pkgs = ["foo/bar-1"]
1789 if with_chrome:
1790 nodes.append(dependency_graph.PackageNode(chrome, root))
1791 root_pkgs.append(chrome.cpvr)
1792 if with_followers:
1793 nodes.extend(
1794 [dependency_graph.PackageNode(f, root) for f in followers]
1795 )
1796 root_pkgs.extend([f.cpvr for f in followers])
Alex Klein6becabc2020-09-11 14:03:05 -06001797
Alex Klein1699fab2022-09-08 08:46:06 -06001798 return dependency_graph.DependencyGraph(nodes, root, root_pkgs)
Alex Klein6becabc2020-09-11 14:03:05 -06001799
Alex Klein1699fab2022-09-08 08:46:06 -06001800 def test_needs_all(self):
1801 """Verify we need source when we have no prebuilts."""
1802 graph = self._build_graph(with_chrome=True, with_followers=True)
1803 self.PatchObject(
1804 depgraph, "get_sysroot_dependency_graph", return_value=graph
1805 )
1806 self.PatchObject(packages, "has_prebuilt", return_value=False)
1807 self.PatchObject(
1808 packages,
1809 "uprev_chrome",
1810 return_value=uprev_lib.UprevVersionedPackageResult(),
1811 )
Alex Klein6becabc2020-09-11 14:03:05 -06001812
Alex Klein1699fab2022-09-08 08:46:06 -06001813 build_target = build_target_lib.BuildTarget("build_target")
Alex Klein6becabc2020-09-11 14:03:05 -06001814
Alex Klein1699fab2022-09-08 08:46:06 -06001815 result = packages.needs_chrome_source(build_target)
Alex Klein6becabc2020-09-11 14:03:05 -06001816
Alex Klein1699fab2022-09-08 08:46:06 -06001817 self.assertTrue(result.needs_chrome_source)
1818 self.assertTrue(result.builds_chrome)
1819 self.assertTrue(result.packages)
1820 self.assertEqual(
1821 len(result.packages), len(constants.OTHER_CHROME_PACKAGES) + 1
1822 )
1823 self.assertTrue(result.missing_chrome_prebuilt)
1824 self.assertTrue(result.missing_follower_prebuilt)
1825 self.assertFalse(result.local_uprev)
Alex Klein6becabc2020-09-11 14:03:05 -06001826
Alex Klein1699fab2022-09-08 08:46:06 -06001827 def test_needs_none(self):
1828 """Verify not building any of the chrome packages prevents needing it."""
1829 graph = self._build_graph(with_chrome=False, with_followers=False)
1830 self.PatchObject(
1831 depgraph, "get_sysroot_dependency_graph", return_value=graph
1832 )
1833 self.PatchObject(packages, "has_prebuilt", return_value=False)
1834 self.PatchObject(
1835 packages,
1836 "uprev_chrome",
1837 return_value=uprev_lib.UprevVersionedPackageResult(),
1838 )
Alex Klein6becabc2020-09-11 14:03:05 -06001839
Alex Klein1699fab2022-09-08 08:46:06 -06001840 build_target = build_target_lib.BuildTarget("build_target")
Alex Klein6becabc2020-09-11 14:03:05 -06001841
Alex Klein1699fab2022-09-08 08:46:06 -06001842 result = packages.needs_chrome_source(build_target)
Alex Klein6becabc2020-09-11 14:03:05 -06001843
Alex Klein1699fab2022-09-08 08:46:06 -06001844 self.assertFalse(result.needs_chrome_source)
1845 self.assertFalse(result.builds_chrome)
1846 self.assertFalse(result.packages)
1847 self.assertFalse(result.missing_chrome_prebuilt)
1848 self.assertFalse(result.missing_follower_prebuilt)
1849 self.assertFalse(result.local_uprev)
Alex Klein6becabc2020-09-11 14:03:05 -06001850
Alex Klein1699fab2022-09-08 08:46:06 -06001851 def test_needs_chrome_only(self):
1852 """Verify only chrome triggers needs chrome source."""
1853 graph = self._build_graph(with_chrome=True, with_followers=False)
1854 self.PatchObject(
1855 depgraph, "get_sysroot_dependency_graph", return_value=graph
1856 )
1857 self.PatchObject(packages, "has_prebuilt", return_value=False)
1858 self.PatchObject(
1859 packages,
1860 "uprev_chrome",
1861 return_value=uprev_lib.UprevVersionedPackageResult(),
1862 )
Alex Klein6becabc2020-09-11 14:03:05 -06001863
Alex Klein1699fab2022-09-08 08:46:06 -06001864 build_target = build_target_lib.BuildTarget("build_target")
Alex Klein6becabc2020-09-11 14:03:05 -06001865
Alex Klein1699fab2022-09-08 08:46:06 -06001866 result = packages.needs_chrome_source(build_target)
Alex Klein6becabc2020-09-11 14:03:05 -06001867
Alex Klein1699fab2022-09-08 08:46:06 -06001868 self.assertTrue(result.needs_chrome_source)
1869 self.assertTrue(result.builds_chrome)
1870 self.assertTrue(result.packages)
1871 self.assertEqual(
1872 set([p.atom for p in result.packages]), {constants.CHROME_CP}
1873 )
1874 self.assertTrue(result.missing_chrome_prebuilt)
1875 self.assertFalse(result.missing_follower_prebuilt)
1876 self.assertFalse(result.local_uprev)
Alex Klein6becabc2020-09-11 14:03:05 -06001877
Alex Klein1699fab2022-09-08 08:46:06 -06001878 def test_needs_followers_only(self):
1879 """Verify only chrome followers triggers needs chrome source."""
1880 graph = self._build_graph(with_chrome=False, with_followers=True)
1881 self.PatchObject(
1882 depgraph, "get_sysroot_dependency_graph", return_value=graph
1883 )
1884 self.PatchObject(packages, "has_prebuilt", return_value=False)
1885 self.PatchObject(
1886 packages,
1887 "uprev_chrome",
1888 return_value=uprev_lib.UprevVersionedPackageResult(),
1889 )
Alex Klein6becabc2020-09-11 14:03:05 -06001890
Alex Klein1699fab2022-09-08 08:46:06 -06001891 build_target = build_target_lib.BuildTarget("build_target")
Alex Klein6becabc2020-09-11 14:03:05 -06001892
Alex Klein1699fab2022-09-08 08:46:06 -06001893 result = packages.needs_chrome_source(build_target)
Alex Klein6becabc2020-09-11 14:03:05 -06001894
Alex Klein1699fab2022-09-08 08:46:06 -06001895 self.assertTrue(result.needs_chrome_source)
1896 self.assertFalse(result.builds_chrome)
1897 self.assertTrue(result.packages)
1898 self.assertEqual(
1899 set([p.atom for p in result.packages]),
1900 set(constants.OTHER_CHROME_PACKAGES),
1901 )
1902 self.assertFalse(result.missing_chrome_prebuilt)
1903 self.assertTrue(result.missing_follower_prebuilt)
1904 self.assertFalse(result.local_uprev)
Alex Klein6becabc2020-09-11 14:03:05 -06001905
Alex Klein1699fab2022-09-08 08:46:06 -06001906 def test_has_prebuilts(self):
1907 """Test prebuilts prevent us from needing chrome source."""
1908 graph = self._build_graph(with_chrome=True, with_followers=True)
1909 self.PatchObject(
1910 depgraph, "get_sysroot_dependency_graph", return_value=graph
1911 )
1912 self.PatchObject(packages, "has_prebuilt", return_value=True)
1913 self.PatchObject(
1914 packages,
1915 "uprev_chrome",
1916 return_value=uprev_lib.UprevVersionedPackageResult(),
1917 )
Alex Klein6becabc2020-09-11 14:03:05 -06001918
Alex Klein1699fab2022-09-08 08:46:06 -06001919 build_target = build_target_lib.BuildTarget("build_target")
Alex Klein6becabc2020-09-11 14:03:05 -06001920
Alex Klein1699fab2022-09-08 08:46:06 -06001921 result = packages.needs_chrome_source(build_target)
Alex Klein6becabc2020-09-11 14:03:05 -06001922
Alex Klein1699fab2022-09-08 08:46:06 -06001923 self.assertFalse(result.needs_chrome_source)
1924 self.assertTrue(result.builds_chrome)
1925 self.assertFalse(result.packages)
1926 self.assertFalse(result.missing_chrome_prebuilt)
1927 self.assertFalse(result.missing_follower_prebuilt)
1928 self.assertFalse(result.local_uprev)
Alex Klein6becabc2020-09-11 14:03:05 -06001929
Alex Klein1699fab2022-09-08 08:46:06 -06001930 def test_compile_source(self):
1931 """Test compile source ignores prebuilts."""
1932 graph = self._build_graph(with_chrome=True, with_followers=True)
1933 self.PatchObject(
1934 depgraph, "get_sysroot_dependency_graph", return_value=graph
1935 )
1936 self.PatchObject(packages, "has_prebuilt", return_value=True)
1937 self.PatchObject(
1938 packages,
1939 "uprev_chrome",
1940 return_value=uprev_lib.UprevVersionedPackageResult(),
1941 )
Alex Klein6becabc2020-09-11 14:03:05 -06001942
Alex Klein1699fab2022-09-08 08:46:06 -06001943 build_target = build_target_lib.BuildTarget("build_target")
Alex Klein6becabc2020-09-11 14:03:05 -06001944
Alex Klein1699fab2022-09-08 08:46:06 -06001945 result = packages.needs_chrome_source(build_target, compile_source=True)
Alex Klein6becabc2020-09-11 14:03:05 -06001946
Alex Klein1699fab2022-09-08 08:46:06 -06001947 self.assertTrue(result.needs_chrome_source)
1948 self.assertTrue(result.builds_chrome)
1949 self.assertTrue(result.packages)
1950 self.assertEqual(
1951 len(result.packages), len(constants.OTHER_CHROME_PACKAGES) + 1
1952 )
1953 self.assertTrue(result.missing_chrome_prebuilt)
1954 self.assertTrue(result.missing_follower_prebuilt)
1955 self.assertFalse(result.local_uprev)
Alex Kleinde7b76d2021-07-12 12:28:44 -06001956
Alex Klein1699fab2022-09-08 08:46:06 -06001957 def test_local_uprev(self):
1958 """Test compile source ignores prebuilts."""
1959 graph = self._build_graph(with_chrome=True, with_followers=True)
1960 self.PatchObject(
1961 depgraph, "get_sysroot_dependency_graph", return_value=graph
1962 )
1963 self.PatchObject(packages, "has_prebuilt", return_value=False)
Alex Klein75110572021-07-14 10:44:39 -06001964
Alex Klein1699fab2022-09-08 08:46:06 -06001965 uprev_result = uprev_lib.UprevVersionedPackageResult()
1966 uprev_result.add_result("1.2.3.4", ["/tmp/foo"])
1967 self.PatchObject(packages, "uprev_chrome", return_value=uprev_result)
Alex Kleinde7b76d2021-07-12 12:28:44 -06001968
Alex Klein1699fab2022-09-08 08:46:06 -06001969 build_target = build_target_lib.BuildTarget("build_target")
Alex Kleinde7b76d2021-07-12 12:28:44 -06001970
Alex Klein1699fab2022-09-08 08:46:06 -06001971 result = packages.needs_chrome_source(build_target, compile_source=True)
Alex Kleinde7b76d2021-07-12 12:28:44 -06001972
Alex Klein1699fab2022-09-08 08:46:06 -06001973 self.assertTrue(result.needs_chrome_source)
1974 self.assertTrue(result.builds_chrome)
1975 self.assertTrue(result.packages)
1976 self.assertEqual(
1977 len(result.packages), len(constants.OTHER_CHROME_PACKAGES) + 1
1978 )
1979 self.assertTrue(result.missing_chrome_prebuilt)
1980 self.assertTrue(result.missing_follower_prebuilt)
1981 self.assertTrue(result.local_uprev)
Alex Klein6becabc2020-09-11 14:03:05 -06001982
1983
Ben Reich4f3fa1b2020-12-19 08:21:26 +00001984class UprevDrivefsTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06001985 """Tests for uprev_drivefs."""
Ben Reich4f3fa1b2020-12-19 08:21:26 +00001986
Alex Klein1699fab2022-09-08 08:46:06 -06001987 def setUp(self):
1988 self.refs = [
1989 GitRef(
1990 path="/chromeos/platform/drivefs-google3/",
1991 ref="refs/tags/drivefs_45.0.2",
1992 revision="123",
1993 )
1994 ]
1995 self.MOCK_DRIVEFS_EBUILD_PATH = "drivefs.45.0.2-r1.ebuild"
Ben Reich4f3fa1b2020-12-19 08:21:26 +00001996
Alex Klein1699fab2022-09-08 08:46:06 -06001997 def revisionBumpOutcome(self, ebuild_path):
1998 return uprev_lib.UprevResult(
1999 uprev_lib.Outcome.REVISION_BUMP, [ebuild_path]
2000 )
Ben Reich4f3fa1b2020-12-19 08:21:26 +00002001
Alex Klein1699fab2022-09-08 08:46:06 -06002002 def majorBumpOutcome(self, ebuild_path):
2003 return uprev_lib.UprevResult(
2004 uprev_lib.Outcome.VERSION_BUMP, [ebuild_path]
2005 )
Ben Reich4f3fa1b2020-12-19 08:21:26 +00002006
Alex Klein1699fab2022-09-08 08:46:06 -06002007 def sameVersionOutcome(self):
2008 return uprev_lib.UprevResult(uprev_lib.Outcome.SAME_VERSION_EXISTS)
Ben Reich4f3fa1b2020-12-19 08:21:26 +00002009
Alex Klein1699fab2022-09-08 08:46:06 -06002010 def test_latest_version_returns_none(self):
2011 """Test no refs were supplied"""
2012 output = packages.uprev_drivefs(None, [], None)
2013 self.assertFalse(output.uprevved)
Ben Reich4f3fa1b2020-12-19 08:21:26 +00002014
Alex Klein1699fab2022-09-08 08:46:06 -06002015 def test_drivefs_uprev_fails(self):
2016 """Test a single ref is supplied."""
2017 self.PatchObject(
2018 uprev_lib,
2019 "uprev_workon_ebuild_to_version",
2020 side_effect=[None, None],
2021 )
2022 output = packages.uprev_drivefs(None, self.refs, None)
2023 self.assertFalse(output.uprevved)
Ben Reich4f3fa1b2020-12-19 08:21:26 +00002024
Alex Klein1699fab2022-09-08 08:46:06 -06002025 def test_same_version_exists(self):
2026 """Test the same version exists uprev should not happen."""
2027 drivefs_outcome = self.sameVersionOutcome()
2028 self.PatchObject(
2029 uprev_lib,
2030 "uprev_workon_ebuild_to_version",
2031 side_effect=[drivefs_outcome],
2032 )
2033 output = packages.uprev_drivefs(None, self.refs, None)
2034 self.assertFalse(output.uprevved)
Ben Reich4f3fa1b2020-12-19 08:21:26 +00002035
Alex Klein1699fab2022-09-08 08:46:06 -06002036 def test_revision_bump_both_packages(self):
2037 """Test both packages uprev, should succeed."""
2038 drivefs_outcome = self.revisionBumpOutcome(
2039 self.MOCK_DRIVEFS_EBUILD_PATH
2040 )
2041 self.PatchObject(
2042 uprev_lib,
2043 "uprev_workon_ebuild_to_version",
2044 side_effect=[drivefs_outcome],
2045 )
2046 output = packages.uprev_drivefs(None, self.refs, None)
2047 self.assertTrue(output.uprevved)
Ben Reich4f3fa1b2020-12-19 08:21:26 +00002048
Alex Klein1699fab2022-09-08 08:46:06 -06002049 def test_major_bump_both_packages(self):
2050 """Test both packages uprev, should succeed."""
2051 drivefs_outcome = self.majorBumpOutcome(self.MOCK_DRIVEFS_EBUILD_PATH)
2052 self.PatchObject(
2053 uprev_lib,
2054 "uprev_workon_ebuild_to_version",
2055 side_effect=[drivefs_outcome],
2056 )
2057 output = packages.uprev_drivefs(None, self.refs, None)
2058 self.assertTrue(output.uprevved)
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002059
2060
Denis Nikitin63613e32022-09-09 22:26:50 -07002061class UprevKernelAfdo(cros_test_lib.RunCommandTempDirTestCase):
2062 """Tests for uprev_kernel_afdo."""
2063
2064 def setUp(self):
2065 # patch_ebuild_vars is tested separately.
2066 self.mock_patch = self.PatchObject(packages, "patch_ebuild_vars")
Denis Nikitin88ad5132022-09-28 12:10:01 -07002067 self.PatchObject(constants, "SOURCE_ROOT", new=self.tempdir)
Denis Nikitin63613e32022-09-09 22:26:50 -07002068 self.metadata_dir = os.path.join(
Denis Nikitin63613e32022-09-09 22:26:50 -07002069 "src",
2070 "third_party",
2071 "toolchain-utils",
2072 "afdo_metadata",
2073 )
Denis Nikitin88ad5132022-09-28 12:10:01 -07002074 osutils.SafeMakedirs(os.path.join(self.tempdir, self.metadata_dir))
Denis Nikitin63613e32022-09-09 22:26:50 -07002075
2076 def test_uprev_kernel_afdo_version(self):
2077 """Test kernel afdo version uprev."""
2078 json_files = {
2079 "kernel_afdo.json": (
2080 "{\n"
2081 ' "chromeos-kernel-5_4": {\n'
2082 ' "name": "R106-12345.0-0123456789"\n'
2083 " }\n"
2084 "}"
2085 ),
2086 "kernel_arm_afdo.json": (
2087 "{\n"
2088 ' "chromeos-kernel-5_15": {\n'
2089 ' "name": "R107-67890.0-0123456789"\n'
2090 " }\n"
2091 "}"
2092 ),
2093 }
2094 for f, contents in json_files.items():
2095 self.WriteTempFile(os.path.join(self.metadata_dir, f), contents)
2096
2097 returned_output = packages.uprev_kernel_afdo()
2098
Denis Nikitin88ad5132022-09-28 12:10:01 -07002099 package_root = os.path.join(
2100 constants.SOURCE_ROOT,
2101 constants.CHROMIUMOS_OVERLAY_DIR,
2102 "sys-kernel",
Denis Nikitin63613e32022-09-09 22:26:50 -07002103 )
2104 expect_result = [
2105 uprev_lib.UprevVersionedPackageModifications(
2106 new_version="R106-12345.0-0123456789",
2107 files=[
2108 os.path.join(
2109 package_root,
2110 "chromeos-kernel-5_4",
2111 "chromeos-kernel-5_4-9999.ebuild",
2112 ),
2113 os.path.join(
2114 package_root, "chromeos-kernel-5_4", "Manifest"
2115 ),
2116 ],
2117 ),
2118 uprev_lib.UprevVersionedPackageModifications(
2119 new_version="R107-67890.0-0123456789",
2120 files=[
2121 os.path.join(
2122 package_root,
2123 "chromeos-kernel-5_15",
2124 "chromeos-kernel-5_15-9999.ebuild",
2125 ),
2126 os.path.join(
2127 package_root, "chromeos-kernel-5_15", "Manifest"
2128 ),
2129 ],
2130 ),
2131 ]
2132 self.assertTrue(returned_output.uprevved)
2133 self.assertEqual(returned_output.modified, expect_result)
2134
2135 def test_uprev_kernel_afdo_empty_json(self):
2136 """Test kernel afdo version unchanged."""
2137 json_files = {
2138 "kernel_afdo.json": "{}",
2139 "kernel_arm_afdo.json": "{}",
2140 }
2141 for f, contents in json_files.items():
2142 self.WriteTempFile(os.path.join(self.metadata_dir, f), contents)
2143
2144 returned_output = packages.uprev_kernel_afdo()
2145 self.assertFalse(returned_output.uprevved)
2146
2147 def test_uprev_kernel_afdo_empty_file(self):
2148 """Test malformed json raises."""
2149 json_files = {
2150 "kernel_afdo.json": "",
2151 "kernel_arm_afdo.json": "",
2152 }
2153 for f, contents in json_files.items():
2154 self.WriteTempFile(os.path.join(self.metadata_dir, f), contents)
2155
2156 with self.assertRaisesRegex(
2157 json.decoder.JSONDecodeError, "Expecting value"
2158 ):
2159 packages.uprev_kernel_afdo()
2160
2161 def test_uprev_kernel_afdo_manifest_raises(self):
2162 """Test manifest update raises."""
2163 json_files = {
2164 "kernel_afdo.json": (
2165 "{\n"
2166 ' "chromeos-kernel-5_4": {\n'
2167 ' "name": "R106-12345.0-0123456789"\n'
2168 " }\n"
2169 "}"
2170 ),
2171 }
2172 for f, contents in json_files.items():
2173 self.WriteTempFile(os.path.join(self.metadata_dir, f), contents)
2174 # run() raises exception.
2175 self.rc.SetDefaultCmdResult(
2176 side_effect=cros_build_lib.RunCommandError("error")
2177 )
2178
2179 with self.assertRaises(uprev_lib.EbuildManifestError):
2180 packages.uprev_kernel_afdo()
2181
2182
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002183# TODO(chenghaoyang): Shouldn't use uprev_workon_ebuild_to_version.
2184class UprevPerfettoTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06002185 """Tests for uprev_perfetto."""
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002186
Alex Klein1699fab2022-09-08 08:46:06 -06002187 def setUp(self):
2188 self.refs = [GitRef(path="/foo", ref="refs/tags/v12.0", revision="123")]
2189 self.MOCK_PERFETTO_EBUILD_PATH = "perfetto-12.0-r1.ebuild"
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002190
Alex Klein1699fab2022-09-08 08:46:06 -06002191 def revisionBumpOutcome(self, ebuild_path):
2192 return uprev_lib.UprevResult(
2193 uprev_lib.Outcome.REVISION_BUMP, [ebuild_path]
2194 )
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002195
Alex Klein1699fab2022-09-08 08:46:06 -06002196 def majorBumpOutcome(self, ebuild_path):
2197 return uprev_lib.UprevResult(
2198 uprev_lib.Outcome.VERSION_BUMP, [ebuild_path]
2199 )
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002200
Alex Klein1699fab2022-09-08 08:46:06 -06002201 def newerVersionOutcome(self):
2202 return uprev_lib.UprevResult(uprev_lib.Outcome.NEWER_VERSION_EXISTS)
Harvey Yang3eee06c2021-03-18 15:47:56 +08002203
Alex Klein1699fab2022-09-08 08:46:06 -06002204 def sameVersionOutcome(self):
2205 return uprev_lib.UprevResult(uprev_lib.Outcome.SAME_VERSION_EXISTS)
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002206
Alex Klein1699fab2022-09-08 08:46:06 -06002207 def test_latest_version_returns_none(self):
2208 """Test no refs were supplied"""
2209 output = packages.uprev_perfetto(None, [], None)
2210 self.assertFalse(output.uprevved)
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002211
Alex Klein1699fab2022-09-08 08:46:06 -06002212 def test_perfetto_uprev_fails(self):
2213 """Test a single ref is supplied."""
2214 self.PatchObject(
2215 uprev_lib, "uprev_workon_ebuild_to_version", side_effect=[None]
2216 )
2217 output = packages.uprev_perfetto(None, self.refs, None)
2218 self.assertFalse(output.uprevved)
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002219
Alex Klein1699fab2022-09-08 08:46:06 -06002220 def test_newer_version_exists(self):
2221 """Test the newer version exists uprev should not happen."""
2222 perfetto_outcome = self.newerVersionOutcome()
2223 self.PatchObject(
2224 uprev_lib,
2225 "uprev_workon_ebuild_to_version",
2226 side_effect=[perfetto_outcome],
2227 )
2228 output = packages.uprev_perfetto(None, self.refs, None)
2229 self.assertFalse(output.uprevved)
Harvey Yang3eee06c2021-03-18 15:47:56 +08002230
Alex Klein1699fab2022-09-08 08:46:06 -06002231 def test_same_version_exists(self):
2232 """Test the same version exists uprev should not happen."""
2233 perfetto_outcome = self.sameVersionOutcome()
2234 self.PatchObject(
2235 uprev_lib,
2236 "uprev_workon_ebuild_to_version",
2237 side_effect=[perfetto_outcome],
2238 )
2239 output = packages.uprev_perfetto(None, self.refs, None)
2240 self.assertFalse(output.uprevved)
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002241
Alex Klein1699fab2022-09-08 08:46:06 -06002242 def test_revision_bump_perfetto_package(self):
2243 """Test perfetto package uprev."""
2244 perfetto_outcome = self.revisionBumpOutcome(
2245 self.MOCK_PERFETTO_EBUILD_PATH
2246 )
2247 self.PatchObject(
2248 uprev_lib,
2249 "uprev_workon_ebuild_to_version",
2250 side_effect=[perfetto_outcome],
2251 )
2252 output = packages.uprev_perfetto(None, self.refs, None)
2253 self.assertTrue(output.uprevved)
Harvey Yang9c61e9c2021-03-02 16:32:43 +08002254
Alex Klein1699fab2022-09-08 08:46:06 -06002255 def test_major_bump_perfetto_package(self):
2256 """Test perfetto package uprev."""
2257 perfetto_outcome = self.majorBumpOutcome(self.MOCK_PERFETTO_EBUILD_PATH)
2258 self.PatchObject(
2259 uprev_lib,
2260 "uprev_workon_ebuild_to_version",
2261 side_effect=[perfetto_outcome],
2262 )
2263 output = packages.uprev_perfetto(None, self.refs, None)
2264 self.assertTrue(output.uprevved)
Julio Hurtadof1befec2021-05-05 21:34:26 +00002265
Chinglin Yuad12a512022-10-07 17:26:12 +08002266 def test_revision_bump_trunk(self):
2267 """Test revision bump on receiving non-versioned trunk refs."""
Chinglin Yu5de28a42022-11-11 19:52:21 +08002268 refs = [
2269 GitRef(
2270 path="/foo", ref="refs/heads/main", revision="0123456789abcdef"
2271 )
2272 ]
Chinglin Yuad12a512022-10-07 17:26:12 +08002273 perfetto_outcome = self.revisionBumpOutcome(
2274 self.MOCK_PERFETTO_EBUILD_PATH
2275 )
2276 self.PatchObject(
2277 uprev_lib, "get_stable_ebuild_version", return_value="12.0"
2278 )
2279 self.PatchObject(
2280 uprev_lib,
2281 "uprev_workon_ebuild_to_version",
2282 side_effect=[perfetto_outcome],
2283 )
2284 output = packages.uprev_perfetto(None, refs, None)
2285 self.assertTrue(output.uprevved)
Chinglin Yu5de28a42022-11-11 19:52:21 +08002286 self.assertEqual(output.modified[0].new_version, "12.0-012345678")
Chinglin Yuad12a512022-10-07 17:26:12 +08002287
Alex Klein627e04c2021-11-10 15:56:47 -07002288
Julio Hurtadof1befec2021-05-05 21:34:26 +00002289class UprevLacrosTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06002290 """Tests for uprev_lacros"""
Julio Hurtadof1befec2021-05-05 21:34:26 +00002291
Alex Klein1699fab2022-09-08 08:46:06 -06002292 def setUp(self):
2293 self.refs = [
2294 GitRef(
2295 path="/lacros", ref="refs/heads/main", revision="123.456.789.0"
2296 )
2297 ]
2298 self.MOCK_LACROS_EBUILD_PATH = "chromeos-lacros-123.456.789.0-r1.ebuild"
Julio Hurtadof1befec2021-05-05 21:34:26 +00002299
Alex Klein1699fab2022-09-08 08:46:06 -06002300 def revisionBumpOutcome(self, ebuild_path):
2301 return uprev_lib.UprevResult(
2302 uprev_lib.Outcome.REVISION_BUMP, [ebuild_path]
2303 )
Julio Hurtadof1befec2021-05-05 21:34:26 +00002304
Alex Klein1699fab2022-09-08 08:46:06 -06002305 def majorBumpOutcome(self, ebuild_path):
2306 return uprev_lib.UprevResult(
2307 uprev_lib.Outcome.VERSION_BUMP, [ebuild_path]
2308 )
Julio Hurtadof1befec2021-05-05 21:34:26 +00002309
Alex Klein1699fab2022-09-08 08:46:06 -06002310 def newerVersionOutcome(self, ebuild_path):
2311 return uprev_lib.UprevResult(
2312 uprev_lib.Outcome.NEWER_VERSION_EXISTS, [ebuild_path]
2313 )
Julio Hurtadoa994e002021-07-07 17:57:45 +00002314
Alex Klein1699fab2022-09-08 08:46:06 -06002315 def sameVersionOutcome(self, ebuild_path):
2316 return uprev_lib.UprevResult(
2317 uprev_lib.Outcome.SAME_VERSION_EXISTS, [ebuild_path]
2318 )
Julio Hurtadoa994e002021-07-07 17:57:45 +00002319
Alex Klein1699fab2022-09-08 08:46:06 -06002320 def newEbuildCreatedOutcome(self, ebuild_path):
2321 return uprev_lib.UprevResult(
2322 uprev_lib.Outcome.NEW_EBUILD_CREATED, [ebuild_path]
2323 )
Julio Hurtadof1befec2021-05-05 21:34:26 +00002324
Alex Klein1699fab2022-09-08 08:46:06 -06002325 def test_lacros_uprev_fails(self):
2326 """Test a lacros package uprev with no triggers"""
2327 self.PatchObject(
2328 uprev_lib, "uprev_workon_ebuild_to_version", side_effect=[None]
2329 )
2330 with self.assertRaises(IndexError):
2331 packages.uprev_lacros(None, [], None)
Julio Hurtadof1befec2021-05-05 21:34:26 +00002332
Alex Klein1699fab2022-09-08 08:46:06 -06002333 def test_lacros_uprev_revision_bump(self):
2334 """Test lacros package uprev."""
2335 lacros_outcome = self.revisionBumpOutcome(self.MOCK_LACROS_EBUILD_PATH)
2336 self.PatchObject(
2337 uprev_lib,
2338 "uprev_workon_ebuild_to_version",
2339 side_effect=[lacros_outcome],
2340 )
2341 output = packages.uprev_lacros(None, self.refs, None)
2342 self.assertTrue(output.uprevved)
Julio Hurtadof1befec2021-05-05 21:34:26 +00002343
Alex Klein1699fab2022-09-08 08:46:06 -06002344 def test_lacros_uprev_version_bump(self):
2345 """Test lacros package uprev."""
2346 lacros_outcome = self.majorBumpOutcome(self.MOCK_LACROS_EBUILD_PATH)
2347 self.PatchObject(
2348 uprev_lib,
2349 "uprev_workon_ebuild_to_version",
2350 side_effect=[lacros_outcome],
2351 )
2352 output = packages.uprev_lacros(None, self.refs, None)
2353 self.assertTrue(output.uprevved)
Julio Hurtadof1befec2021-05-05 21:34:26 +00002354
Alex Klein1699fab2022-09-08 08:46:06 -06002355 def test_lacros_uprev_new_ebuild_created(self):
2356 """Test lacros package uprev."""
2357 lacros_outcome = self.newEbuildCreatedOutcome(
2358 self.MOCK_LACROS_EBUILD_PATH
2359 )
2360 self.PatchObject(
2361 uprev_lib,
2362 "uprev_workon_ebuild_to_version",
2363 side_effect=[lacros_outcome],
2364 )
2365 output = packages.uprev_lacros(None, self.refs, None)
2366 self.assertTrue(output.uprevved)
Julio Hurtadoa994e002021-07-07 17:57:45 +00002367
Alex Klein1699fab2022-09-08 08:46:06 -06002368 def test_lacros_uprev_newer_version_exist(self):
2369 """Test the newer version exists uprev should not happen."""
2370 lacros_outcome = self.newerVersionOutcome(self.MOCK_LACROS_EBUILD_PATH)
2371 self.PatchObject(
2372 uprev_lib,
2373 "uprev_workon_ebuild_to_version",
2374 side_effect=[lacros_outcome],
2375 )
2376 output = packages.uprev_lacros(None, self.refs, None)
2377 self.assertFalse(output.uprevved)
Julio Hurtadoa994e002021-07-07 17:57:45 +00002378
Alex Klein1699fab2022-09-08 08:46:06 -06002379 def test_lacros_uprev_same_version_exist(self):
2380 """Test the same version exists uprev should not happen."""
2381 lacros_outcome = self.sameVersionOutcome(self.MOCK_LACROS_EBUILD_PATH)
2382 self.PatchObject(
2383 uprev_lib,
2384 "uprev_workon_ebuild_to_version",
2385 side_effect=[lacros_outcome],
2386 )
2387 output = packages.uprev_lacros(None, self.refs, None)
2388 self.assertFalse(output.uprevved)
Julio Hurtado870ed322021-12-03 18:22:40 +00002389
2390
2391class UprevLacrosInParallelTest(cros_test_lib.MockTestCase):
Alex Klein1699fab2022-09-08 08:46:06 -06002392 """Tests for uprev_lacros"""
Julio Hurtado870ed322021-12-03 18:22:40 +00002393
Alex Klein1699fab2022-09-08 08:46:06 -06002394 def setUp(self):
2395 self.refs = [
2396 GitRef(
2397 path="/lacros", revision="abc123", ref="refs/tags/123.456.789.0"
2398 )
2399 ]
2400 self.MOCK_LACROS_EBUILD_PATH = "chromeos-lacros-123.456.789.0-r1.ebuild"
Julio Hurtado870ed322021-12-03 18:22:40 +00002401
Alex Klein1699fab2022-09-08 08:46:06 -06002402 def revisionBumpOutcome(self, ebuild_path):
2403 return uprev_lib.UprevResult(
2404 uprev_lib.Outcome.REVISION_BUMP, [ebuild_path]
2405 )
Julio Hurtado870ed322021-12-03 18:22:40 +00002406
Alex Klein1699fab2022-09-08 08:46:06 -06002407 def majorBumpOutcome(self, ebuild_path):
2408 return uprev_lib.UprevResult(
2409 uprev_lib.Outcome.VERSION_BUMP, [ebuild_path]
2410 )
Julio Hurtado870ed322021-12-03 18:22:40 +00002411
Alex Klein1699fab2022-09-08 08:46:06 -06002412 def newerVersionOutcome(self, ebuild_path):
2413 return uprev_lib.UprevResult(
2414 uprev_lib.Outcome.NEWER_VERSION_EXISTS, [ebuild_path]
2415 )
Julio Hurtado870ed322021-12-03 18:22:40 +00002416
Alex Klein1699fab2022-09-08 08:46:06 -06002417 def sameVersionOutcome(self, ebuild_path):
2418 return uprev_lib.UprevResult(
2419 uprev_lib.Outcome.SAME_VERSION_EXISTS, [ebuild_path]
2420 )
Julio Hurtado870ed322021-12-03 18:22:40 +00002421
Alex Klein1699fab2022-09-08 08:46:06 -06002422 def newEbuildCreatedOutcome(self, ebuild_path):
2423 return uprev_lib.UprevResult(
2424 uprev_lib.Outcome.NEW_EBUILD_CREATED, [ebuild_path]
2425 )
Julio Hurtado870ed322021-12-03 18:22:40 +00002426
Alex Klein1699fab2022-09-08 08:46:06 -06002427 def test_lacros_uprev_fails(self):
2428 """Test a lacros package uprev with no triggers"""
2429 self.PatchObject(
2430 uprev_lib, "uprev_workon_ebuild_to_version", side_effect=[None]
2431 )
Alex Klein314fb5d2022-10-24 14:56:31 -06002432 with self.assertRaises(uprev_lib.NoRefsError):
Alex Klein1699fab2022-09-08 08:46:06 -06002433 packages.uprev_lacros_in_parallel(None, [], None)
Julio Hurtado870ed322021-12-03 18:22:40 +00002434
Alex Klein1699fab2022-09-08 08:46:06 -06002435 def test_lacros_uprev_revision_bump(self):
2436 """Test lacros package uprev."""
2437 lacros_outcome = self.revisionBumpOutcome(self.MOCK_LACROS_EBUILD_PATH)
2438 self.PatchObject(
2439 uprev_lib,
2440 "uprev_workon_ebuild_to_version",
2441 side_effect=[lacros_outcome],
2442 )
2443 output = packages.uprev_lacros_in_parallel(None, self.refs, None)
2444 self.assertTrue(output.uprevved)
Julio Hurtado870ed322021-12-03 18:22:40 +00002445
Alex Klein1699fab2022-09-08 08:46:06 -06002446 def test_lacros_uprev_version_bump(self):
2447 """Test lacros package uprev."""
2448 lacros_outcome = self.majorBumpOutcome(self.MOCK_LACROS_EBUILD_PATH)
2449 self.PatchObject(
2450 uprev_lib,
2451 "uprev_workon_ebuild_to_version",
2452 side_effect=[lacros_outcome],
2453 )
2454 output = packages.uprev_lacros_in_parallel(None, self.refs, None)
2455 self.assertTrue(output.uprevved)
Julio Hurtado870ed322021-12-03 18:22:40 +00002456
Alex Klein1699fab2022-09-08 08:46:06 -06002457 def test_lacros_uprev_new_ebuild_created(self):
2458 """Test lacros package uprev."""
2459 lacros_outcome = self.newEbuildCreatedOutcome(
2460 self.MOCK_LACROS_EBUILD_PATH
2461 )
2462 self.PatchObject(
2463 uprev_lib,
2464 "uprev_workon_ebuild_to_version",
2465 side_effect=[lacros_outcome],
2466 )
2467 output = packages.uprev_lacros_in_parallel(None, self.refs, None)
2468 self.assertTrue(output.uprevved)
Julio Hurtado870ed322021-12-03 18:22:40 +00002469
Alex Klein1699fab2022-09-08 08:46:06 -06002470 def test_lacros_uprev_newer_version_exist(self):
2471 """Test the newer version exists uprev should not happen."""
2472 lacros_outcome = self.newerVersionOutcome(self.MOCK_LACROS_EBUILD_PATH)
2473 self.PatchObject(
2474 uprev_lib,
2475 "uprev_workon_ebuild_to_version",
2476 side_effect=[lacros_outcome],
2477 )
2478 output = packages.uprev_lacros_in_parallel(None, self.refs, None)
2479 self.assertFalse(output.uprevved)
Julio Hurtado870ed322021-12-03 18:22:40 +00002480
Alex Klein1699fab2022-09-08 08:46:06 -06002481 def test_lacros_uprev_same_version_exist(self):
2482 """Test the same version exists uprev should not happen."""
2483 lacros_outcome = self.sameVersionOutcome(self.MOCK_LACROS_EBUILD_PATH)
2484 self.PatchObject(
2485 uprev_lib,
2486 "uprev_workon_ebuild_to_version",
2487 side_effect=[lacros_outcome],
2488 )
2489 output = packages.uprev_lacros_in_parallel(None, self.refs, None)
2490 self.assertFalse(output.uprevved)