| # Copyright 2014 The ChromiumOS Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Unittests for prebuilts.""" |
| |
| import os |
| from unittest import mock |
| |
| from chromite.cbuildbot import cbuildbot_unittest |
| from chromite.cbuildbot import prebuilts |
| from chromite.cbuildbot.stages import generic_stages_unittest |
| from chromite.lib import constants |
| from chromite.lib import cros_test_lib |
| from chromite.lib import osutils |
| |
| |
| DEFAULT_CHROME_BRANCH = "27" |
| |
| # pylint: disable=protected-access |
| class PrebuiltTest(cros_test_lib.RunCommandTempDirTestCase): |
| """Test general cbuildbot command methods.""" |
| |
| def setUp(self): |
| self._board = "test-board" |
| self._buildroot = self.tempdir |
| self._overlays = [ |
| "%s/src/third_party/chromiumos-overlay" % self._buildroot |
| ] |
| self._chroot = os.path.join(self._buildroot, "chroot") |
| os.makedirs(os.path.join(self._buildroot, ".repo")) |
| |
| def testSdkPrebuilts(self): |
| """Test UploadPrebuilts for SDK builds.""" |
| # A magical date for a magical time. |
| version = "1994.04.02.000000" |
| |
| # Fake out toolchains overlay tarballs. |
| tarball_dir = os.path.join( |
| self._buildroot, |
| constants.DEFAULT_CHROOT_DIR, |
| constants.SDK_OVERLAYS_OUTPUT, |
| ) |
| osutils.SafeMakedirs(tarball_dir) |
| |
| toolchain_overlay_tarball_args = [] |
| # Sample toolchain combos, corresponding to x86-alex and daisy. |
| toolchain_combos = ( |
| ("i686-pc-linux-gnu",), |
| ("armv7a-cros-linux-gnueabi", "arm-none-eabi"), |
| ) |
| for toolchains in [ |
| "-".join(sorted(combo)) for combo in toolchain_combos |
| ]: |
| tarball = "built-sdk-overlay-toolchains-%s.tar.xz" % toolchains |
| tarball_path = os.path.join(tarball_dir, tarball) |
| osutils.Touch(tarball_path) |
| tarball_arg = "%s:%s" % (toolchains, tarball_path) |
| toolchain_overlay_tarball_args.append( |
| ["--toolchains-overlay-tarball", tarball_arg] |
| ) |
| |
| # Fake out toolchain tarballs. |
| tarball_dir = os.path.join( |
| self._buildroot, |
| constants.DEFAULT_CHROOT_DIR, |
| constants.SDK_TOOLCHAINS_OUTPUT, |
| ) |
| osutils.SafeMakedirs(tarball_dir) |
| |
| toolchain_tarball_args = [] |
| for tarball_base in ("i686", "arm-none-eabi"): |
| tarball = "%s.tar.xz" % tarball_base |
| tarball_path = os.path.join(tarball_dir, tarball) |
| osutils.Touch(tarball_path) |
| tarball_arg = "%s:%s" % (tarball_base, tarball_path) |
| toolchain_tarball_args.append(["--toolchain-tarball", tarball_arg]) |
| |
| prebuilts.UploadPrebuilts( |
| constants.CHROOT_BUILDER_TYPE, |
| False, |
| buildroot=self._buildroot, |
| board=self._board, |
| version=version, |
| ) |
| self.assertCommandContains( |
| [constants.CHROOT_BUILDER_TYPE, "gs://chromeos-prebuilt"] |
| ) |
| |
| self.assertCommandContains( |
| [ |
| "--toolchains-overlay-upload-path", |
| "1994/04/cros-sdk-overlay-toolchains-%%(toolchains)s-" |
| "%(version)s.tar.xz", |
| ] |
| ) |
| self.assertCommandContains( |
| [ |
| "--toolchain-upload-path", |
| "1994/04/%%(target)s-%(version)s.tar.xz", |
| ] |
| ) |
| for args in toolchain_overlay_tarball_args + toolchain_tarball_args: |
| self.assertCommandContains(args) |
| self.assertCommandContains(["--set-version", version]) |
| self.assertCommandContains( |
| [ |
| "--prepackaged-tarball", |
| os.path.join(self._buildroot, "built-sdk.tar.xz"), |
| ] |
| ) |
| |
| def testDevInstallerPrebuilts(self, packages=("package1", "package2")): |
| """Test UploadDevInstallerPrebuilts.""" |
| args = ["gs://dontcare", "some_path_to_key", "https://my_test/location"] |
| with mock.patch.object( |
| prebuilts, "_AddPackagesForPrebuilt", return_value=packages |
| ): |
| prebuilts.UploadDevInstallerPrebuilts( |
| *args, buildroot=self._buildroot, board=self._board |
| ) |
| self.assertCommandContains(args[2:] + args[0:2]) |
| |
| def testAddPackagesForPrebuilt(self): |
| """Test AddPackagesForPrebuilt.""" |
| self.assertEqual(prebuilts._AddPackagesForPrebuilt("/"), None) |
| |
| data = """# comment! |
| cat/pkg-0 |
| ca-t2/pkg2-123 |
| ca-t3/pk-g4-4.0.1-r333 |
| """ |
| pkgs = [ |
| "cat/pkg", |
| "ca-t2/pkg2", |
| "ca-t3/pk-g4", |
| ] |
| cmds = ["--packages=" + x for x in pkgs] |
| f = os.path.join(self.tempdir, "package.provided") |
| osutils.WriteFile(f, data) |
| self.assertEqual(prebuilts._AddPackagesForPrebuilt(f), cmds) |
| |
| def testMissingDevInstallerFile(self): |
| """Test that we raise an exception when the installer file is missing.""" |
| self.assertRaises( |
| prebuilts.PackageFileMissing, |
| self.testDevInstallerPrebuilts, |
| packages=(), |
| ) |
| |
| |
| # pylint: disable=too-many-ancestors |
| class BinhostConfWriterTest( |
| generic_stages_unittest.RunCommandAbstractStageTestCase, |
| cbuildbot_unittest.SimpleBuilderTestCase, |
| ): |
| """Tests for the BinhostConfWriter class.""" |
| |
| cmd = "upload_prebuilts" |
| RELEASE_TAG = "1234.5.6" |
| VERSION = "R%s-%s" % (DEFAULT_CHROME_BRANCH, RELEASE_TAG) |
| |
| # Our API here is not great when it comes to kwargs passing. |
| def _Prepare( |
| self, bot_id=None, **kwargs |
| ): # pylint: disable=arguments-differ |
| super()._Prepare(bot_id, **kwargs) |
| self.cmd = os.path.join( |
| self.build_root, constants.CHROMITE_BIN_SUBDIR, "upload_prebuilts" |
| ) |
| self._run.options.prebuilts = True |
| |
| def _Run(self, build_config): |
| """Prepare and run a BinhostConfWriter. |
| |
| Args: |
| build_config: Name of build config to run for. |
| """ |
| self._Prepare(build_config) |
| confwriter = prebuilts.BinhostConfWriter(self._run) |
| confwriter.Perform() |
| |
| def ConstructStage(self): |
| pass |
| |
| def _VerifyResults(self, public_slave_boards=(), private_slave_boards=()): |
| """Verify that the expected prebuilt commands were run. |
| |
| Do various assertions on the two RunCommands that were run by stage. |
| There should be one private (--private) and one public (default) run. |
| |
| Args: |
| public_slave_boards: List of public slave boards. |
| private_slave_boards: List of private slave boards. |
| """ |
| # TODO(mtennant): Add functionality in partial_mock to support more flexible |
| # asserting. For example here, asserting that '--sync-host' appears in |
| # the command that did not include '--public'. |
| |
| # Some args are expected for any public run. |
| if public_slave_boards: |
| # It would be nice to confirm that --private is not in command, but note |
| # that --sync-host should not appear in the --private command. |
| cmd = [self.cmd, "--sync-binhost-conf", "--sync-host"] |
| self.assertCommandContains(cmd, expected=True) |
| |
| # Some args are expected for any private run. |
| if private_slave_boards: |
| cmd = [self.cmd, "--sync-binhost-conf", "--private"] |
| self.assertCommandContains(cmd, expected=True) |
| |
| # Assert public slave boards are mentioned in public run. |
| for board in public_slave_boards: |
| # This check does not actually confirm that this board was in the public |
| # run rather than the private run, unfortunately. |
| cmd = [self.cmd, "--slave-board", board] |
| self.assertCommandContains(cmd, expected=True) |
| |
| # Assert private slave boards are mentioned in private run. |
| for board in private_slave_boards: |
| cmd = [self.cmd, "--slave-board", board, "--private"] |
| self.assertCommandContains(cmd, expected=True) |
| |
| # We expect --set-version so long as build config has manifest_version=True. |
| self.assertCommandContains( |
| [self.cmd, "--set-version", self.VERSION], |
| expected=self._run.config.manifest_version, |
| ) |
