def test_find_fingerprints_with_test_path(self): """Tests get_firmware_versions with mocked output.""" self.monkeypatch.setattr(constants, 'SOURCE_ROOT', self.tempdir) build_target = build_target_lib.BuildTarget(self.board) result = packages.find_fingerprints(build_target) self.assertEqual(result, [self.fingerprint_contents]) self.assertIn('Reading fingerprint file', self.caplog.text)
def setUp(self): self.uprev = self.PatchObject(packages, 'uprev_android') self.input_proto = android_pb2.MarkStableRequest() self.input_proto.tracking_branch = 'tracking-branch' self.input_proto.package_name = 'android-package-name' self.input_proto.android_build_branch = 'android_build_branch' self.input_proto.build_targets.add().name = 'foo' self.input_proto.build_targets.add().name = 'bar' self.build_targets = [ build_target_lib.BuildTarget('foo'), build_target_lib.BuildTarget('bar') ] self.response = android_pb2.MarkStableResponse()
def test_get_firmware_versions(self): """Tests get_firmware_versions with mocked output.""" build_target = build_target_lib.BuildTarget(self.board) result = packages.get_all_firmware_versions(build_target) self.assertEqual(len(result), 5) self.assertEqual( result['reef'], packages.FirmwareVersions('reef', 'Google_Reef.9042.87.1', 'Google_Reef.9042.110.0', 'reef_v1.1.5900-ab1ee51', 'reef_v1.1.5909-bd1f0c9')) self.assertEqual( result['pyro'], packages.FirmwareVersions('pyro', 'Google_Pyro.9042.87.1', 'Google_Pyro.9042.110.0', 'pyro_v1.1.5900-ab1ee51', 'pyro_v1.1.5909-bd1f0c9')) self.assertEqual( result['snappy'], packages.FirmwareVersions('snappy', 'Google_Snappy.9042.110.0', None, 'snappy_v1.1.5909-bd1f0c9', None)) self.assertEqual( result['sand'], packages.FirmwareVersions('sand', 'Google_Sand.9042.110.0', None, 'sand_v1.1.5909-bd1f0c9', None)) self.assertEqual( result['electro'], packages.FirmwareVersions('electro', 'Google_Reef.9042.87.1', 'Google_Reef.9042.110.0', 'reef_v1.1.5900-ab1ee51', 'reef_v1.1.5909-bd1f0c9'))
def setUp(self): self.board = 'board' self.build_target = build_target_lib.BuildTarget(self.board) self.chroot = chroot_lib.Chroot(path=self.tempdir) # Make the chroot's tmp directory, used for the parallel emerge status file. tempdir = os.path.join(self.tempdir, 'tmp') osutils.SafeMakedirs(tempdir)
def test_get_firmware_versions(self): """Tests get_firmware_versions with mocked output.""" build_target = build_target_lib.BuildTarget(self.board) result = packages.get_firmware_versions(build_target) versions = packages.FirmwareVersions(None, 'Google_Kevin.8785.178.0', None, 'kevin_v1.10.184-459421c', None) self.assertEqual(result, versions)
def testSuccess(self): """Test successful handling case.""" name = 'board' build_target_message = common_pb2.BuildTarget(name=name) expected = build_target_lib.BuildTarget(name) result = controller_util.ParseBuildTarget(build_target_message) self.assertEqual(expected, result)
def testBuilds(self): """Test successful call handling.""" patch = self.PatchObject(packages_service, 'builds', return_value=True) request = self._GetRequest(board='foo') packages_controller.BuildsChrome(request, self.response, self.api_config) self.assertTrue(self.response.builds_chrome) patch.assert_called_once_with(constants.CHROME_CP, build_target_lib.BuildTarget('foo'), [])
def setUp(self): self.PatchObject(cros_build_lib, 'IsInsideChroot', return_value=True) # A board we have a sysroot for already. self.board = 'board' self.sysroot_path = os.path.join(self.tempdir, 'build', self.board) self.build_target = build_target_lib.BuildTarget( self.board, build_root=self.sysroot_path) self.sysroot = sysroot_lib.Sysroot(self.sysroot_path) # A board we don't have a sysroot for yet. self.unbuilt_board = 'board2' self.unbuilt_path = os.path.join(self.tempdir, 'build', self.unbuilt_board) self.unbuilt_target = build_target_lib.BuildTarget( self.unbuilt_board, build_root=self.unbuilt_path) self.unbuilt_sysroot = sysroot_lib.Sysroot(self.unbuilt_path) osutils.SafeMakedirs(self.sysroot_path)
def test_find_fingerprints(self): """Tests get_firmware_versions with mocked output.""" # Use board name whose path for fingerprint file does not exist. # Verify that fingerprint file is not found and None is returned. build_target = build_target_lib.BuildTarget('wrong-boardname') self.monkeypatch.setattr(constants, 'SOURCE_ROOT', self.tempdir) result = packages.find_fingerprints(build_target) self.assertEqual(result, []) self.assertIn('Fingerprint file not found', self.caplog.text)
def _make_instance(self, sha, number, board, profile_name, location): """Return a binpkg.PackageIndexInfo instance.""" return binpkg.PackageIndexInfo( snapshot_sha=sha, snapshot_number=number, build_target=build_target_lib.BuildTarget( name=board) if board else None, profile=sysroot_lib.Profile( name=profile_name) if profile_name else None, location=location)
def testSuccess(self): """Test successful handling case.""" names = ['foo', 'bar', 'baz'] message = build_api_test_pb2.TestRequestMessage() for name in names: message.build_targets.add().name = name result = controller_util.ParseBuildTargets(message.build_targets) expected = [build_target_lib.BuildTarget(name) for name in names] self.assertCountEqual(expected, result)
def _ParseArgs(argv): """Parse and validate arguments.""" parser = GetParser() opts = parser.parse_args(argv) opts.build_target = build_target_lib.BuildTarget(opts.build_target_name) opts.force = opts.force or opts.build_target.name != read_build_target_file( ) opts.Freeze() return opts
def __init__(self, snapshot_sha='', snapshot_number=0, build_target=None, profile=None, location=''): self.snapshot_sha = snapshot_sha self.snapshot_number = snapshot_number self.build_target = build_target or build_target_lib.BuildTarget( name='') self.profile = profile or sysroot_lib.Profile() self.location = location
def setUp(self): self.PatchObject(constants, 'SOURCE_ROOT', new=self.tempdir) self.chroot_path = os.path.join(self.tempdir, 'chroot') self.sysroot_path = '/build/foo' self.root = os.path.join(self.chroot_path, self.sysroot_path.lstrip('/'), 'packages') self.chroot = chroot_lib.Chroot(self.chroot_path) self.sysroot = sysroot_lib.Sysroot(self.sysroot_path) self.build_target = build_target_lib.BuildTarget('foo') osutils.SafeMakedirs(self.root)
def testParseProfile(self): """Test the parsing of a profile.""" name = 'build-target-name' profile = 'profile' build_target_msg = common_pb2.BuildTarget(name=name) profile_msg = sysroot_pb2.Profile(name=profile) expected = build_target_lib.BuildTarget(name, profile=profile) result = controller_util.ParseBuildTarget(build_target_msg, profile_message=profile_msg) self.assertEqual(expected, result)
def testGetChromeVersion(self): """Verify basic return values.""" chrome_version = '76.0.1.2' chrome_version_mock = self.PatchObject(packages_service, 'determine_chrome_version', return_value=chrome_version) request = self._GetRequest(board='betty') packages_controller.GetChromeVersion(request, self.response, self.api_config) self.assertEqual(self.response.version, chrome_version) # Verify call to determine_chrome_version passes a build_target object. build_target = build_target_lib.BuildTarget('betty') chrome_version_mock.assert_called_with(build_target)
def test_invalid_build_config(self): """Test invalid build configs.""" module = mock.MagicMock(BUILD_WORKON_PACKAGES=('pkg1', 'pkg2'), BUILD_PACKAGES=tuple()) self.PatchObject(ap_firmware, '_get_config_module', return_value=module) with self.assertRaises(ap_firmware.InvalidConfigError): # pylint: disable=protected-access ap_firmware._get_build_config( build_target_lib.BuildTarget('board'))
def setUp(self): # Create the build target. self.build_target = build_target_lib.BuildTarget('board') # Create the chroot. self.chroot_dir = os.path.join(self.tempdir, 'chroot') self.chroot_tmp = os.path.join(self.chroot_dir, 'tmp') osutils.SafeMakedirs(self.chroot_tmp) self.chroot = chroot_lib.Chroot(path=self.chroot_dir) # Create the output directory. self.output_dir = os.path.join(self.tempdir, 'output_dir') osutils.SafeMakedirs(self.output_dir)
def setUp(self): # Avoid sudo password prompt for config writing. self.PatchObject(os, 'getuid', return_value=0) self.PatchObject(os, 'geteuid', return_value=0) # It has to be run inside the chroot. self.PatchObject(cros_build_lib, 'IsInsideChroot', return_value=True) # A board we have a sysroot for already. self.board = 'board' self.sysroot_path = os.path.join(self.tempdir, 'build', self.board) self.build_target = build_target_lib.BuildTarget( self.board, build_root=self.sysroot_path) # A board we don't have a sysroot for yet. self.unbuilt_board = 'board2' self.unbuilt_path = os.path.join(self.tempdir, 'build', self.unbuilt_board) self.unbuilt_target = build_target_lib.BuildTarget( self.unbuilt_board, build_root=self.unbuilt_path) # Create the sysroot. osutils.SafeMakedirs(self.sysroot_path)
def testGetBuildPackagesEnv(self): """Test the build_packages env.""" instance = sysroot.BuildPackagesRunConfig() # PORTAGE_BINHOST is not set when there are no package_indexes self.assertNotIn('PORTAGE_BINHOST', instance.GetEnv()) # PORTAGE_BINHOST is correctly set when there are package_indexes. pkg_indexes = [ binpkg.PackageIndexInfo( build_target=build_target_lib.BuildTarget('board'), snapshot_sha='A', location='AAAA'), binpkg.PackageIndexInfo( build_target=build_target_lib.BuildTarget('board'), snapshot_sha='B', location='BBBB') ] instance = sysroot.BuildPackagesRunConfig(package_indexes=pkg_indexes) env = instance.GetEnv() self.assertEqual(env.get('PORTAGE_BINHOST'), ' '.join([x.location for x in reversed(pkg_indexes)]))
def testBuildsChromeWithPackages(self): """Test successful call with packages handling.""" patch = self.PatchObject(packages_service, 'builds', return_value=True) package = common_pb2.PackageInfo( category='category', package_name='name', version='1.01', ) request = self._GetRequest(board='foo', packages=[package]) packages_controller.BuildsChrome(request, self.response, self.api_config) self.assertTrue(self.response.builds_chrome) patch.assert_called_once_with(constants.CHROME_CP, build_target_lib.BuildTarget('foo'), [controller_util.PackageInfoToCPV(package)])
def test_no_workon_config(self): """Test building of the build config object with no workon packages.""" module = mock.MagicMock(BUILD_WORKON_PACKAGES=None, BUILD_PACKAGES=('pkg3', 'pkg4')) self.PatchObject(ap_firmware, '_get_config_module', return_value=module) # pylint: disable=protected-access build_config = ap_firmware._get_build_config( build_target_lib.BuildTarget('board')) self.assertFalse(build_config.workon) self.assertEqual(('pkg3', 'pkg4'), build_config.build)
def testGetTargetVersions(self): """Verify basic return values.""" # Mock that chrome is built and set the chrome_version. self.PatchObject(packages_service, 'builds', return_value=True) chrome_version = '76.0.1.2' chrome_version_mock = self.PatchObject(packages_service, 'determine_chrome_version', return_value=chrome_version) android_version = 'android_test_version' android_version_mock = self.PatchObject(packages_service, 'determine_android_version', return_value=android_version) android_branch = 'android_test_branch' android_branch_mock = self.PatchObject(packages_service, 'determine_android_branch', return_value=android_branch) android_target = 'android_test_target' android_target_mock = self.PatchObject(packages_service, 'determine_android_target', return_value=android_target) platform_version = '12345.1.2' self.PatchObject(packages_service, 'determine_platform_version', return_value=platform_version) milestone_version = '79' self.PatchObject(packages_service, 'determine_milestone_version', return_value=milestone_version) full_version = 'R79-12345.1.2' self.PatchObject(packages_service, 'determine_full_version', return_value=full_version) request = self._GetRequest(board='betty') packages_controller.GetTargetVersions(request, self.response, self.api_config) self.assertEqual(self.response.android_version, android_version) self.assertEqual(self.response.android_branch_version, android_branch) self.assertEqual(self.response.android_target_version, android_target) self.assertEqual(self.response.chrome_version, chrome_version) self.assertEqual(self.response.platform_version, platform_version) self.assertEqual(self.response.milestone_version, milestone_version) self.assertEqual(self.response.full_version, full_version) # Verify call to determine_chrome_version passes a build_target object. build_target = build_target_lib.BuildTarget('betty') chrome_version_mock.assert_called_with(build_target) # Verify call to determine_android_version passes a list of the board name. android_version_mock.assert_called_with(['betty']) # Verify call to determine_android_branch passes a board name. android_branch_mock.assert_called_with('betty') # Verify call to determine_android_target passes a board name. android_target_mock.assert_called_with('betty')
def Run(self): """Perform the cros flash-ap command.""" commandline.RunInsideChroot(self) self.validate_options() build_target = build_target_lib.BuildTarget(self.options.build_target) try: ap_firmware.deploy(build_target, self.options.image, self.options.device, flashrom=self.options.flashrom, fast=self.options.fast, verbose=self.options.verbose, dryrun=self.options.dry_run) except ap_firmware.Error as e: cros_build_lib.Die(e)
def testFullRun(self): """Test a regular full run. This method is basically just a sanity check that it's trying to create the sysroot and install the toolchain by default. """ target_sysroot = sysroot_lib.Sysroot('/build/board') create_mock = self.PatchObject(sysroot, 'Create', return_value=target_sysroot) install_toolchain_mock = self.PatchObject(sysroot, 'InstallToolchain') sysroot.SetupBoard(build_target_lib.BuildTarget('board')) create_mock.assert_called_once() install_toolchain_mock.assert_called_once()
def test_no_uprev(self): """Test no uprev handling.""" self.rc.AddCmdResult(partial_mock.In('cros_mark_android_as_stable'), stdout='') build_targets = [ build_target_lib.BuildTarget(t) for t in ['foo', 'bar'] ] packages.uprev_android('refs/tracking-branch', 'android/package', 'refs/android-build-branch', Chroot(), build_targets=build_targets) self.assertCommandContains( ['cros_mark_android_as_stable', '--boards=foo:bar']) self.assertCommandContains(['emerge-foo'], expected=False) self.assertCommandContains(['emerge-bar'], expected=False)
def test_success(self): """Test successful run handling.""" self.rc.AddCmdResult(partial_mock.In('cros_mark_android_as_stable'), stdout='ANDROID_ATOM=android/android-1.0\n') build_targets = [ build_target_lib.BuildTarget(t) for t in ['foo', 'bar'] ] packages.uprev_android('refs/tracking-branch', 'android/package', 'refs/android-build-branch', Chroot(), build_targets=build_targets) self.assertCommandContains( ['cros_mark_android_as_stable', '--boards=foo:bar']) self.assertCommandContains(['emerge-foo']) self.assertCommandContains(['emerge-bar'])
def testRegenConfigs(self): """Test the regen configs install prevention.""" target_sysroot = sysroot_lib.Sysroot('/build/board') create_mock = self.PatchObject(sysroot, 'Create', return_value=target_sysroot) install_toolchain_mock = self.PatchObject(sysroot, 'InstallToolchain') target = build_target_lib.BuildTarget('board') configs = sysroot.SetupBoardRunConfig(regen_configs=True) sysroot.SetupBoard(target, run_configs=configs) # Should still try to create the sysroot, but should not try to install # the toolchain. create_mock.assert_called_once() install_toolchain_mock.assert_not_called()
def setUp(self): # Currently just used to keep the parallel emerge status file from being # created in the chroot. This probably isn't strictly necessary, but since # we can otherwise run this test without a chroot existing at all and # without touching the chroot folder, it's better to keep it out of there # all together. self.PatchObject(cros_build_lib, 'IsInsideChroot', return_value=True) self.board = 'board' self.target = build_target_lib.BuildTarget(self.board) self.sysroot_path = '/sysroot/path' self.sysroot = sysroot_lib.Sysroot(self.sysroot_path) self.build_packages = os.path.join(constants.CROSUTILS_DIR, 'build_packages') self.base_command = [ self.build_packages, '--board', self.board, '--board_root', self.sysroot_path ]
def test_build(self): """Sanity checks the workon and command building functions properly.""" # Note: The workon helper handles looking up full category/package atom # when just given package names. build_pkgs = ('build1', 'build2') workon_pkgs = ('workon1', 'workon2') # Inconsequential pkgs + 1 we need. existing_workons = ['cat/pkg1', 'cat/pkg2', 'cat/workon1'] existing_and_required = existing_workons + ['cat/workon2'] # Should only stop the ones that weren't previously worked on. expected_workon_stop = ['cat/workon2'] build_config = ap_firmware.BuildConfig(workon=workon_pkgs, build=build_pkgs) build_target = build_target_lib.BuildTarget('board') # Simulate starting the required workon packages. Return first the existing # workon packages, then the ones we're starting plus the existing. self.PatchObject(workon_helper.WorkonHelper, 'ListAtoms', side_effect=[existing_workons, existing_and_required]) # Start and stop workon patches for verifying calls. start_patch = self.PatchObject(workon_helper.WorkonHelper, 'StartWorkingOnPackages') stop_patch = self.PatchObject(workon_helper.WorkonHelper, 'StopWorkingOnPackages') # Patch in the build config. self.PatchObject(ap_firmware, '_get_build_config', return_value=build_config) ap_firmware.build(build_target, 'board-variant') # Verify the workon packages. Should be starting all the required workon # packages, but only stopping the ones that we started in the command. start_patch.assert_called_once_with(workon_pkgs) stop_patch.assert_called_once_with(expected_workon_stop) # Verify we try to build all the build packages, and that the FW_NAME envvar # has been set. self.rc.assertCommandContains(list(build_pkgs), extra_env={'FW_NAME': 'board-variant'})