Example #1
0
    def test_older_version(self):
        """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_chrome_uprev_no_existing_stable(overlay_stack):
    """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_no_chrome_uprev_older_version(overlay_stack, caplog):
    """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_no_chrome_uprev_same_version(overlay_stack, caplog):
    """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_chrome_uprev_revision_bump(overlay_stack):
    """Test that 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_basic_chrome_uprev(overlay_stack):
    """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
Example #7
0
    def test_no_change(self):
        """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)
Example #8
0
    def test_new_version(self):
        """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)
Example #9
0
    def test_uprev(self):
        """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)
def test_find_chrome_stable_candidate(overlay_stack):
    """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
Example #11
0
def uprev_chrome(build_targets, refs, chroot):
    """Uprev chrome and its related packages.

  See: uprev_versioned_package.
  """
    # Determine the version from the refs (tags), i.e. the chrome versions are the
    # tag names.
    chrome_version = uprev_lib.get_chrome_version_from_refs(refs)

    uprev_manager = uprev_lib.UprevChromeManager(chrome_version,
                                                 build_targets=build_targets,
                                                 chroot=chroot)
    result = UprevVersionedPackageResult()
    # Start with chrome itself, as we can't do anything else unless chrome
    # uprevs successfully.
    if not uprev_manager.uprev(constants.CHROME_CP):
        return result

    # With a successful chrome rev, also uprev related packages.
    for package in constants.OTHER_CHROME_PACKAGES:
        uprev_manager.uprev(package)

    return result.add_result(chrome_version, uprev_manager.modified_ebuilds)
def uprev_chrome(build_targets, refs, chroot):
    """Uprev chrome and its related packages.

  See: uprev_versioned_package.
  """
    # Determine the version from the refs (tags), i.e. the chrome versions are the
    # tag names.
    chrome_version = uprev_lib.get_chrome_version_from_refs(refs)
    logging.debug('Chrome version determined from refs: %s', chrome_version)

    uprev_manager = uprev_lib.UprevChromeManager(chrome_version,
                                                 build_targets=build_targets,
                                                 chroot=chroot)
    result = UprevVersionedPackageResult()
    # Start with chrome itself, as we can't do anything else unless chrome
    # uprevs successfully.
    # TODO(crbug.com/1080429): Handle all possible outcomes of a Chrome uprev
    #     attempt. The expected behavior is documented in the following table:
    #
    #     Outcome of Chrome uprev attempt:
    #     NEWER_VERSION_EXISTS:
    #       Do nothing.
    #     SAME_VERSION_EXISTS or REVISION_BUMP:
    #       Uprev followers
    #       Assert not VERSION_BUMP (any other outcome is fine)
    #     VERSION_BUMP or NEW_EBUILD_CREATED:
    #       Uprev followers
    #       Assert that Chrome & followers are at same package version
    if not uprev_manager.uprev(constants.CHROME_CP):
        return result

    # With a successful chrome rev, also uprev related packages.
    for package in constants.OTHER_CHROME_PACKAGES:
        uprev_manager.uprev(package)

    return result.add_result(chrome_version, uprev_manager.modified_ebuilds)