| # Copyright 2019 The ChromiumOS Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """uprev_lib tests.""" |
| |
| import os |
| import pathlib |
| from unittest import mock |
| |
| import pytest |
| |
| import chromite as cr |
| from chromite.lib import build_target_lib |
| from chromite.lib import chroot_lib |
| from chromite.lib import constants |
| from chromite.lib import cros_test_lib |
| from chromite.lib import osutils |
| from chromite.lib import parallel |
| from chromite.lib import uprev_lib |
| from chromite.lib.parser import package_info |
| |
| |
| class ChromeVersionTest(cros_test_lib.TestCase): |
| """Tests for best_version and get_version_from_refs.""" |
| |
| def setUp(self) -> None: |
| # The tag ref template. |
| ref_tpl = "refs/tags/%s" |
| |
| self.best = "4.3.2.1" |
| self.versions = ["1.2.3.4", self.best, "4.2.2.1", "4.3.1.4"] |
| self.best_ref = uprev_lib.GitRef("/path", ref_tpl % self.best, "abc123") |
| self.refs = [ |
| uprev_lib.GitRef("/path", ref_tpl % v, "abc123") |
| for v in self.versions |
| ] |
| |
| self.unstable = "9999" |
| self.unstable_versions = self.versions + [self.unstable] |
| |
| def test_single_version(self) -> None: |
| """Test a single version.""" |
| self.assertEqual(self.best, uprev_lib.best_version([self.best])) |
| |
| def test_multiple_versions(self) -> None: |
| """Test a single version.""" |
| self.assertEqual(self.best, uprev_lib.best_version(self.versions)) |
| |
| def test_no_versions_fail(self) -> None: |
| """Test no versions given.""" |
| with self.assertRaises(uprev_lib.NoVersionsError): |
| uprev_lib.best_version([]) |
| |
| def test_unstable_only(self) -> None: |
| """Test the unstable version.""" |
| self.assertEqual(self.unstable, uprev_lib.best_version([self.unstable])) |
| |
| def test_unstable_multiple(self) -> None: |
| """Test unstable alongside multiple other versions.""" |
| self.assertEqual( |
| self.unstable, uprev_lib.best_version(self.unstable_versions) |
| ) |
| |
| def test_single_ref(self) -> None: |
| """Test a single ref.""" |
| self.assertEqual( |
| self.best, uprev_lib.get_version_from_refs([self.best_ref]) |
| ) |
| |
| def test_multiple_refs(self) -> None: |
| """Test multiple refs.""" |
| self.assertEqual(self.best, uprev_lib.get_version_from_refs(self.refs)) |
| |
| def test_no_refs_fail(self) -> None: |
| """Test no versions given.""" |
| with self.assertRaises(uprev_lib.NoRefsError): |
| uprev_lib.get_version_from_refs([]) |
| |
| |
| class ChromeEbuildVersionTest(cros_test_lib.MockTempDirTestCase): |
| """Tests for best_chrome_ebuild and get_stable_chrome_version.""" |
| |
| def setUp(self) -> None: |
| # Setup some ebuilds to test against. |
| pkg_dir = os.path.join(self.tempdir, constants.CHROME_CP) |
| osutils.SafeMakedirs(pkg_dir) |
| ebuild = os.path.join(pkg_dir, "chromeos-chrome-%s_rc-r%s.ebuild") |
| unstable_ebuild = os.path.join(pkg_dir, "chromeos-chrome-9999.ebuild") |
| |
| best_version = "4.3.2.1" |
| rest_versions = ["1.2.3.4", "4.3.2.0"] |
| |
| best_revs = [2, 12] |
| rest_revs = best_revs + [21] |
| |
| # Other versions to set up to compare against. |
| ebuild_paths = [ebuild % (best_version, rev) for rev in best_revs] |
| ebuild_paths += [ |
| ebuild % (ver, rev) for ver in rest_versions for rev in rest_revs |
| ] |
| best_ebuild_path = ebuild % (best_version, max(best_revs)) |
| |
| # Write stable ebuild data. |
| stable_data = "KEYWORDS=*" |
| osutils.WriteFile(best_ebuild_path, stable_data) |
| for path in ebuild_paths: |
| osutils.WriteFile(path, stable_data) |
| # Write the unstable ebuild. |
| unstable_data = "KEYWORDS=~*" |
| osutils.WriteFile(unstable_ebuild, unstable_data) |
| |
| # Create the ebuilds. |
| self.ebuilds = [uprev_lib.ChromeEBuild(path) for path in ebuild_paths] |
| self.best_ebuild = uprev_lib.ChromeEBuild(best_ebuild_path) |
| |
| def test_no_ebuilds(self) -> None: |
| """Test error on no ebuilds provided.""" |
| with self.assertRaises(uprev_lib.NoEbuildsError): |
| uprev_lib.best_chrome_ebuild([]) |
| |
| def test_single_ebuild(self) -> None: |
| """Test a single ebuild.""" |
| best = uprev_lib.best_chrome_ebuild([self.best_ebuild]) |
| self.assertEqual(self.best_ebuild.ebuild_path, best.ebuild_path) |
| |
| def test_multiple_ebuilds(self) -> None: |
| """Test multiple ebuilds.""" |
| best = uprev_lib.best_chrome_ebuild(self.ebuilds) |
| self.assertEqual(self.best_ebuild.ebuild_path, best.ebuild_path) |
| |
| def test_get_stable_version(self) -> None: |
| """Test fetching latest stable version from ebuilds.""" |
| self.PatchObject(uprev_lib, "_CHROME_OVERLAY_PATH", new=self.tempdir) |
| version = uprev_lib.get_stable_chrome_version() |
| self.assertEqual(self.best_ebuild.chrome_version, version) |
| |
| |
| class FindChromeEbuildsTest(cros_test_lib.TempDirTestCase): |
| """find_chrome_ebuilds tests.""" |
| |
| def setUp(self) -> None: |
| ebuild = os.path.join(self.tempdir, "chromeos-chrome-%s.ebuild") |
| self.unstable = ebuild % "9999" |
| self.alpha_unstable = ebuild % "4.3.2.1_alpha-r12" |
| self.best_stable = ebuild % "4.3.2.1_rc-r12" |
| self.old_stable = ebuild % "4.3.2.1_rc-r2" |
| |
| unstable_data = "KEYWORDS=~*" |
| stable_data = "KEYWORDS=*" |
| |
| osutils.WriteFile(self.unstable, unstable_data) |
| osutils.WriteFile(self.alpha_unstable, unstable_data) |
| osutils.WriteFile(self.best_stable, stable_data) |
| osutils.WriteFile(self.old_stable, stable_data) |
| |
| def test_find_all(self) -> None: |
| unstable, stables = uprev_lib.find_chrome_ebuilds(self.tempdir) |
| self.assertEqual(self.unstable, unstable.ebuild_path) |
| self.assertCountEqual( |
| [self.best_stable, self.old_stable], |
| [stable.ebuild_path for stable in stables], |
| ) |
| |
| |
| class UprevChromeManagerTest(cros_test_lib.MockTempDirTestCase): |
| """UprevChromeManager tests.""" |
| |
| def setUp(self) -> None: |
| ebuild = "chromeos-chrome-%s.ebuild" |
| self.stable_chrome_version = "4.3.2.1" |
| self.new_chrome_version = "4.3.2.2" |
| self.stable_revision = 1 |
| stable_version = "%s_rc-r%d" % ( |
| self.stable_chrome_version, |
| self.stable_revision, |
| ) |
| |
| self.package_dir = os.path.join(self.tempdir, constants.CHROME_CP) |
| osutils.SafeMakedirs(self.package_dir) |
| |
| self.stable_path = os.path.join( |
| self.package_dir, ebuild % stable_version |
| ) |
| self.unstable_path = os.path.join(self.package_dir, ebuild % "9999") |
| |
| osutils.WriteFile(self.stable_path, "KEYWORDS=*\n") |
| osutils.WriteFile(self.unstable_path, "KEYWORDS=~*\n") |
| |
| # Avoid chroot interactions for the tests. |
| self.PatchObject(uprev_lib, "clean_stale_packages") |
| |
| def test_no_change(self) -> None: |
| """Test a no-change uprev.""" |
| # No changes should be made when the stable and unstable ebuilds match. |
| manager = uprev_lib.UprevChromeManager( |
| self.stable_chrome_version, overlay_dir=self.tempdir |
| ) |
| manager.uprev(constants.CHROME_CP) |
| |
| self.assertFalse(manager.modified_ebuilds) |
| |
| def test_older_version(self) -> None: |
| """Test uprevving to an older version.""" |
| manager = uprev_lib.UprevChromeManager( |
| "1.2.3.4", overlay_dir=self.tempdir |
| ) |
| manager.uprev(constants.CHROME_CP) |
| |
| self.assertFalse(manager.modified_ebuilds) |
| |
| def test_new_version(self) -> None: |
| """Test a new chrome version.""" |
| # The stable ebuild should be replaced with one of the new version. |
| manager = uprev_lib.UprevChromeManager( |
| self.new_chrome_version, overlay_dir=self.tempdir |
| ) |
| manager.uprev(constants.CHROME_CP) |
| |
| # The old one should be deleted and the new one should exist. |
| new_path = self.stable_path.replace( |
| self.stable_chrome_version, self.new_chrome_version |
| ) |
| self.assertCountEqual( |
| [self.stable_path, new_path], manager.modified_ebuilds |
| ) |
| self.assertExists(new_path) |
| self.assertNotExists(self.stable_path) |
| |
| new_ebuild = uprev_lib.ChromeEBuild(new_path) |
| expected_version = "%s_rc-r1" % self.new_chrome_version |
| self.assertEqual(expected_version, new_ebuild.version) |
| |
| def test_uprev(self) -> None: |
| """Test a revision bump.""" |
| # Make the contents different to force the uprev. |
| osutils.WriteFile(self.unstable_path, 'IUSE=""', mode="a") |
| manager = uprev_lib.UprevChromeManager( |
| self.stable_chrome_version, overlay_dir=self.tempdir |
| ) |
| manager.uprev(constants.CHROME_CP) |
| |
| new_path = self.stable_path.replace( |
| "-r%d" % self.stable_revision, "-r%d" % (self.stable_revision + 1) |
| ) |
| |
| self.assertCountEqual( |
| [self.stable_path, new_path], manager.modified_ebuilds |
| ) |
| self.assertExists(new_path) |
| self.assertNotExists(self.stable_path) |
| |
| new_ebuild = uprev_lib.ChromeEBuild(new_path) |
| expected_version = "%s_rc-r%d" % ( |
| self.stable_chrome_version, |
| self.stable_revision + 1, |
| ) |
| self.assertEqual(expected_version, new_ebuild.version) |
| |
| |
| class UprevManagerTest(cros_test_lib.MockTestCase): |
| """UprevManager tests.""" |
| |
| def test_clean_stale_packages_no_chroot(self) -> None: |
| """Test no chroot skip.""" |
| manager = uprev_lib.UprevOverlayManager([], None) |
| self.PatchObject(parallel, "RunTasksInProcessPool") |
| |
| # pylint: disable=protected-access |
| manager._clean_stale_packages() |
| |
| # Make sure we aren't doing any work. |
| # TODO(crbug/1065172): Invalid assertion that was previously mocked. |
| # patch.assert_not_called() |
| |
| def test_clean_stale_packages_chroot_not_exists(self) -> None: |
| """Cannot run the commands when the chroot does not exist.""" |
| chroot = chroot_lib.Chroot() |
| self.PatchObject(chroot, "exists", return_value=False) |
| manager = uprev_lib.UprevOverlayManager([], None, chroot=chroot) |
| self.PatchObject(parallel, "RunTasksInProcessPool") |
| |
| # pylint: disable=protected-access |
| manager._clean_stale_packages() |
| |
| # Make sure we aren't doing any work. |
| # TODO(crbug/1065172): Invalid assertion that was previously mocked. |
| # patch.assert_not_called() |
| |
| def test_clean_stale_packages_no_build_targets(self) -> None: |
| """Make sure it behaves as expected with no build targets provided.""" |
| chroot = chroot_lib.Chroot() |
| self.PatchObject(chroot, "exists", return_value=True) |
| manager = uprev_lib.UprevOverlayManager([], None, chroot=chroot) |
| patch = self.PatchObject(parallel, "RunTasksInProcessPool") |
| |
| # pylint: disable=protected-access |
| manager._clean_stale_packages() |
| |
| # Make sure we aren't doing any work. |
| patch.assert_called_once_with(mock.ANY, [[None]]) |
| |
| def test_clean_stale_packages_with_boards(self) -> None: |
| """Test it cleans all boards as well as the chroot.""" |
| targets = ["board1", "board2"] |
| build_targets = [build_target_lib.BuildTarget(t) for t in targets] |
| chroot = chroot_lib.Chroot() |
| self.PatchObject(chroot, "exists", return_value=True) |
| manager = uprev_lib.UprevOverlayManager( |
| [], None, chroot=chroot, build_targets=build_targets |
| ) |
| patch = self.PatchObject(parallel, "RunTasksInProcessPool") |
| |
| # pylint: disable=protected-access |
| manager._clean_stale_packages() |
| |
| patch.assert_called_once_with(mock.ANY, [[t] for t in targets + [None]]) |
| |
| |
| def test_find_chrome_ebuilds(overlay_stack) -> None: |
| """Test that chrome ebuilds can be discovered in the test overlay.""" |
| |
| (overlay,) = overlay_stack(1) |
| unstable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="9999", keywords="~*" |
| ) |
| stable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="78.0.3876.1-r1" |
| ) |
| overlay.add_package(unstable_chrome) |
| overlay.add_package(stable_chrome) |
| |
| unstable, stable = uprev_lib.find_chrome_ebuilds( |
| overlay.path / "chromeos-base" / "chromeos-chrome" |
| ) |
| assert unstable |
| assert stable |
| |
| |
| def test_find_chrome_stable_candidate(overlay_stack) -> None: |
| """Test that a stable uprev candidate can be chosen in the expected case.""" |
| NEW_CHROME_VERSION = "80.0.1234.0" |
| |
| (overlay,) = overlay_stack(1) |
| unstable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="9999", keywords="~*" |
| ) |
| stable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="78.0.3876.0_rc-r1" |
| ) |
| overlay.add_package(unstable_chrome) |
| overlay.add_package(stable_chrome) |
| |
| _unstable, stable = uprev_lib.find_chrome_ebuilds( |
| overlay.path / "chromeos-base" / "chromeos-chrome" |
| ) |
| assert stable |
| uprev_manager = uprev_lib.UprevChromeManager(version=NEW_CHROME_VERSION) |
| # pylint: disable=protected-access |
| candidate = uprev_manager._find_chrome_uprev_candidate(stable) |
| assert candidate |
| |
| |
| def test_basic_chrome_uprev(overlay_stack) -> None: |
| """Test that the default uprev path works as expected.""" |
| NEW_CHROME_VERSION = "80.0.1234.0" |
| |
| (overlay,) = overlay_stack(1) |
| unstable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="9999", keywords="~*" |
| ) |
| stable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="78.0.3876.0_rc-r1" |
| ) |
| overlay.add_package(unstable_chrome) |
| overlay.add_package(stable_chrome) |
| |
| uprev_manager = uprev_lib.UprevChromeManager( |
| version=NEW_CHROME_VERSION, overlay_dir=overlay.path |
| ) |
| |
| result = uprev_manager.uprev(constants.CHROME_CP) |
| assert result |
| assert result.outcome is uprev_lib.Outcome.VERSION_BUMP |
| |
| new_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="80.0.1234.0_rc-r1" |
| ) |
| |
| assert new_chrome.cpv in overlay |
| |
| |
| def test_chrome_uprev_revision_bump(overlay_stack) -> None: |
| """Verify an uprev with the same major version just increments revision.""" |
| NEW_CHROME_VERSION = "80.0.1234.0" |
| |
| (overlay,) = overlay_stack(1) |
| unstable_chrome = cr.test.Package( |
| "chromeos-base", |
| "chromeos-chrome", |
| version="9999", |
| keywords="~*", |
| depend="foo/bar", |
| ) |
| stable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="80.0.1234.0_rc-r1" |
| ) |
| |
| overlay.add_package(unstable_chrome) |
| overlay.add_package(stable_chrome) |
| |
| uprev_manager = uprev_lib.UprevChromeManager( |
| version=NEW_CHROME_VERSION, overlay_dir=overlay.path |
| ) |
| |
| result = uprev_manager.uprev(constants.CHROME_CP) |
| assert result |
| assert result.outcome is uprev_lib.Outcome.REVISION_BUMP |
| |
| expected_uprev = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="80.0.1234.0_rc-r2" |
| ) |
| |
| assert expected_uprev.cpv in overlay |
| |
| |
| def test_no_chrome_uprev_same_version(overlay_stack, caplog) -> None: |
| """Test that no uprev occurs when version and contents are the same.""" |
| NEW_CHROME_VERSION = "80.0.1234.0" |
| |
| (overlay,) = overlay_stack(1) |
| unstable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="9999", keywords="~*" |
| ) |
| stable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="80.0.1234.0_rc-r1" |
| ) |
| |
| overlay.add_package(unstable_chrome) |
| overlay.add_package(stable_chrome) |
| |
| uprev_manager = uprev_lib.UprevChromeManager( |
| version=NEW_CHROME_VERSION, overlay_dir=overlay.path |
| ) |
| |
| result = uprev_manager.uprev(constants.CHROME_CP) |
| assert not result |
| assert result.outcome is uprev_lib.Outcome.SAME_VERSION_EXISTS |
| |
| ebuild_redundant_warning = ( |
| "Previous ebuild with same version found and ebuild is redundant." |
| ) |
| assert ebuild_redundant_warning in caplog.text |
| |
| |
| def test_no_chrome_uprev_older_version(overlay_stack, caplog) -> None: |
| """Test that no uprev occurs when a newer version already exists.""" |
| # Intentionally older than what already exists. |
| NEW_CHROME_VERSION = "55.0.1234.0" |
| |
| (overlay,) = overlay_stack(1) |
| unstable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="9999", keywords="~*" |
| ) |
| stable_chrome = cr.test.Package( |
| "chromeos-base", "chromeos-chrome", version="80.0.1234.0_rc-r1" |
| ) |
| |
| overlay.add_package(unstable_chrome) |
| overlay.add_package(stable_chrome) |
| |
| uprev_manager = uprev_lib.UprevChromeManager( |
| version=NEW_CHROME_VERSION, overlay_dir=overlay.path |
| ) |
| |
| result = uprev_manager.uprev(constants.CHROME_CP) |
| assert not result |
| assert result.outcome is uprev_lib.Outcome.NEWER_VERSION_EXISTS |
| |
| newer_version_warning = ( |
| "A chrome ebuild candidate with a higher version than the " |
| "requested uprev version was found." |
| ) |
| assert newer_version_warning in caplog.messages |
| assert "Candidate version found: 80.0.1234.0" in caplog.messages |
| |
| |
| def test_chrome_uprev_no_existing_stable(overlay_stack) -> None: |
| """Test that an uprev generates a stable ebuild if one doesn't exist yet.""" |
| NEW_CHROME_VERSION = "80.0.1234.0" |
| |
| (overlay,) = overlay_stack(1) |
| unstable_chrome = cr.test.Package( |
| "chromeos-base", |
| "chromeos-chrome", |
| version="9999", |
| keywords="~*", |
| depend="foo/bar", |
| ) |
| |
| overlay.add_package(unstable_chrome) |
| |
| uprev_manager = uprev_lib.UprevChromeManager( |
| version=NEW_CHROME_VERSION, overlay_dir=overlay.path |
| ) |
| |
| result = uprev_manager.uprev(constants.CHROME_CP) |
| assert result |
| assert result.outcome is uprev_lib.Outcome.NEW_EBUILD_CREATED |
| |
| stable_chrome = cr.test.Package( |
| "chromeos-base", |
| "chromeos-chrome", |
| version=f"{NEW_CHROME_VERSION}_rc-r1", |
| ) |
| |
| assert stable_chrome.cpv in overlay |
| |
| |
| def test_get_stable_ebuild_version(overlay_stack, monkeypatch) -> None: |
| """Test getting the stable ebuild version.""" |
| (overlay,) = overlay_stack(1) |
| unstable_package = cr.test.Package( |
| "chromeos-base", |
| "test-package", |
| version="9999", |
| keywords="~*", |
| inherit="cros-workon", |
| ) |
| stable_package = cr.test.Package( |
| "chromeos-base", "test-package", version="30.0" |
| ) |
| |
| overlay.add_package(unstable_package) |
| overlay.add_package(stable_package) |
| |
| monkeypatch.setattr(uprev_lib, "SRC_ROOT", overlay.path) |
| stable_version = uprev_lib.get_stable_ebuild_version( |
| pathlib.Path(unstable_package.category) / unstable_package.package, |
| ) |
| |
| assert stable_version == stable_package.package_info.version |
| |
| |
| def test_get_stable_ebuild_version_2_stable_ebuilds( |
| overlay_stack, monkeypatch |
| ) -> None: |
| """Test getting the stable ebuild version on multiple stable ebuilds.""" |
| (overlay,) = overlay_stack(1) |
| unstable_package = cr.test.Package( |
| "chromeos-base", |
| "test-package", |
| version="9999", |
| keywords="~*", |
| inherit="cros-workon", |
| ) |
| stable_package_30 = cr.test.Package( |
| "chromeos-base", "test-package", version="30.0" |
| ) |
| stable_package_31 = cr.test.Package( |
| "chromeos-base", "test-package", version="31.0" |
| ) |
| |
| overlay.add_package(unstable_package) |
| overlay.add_package(stable_package_30) |
| overlay.add_package(stable_package_31) |
| |
| monkeypatch.setattr(uprev_lib, "SRC_ROOT", overlay.path) |
| with pytest.raises(uprev_lib.TooManyStableEbuildsError): |
| _ = uprev_lib.get_stable_ebuild_version( |
| pathlib.Path(unstable_package.category) / unstable_package.package, |
| ) |
| |
| |
| def test_get_stable_ebuild_version_no_unstable( |
| overlay_stack, monkeypatch |
| ) -> None: |
| """Test getting the stable ebuild version on no unstable ebuild.""" |
| (overlay,) = overlay_stack(1) |
| stable_package = cr.test.Package( |
| "chromeos-base", "test-package", version="30.0" |
| ) |
| |
| overlay.add_package(stable_package) |
| |
| monkeypatch.setattr(uprev_lib, "SRC_ROOT", overlay.path) |
| with pytest.raises(uprev_lib.NoUnstableEbuildError): |
| _ = uprev_lib.get_stable_ebuild_version( |
| pathlib.Path(stable_package.category) / stable_package.package, |
| ) |
| |
| |
| @pytest.mark.inside_only |
| def test_non_workon_fails_uprev_workon_ebuild_to_version( |
| overlay_stack, monkeypatch |
| ) -> None: |
| (overlay,) = overlay_stack(1) |
| unstable_package = cr.test.Package( |
| "chromeos-base", |
| "test-package", |
| version="9999", |
| keywords="~*", |
| ) |
| |
| overlay.add_package(unstable_package) |
| |
| monkeypatch.setattr(uprev_lib, "SRC_ROOT", overlay.path) |
| with pytest.raises(uprev_lib.EbuildUprevError): |
| uprev_lib.uprev_workon_ebuild_to_version( |
| pathlib.Path(unstable_package.category) / unstable_package.package, |
| target_version="1", |
| chroot=chroot_lib.Chroot(), |
| ) |
| |
| stable_package = package_info.PackageInfo( |
| "chromeos-base", |
| "test-package", |
| version="1", |
| revision="1", |
| ) |
| |
| assert not stable_package in overlay |
| |
| |
| @pytest.mark.inside_only |
| def test_simple_uprev_workon_ebuild_to_version( |
| overlay_stack, monkeypatch |
| ) -> None: |
| (overlay,) = overlay_stack(1) |
| unstable_package = cr.test.Package( |
| "chromeos-base", |
| "test-package", |
| version="9999", |
| keywords="~*", |
| inherit="cros-workon", |
| CROS_WORKON_PROJECT="chromiumos/infra/build/empty-project", |
| CROS_WORKON_LOCALNAME="empty-project", |
| ) |
| |
| overlay.add_package(unstable_package) |
| |
| monkeypatch.setattr(uprev_lib, "SRC_ROOT", overlay.path) |
| res = uprev_lib.uprev_workon_ebuild_to_version( |
| pathlib.Path(unstable_package.category) / unstable_package.package, |
| target_version="1", |
| chroot=chroot_lib.Chroot(), |
| ) |
| |
| assert res.outcome is uprev_lib.Outcome.NEW_EBUILD_CREATED |
| |
| stable_package = package_info.PackageInfo( |
| "chromeos-base", |
| "test-package", |
| version="1", |
| revision="1", |
| ) |
| |
| assert stable_package in overlay |
| |
| |
| def test_uprev_workon_ebuild_to_version_newer_exists( |
| overlay_stack, monkeypatch |
| ) -> None: |
| """Test no uprev when downrev not allowed and newer version exists.""" |
| (overlay,) = overlay_stack(1) |
| unstable_ebuild = cr.test.Package( |
| "chromeos-base", |
| "uprev-test", |
| version="9999", |
| keywords="~*", |
| inherit="cros-workon", |
| ) |
| stable_ebuild = cr.test.Package( |
| "chromeos-base", "uprev-test", version="5.0.3-r2", inherit="cros-workon" |
| ) |
| |
| overlay.add_package(unstable_ebuild) |
| overlay.add_package(stable_ebuild) |
| |
| monkeypatch.setattr(uprev_lib, "SRC_ROOT", overlay.path) |
| result = uprev_lib.uprev_workon_ebuild_to_version( |
| "chromeos-base/uprev-test", |
| "1.2.3", |
| allow_downrev=False, |
| chroot=chroot_lib.Chroot(), |
| ) |
| |
| assert not result |
| assert result.outcome is uprev_lib.Outcome.NEWER_VERSION_EXISTS |
