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)