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
