def testBuildAndArchiveDeltaSysroot(self):
"""Test tarball is added to upload queue."""
stage = self.ConstructStageForArchiveStep()
with cros_build_lib_unittest.RunCommandMock() as rc:
rc.SetDefaultCmdResult()
stage.BuildAndArchiveDeltaSysroot()
stage._upload_queue.put.assert_called_with([constants.DELTA_SYSROOT_TAR])
def setUp(self):
self.rc_mock = cros_build_lib_unittest.RunCommandMock()
self.rc_mock.SetDefaultCmdResult()
self.StartPatcher(self.rc_mock)
self.sdk_mock = self.StartPatcher(
SDKFetcherMock(external_mocks=[self.rc_mock]))
# This needs to occur before initializing MockChromeSDKCommand.
self.bashrc = os.path.join(self.tempdir, 'bashrc')
self.PatchObject(constants, 'CHROME_SDK_BASHRC', new=self.bashrc)
self.PatchObject(osutils,
'SourceEnvironment',
autospec=True,
side_effect=self.SourceEnvironmentMock)
self.rc_mock.AddCmdResult(
cros_chrome_sdk.ChromeSDKCommand.GOMACC_PORT_CMD, output='8088')
# Initialized by SetupCommandMock.
self.cmd_mock = None
# Set up a fake Chrome src/ directory
self.chrome_root = os.path.join(self.tempdir, 'chrome_root')
self.chrome_src_dir = os.path.join(self.chrome_root, 'src')
osutils.SafeMakedirs(self.chrome_src_dir)
osutils.Touch(os.path.join(self.chrome_root, '.gclient'))
def _assertRunBuildScript(self, in_chroot=False, error=None, raises=None):
"""Test the RunBuildScript function.
Args:
in_chroot: Whether to enter the chroot or not.
tmpf: If the chroot tempdir exists, a NamedTemporaryFile that contains
a list of the packages that failed to build.
raises: If the command should fail, the exception to be raised.
"""
# Write specified error message to status file.
def WriteError(_cmd, extra_env=None, **_kwargs):
if extra_env is not None and error is not None:
status_file = extra_env['PARALLEL_EMERGE_STATUS_FILE']
osutils.WriteFile(status_file, error)
buildroot = self.tempdir
os.makedirs(os.path.join(buildroot, '.repo'))
if error is not None:
os.makedirs(os.path.join(buildroot, 'chroot', 'tmp'))
# Run the command, throwing an exception if it fails.
with cros_build_lib_unittest.RunCommandMock() as m:
cmd = ['example', 'command']
returncode = 1 if raises else 0
m.AddCmdResult(cmd, returncode=returncode, side_effect=WriteError)
with mock.patch.object(git, 'ReinterpretPathForChroot',
side_effect=lambda x: x):
with cros_test_lib.LoggingCapturer():
# If the script failed, the exception should be raised and printed.
if raises:
self.assertRaises(raises, commands._RunBuildScript, buildroot,
cmd, enter_chroot=in_chroot)
else:
commands._RunBuildScript(buildroot, cmd, enter_chroot=in_chroot)
def testBlockDevice(self):
"""Test block device info when there is no record or a record is stale."""
disk = self._CreateDisk(1)
mock_device = '/dev/sda1'
mock_size = 12345678987654321
mock_ids = ['ata-ST1000DM003-1ER162_Z4Y3WQDB-part1']
mock_labels = ['BOOT-PARTITION']
mock_lsblk = 'NAME="sda1" RM="0" TYPE="part" SIZE="%s"' % mock_size
self.StartPatcher(mock.patch('chromite.lib.osutils.ResolveSymlink'))
osutils.ResolveSymlink.return_value = '/dev/sda1'
with cros_build_lib_unittest.RunCommandMock() as rc_mock:
rc_mock.AddCmdResult(
partial_mock.In(systeminfo.SYSTEMFILE_DEV_DISKBY['ids']),
output='\n'.join(mock_ids))
rc_mock.AddCmdResult(
partial_mock.In(systeminfo.SYSTEMFILE_DEV_DISKBY['labels']),
output='\n'.join(mock_labels))
rc_mock.AddCmdResult(partial_mock.In('lsblk'), output=mock_lsblk)
mock_blockdevice = [systeminfo.RESOURCE_BLOCKDEVICE(mock_device,
mock_size,
mock_ids,
mock_labels)]
self.assertEquals(disk.BlockDevices(mock_device), mock_blockdevice)
def testNonFFPush(self):
"""Non fast-forward push error propagates to the caller."""
with cros_build_lib_unittest.RunCommandMock() as rc_mock:
rc_mock.AddCmdResult(partial_mock.In('push'),
returncode=128,
error=self.NON_FF_PUSH_ERROR)
self.assertRaises(cros_build_lib.RunCommandError, self._RunGitPush)
def setUp(self):
self.StartPatcher(generic_stages_unittest.ArchivingStageMixinMock())
self.StartPatcher(parallel_unittest.ParallelMock())
self.rc_mock = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
self.rc_mock.SetDefaultCmdResult(output='')
self.stage = None
def setUp(self):
self.rc_mock = self.StartPatcher(
cros_build_lib_unittest.RunCommandMock())
self.email_mock = self.PatchObject(alerts, 'SendEmail')
self.user = '******'
self.email = '*****@*****.**'
self.loas = loas.Loas(self.user, self.email)
def setUp(self):
self.rc_mock = cros_build_lib_unittest.RunCommandMock()
self.rc_mock.SetDefaultCmdResult()
self.StartPatcher(self.rc_mock)
self.cmd_mock = MockChromeSDKCommand(
['--board', SDKFetcherMock.BOARD, 'true'],
base_args=['--cache-dir', self.tempdir])
self.StartPatcher(self.cmd_mock)
def testPersistentTransientError(self):
"""GitPush fails if transient error occurs multiple times."""
for error in self.TRANSIENT_ERRORS:
with cros_build_lib_unittest.RunCommandMock() as rc_mock:
rc_mock.AddCmdResult(partial_mock.In('push'),
returncode=128,
error=error)
self.assertRaises(cros_build_lib.RunCommandError,
self._RunGitPush)
def testBuildAndArchiveDeltaSysrootFailure(self):
"""Test tarball not added to upload queue on command exception."""
stage = self.ConstructStageForArchiveStep()
with cros_build_lib_unittest.RunCommandMock() as rc:
rc.AddCmdResult(partial_mock.In('generate_delta_sysroot'), returncode=1,
error='generate_delta_sysroot: error')
self.assertRaises2(cros_build_lib.RunCommandError,
stage.BuildAndArchiveDeltaSysroot)
self.assertFalse(stage._upload_queue.put.called)
def setUp(self):
self.StartPatcher(generic_stages_unittest.ArchivingStageMixinMock())
self.gen_mock = self.PatchObject(commands, 'GenerateBreakpadSymbols')
self.upload_mock = self.PatchObject(commands, 'UploadSymbols')
self.tar_mock = self.PatchObject(commands, 'GenerateDebugTarball')
self.rc_mock = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
self.rc_mock.SetDefaultCmdResult(output='')
self.stage = None
def setUp(self):
self.rc_mock = cros_build_lib_unittest.RunCommandMock()
self.StartPatcher(self.rc_mock)
self.rc_mock.SetDefaultCmdResult()
self.PatchObject(glob, 'glob', return_value=LOOP_PARTS_LIST)
def fake_which(val, *_arg, **_kwargs):
return val
self.PatchObject(osutils, 'Which', side_effect=fake_which)
def testGetPortageEnvVar(self):
"""Basic test case for _GetPortageEnvVar function."""
stage = self.ConstructStage()
board = self._current_board
envvar = 'EXAMPLE'
rc_mock = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
rc_mock.AddCmdResult(['portageq-%s' % board, 'envvar', envvar],
output='RESULT\n')
result = stage._GetPortageEnvVar(envvar, board)
self.assertEqual(result, 'RESULT')
def testOneTimeTransientError(self):
"""GitPush retries transient errors."""
for error in self.TRANSIENT_ERRORS:
with cros_build_lib_unittest.RunCommandMock() as rc_mock:
results = [
rc_mock.CmdResult(128, '', error),
rc_mock.CmdResult(0, 'success', ''),
]
# pylint: disable=cell-var-from-loop
side_effect = lambda *_args, **_kwargs: results.pop(0)
rc_mock.AddCmdResult(partial_mock.In('push'),
side_effect=side_effect)
self._RunGitPush()
def RemoteSh(self, inst, cmd, *args, **kwargs):
"""Simulates a RemoteSh invocation."""
result = self._results['RemoteSh'].LookupResult(
(cmd,), hook_args=(inst, cmd,) + args, hook_kwargs=kwargs)
# Run the real RemoteSh with RunCommand mocked out.
rc_mock = cros_build_lib_unittest.RunCommandMock()
rc_mock.AddCmdResult(
partial_mock.Ignore(), result.returncode, result.output,
result.error)
with rc_mock:
return self.backup['RemoteSh'](inst, cmd, *args, **kwargs)
def _DoCommand(self, inst, gsutil_cmd, **kwargs):
result = self._results['_DoCommand'].LookupResult((gsutil_cmd, ),
hook_args=(
inst,
gsutil_cmd,
),
hook_kwargs=kwargs)
rc_mock = cros_build_lib_unittest.RunCommandMock()
rc_mock.AddCmdResult(partial_mock.ListRegex('gsutil'),
result.returncode, result.output, result.error)
with rc_mock:
return self.backup['_DoCommand'](inst, gsutil_cmd, **kwargs)
def setUp(self):
dir_struct = [
'repo/.repo/',
'repo/manifest/',
'gclient/.gclient',
]
cros_test_lib.CreateOnDiskHierarchy(self.tempdir, dir_struct)
self.repo_root = os.path.join(self.tempdir, 'repo')
self.gclient_root = os.path.join(self.tempdir, 'gclient')
self.nocheckout_root = os.path.join(self.tempdir, 'nothing')
self.rc_mock = self.StartPatcher(
cros_build_lib_unittest.RunCommandMock())
self.cwd_mock = self.PatchObject(os, 'getcwd')
def __init__(self, args, base_args=None):
partial_mock.PartialMock.__init__(self)
self.args = args
self.rc_mock = cros_build_lib_unittest.RunCommandMock()
self.rc_mock.SetDefaultCmdResult()
parser = commandline.ArgumentParser(caching=True)
subparsers = parser.add_subparsers()
subparser = subparsers.add_parser(self.COMMAND, caching=True)
self.TARGET_CLASS.AddParser(subparser)
args = base_args if base_args else []
args += [self.COMMAND] + self.args
options = parser.parse_args(args)
self.inst = options.command_class(options)
def testIt(self):
"""A simple run-through test."""
rc_mock = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
rc_mock.SetDefaultCmdResult()
self.PatchObject(chrome_stages.SimpleChromeWorkflowStage,
'_ArchiveChromeEbuildEnv',
autospec=True)
self.PatchObject(chrome_stages.SimpleChromeWorkflowStage,
'_VerifyChromeDeployed',
autospec=True)
self.PatchObject(chrome_stages.SimpleChromeWorkflowStage,
'_VerifySDKEnvironment',
autospec=True)
self.RunStage()
def testGetNextBuildSpec(self):
"""End-to-end test of updating the manifest."""
my_info = manifest_version.VersionInfo('1.2.3', chrome_branch='4')
self.PatchObject(manifest_version.BuildSpecsManager,
'GetCurrentVersionInfo',
return_value=my_info)
self.PatchObject(repository.RepoRepository, 'Sync')
self.PatchObject(repository.RepoRepository,
'ExportManifest',
return_value='<manifest />')
rc = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
rc.SetDefaultCmdResult()
self.manager.GetNextBuildSpec(retries=0)
self.manager.UpdateStatus({self.build_names[0]: True})
def RunStageWithConfig(self, mock_configurator=None):
"""Run the given config"""
try:
with cros_build_lib_unittest.RunCommandMock() as rc:
rc.SetDefaultCmdResult()
if mock_configurator:
mock_configurator(rc)
with self.OutputCapturer():
with cros_test_lib.LoggingCapturer():
self.RunStage()
yield rc
except AssertionError as ex:
msg = '%s failed the following test:\n%s' % (self._bot_id, ex)
raise AssertionError(msg)
def setUp(self):
self.elf_file = os.path.join(self.tempdir, 'elf')
osutils.Touch(self.elf_file)
self.debug_dir = os.path.join(self.tempdir, 'debug')
self.debug_file = os.path.join(self.debug_dir, 'elf.debug')
osutils.Touch(self.debug_file, makedirs=True)
# Not needed as the code itself should create it as needed.
self.breakpad_dir = os.path.join(self.debug_dir, 'breakpad')
self.rc_mock = self.StartPatcher(
cros_build_lib_unittest.RunCommandMock())
self.rc_mock.SetDefaultCmdResult(output='MODULE OS CPU ID NAME')
self.assertCommandContains = self.rc_mock.assertCommandContains
self.sym_file = os.path.join(self.breakpad_dir, 'NAME/ID/NAME.sym')
self.StartPatcher(FindDebugDirMock(self.debug_dir))
def setUp(self):
self.PatchObject(commandline.ArgumentParser, 'ConfigureCacheDir')
dir_struct = [
'repo/.repo/',
'gclient/.gclient',
'submodule/.git/',
]
cros_test_lib.CreateOnDiskHierarchy(self.tempdir, dir_struct)
self.repo_root = os.path.join(self.tempdir, 'repo')
self.gclient_root = os.path.join(self.tempdir, 'gclient')
self.submodule_root = os.path.join(self.tempdir, 'submodule')
self.nocheckout_root = os.path.join(self.tempdir, 'nothing')
self.rc_mock = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
self.rc_mock.AddCmdResult(
partial_mock.In('config'), output=constants.CHROMIUM_GOB_URL)
self.cwd_mock = self.PatchObject(os, 'getcwd')
self.parser = commandline.ArgumentParser(caching=True)
def testArchForToolchain(self):
"""Tests that we correctly parse crossdev's output."""
rc_mock = cros_build_lib_unittest.RunCommandMock()
noarch = """target=foo
category=bla
"""
rc_mock.SetDefaultCmdResult(output=noarch)
with rc_mock:
self.assertEqual(None, toolchain.GetArchForTarget('fake_target'))
amd64arch = """arch=amd64
target=foo
"""
rc_mock.SetDefaultCmdResult(output=amd64arch)
with rc_mock:
self.assertEqual('amd64',
toolchain.GetArchForTarget('fake_target'))
def RemoteSh(self, inst, cmd, *args, **kwargs):
"""Simulates a RemoteSh invocation.
Returns:
A CommandResult object with an additional member |rc_mock| to
enable examination of the underlying RunCommand() function call.
"""
result = self._results['RemoteSh'].LookupResult(
(cmd,), hook_args=(inst, cmd,) + args, hook_kwargs=kwargs)
# Run the real RemoteSh with RunCommand mocked out.
rc_mock = cros_build_lib_unittest.RunCommandMock()
rc_mock.AddCmdResult(
partial_mock.Ignore(), result.returncode, result.output, result.error)
with rc_mock:
result = self.backup['RemoteSh'](inst, cmd, *args, **kwargs)
result.rc_mock = rc_mock
return result
def testRestartInChrootWithChrootArgs(self):
"""Verify args and chroot args from exception are used."""
# Setup Mocks/Fakes
rc = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
rc.SetDefaultCmdResult()
def findTarget(_):
"""ScriptWrapperMain needs a function to find a function to run."""
def raiseChrootRequiredError(_args):
raise commandline.ChrootRequiredError(self.CMD_ARGS,
self.CHROOT_ARGS)
return raiseChrootRequiredError
# Run Test
commandline.ScriptWrapperMain(findTarget, ['unrelated'])
# Verify Results
rc.assertCommandContains(enter_chroot=True)
rc.assertCommandContains(self.CMD_ARGS)
rc.assertCommandContains(chroot_args=self.CHROOT_ARGS)
def testRestartInChrootPreserveArgs(self):
"""Verify args to ScriptWrapperMain are passed through to chroot.."""
# Setup Mocks/Fakes
rc = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
rc.SetDefaultCmdResult()
def findTarget(target):
"""ScriptWrapperMain needs a function to find a function to run."""
def raiseChrootRequiredError(args):
raise commandline.ChrootRequiredError(args)
self.lastTargetFound = target
return raiseChrootRequiredError
# Run Test
commandline.ScriptWrapperMain(findTarget, self.SYS_ARGV)
# Verify Results
rc.assertCommandContains(enter_chroot=True)
rc.assertCommandContains(self.CMD_ARGS)
self.assertEqual('/cmd', self.lastTargetFound)
def _assertRunBuildScript(self, in_chroot=False, error=None, raises=None,
**kwargs):
"""Test the RunBuildScript function.
Args:
in_chroot: Whether to enter the chroot or not.
error: error result message to simulate.
raises: If the command should fail, the exception to be raised.
kwargs: Extra kwargs passed to RunBuildScript.
"""
# Write specified error message to status file.
def WriteError(_cmd, extra_env=None, **_kwargs):
if extra_env is not None and error is not None:
status_file = extra_env[constants.PARALLEL_EMERGE_STATUS_FILE_ENVVAR]
osutils.WriteFile(status_file, error)
buildroot = self.tempdir
osutils.SafeMakedirs(os.path.join(buildroot, '.repo'))
if error is not None:
osutils.SafeMakedirs(os.path.join(buildroot, 'chroot', 'tmp'))
# Run the command, throwing an exception if it fails.
with cros_build_lib_unittest.RunCommandMock() as m:
cmd = ['example', 'command']
sudo_cmd = ['sudo', '--'] + cmd
returncode = 1 if raises else 0
m.AddCmdResult(cmd, returncode=returncode, side_effect=WriteError)
m.AddCmdResult(sudo_cmd, returncode=returncode, side_effect=WriteError)
with mock.patch.object(path_util, 'ToChrootPath',
side_effect=lambda x: x):
with cros_test_lib.LoggingCapturer():
# If the script failed, the exception should be raised and printed.
if raises:
self.assertRaises(raises, commands.RunBuildScript, buildroot,
cmd, enter_chroot=in_chroot, **kwargs)
else:
commands.RunBuildScript(buildroot, cmd, enter_chroot=in_chroot,
**kwargs)
def setUp(self):
"""Setup patchers for specified bot id."""
# Mock out methods as needed.
self.StartPatcher(parallel_unittest.ParallelMock())
self.StartPatcher(git_unittest.ManifestCheckoutMock())
self._CreateVersionFile()
self.rc_mock = self.StartPatcher(
cros_build_lib_unittest.RunCommandMock())
self.rc_mock.SetDefaultCmdResult()
# We have a versioned manifest (generated by ManifestVersionSyncStage) and
# the regular, user-maintained manifests.
manifests = {
'.repo/manifest.xml': VERSIONED_MANIFEST_CONTENTS,
'manifest/default.xml': MANIFEST_CONTENTS,
'manifest-internal/official.xml': MANIFEST_CONTENTS,
}
for m_path, m_content in manifests.iteritems():
full_path = os.path.join(self.build_root, m_path)
osutils.SafeMakedirs(os.path.dirname(full_path))
osutils.WriteFile(full_path, m_content)
self.norm_name = git.NormalizeRef(self.RELEASE_BRANCH_NAME)
def setUp(self): self.rc_mock = self.StartPatcher(cros_build_lib_unittest.RunCommandMock())
