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'})
