def setUp(self):
self.build_root = self.tempdir
# Prepare a fake chroot.
self.fake_chroot = os.path.join(self.build_root,
'chroot/build/amd64-host')
fake_pkgdb_path = os.path.join(self.fake_chroot, 'var/db/pkg')
os.makedirs(fake_pkgdb_path)
for cat, pkgs in self.fake_pkgdb.iteritems():
catpath = os.path.join(fake_pkgdb_path, cat)
if cat == 'invalid':
# Invalid category is a file. Should not be delved into.
osutils.Touch(catpath)
continue
os.makedirs(catpath)
for pkg in pkgs:
pkgpath = os.path.join(catpath, pkg)
if pkg == 'invalid':
# Invalid package is a file instead of a directory/
osutils.Touch(pkgpath)
continue
os.makedirs(pkgpath)
if pkg.endswith('-invalid'):
# Invalid package does not meet existence of "%s/%s.ebuild" file.
osutils.Touch(os.path.join(pkgpath, 'whatever'))
continue
# Correct pkg.
osutils.Touch(os.path.join(pkgpath, pkg + '.ebuild'))
pv = portage_utilities.SplitPV(pkg)
key = '%s/%s' % (cat, pv.package)
self.fake_packages.append((key, pv.version))
def setUp(self):
# Fake out environment.
options = Options()
options.ssh_private_key = os.path.join(self.tempdir, 'ssh-private-key')
osutils.Touch(options.ssh_private_key)
self.options = options
test_results_root = os.path.join(self.tempdir, 'test-results')
self.test_results_all = os.path.join(test_results_root, 'all')
self.test_results_failed = os.path.join(test_results_root, 'failed')
osutils.SafeMakedirs(self.test_results_all)
self.test_results_root = test_results_root
self.json_key_file = os.path.join(self.tempdir, 'service_account.json')
osutils.Touch(self.json_key_file)
self.image_path = os.path.join(self.tempdir, self.GCE_TARBALL)
osutils.Touch(self.image_path)
# Mock out model or class level methods.
self.PatchObject(AUWorker,
'GetNextResultsPath',
autospec=True,
return_value=(self.test_results_all,
self.test_results_failed))
self.PatchObject(GceContext,
'ForServiceAccountThreadSafe',
spec=GceContext.ForServiceAccountThreadSafe)
def testBuildStrippedPackagesArchive(self):
"""Test generation of stripped package tarball using globs."""
package_globs = ['chromeos-base/chromeos-chrome', 'sys-kernel/*kernel*']
self.PatchObject(
portage_util, 'FindPackageNameMatches',
side_effect=[
[portage_util.SplitCPV('chromeos-base/chrome-1-r0')],
[portage_util.SplitCPV('sys-kernel/kernel-1-r0'),
portage_util.SplitCPV('sys-kernel/kernel-2-r0')]])
# Drop "stripped packages".
pkg_dir = pathjoin(self._buildroot, 'chroot', 'build', 'test-board',
'stripped-packages')
osutils.Touch(pathjoin(pkg_dir, 'chromeos-base', 'chrome-1-r0.tbz2'),
makedirs=True)
sys_kernel = pathjoin(pkg_dir, 'sys-kernel')
osutils.Touch(pathjoin(sys_kernel, 'kernel-1-r0.tbz2'), makedirs=True)
osutils.Touch(pathjoin(sys_kernel, 'kernel-1-r01.tbz2'), makedirs=True)
osutils.Touch(pathjoin(sys_kernel, 'kernel-2-r0.tbz1'), makedirs=True)
osutils.Touch(pathjoin(sys_kernel, 'kernel-2-r0.tbz2'), makedirs=True)
stripped_files_list = [
abspath(pathjoin(pkg_dir, 'chromeos-base', 'chrome-1-r0.tbz2')),
abspath(pathjoin(pkg_dir, 'sys-kernel', 'kernel-1-r0.tbz2')),
abspath(pathjoin(pkg_dir, 'sys-kernel', 'kernel-2-r0.tbz2'))]
tar_mock = self.PatchObject(commands, 'BuildTarball')
self.PatchObject(cros_build_lib, 'RunCommand')
commands.BuildStrippedPackagesTarball(self._buildroot,
'test-board',
package_globs,
self.tempdir)
tar_mock.assert_called_once_with(
self._buildroot, stripped_files_list,
pathjoin(self.tempdir, 'stripped-packages.tar'),
compressed=False)
def testChooseImage(self):
"""Tests that we can detect a GPT image."""
# pylint: disable=protected-access
with self.PatchObject(flash,
'_IsFilePathGPTDiskImage',
return_value=True):
# No images defined. Choosing the image should raise an error.
with self.assertRaises(ValueError):
flash._ChooseImageFromDirectory(self.tempdir)
file_a = os.path.join(self.tempdir, 'a')
osutils.Touch(file_a)
# Only one image available, it should be selected automatically.
self.assertEqual(file_a,
flash._ChooseImageFromDirectory(self.tempdir))
osutils.Touch(os.path.join(self.tempdir, 'b'))
file_c = os.path.join(self.tempdir, 'c')
osutils.Touch(file_c)
osutils.Touch(os.path.join(self.tempdir, 'd'))
# Multiple images available, we should ask the user to select the right
# image.
with self.PatchObject(cros_build_lib, 'GetChoice', return_value=2):
self.assertEqual(file_c,
flash._ChooseImageFromDirectory(self.tempdir))
def setUp(self):
self.prog_path = os.path.join(self.tempdir, 'prog')
osutils.Touch(self.prog_path, mode=0o755)
self.text_path = os.path.join(self.tempdir, 'text')
osutils.Touch(self.text_path, mode=0o644)
# A random path for us to validate.
os.environ['PATH'] = '/:%s' % (self.tempdir,)
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])
self.testUploadPrebuilts(builder_type=constants.CHROOT_BUILDER_TYPE,
version=version)
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 testChromeAndAppShellDetection(self):
"""Check for a chrome deployment when app_shell also exists."""
osutils.Touch(os.path.join(self.deploy.options.build_dir, 'chrome'),
makedirs=True)
osutils.Touch(os.path.join(self.deploy.options.build_dir, 'app_shell'),
makedirs=True)
self.deploy._CheckDeployType()
self.assertTrue(self.getCopyPath('chrome'))
self.assertFalse(self.getCopyPath('app_shell'))
def testListdirFullpath(self):
file_a = os.path.join(self.tempdir, 'a')
file_b = os.path.join(self.tempdir, 'b')
osutils.Touch(file_a)
osutils.Touch(file_b)
self.assertEqual(sorted(utils.ListdirFullpath(self.tempdir)),
[file_a, file_b])
def setUp(self):
self.target_image = os.path.join(
self.tempdir,
'link/R37-5952.0.2014_06_12_2302-a1/chromiumos_test_image.bin')
osutils.Touch(self.target_image, makedirs=True)
self.dummy_dlc_image = os.path.join(
self.tempdir,
'link/R37-5952.0.2014_06_12_2302-a1/dlc/dummy-dlc/package/dlc.img')
osutils.Touch(self.dummy_dlc_image, makedirs=True)
def testEmptyWithContentsMaxFlags(self):
"""Test ability to empty actual directory contents."""
osutils.Touch(self.nestedfile, makedirs=True)
osutils.Touch(self.topfile, makedirs=True)
osutils.EmptyDir(self.tempdir, ignore_missing=True, sudo=True)
self.assertExists(self.tempdir)
self.assertNotExists(self.subdir)
self.assertNotExists(self.topfile)
def testIgnores(self):
"""Verify we skip ignored dirs."""
for f in ('foo', 'bar_unittest'):
osutils.Touch(os.path.join(self.tempdir, f))
# Make sure it works first.
found = run_tests.FindTests(search_paths=(self.tempdir, ))
self.assertEqual(sorted(found), ['./bar_unittest'])
# Mark the dir ignored.
osutils.Touch(os.path.join(self.tempdir, '.testignore'))
# Make sure we ignore it.
found = run_tests.FindTests(search_paths=(self.tempdir, ))
self.assertEqual(list(found), [])
def Run(self, func, *args, **kwargs):
"""Run func, parse its output, and update the progress bar.
Args:
func: Function to execute in the background and whose output is to be
captured.
update_period: Optional argument to specify the period that output should
be read.
log_level: Logging level to run the func at. By default, it runs at log
level info.
"""
update_period = kwargs.pop('update_period',
self._PROGRESS_BAR_UPDATE_INTERVAL)
# If we are not running in a terminal device, do not display the progress
# bar.
if not self._isatty:
log_level = kwargs.pop('log_level', logging.INFO)
restore_log_level = logging.getLogger().getEffectiveLevel()
logging.getLogger().setLevel(log_level)
try:
func(*args, **kwargs)
finally:
logging.getLogger().setLevel(restore_log_level)
return
with osutils.TempDir() as tempdir:
self._stdout_path = os.path.join(tempdir, STDOUT_FILE)
self._stderr_path = os.path.join(tempdir, STDERR_FILE)
osutils.Touch(self._stdout_path)
osutils.Touch(self._stderr_path)
try:
with parallel.BackgroundTaskRunner(
self.CaptureOutputInBackground, func, *args,
**kwargs) as queue:
queue.put([])
self.OpenStdoutStderr()
while True:
self.ParseOutput()
if self.WaitUntilComplete(update_period):
break
# Before we exit, parse the output again to update progress bar.
self.ParseOutput()
# Final sanity check to update the progress bar to 100% if it was used
# by ParseOutput
self.Cleanup()
except:
# Add a blank line before the logging message so the message isn't
# touching the progress bar.
sys.stdout.write('\n')
logging.error('Oops. Something went wrong.')
# Raise the exception so it can be caught again.
raise
def testListKeys(self):
"""Verifies that ListKeys() returns any items present in the cache."""
osutils.Touch(os.path.join(self.tempdir, 'file1'))
cache.CacheReference(self.cache, ('key1', )).Assign(
os.path.join(self.tempdir, 'file1'))
osutils.Touch(os.path.join(self.tempdir, 'file2'))
cache.CacheReference(self.cache, ('key2', )).Assign(
os.path.join(self.tempdir, 'file2'))
keys = self.cache.ListKeys()
self.assertEqual(len(keys), 2)
self.assertIn(('key1', ), keys)
self.assertIn(('key2', ), keys)
def ConstructStage(self):
self._run.GetArchive().SetupArchivePath()
self._run.config['moblab_vm_tests'] = [
config_lib.MoblabVMTestConfig(constants.MOBLAB_VM_SMOKE_TEST_TYPE),
]
stage = vm_test_stages.MoblabVMTestStage(self._run, self.buildstore,
self._current_board)
image_dir = stage.GetImageDirSymlink()
osutils.Touch(os.path.join(image_dir, constants.TEST_KEY_PRIVATE),
makedirs=True)
osutils.Touch(os.path.join(image_dir, constants.TEST_IMAGE_BIN),
makedirs=True)
return stage
def testCandidateBuildSpecPathExistingCandidates(self):
"""Test CandidateBuildSpecPath, with existing candidates."""
# Create some preexisting build specs.
osutils.Touch(os.path.join(self.manifest_versions_int,
'cat/buildspecs/11/1.2.3-rc1.xml'),
makedirs=True)
osutils.Touch(os.path.join(self.manifest_versions_int,
'cat/buildspecs/11/1.2.3-rc2.xml'),
makedirs=True)
result = manifest_version.CandidateBuildSpecPath(
self.version_info, 'cat', self.manifest_versions_int)
self.assertEqual(result, 'cat/buildspecs/11/1.2.3-rc3.xml')
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.SetDefaultCmdResult(output='MODULE OS CPU ID NAME')
self.assertCommandContains = self.rc.assertCommandContains
self.sym_file = os.path.join(self.breakpad_dir, 'NAME/ID/NAME.sym')
self.StartPatcher(FindDebugDirMock(self.debug_dir))
def setUp(self):
self.image_dir = os.path.join(self.tempdir, 'images')
osutils.SafeMakedirs(self.image_dir)
self.output_dir = os.path.join(self.tempdir, 'output')
osutils.SafeMakedirs(self.output_dir)
self.images = []
for img in artifacts.IMAGE_TARS.keys():
full_path = os.path.join(self.image_dir, img)
self.images.append(full_path)
osutils.Touch(full_path)
osutils.Touch(os.path.join(self.image_dir, 'irrelevant_image.bin'))
osutils.Touch(os.path.join(self.image_dir, 'foo.txt'))
osutils.Touch(os.path.join(self.image_dir, 'bar'))
def setUp(self):
self.mv_path = self.tempdir
self.version = '1.2.3'
self.resolvedVersionSpec = os.path.join(self.mv_path, 'buildspecs',
'12', '1.2.3.xml')
self.invalidSpec = os.path.join('invalid', 'spec')
self.validSpec = os.path.join('valid', 'spec')
self.resolvedValidSpec = os.path.join(self.mv_path, 'valid',
'spec.xml')
osutils.Touch(self.resolvedVersionSpec, makedirs=True)
osutils.Touch(self.resolvedValidSpec, makedirs=True)
def testCleaningFalse(self, gen_mock):
"""Verify behavior of clean_breakpad=False"""
with parallel_unittest.ParallelMock():
# Dir does not exist, and then does.
self.assertNotExists(self.breakpad_dir)
ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
self.board,
sysroot=self.board_dir,
generate_count=1,
clean_breakpad=False)
self.assertEquals(ret, 0)
self.assertEquals(gen_mock.call_count, 1)
self.assertExists(self.breakpad_dir)
# Dir exists before & after.
# File exists before & after.
dummy_file = os.path.join(self.breakpad_dir, 'fooooooooo')
osutils.Touch(dummy_file)
ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
self.board,
sysroot=self.board_dir,
generate_count=1,
clean_breakpad=False)
self.assertEquals(ret, 0)
self.assertEquals(gen_mock.call_count, 2)
self.assertExists(dummy_file)
def testSdkPrebuilts(self):
"""Test UploadPrebuilts for SDK builds."""
# A magical date for a magical time.
version = '1994.04.02.000000'
# Fake out toolchain tarballs.
tarball_dir = os.path.join(self._buildroot,
constants.DEFAULT_CHROOT_DIR,
constants.SDK_TOOLCHAINS_OUTPUT)
osutils.SafeMakedirs(tarball_dir)
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)
tarball_args.append(['--toolchain-tarball', tarball_arg])
with mock.patch.object(commands,
'_GenerateSdkVersion',
return_value=version):
self.testUploadPrebuilts(
builder_type=constants.CHROOT_BUILDER_TYPE)
self.assertCommandContains([
'--toolchain-upload-path', '1994/04/%%(target)s-%(version)s.tar.xz'
])
for args in tarball_args:
self.assertCommandContains(args)
self.assertCommandContains(['--set-version', version])
self.assertCommandContains([
'--prepackaged-tarball',
os.path.join(self._buildroot, 'built-sdk.tar.xz')
])
def testSubdirs(self):
"""We should recurse into subdirs."""
for f in ('bar_unittest', 'somw/dir/a/cow_unittest'):
osutils.Touch(os.path.join(self.tempdir, f), makedirs=True)
found = run_tests.FindTests(search_paths=(self.tempdir, ))
self.assertEqual(sorted(found),
['./bar_unittest', 'somw/dir/a/cow_unittest'])
def _create_gerrit_instance(self, tmp_dir):
default_host = 't3st-chr0m3'
git_host = os.environ.get('CROS_TEST_GIT_HOST',
constants.GOB_HOST % default_host)
gerrit_host = os.environ.get(
'CROS_TEST_GERRIT_HOST',
'%s-review.googlesource.com' % default_host)
project_prefix = 'test-%s/' % (cros_build_lib.GetRandomString(), )
cookies_path = os.environ.get('CROS_TEST_COOKIES_PATH',
constants.GITCOOKIES_PATH)
# "o" is the cookie name that GoB uses in its instructions.
cookie_names_str = os.environ.get('CROS_TEST_COOKIE_NAMES', 'o')
cookie_names = {c for c in cookie_names_str.split(',') if c}
tmpcookies_path = os.path.join(tmp_dir, '.gitcookies')
if os.path.exists(cookies_path):
shutil.copy(cookies_path, tmpcookies_path)
else:
osutils.Touch(tmpcookies_path)
return self.GerritInstance(
cookie_names=cookie_names,
cookies_path=tmpcookies_path,
gerrit_host=gerrit_host,
gerrit_url='https://%s/' % gerrit_host,
git_host=git_host,
git_url='https://%s/' % git_host,
project_prefix=project_prefix,
)
def _TestPerformStage(self,
extra_config=None,
create_android_symbols_archive=False):
"""Run PerformStage for the stage with the given extra config."""
if not extra_config:
extra_config = {
'archive_build_debug': True,
'vm_tests': True,
'upload_symbols': True,
}
self._Prepare(extra_config=extra_config)
self._run.attrs.release_tag = self.VERSION
self.tar_mock.side_effect = '/my/tar/ball'
self.stage = self.ConstructStage()
if create_android_symbols_archive:
symbols_file = os.path.join(self.stage.archive_path,
constants.ANDROID_SYMBOLS_FILE)
osutils.Touch(symbols_file)
try:
self.stage.PerformStage()
except Exception:
return self.stage._HandleStageException(sys.exc_info())
def testPathVerifyWarnings(self):
"""Test the user rc PATH verification codepath."""
def SourceEnvironmentMock(*_args, **_kwargs):
return {
'PATH': ':'.join([os.path.dirname(p) for p in abs_paths]),
}
self.PatchObject(osutils,
'SourceEnvironment',
side_effect=SourceEnvironmentMock)
file_list = (
'goma/goma_ctl.sh',
'clang/clang',
'chromite/parallel_emerge',
)
abs_paths = [
os.path.join(self.tempdir, relpath) for relpath in file_list
]
for p in abs_paths:
osutils.Touch(p, makedirs=True, mode=0755)
with cros_test_lib.LoggingCapturer() as logs:
cros_chrome_sdk.ChromeSDKCommand._VerifyGoma(None)
cros_chrome_sdk.ChromeSDKCommand._VerifyClang(None)
cros_chrome_sdk.ChromeSDKCommand._VerifyChromiteBin(None)
for msg in ['managed Goma', 'default Clang', 'default Chromite']:
self.AssertLogsMatch(logs, msg)
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 testChromeDetection(self):
"""Check for a regular chrome deployment"""
osutils.Touch(os.path.join(self.deploy.options.build_dir, 'chrome'),
makedirs=True)
self.deploy._CheckDeployType()
self.assertTrue(self.getCopyPath('chrome'))
self.assertFalse(self.getCopyPath('app_shell'))
def setUp(self):
for d in ('foo', 'bar', 'some/dir/here'):
d = os.path.join(self.tempdir, d)
osutils.SafeMakedirs(d)
for f in ('ignored', 'real.sym', 'no.sym.here'):
f = os.path.join(d, f)
osutils.Touch(f)
def FakeRunBuildScript(self,
build_root,
cmd,
chromite_cmd=False,
**kwargs):
if cmd[0] == 'cros_setup_toolchains':
self.assertEqual(self.build_root, build_root)
self.assertTrue(chromite_cmd)
self.assertTrue(kwargs.get('enter_chroot', False))
self.assertTrue(kwargs.get('sudo', False))
# Drop a uniquely named file in the toolchain overlay merged location.
sysroot = None
board = None
targets = None
for opt in cmd[1:]:
if opt.startswith('--sysroot='):
sysroot = opt[len('--sysroot='):]
elif opt.startswith('--include-boards='):
board = opt[len('--include-boards='):]
elif opt.startswith('--targets='):
targets = opt[len('--targets='):]
self.assertTrue(sysroot)
self.assertTrue(board)
self.assertEqual('boards', targets)
merged_dir = os.path.join(self.build_root,
constants.DEFAULT_CHROOT_DIR,
sysroot.lstrip(os.path.sep))
osutils.Touch(os.path.join(merged_dir, board + '.tmp'))
def testUprev(self):
recorded_args = []
self.PatchObject(upload_prebuilts, 'RevGitFile',
lambda *args, **kwargs: recorded_args.append(args))
out_dir = os.path.join(self.build_root, 'chroot', 'tmp',
'toolchain-pkgs')
osutils.SafeMakedirs(out_dir)
osutils.Touch(os.path.join(out_dir, 'fake_sdk.tar.xz'))
self._Prepare('chromiumos-sdk')
self.RunStage()
# upload_prebuilts.RevGitFile should be called exact once.
self.assertEqual(1, len(recorded_args))
sdk_conf, sdk_settings = recorded_args[0]
self.assertEqual(
sdk_conf,
os.path.join(self.build_root, 'src', 'third_party',
'chromiumos-overlay', 'chromeos', 'binhost', 'host',
'sdk_version.conf'))
self.assertEqual(
sdk_settings, {
'SDK_LATEST_VERSION': self._VERSION,
'TC_PATH': '2017/09/%(target)s-2017.09.01.155318.tar.xz'
})
def setUp(self):
self.json_key_file = os.path.join(self.tempdir, 'service_account.json')
osutils.Touch(self.json_key_file)
for cmd in ('from_stream', 'create_scoped'):
self.PatchObject(GoogleCredentials, cmd, autospec=True)
self.PatchObject(gce.GceContext, 'GetZoneRegion', autospec=True,
return_value=self._ZONE)
