def testRows(self): """Test the .rows property. Testing a property gets ugly.""" mocked_gdclient = self.mox.CreateMock(gdata_lib.RetrySpreadsheetsService) scomm = self.NewScomm(gd_client=mocked_gdclient, connect=True) # Simulate a List feed from spreadsheet for all rows. rows = [{'col_name': 'Joe', 'col_age': '12', 'col_zip': '12345'}, {'col_name': 'Bob', 'col_age': '15', 'col_zip': '54321'}, ] entry = [] for row in rows: custom = dict((k, cros_test_lib.EasyAttr(text=v)) for (k, v) in row.iteritems()) entry.append(cros_test_lib.EasyAttr(custom=custom)) feed = cros_test_lib.EasyAttr(entry=entry) # This is the replay script for the test. mocked_gdclient.GetListFeed(self.SS_KEY, self.WS_KEY).AndReturn(feed) self.mox.ReplayAll() # This is the test verification. result = scomm.rows del scomm # Force deletion now before VerifyAll. self.mox.VerifyAll() self.assertEquals(tuple(rows), result) # Result tuple should have spreadsheet row num as attribute on each row. self.assertEquals(2, result[0].ss_row_num) self.assertEquals(3, result[1].ss_row_num) # Result tuple should have spreadsheet row obj as attribute on each row. self.assertEquals(entry[0], result[0].ss_row_obj) self.assertEquals(entry[1], result[1].ss_row_obj)
def testSanityCheckOptions(self): """Like testInit, but just call SanityCheckOptions().""" options_e = cros_test_lib.EasyAttr() options_a = cros_test_lib.EasyAttr(a='a') options_b = cros_test_lib.EasyAttr(b='b') options_ab = cros_test_lib.EasyAttr(a='a', b='b') options_abc = cros_test_lib.EasyAttr(a='a', b='b', c='c') self.assertTrue(common.OptionsChecker.SanityCheckOptions(options_e)) self.assertTrue(common.OptionsChecker.SanityCheckOptions(options_abc)) self.assertTrue(ClassAOptionsChecker.SanityCheckOptions(options_a)) self.assertTrue(ClassBOptionsChecker.SanityCheckOptions(options_ab)) self.assertTrue(ClassBOptionsChecker.SanityCheckOptions(options_abc)) # Missing 'a' argument. with self.assertRaises(common.MissingRequiredOptionsException) as cm: ClassAOptionsChecker.SanityCheckOptions(options_b) exception_message = cm.exception.message self.assertTrue('Missing command line' in exception_message) self.assertTrue('ClassAOptionsChecker' in exception_message) self.assertTrue("['a']" in exception_message) # Missing derived 'a' argument. with self.assertRaises(common.MissingRequiredOptionsException) as cm: ClassBOptionsChecker.SanityCheckOptions(options_b) exception_message = cm.exception.message self.assertTrue('Missing command line' in exception_message) self.assertTrue('ClassBOptionsChecker' in exception_message) self.assertTrue("['a']" in exception_message)
def testInit(self): """Tests constructor with OptionChecker.""" options_e = cros_test_lib.EasyAttr() options_a = cros_test_lib.EasyAttr(a='a') options_b = cros_test_lib.EasyAttr(b='b') options_ab = cros_test_lib.EasyAttr(a='a', b='b') options_abc = cros_test_lib.EasyAttr(a='a', b='b', c='c') # Expect no exceptions. common.OptionsChecker(options_e) common.OptionsChecker(options_abc) ClassAOptionsChecker(options_a) ClassBOptionsChecker(options_ab) ClassBOptionsChecker(options_abc) # Missing 'a' argument. with self.assertRaises(common.MissingRequiredOptionsException) as cm: ClassAOptionsChecker(options_b) exception_message = cm.exception.message self.assertTrue('Missing command line' in exception_message) self.assertTrue('ClassAOptionsChecker' in exception_message) self.assertTrue("['a']" in exception_message) # Missing derived 'a' argument. with self.assertRaises(common.MissingRequiredOptionsException) as cm: ClassBOptionsChecker(options_b) exception_message = cm.exception.message self.assertTrue('Missing command line' in exception_message) self.assertTrue('ClassBOptionsChecker' in exception_message) self.assertTrue("['a']" in exception_message)
def testColumns(self): """Test the .columns property. Testing a property gets ugly.""" self.mox.StubOutWithMock(gdata.spreadsheet.service, 'CellQuery') mocked_gdclient = self.mox.CreateMock( gdata_lib.RetrySpreadsheetsService) scomm = self.NewScomm(gd_client=mocked_gdclient, connect=True) query = {'max-row': '1'} # Simulate a Cells feed from spreadsheet for the column row. cols = [c[0].upper() + c[1:] for c in self.COLUMNS] entry = [ cros_test_lib.EasyAttr(content=cros_test_lib.EasyAttr(text=c)) for c in cols ] feed = cros_test_lib.EasyAttr(entry=entry) # This is the replay script for the test. gdata.spreadsheet.service.CellQuery().AndReturn(query) mocked_gdclient.GetCellsFeed(self.SS_KEY, self.WS_KEY, query=query).AndReturn(feed) self.mox.ReplayAll() # This is the test verification. result = scomm.columns del scomm # Force deletion now before VerifyAll. self.mox.VerifyAll() expected_result = self.COLUMNS self.assertEquals(expected_result, result)
def testCreateTrackerIssue(self): author = 'TheAuthor' mocked_itclient = self.mox.CreateMock( gd_ph_client.ProjectHostingClient) mocked_tcomm = self.mox.CreateMock(gdata_lib.TrackerComm) mocked_tcomm.author = author mocked_tcomm.it_client = mocked_itclient mocked_tcomm.project_name = 'TheProject' issue = cros_test_lib.EasyAttr(title='TheTitle', summary='TheSummary', status='TheStatus', owner='TheOwner', labels='TheLabels', ccs=[]) # Replay script issue_id = cros_test_lib.EasyAttr(id=cros_test_lib.EasyAttr( text='foo/bar/123')) mocked_itclient.add_issue(project_name='TheProject', title=issue.title, content=issue.summary, author=author, status=issue.status, owner=issue.owner, labels=issue.labels, ccs=issue.ccs).AndReturn(issue_id) self.mox.ReplayAll() # Verify result = gdata_lib.TrackerComm.CreateTrackerIssue(mocked_tcomm, issue) self.mox.VerifyAll() self.assertEquals(123, result)
def testFileSize(self): self.mox.StubOutWithMock(utils, 'RunCommand') gs_uri = '%s/%s' % (self.bucket_uri, 'some/file/path') # Set up the test replay script. cmd = [self.gsutil, '-d', 'stat', gs_uri] size = 96 output = '\n'.join([ 'header: x-goog-generation: 1386322968237000', 'header: x-goog-metageneration: 1', 'header: x-goog-stored-content-encoding: identity', 'header: x-goog-stored-content-length: %d' % size, 'header: Content-Type: application/octet-stream' ]) utils.RunCommand(cmd, redirect_stdout=True, redirect_stderr=True, return_result=True).AndReturn( cros_test_lib.EasyAttr(output=output)) self.mox.ReplayAll() # Run the test verification. result = gslib.FileSize(gs_uri) self.assertEqual(size, result) self.mox.VerifyAll()
def GetBuilder(self, base_dir=None, board=None, reuse_repo=True, chromium_dir=None, build_dir=None, archive_build=True, reuse_build=True): """Obtains a SimpleChromeBuilder instance. Args: base_dir: Base directory. Default self.tempdir. board: Board name. Default self.BOARD. reuse_repo: True to reuse repo. chromium_dir: Optional. If specified, use the chromium repo the path points to. build_dir: Optional. Store build result to it if specified. archive_build: True to archive build. reuse_build: True to reuse previous build. Returns: A SimpleChromeBuilder instance. """ if base_dir is None: base_dir = self.tempdir if board is None: board = self.BOARD options = cros_test_lib.EasyAttr( base_dir=base_dir, board=board, reuse_repo=reuse_repo, chromium_dir=chromium_dir, build_dir=build_dir, archive_build=archive_build, reuse_build=reuse_build) builder = simple_chrome_builder.SimpleChromeBuilder(options) # Override gclient path. builder.gclient = self.gclient_path return builder
def testBuildNoArchive(self): gsync_mock = self.PatchObject(simple_chrome_builder.SimpleChromeBuilder, 'GclientSync') success_result = cros_test_lib.EasyAttr(returncode=0) chrome_sdk_run_mock = self.PatchObject( commands.ChromeSDK, 'Run', side_effect=self._ChromeSdkRunSideEffect, return_value=success_result) chrome_sdk_ninja_mock = self.PatchObject( commands.ChromeSDK, 'Ninja', return_value=success_result) commit_label = 'test' archive_path = os.path.join( self.default_archive_base, 'out_%s_%s' % (self.BOARD, commit_label), 'Release') self.assertFalse(os.path.isdir(archive_path)) builder = self.GetBuilder(archive_build=False) build_to_deploy = builder.Build(commit_label) # No archive. Check that archive_path is not created. self.assertNotEqual(archive_path, build_to_deploy) self.assertFalse(os.path.isdir(archive_path)) self.assertEqual(os.path.join('out_%s' % self.BOARD, 'Release'), build_to_deploy) self.assertTrue(os.path.isdir( os.path.join(self.default_repo_dir, build_to_deploy))) gsync_mock.assert_called() chrome_sdk_run_mock.assert_called_with( ['bash', '-c', 'gn gen out_%s/Release --args="$GN_ARGS"' % self.BOARD], run_args=self.log_output_args) chrome_sdk_ninja_mock.assert_called_with(run_args=self.log_output_args)
def testBuild(self): gsync_mock = self.PatchObject( simple_chrome_builder.SimpleChromeBuilder, 'GclientSync') success_result = cros_test_lib.EasyAttr(returncode=0) chrome_sdk_run_mock = self.PatchObject( commands.ChromeSDK, 'Run', side_effect=self._ChromeSdkRunSideEffect, return_value=success_result) chrome_sdk_ninja_mock = self.PatchObject(commands.ChromeSDK, 'Ninja', return_value=success_result) commit_label = 'test' archive_path = os.path.join(self.default_archive_base, 'out_%s_%s' % (self.BOARD, commit_label), 'Release') self.assertFalse(os.path.isdir(archive_path)) builder = self.GetBuilder() build_to_deploy = builder.Build(commit_label) self.assertEqual(archive_path, build_to_deploy) # Check that build_to_deploy exists after builder.Build() self.assertTrue(os.path.isdir(archive_path)) gsync_mock.assert_called() chrome_sdk_run_mock.assert_called_with([ 'bash', '-c', 'gn gen out_%s/Release --args="$GN_ARGS"' % self.BOARD ], run_args=self.log_output_args) chrome_sdk_ninja_mock.assert_called_with( targets=['chrome', 'chrome_sandbox', 'nacl_helper'], run_args=self.log_output_args)
def testListFiles(self): files = [ '%s/some/path' % self.bucket_uri, '%s/some/file/path' % self.bucket_uri, ] directories = [ '%s/some/dir/' % self.bucket_uri, '%s/some/dir/path/' % self.bucket_uri, ] gs_uri = '%s/**' % self.bucket_uri cmd = [self.gsutil, 'ls', gs_uri] # Prepare cmd_result for a good run. # Fake a trailing empty line. output = '\n'.join(files + directories + ['']) cmd_result_ok = cros_test_lib.EasyAttr(output=output, returncode=0) # Prepare exception for a run that finds nothing. stderr = 'CommandException: One or more URLs matched no objects.\n' cmd_result_empty = cros_build_lib.CommandResult(error=stderr) empty_exception = cros_build_lib.RunCommandError( stderr, cmd_result_empty) # Prepare exception for a run that triggers a GS failure. error = cros_build_lib.RunCommandError(GS_RETRY_FAILURE, self.cmd_result) # Set up the test replay script. # Run 1, runs ok. cros_build_lib.RunCommand( cmd, redirect_stdout=True, redirect_stderr=True).AndReturn(cmd_result_ok) # Run 2, runs ok, sorts files. cros_build_lib.RunCommand( cmd, redirect_stdout=True, redirect_stderr=True).AndReturn(cmd_result_ok) # Run 3, finds nothing. cros_build_lib.RunCommand( cmd, redirect_stdout=True, redirect_stderr=True).AndRaise(empty_exception) # Run 4, failure in GS. for _ix in xrange(gslib.RETRY_ATTEMPTS + 1): cros_build_lib.RunCommand(cmd, redirect_stdout=True, redirect_stderr=True).AndRaise(error) self.mox.ReplayAll() # Run the test verification. result = gslib.ListFiles(self.bucket_uri, recurse=True) self.assertEqual(files, result) result = gslib.ListFiles(self.bucket_uri, recurse=True, sort=True) self.assertEqual(sorted(files), result) result = gslib.ListFiles(self.bucket_uri, recurse=True) self.assertEqual([], result) self.assertRaises(gslib.GSLibError, gslib.ListFiles, self.bucket_uri, recurse=True) self.mox.VerifyAll()
def testGenerateTrackerTokenOK(self): mocked_insidechroot = self._MockInsideChroot() # Create replay script. mocked_creds = mocked_insidechroot.creds mocked_itclient = mocked_insidechroot.it_client mocked_creds.user = '******' mocked_creds.password = '******' auth_token = 'SomeToken' mocked_itclient.auth_token = cros_test_lib.EasyAttr( token_string=auth_token) mocked_creds.LoadCreds(cgt.CRED_FILE) mocked_itclient.ClientLogin(mocked_creds.user, mocked_creds.password, source='Package Status', service='code', account_type='GOOGLE') mocked_creds.SetTrackerAuthToken(auth_token) self.mox.ReplayAll() # Run test verification. with self.OutputCapturer(): result = cgt.InsideChroot._GenerateTrackerToken( mocked_insidechroot) self.assertTrue(result, '_GenerateTrackerToken should have passed') self.mox.VerifyAll()
def _TestGenIssueForRowNeedsUpgrade(self, row): mocked_syncer = self.mox.CreateMock(sps.Syncer) mocked_syncer.default_owner = None mocked_syncer.scomm = cros_test_lib.EasyAttr(ss_key='SomeSSKey') # Replay script for arch in sps.ARCHES: state = sps.Syncer._GetRowValue(mocked_syncer, row, utable.UpgradeTable.COL_STATE, arch) mocked_syncer._GetRowValue(row, utable.UpgradeTable.COL_STATE, arch).AndReturn(state) red_team = sps.Syncer._ReduceTeamName(mocked_syncer, row[sps.COL_TEAM]) mocked_syncer._ReduceTeamName(row[sps.COL_TEAM]).AndReturn(red_team) red_owner = sps.Syncer._ReduceOwnerName(mocked_syncer, row[sps.COL_OWNER]) mocked_syncer._ReduceOwnerName(row[sps.COL_OWNER]).AndReturn(red_owner) for arch in sps.ARCHES: mocked_syncer._GetRowValue(row, utable.UpgradeTable.COL_CURRENT_VER, arch).AndReturn('1') mocked_syncer._GetRowValue( row, utable.UpgradeTable.COL_STABLE_UPSTREAM_VER, arch).AndReturn('2') mocked_syncer._GetRowValue( row, utable.UpgradeTable.COL_LATEST_UPSTREAM_VER, arch).AndReturn('3') self.mox.ReplayAll() # Verify result = sps.Syncer._GenIssueForRow(mocked_syncer, row) self.mox.VerifyAll() return result
def testGetTrackerIssueById(self): mocked_itclient = self.mox.CreateMock( gd_ph_client.ProjectHostingClient) tcomm = gdata_lib.TrackerComm() tcomm.it_client = mocked_itclient tcomm.project_name = 'TheProject' self.mox.StubOutClassWithMocks(gd_ph_client, 'Query') self.mox.StubOutClassWithMocks(gdata_lib, 'Issue') self.mox.StubOutWithMock(gdata_lib.Issue, 'InitFromTracker') issue_id = 12345 feed = cros_test_lib.EasyAttr(entry=['hi', 'there']) # Replay script mocked_query = gd_ph_client.Query(issue_id=str(issue_id)) mocked_itclient.get_issues('TheProject', query=mocked_query).AndReturn(feed) mocked_issue = gdata_lib.Issue() mocked_issue.InitFromTracker(feed.entry[0], 'TheProject') self.mox.ReplayAll() # Verify issue = tcomm.GetTrackerIssueById(issue_id) self.mox.VerifyAll() self.assertEquals(mocked_issue, issue)
def testMD5SumAccessError(self): gs_uri = 'gs://bucket/foo/bar/somefile' crc32c = 'c96fd51e' crc32c_64 = base64.b64encode(base64.b16decode(crc32c, casefold=True)) md5_sum = 'b026324c6904b2a9cb4b88d6d61c81d1' md5_sum_64 = base64.b64encode(base64.b16decode(md5_sum, casefold=True)) output = '\n'.join([ '%s:' % gs_uri, ' Creation time: Tue, 04 Mar 2014 19:55:26 GMT', ' Content-Language: en', ' Content-Length: 2', ' Content-Type: application/octet-stream', ' Hash (crc32c): %s' % crc32c_64, ' Hash (md5): %s' % md5_sum_64, ' ETag: CMi938jU+bwCEAE=', ' Generation: 1393962926989000', ' Metageneration: 1', ' ACL: ACCESS DENIED. Note: you need OWNER ' 'permission', ' on the object to read its ACL.', ]) # Set up the test replay script. cmd = [self.gsutil, 'ls', '-L', gs_uri] cros_build_lib.RunCommand( cmd, redirect_stdout=True, redirect_stderr=True, error_code_ok=True).AndReturn( cros_test_lib.EasyAttr(output=output)) self.mox.ReplayAll() # Run the test verification. result = gslib.MD5Sum(gs_uri) self.assertEqual(md5_sum, result) self.mox.VerifyAll()
def testOutsideChrootNoTokenFile(self): mocked_outsidechroot = self._MockOutsideChroot('foo') self.mox.StubOutWithMock(cgt, '_ChrootPathToExternalPath') self.mox.StubOutWithMock(os.path, 'exists') self.mox.StubOutWithMock(build_lib, 'RunCommand') cmd = ['check_gdata_token', 'foo'] run_result = cros_test_lib.EasyAttr(returncode=0) # Create replay script. build_lib.RunCommand(cmd, enter_chroot=True, print_cmd=False, error_code_ok=True).AndReturn(run_result) cgt._ChrootPathToExternalPath(cgt.TOKEN_FILE).AndReturn('chr-tok') os.path.exists('chr-tok').AndReturn(False) self.mox.ReplayAll() # Run test verification. with self.OutputCapturer(): # Test should exit with failure. self.AssertFuncSystemExitNonZero(cgt.OutsideChroot.Run, mocked_outsidechroot) self.mox.VerifyAll() self.AssertOutputContainsError()
def testOutsideChrootNoChangeInTokenFile(self): mocked_outsidechroot = self._MockOutsideChroot('foo') self.mox.StubOutWithMock(cgt, '_ChrootPathToExternalPath') self.mox.StubOutWithMock(os.path, 'exists') self.mox.StubOutWithMock(filecmp, 'cmp') self.mox.StubOutWithMock(build_lib, 'RunCommand') cmd = ['check_gdata_token', 'foo'] run_result = cros_test_lib.EasyAttr(returncode=0) # Create replay script. build_lib.RunCommand(cmd, enter_chroot=True, print_cmd=False, error_code_ok=True).AndReturn(run_result) cgt._ChrootPathToExternalPath(cgt.TOKEN_FILE).AndReturn('chr-tok') os.path.exists('chr-tok').AndReturn(True) os.path.exists(cgt.TOKEN_FILE).AndReturn(True) filecmp.cmp(cgt.TOKEN_FILE, 'chr-tok').AndReturn(True) self.mox.ReplayAll() # Run test verification. with self.OutputCapturer(): cgt.OutsideChroot.Run(mocked_outsidechroot) self.mox.VerifyAll()
def setUp(self): self.PatchObject(cros_build_lib, 'IsInsideChroot', return_value=False) # Sets up default options and evaluator object. self.options = cros_test_lib.EasyAttr( base_dir=self.tempdir, board=self.BOARD, test_name=self.TEST_NAME, metric=self.METRIC, metric_take_average=False, reuse_eval=True, chromium_dir=None, cros_dir=None, eval_passing_only=False) self.evaluator = autotest_evaluator.AutotestEvaluator(self.options)
def createTrackerIssue(tid, labels, owner, status, content, title): tissue = cros_test_lib.EasyAttr() tissue.id = cros_test_lib.EasyAttr(text='http://www/some/path/%d' % tid) tissue.label = [cros_test_lib.EasyAttr(text=l) for l in labels] tissue.owner = cros_test_lib.EasyAttr(username=cros_test_lib.EasyAttr( text=owner)) tissue.status = cros_test_lib.EasyAttr(text=status) tissue.content = cros_test_lib.EasyAttr(text=content) tissue.title = cros_test_lib.EasyAttr(text=title) return tissue
def testProcessOptionsResolveBoardFailed(self): # No --board specified. options = self.parser.parse_args(self.DEFAULT_ARGS) self.PatchObject(remote_access, 'ChromiumOSDevice', return_value=cros_test_lib.EasyAttr(board='')) bisector = cros_bisect.BisectCommand(options) self.assertRaisesRegex(Exception, 'Unable to obtain board name from DUT', bisector.ProcessOptions)
def testProcessOptionsResolveBoard(self): # No --board specified. options = self.parser.parse_args(self.DEFAULT_ARGS) self.PatchObject(remote_access, 'ChromiumOSDevice', return_value=cros_test_lib.EasyAttr(board='test_board')) bisector = cros_bisect.BisectCommand(options) bisector.ProcessOptions() self.assertEqual('test_board', bisector.options.board)
def testInitMissingRequiredArgs(self): options = cros_test_lib.EasyAttr() with self.assertRaises(Exception) as cm: simple_chrome_builder.SimpleChromeBuilder(options) exception_message = str(cm.exception) self.assertIn('Missing command line', exception_message) self.assertIn('SimpleChromeBuilder', exception_message) for arg in simple_chrome_builder.SimpleChromeBuilder.REQUIRED_ARGS: self.assertIn(arg, exception_message)
def testInitMissingRequiredArgs(self): """Tests that AE() raises exception when required options are missing.""" options = cros_test_lib.EasyAttr() with self.assertRaises(Exception) as cm: autotest_evaluator.AutotestEvaluator(options) exception_message = str(cm.exception) self.assertIn('Missing command line', exception_message) self.assertIn('AutotestEvaluator', exception_message) for arg in autotest_evaluator.AutotestEvaluator.REQUIRED_ARGS: self.assertIn(arg, exception_message)
def testInitMissingRequiredArgs(self): """Tests that GitBisector raises error when missing required arguments.""" options = cros_test_lib.EasyAttr() with self.assertRaises(common.MissingRequiredOptionsException) as cm: git_bisector.GitBisector(options, self.builder, self.evaluator) exception_message = str(cm.exception) self.assertIn('Missing command line', exception_message) self.assertIn('GitBisector', exception_message) for arg in git_bisector.GitBisector.REQUIRED_ARGS: self.assertIn(arg, exception_message)
def _TestCatWithHeaders(self, gs_uri, cmd_output, cmd_error): # Set up the test replay script. # Run 1, versioning not enabled in bucket, one line of output. cmd = ['gsutil', '-d', 'cat', gs_uri] cmd_result = cros_test_lib.EasyAttr(output=cmd_output, error=cmd_error, cmdstr=' '.join(cmd)) cmd[0] = mox.IsA(str) cros_build_lib.RunCommand( cmd, redirect_stdout=True, redirect_stderr=True).AndReturn(cmd_result) self.mox.ReplayAll()
def testInitMissingRequiredArgs(self): """Tests that ChromeOnCrosBisector raises for missing required argument.""" options = cros_test_lib.EasyAttr() with self.assertRaises(common.MissingRequiredOptionsException) as cm: chrome_on_cros_bisector.ChromeOnCrosBisector( options, self.builder, self.evaluator) exception_message = str(cm.exception) self.assertIn('Missing command line', exception_message) self.assertIn('ChromeOnCrosBisector', exception_message) for arg in chrome_on_cros_bisector.ChromeOnCrosBisector.REQUIRED_ARGS: self.assertIn(arg, exception_message)
def testGetTrackerIssuesByText(self): author = 'TheAuthor' project = 'TheProject' text = "find me" # Set up the fake tracker issue. tissue_id = 1 tissue_labels = ['auto-filed'] tissue_owner = '*****@*****.**' tissue_status = 'Available' tissue_content = 'find me in body' tissue_title = 'find me in title' tissue = createTrackerIssue(tid=tissue_id, labels=tissue_labels, owner=tissue_owner, status=tissue_status, content=tissue_content, title=tissue_title) issue = gdata_lib.Issue(id=tissue_id, labels=tissue_labels, owner=tissue_owner, status=tissue_status, title=tissue_title, summary=tissue_content) # This will get called as part of Issue.InitFromTracker. self.mox.StubOutWithMock(gdata_lib.Issue, 'GetTrackerIssueComments') mocked_itclient = self.mox.CreateMock( gd_ph_client.ProjectHostingClient) tcomm = gdata_lib.TrackerComm() tcomm.author = author tcomm.it_client = mocked_itclient tcomm.project_name = project # We expect a Query instance to be passed into get_issues. # pylint: disable=E1120 self.mox.StubOutClassWithMocks(gd_ph_client, 'Query') mocked_query = gd_ph_client.Query(text_query='%s is:open' % text) feed = cros_test_lib.EasyAttr(entry=[tissue]) mocked_itclient.get_issues(project, query=mocked_query).AndReturn(feed) gdata_lib.Issue.GetTrackerIssueComments(1, project).AndReturn([]) self.mox.ReplayAll() issues = tcomm.GetTrackerIssuesByText(text) self.assertEquals(issues, [issue])
def testCat(self): path = 'gs://bucket/some/gs/path' # Set up the test replay script. cmd = [self.gsutil, 'cat', path] result = cros_test_lib.EasyAttr(error='', output='TheContent') cros_build_lib.RunCommand( cmd, redirect_stdout=True, redirect_stderr=True).AndReturn(result) self.mox.ReplayAll() # Run the test verification. result = gslib.Cat(path) self.assertEquals('TheContent', result) self.mox.VerifyAll()
def testCheckLastLabelWithReuseEvalOptionUnset(self): """Tests CheckLastEvaluate() with options.reuse_eval unset.""" options = cros_test_lib.EasyAttr(base_dir=self.tempdir, reuse_eval=False) self.evaluator = manual_evaluator.ManualEvaluator(options) # Report does not exist. self.assertFalse(self.evaluator.CheckLastEvaluate(self.BUILD_LABEL)) # Generate a report for BUILD_LABEL m = self.PatchObject(cros_build_lib, 'GetInput') m.return_value = 'yes' self.evaluator.Evaluate(None, self.BUILD_LABEL) # Unlike testCheckLastEvaluate(), it returns empty Score() object. self.assertFalse(self.evaluator.CheckLastEvaluate(self.BUILD_LABEL))
def testStat(self): self.mox.StubOutWithMock(utils, 'RunCommand') path = 'gs://bucket/some/gs/path' # Set up the test replay script. cmd = [self.gsutil, 'stat', path] result = cros_test_lib.EasyAttr(error='', output='') utils.RunCommand(cmd, redirect_stdout=True, redirect_stderr=True, return_result=True).AndReturn(result) self.mox.ReplayAll() # Run the test verification. self.assertIs(gslib.Stat(path), None) self.mox.VerifyAll()
def _MockUploader(self, table=None): """Set up a mocked Uploader object.""" uploader = self.mox.CreateMock(ups.Uploader) if not table: # Use default table table = self._CreateDefaultTable() for slot in ups.Uploader.__slots__: uploader.__setattr__(slot, None) uploader._csv_table = table uploader._scomm = self.mox.CreateMock(gdata_lib.SpreadsheetComm) uploader._creds = cros_test_lib.EasyAttr(user=self.EMAIL, password=self.PASSWORD) uploader._ss_row_cache = self._CreateRowCache(table) return uploader