def _mockRpcUtils(self, to_return, control_file_substring=''):
"""Fake out the autotest rpc_utils module with a mockable class.
@param to_return: the value that rpc_utils.create_job_common() should
be mocked out to return.
@param control_file_substring: A substring that is expected to appear
in the control file output string that
is passed to create_job_common.
Default: ''
"""
download_started_time = constants.DOWNLOAD_STARTED_TIME
payload_finished_time = constants.PAYLOAD_FINISHED_TIME
self.mox.StubOutWithMock(rpc_utils, 'create_job_common')
rpc_utils.create_job_common(
mox.And(mox.StrContains(self._NAME), mox.StrContains(self._BUILD)),
priority=self._PRIORITY,
timeout_mins=self._TIMEOUT * 60,
max_runtime_mins=self._TIMEOUT * 60,
control_type='Server',
control_file=mox.And(mox.StrContains(self._BOARD),
mox.StrContains(self._BUILD),
mox.StrContains(control_file_substring)),
hostless=True,
keyvals=mox.And(
mox.In(download_started_time),
mox.In(payload_finished_time))).AndReturn(to_return)
def testGetLatestBuildWithManyDevservers(self):
"""Should successfully return newest build with multiple devservers."""
self.mox.StubOutWithMock(dev_server.ImageServer, 'servers')
self.mox.StubOutWithMock(dev_server.DevServer, 'devserver_healthy')
host0_expected = 'http://host0:8080'
host1_expected = 'http://host1:8082'
dev_server.ImageServer.servers().MultipleTimes().AndReturn(
[host0_expected, host1_expected])
dev_server.DevServer.devserver_healthy(host0_expected).AndReturn(True)
dev_server.DevServer.devserver_healthy(host1_expected).AndReturn(True)
target = 'x86-generic-release'
build_string1 = 'R9-1586.0.0-a1-b1514'
build_string2 = 'R19-1586.0.0-a1-b3514'
to_return1 = StringIO.StringIO(build_string1)
to_return2 = StringIO.StringIO(build_string2)
urllib2.urlopen(
mox.And(mox.StrContains(host0_expected),
mox.StrContains(target))).AndReturn(to_return1)
urllib2.urlopen(
mox.And(mox.StrContains(host1_expected),
mox.StrContains(target))).AndReturn(to_return2)
self.mox.ReplayAll()
build = dev_server.ImageServer.get_latest_build(target)
self.assertEquals(build_string2, build)
def testIntegrationNmoBoard(self):
"""Tests that we successfully generate a nmo control file."""
board = 'x86-mario'
branch = '24'
target = '3000.0.0'
src = '2999.0.0'
argv = ['--nmo', '--dump_dir', self.tmpdir, '--dump', target, board]
# Return npo delta
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % target)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_R%s-%s_%s_delta_dev.bin' % (
branch, src, branch, target, board))
# Return target full payload
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % src)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_%s_full_dev.bin' % (
branch, src, board))
self.mox.ReplayAll()
self.assertEquals(full_release_test.main(argv), 0)
self.assertTrue(
_DoesControlFileHaveSourceTarget(
os.path.join(self.tmpdir, board, 'control.nmo_delta_%s' % src),
src, target))
self.mox.VerifyAll()
def testIntegrationNpoWithArchiveUrl(self):
"""Successfully generate a npo control file with custom url."""
board = 'x86-mario'
branch = '24'
target = '3000.0.0'
src = '3000.0.0'
archive_url = 'gs://chromeos-image-archive/blah-dir/not_a_version'
argv = [
'--npo', '--dump_dir', self.tmpdir, '--dump', '--archive_url',
archive_url, target, board
]
# Return npo delta
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains(archive_url)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_R%s-%s_%s_delta_dev.bin' % (
branch, src, branch, target, board))
# Return target full payload
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains(archive_url)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_%s_full_dev.bin' % (
branch, src, board))
self.mox.ReplayAll()
self.assertEquals(full_release_test.main(argv), 0)
self.assertTrue(
_DoesControlFileHaveSourceTarget(
os.path.join(self.tmpdir, board, 'control.npo_delta_%s' % src),
src, target))
self.mox.VerifyAll()
def _stageTestHelper(self, artifacts=[], files=[], archive_url=None):
"""Helper to test combos of files/artifacts/urls with stage call."""
expected_archive_url = archive_url
if not archive_url:
expected_archive_url = 'gs://my_default_url'
self.mox.StubOutWithMock(dev_server, '_get_image_storage_server')
dev_server._get_image_storage_server().AndReturn(
'gs://my_default_url')
name = 'fake/image'
else:
# This is embedded in the archive_url. Not needed.
name = ''
to_return = StringIO.StringIO('Success')
urllib2.urlopen(
mox.And(mox.StrContains(expected_archive_url),
mox.StrContains(name),
mox.StrContains('artifacts=%s' % ','.join(artifacts)),
mox.StrContains('files=%s' % ','.join(files)),
mox.StrContains('stage?'))).AndReturn(to_return)
to_return = StringIO.StringIO('True')
urllib2.urlopen(
mox.And(mox.StrContains(expected_archive_url),
mox.StrContains(name),
mox.StrContains('artifacts=%s' % ','.join(artifacts)),
mox.StrContains('files=%s' % ','.join(files)),
mox.StrContains('is_staged'))).AndReturn(to_return)
self.mox.ReplayAll()
self.dev_server.stage_artifacts(name, artifacts, files, archive_url)
self.mox.VerifyAll()
def testIntegrationNpoAllBoards(self):
"""Tests that we successfully generate a npo control file 4 all boards.
"""
boards = ['stumpy', 'lumpy', 'bumpy']
branch = '24'
target = '3000.0.0'
src = '3000.0.0'
argv = ['--npo', '-n', target] + boards
for board in boards:
# Return npo delta
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % target)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_R%s-%s_%s_delta_dev.bin' % (
branch, src, branch, target, board))
# Return target full payload
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % src)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_%s_full_dev.bin' % (
branch, src, board))
self.mox.ReplayAll()
self.assertEquals(full_release_test.main(argv), 0)
self.mox.VerifyAll()
self.mox.ResetAll()
# Verify we still run all of them even if one fails.
bad_board = 'stumpy'
for board in boards:
# Return npo delta
if board == bad_board:
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % target)),
mox.IgnoreArg()).\
AndReturn('NO DELTAS FOR YOU')
continue
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % target)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_R%s-%s_%s_delta_dev.bin' % (
branch, src, branch, target, board))
# Return target full payload
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % src)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_%s_full_dev.bin' % (
branch, src, board))
self.mox.ReplayAll()
self.assertEquals(full_release_test.main(argv), 0)
self.mox.VerifyAll()
def testSuccessfulTriggerDownloadASync(self):
"""Call the dev server's download method with synchronous=False."""
name = 'fake/image'
to_return = StringIO.StringIO('Success')
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(name),
mox.StrContains('stage?'))).AndReturn(to_return)
to_return = StringIO.StringIO('True')
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(name),
mox.StrContains('is_staged'))).AndReturn(to_return)
self.mox.ReplayAll()
self.dev_server.trigger_download(name, synchronous=False)
self.mox.VerifyAll()
def testSuccessfulFinishDownload(self):
"""Should successfully call the dev server's finish download method."""
name = 'fake/image'
to_return = StringIO.StringIO('Success')
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(name),
mox.StrContains('stage?'))).AndReturn(to_return)
to_return = StringIO.StringIO('True')
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(name),
mox.StrContains('is_staged'))).AndReturn(to_return)
# Synchronous case requires a call to finish download.
self.mox.ReplayAll()
self.dev_server.finish_download(name) # Raises on failure.
self.mox.VerifyAll()
def testGatherPageData_DownloadBadFilename(self):
aid = self.attachment.attachment_id
path = '/p/proj/issues/attachment?aid=%s&signed_aid=signed_%d' % (
aid, aid)
self.attachment.filename = '<script>alert("xsrf")</script>.txt';
safe_filename = 'attachment-%d.dat' % aid
self.mox.StubOutWithMock(gcs_helpers, 'MaybeCreateDownload')
gcs_helpers.MaybeCreateDownload(
'app_default_bucket',
'/pid/attachments/object_id',
safe_filename).AndReturn(True)
self.mox.StubOutWithMock(gcs_helpers, 'SignUrl')
gcs_helpers.SignUrl(
'app_default_bucket',
'/pid/attachments/object_id-download'
).AndReturn('googleusercontent.com/...-download...')
self.mox.StubOutWithMock(self.servlet, 'redirect')
_request, mr = testing_helpers.GetRequestObjects(
project=self.project,
path=path,
perms=permissions.READ_ONLY_PERMISSIONSET) # includes VIEW
self.servlet.redirect(mox.And(
mox.Not(mox.StrContains(self.attachment.filename)),
mox.StrContains('googleusercontent.com')), abort=True)
self.mox.ReplayAll()
self.servlet.GatherPageData(mr)
self.mox.VerifyAll()
def testFullBeaconShowerShowsAllAvailable(self):
"""Test that if there are a few results, FullBeaconShower shows them."""
self.mox.StubOutWithMock(record_results.FullResultRecord, 'all')
# Object under test:
results_show_handler = record_results.FullBeaconShower()
self.SetupRequestHandlerObjs(results_show_handler)
# Ask for all FullResultRecord datastore records:
ps_result_query = self.mox.CreateMockAnything()
record_results.FullResultRecord.all().AndReturn(ps_result_query)
ps_result_all = self.mox.CreateMockAnything()
ps_result_query.order('-time_received').AndReturn(ps_result_all)
# The fetch returns two objects.
ps_result_all.fetch(mox.IsA(int)).AndReturn([{}, {}])
# Check that the template is told that there are no results.
self.mox.StubOutWithMock(template, 'render')
template.render(
mox.IsA(str), # The path to the template.
# Test that the template dictionary has {numresults = 0}
mox.And(mox.IsA(dict), mox.In('num_results'),
mox.Func(lambda d: d['num_results'] == 2)),
).AndReturn('Render This String')
results_show_handler.response.out.write('Render This String')
self.mox.ReplayAll()
results_show_handler.get()
self.mox.VerifyAll()
def testAdvancedUsage(self):
"""And should work with other Comparators.
Note: this test is reliant on In and ContainsKeyValue.
"""
test_dict = {"mock" : "obj", "testing" : "isCOOL"}
self.assert_(mox.And(mox.In("testing"),
mox.ContainsKeyValue("mock", "obj")) == test_dict)
def testSuccessfulTriggerDownloadSync(self):
"""Call the dev server's download method with synchronous=True."""
name = 'fake/image'
self.mox.StubOutWithMock(dev_server.ImageServer, '_finish_download')
to_return = StringIO.StringIO('Success')
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(name),
mox.StrContains('stage?'))).AndReturn(to_return)
to_return = StringIO.StringIO('True')
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(name),
mox.StrContains('is_staged'))).AndReturn(to_return)
self.dev_server._finish_download(name, mox.IgnoreArg(),
mox.IgnoreArg())
# Synchronous case requires a call to finish download.
self.mox.ReplayAll()
self.dev_server.trigger_download(name, synchronous=True)
self.mox.VerifyAll()
def testNoManifestsSinceRev(self):
"""Ensure we can tell if no builds have succeeded since a given rev."""
rev = 'rev'
self._ExpectGlob(['some/paths'])
self.mox.StubOutWithMock(manifest_versions, '_SystemOutput')
manifest_versions._SystemOutput(
mox.And(mox.StrContains('log'),
mox.StrContains(rev))).MultipleTimes().AndReturn(' ')
self.mox.ReplayAll()
self.assertFalse(self.mv.AnyManifestsSinceRev(rev))
def _testSuccessfulTriggerDownloadAndroid(self, synchronous=True):
"""Call the dev server's download method with given synchronous setting.
@param synchronous: True to call the download method synchronously.
"""
target = 'test_target'
branch = 'test_branch'
build_id = '123456'
self.mox.StubOutWithMock(dev_server.AndroidBuildServer,
'_finish_download')
to_return = StringIO.StringIO('Success')
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(target),
mox.StrContains(branch), mox.StrContains(build_id),
mox.StrContains('stage?'))).AndReturn(to_return)
to_return = StringIO.StringIO('True')
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(target),
mox.StrContains(branch), mox.StrContains(build_id),
mox.StrContains('is_staged'))).AndReturn(to_return)
if synchronous:
android_build_info = {
'target': target,
'build_id': build_id,
'branch': branch
}
build = dev_server.ANDROID_BUILD_NAME_PATTERN % android_build_info
self.android_dev_server._finish_download(
build,
dev_server._ANDROID_ARTIFACTS_TO_BE_STAGED_FOR_IMAGE,
'',
target=target,
build_id=build_id,
branch=branch)
# Synchronous case requires a call to finish download.
self.mox.ReplayAll()
self.android_dev_server.trigger_download(synchronous=synchronous,
target=target,
build_id=build_id,
branch=branch)
self.mox.VerifyAll()
def testUpdateStateful(self):
"""Tests that we call the stateful update script with the correct args.
"""
self.mox.StubOutWithMock(autoupdater.ChromiumOSUpdater, '_run')
self.mox.StubOutWithMock(autoupdater.ChromiumOSUpdater,
'_get_stateful_update_script')
update_url = ('http://172.22.50.205:8082/update/lumpy-chrome-perf/'
'R28-4444.0.0-b2996')
static_update_url = ('http://172.22.50.205:8082/static/'
'lumpy-chrome-perf/R28-4444.0.0-b2996')
update_script = '/usr/local/bin/stateful_update'
# Test with clobber=False.
autoupdater.ChromiumOSUpdater._get_stateful_update_script().AndReturn(
update_script)
autoupdater.ChromiumOSUpdater._run(
mox.And(
mox.StrContains(update_script),
mox.StrContains(static_update_url),
mox.Not(mox.StrContains('--stateful_change=clean'))),
timeout=mox.IgnoreArg())
self.mox.ReplayAll()
updater = autoupdater.ChromiumOSUpdater(update_url)
updater.update_stateful(clobber=False)
self.mox.VerifyAll()
# Test with clobber=True.
self.mox.ResetAll()
autoupdater.ChromiumOSUpdater._get_stateful_update_script().AndReturn(
update_script)
autoupdater.ChromiumOSUpdater._run(
mox.And(
mox.StrContains(update_script),
mox.StrContains(static_update_url),
mox.StrContains('--stateful_change=clean')),
timeout=mox.IgnoreArg())
self.mox.ReplayAll()
updater = autoupdater.ChromiumOSUpdater(update_url)
updater.update_stateful(clobber=True)
self.mox.VerifyAll()
def testGetControlFile(self):
"""Should successfully get a control file from the dev server."""
name = 'fake/build'
file = 'file/one'
contents = 'Multi-line\nControl File Contents\n'
to_return = StringIO.StringIO(contents)
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST), mox.StrContains(name),
mox.StrContains(file))).AndReturn(to_return)
self.mox.ReplayAll()
self.assertEquals(self.dev_server.get_control_file(name, file),
contents)
def testListControlFiles(self):
"""Should successfully list control files from the dev server."""
name = 'fake/build'
control_files = ['file/one', 'file/two']
to_return = StringIO.StringIO('\n'.join(control_files))
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST),
mox.StrContains(name))).AndReturn(to_return)
self.mox.ReplayAll()
paths = self.dev_server.list_control_files(name)
self.assertEquals(len(paths), 2)
for f in control_files:
self.assertTrue(f in paths)
def testGatherPageData_DownloadBadFilename(self):
aid = self.attachment.attachment_id
self.attachment.filename = '<script>alert("xsrf")</script>.txt';
self.mox.StubOutWithMock(self.servlet, 'redirect')
_request, mr = testing_helpers.GetRequestObjects(
project=self.project,
path='/p/proj/issues/attachment?aid=%s' % aid,
perms=permissions.READ_ONLY_PERMISSIONSET) # includes VIEW
self.servlet.redirect(mox.And(
mox.Not(mox.StrContains(self.attachment.filename)),
mox.StrContains('attachment-%d.dat' % aid)), abort=True)
self.mox.ReplayAll()
self.servlet.GatherPageData(mr)
self.mox.VerifyAll()
def testLuksAsOwnerBarcodeTooLong(self):
self.mox.StubOutWithMock(self.c, 'VerifyXsrfToken')
self.c.VerifyXsrfToken('RetrieveSecret')
mock_user = self.mox.CreateMockAnything()
mock_user.email = '*****@*****.**'
mock_user.__getitem__('email').AndReturn(mock_user.email)
self.mox.StubOutWithMock(models, 'GetCurrentUser')
models.GetCurrentUser().AndReturn(mock_user)
models.GetCurrentUser().AndReturn(mock_user)
self.mox.StubOutWithMock(self.c, 'VerifyPermissions')
self.c.VerifyPermissions(
permissions.RETRIEVE, user=mock_user).AndRaise(
models.AccessDeniedError('user is not an admin'))
self.c.VerifyPermissions(permissions.RETRIEVE_OWN, user=mock_user)
volume_uuid = 'foovolumeuuid'
passphrase = '676ffb71232f71ee0ddf643876907f17' * 20
self.c.request = {'json': '0'}
self.c.response = self.mox.CreateMockAnything()
self.c.response.out = self.mox.CreateMockAnything()
self.c.response.out.write(
mox.And(mox.Not(mox.Regex(r'<img class="qr_code" ')),
mox.Regex(passphrase)))
mock_entity = self.mox.CreateMockAnything()
mock_entity.passphrase = passphrase
mock_entity.owner = '*****@*****.**'
self.mox.StubOutWithMock(models.LuksVolume, 'get_by_key_name')
models.LuksVolume.get_by_key_name(volume_uuid).AndReturn(mock_entity)
mock_user.user = self.mox.CreateMockAnything()
self.mox.StubOutWithMock(mock_user.user, 'nickname')
mock_user.user.nickname().AndReturn('mock_user_foo')
self.mox.StubOutWithMock(models.LuksAccessLog, 'Log')
models.LuksAccessLog.Log(message='GET',
entity=mock_entity,
request=self.c.request)
self.mox.StubOutWithMock(self.c, 'SendRetrievalEmail')
self.c.SendRetrievalEmail(mock_entity, mock_user).AndReturn(None)
self.mox.ReplayAll()
self.c.RetrieveSecret(volume_uuid)
self.mox.VerifyAll()
def testIntegrationSpecificBoardFail(self):
"""Tests we don't generate a specific test if either payload missing."""
board = 'x86-mario'
branch = '24'
target = '3000.0.0'
src = '1234.0.0'
argv = [
'--specific', src, '--dump_dir', self.tmpdir, '--dump', target,
board
]
# Return target full payload
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % target)), mox.IgnoreArg()).\
AndReturn('chromeos_R%s-%s_%s_full_dev.bin' % (
branch, target, board))
# No src full payload
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % src)), mox.IgnoreArg()).\
AndReturn('SOME OTHER DATA')
self.mox.ReplayAll()
self.assertEquals(full_release_test.main(argv), 1)
self.mox.VerifyAll()
self.mox.ResetAll()
# Return target full payload
gsutil_util.GSUtilRun(mox.And(
mox.StrContains('gsutil cat'),
mox.StrContains('%s/UPLOADED' % target)), mox.IgnoreArg()).\
AndReturn('SOME OTHER DATA')
self.mox.ReplayAll()
self.assertEquals(full_release_test.main(argv), 1)
self.mox.VerifyAll()
def testGetLatestBuild(self):
"""Should successfully return a build for a given target."""
self.mox.StubOutWithMock(dev_server.ImageServer, 'servers')
self.mox.StubOutWithMock(dev_server.DevServer, 'devserver_healthy')
dev_server.ImageServer.servers().AndReturn([self._HOST])
dev_server.DevServer.devserver_healthy(self._HOST).AndReturn(True)
target = 'x86-generic-release'
build_string = 'R18-1586.0.0-a1-b1514'
to_return = StringIO.StringIO(build_string)
urllib2.urlopen(
mox.And(mox.StrContains(self._HOST),
mox.StrContains(target))).AndReturn(to_return)
self.mox.ReplayAll()
build = dev_server.ImageServer.get_latest_build(target)
self.assertEquals(build_string, build)
def test_emit(self):
fake_date = "2013 3 7"
log_message = "Log me too."
self.mox.StubOutWithMock(self.handler, 'save')
self.mox.StubOutWithMock(datetime, 'datetime')
datetime.datetime.now().AndReturn(fake_date)
self.handler.save(
mox.And(mox.ContainsKeyValue("msg", log_message),
mox.ContainsKeyValue("level", "INFO"),
mox.ContainsKeyValue("timestamp", fake_date)))
self.mox.ReplayAll()
self.logger.info(log_message)
self.mox.VerifyAll()
def testValidAnd(self): """And should be True if both Comparators return True.""" self.assert_(mox.And(mox.IsA(str), mox.IsA(str)) == '1')
def test_run_job(self):
class Object():
pass
autotest_path = 'htap_tsetotua'
autoserv_command = os.path.join(autotest_path, 'server', 'autoserv')
remote = 'etomer'
results_dir = '/tmp/fakeresults'
fast_mode = False
job1_results_dir = '/tmp/fakeresults/results-1-gilbert'
job2_results_dir = '/tmp/fakeresults/results-2-sullivan'
args = 'matey'
expected_args_sublist = ['--args', args]
experimental_keyval = {constants.JOB_EXPERIMENTAL_KEY: False}
self.mox = mox.Mox()
# Create some dummy job objects.
job1 = Object()
job2 = Object()
setattr(job1, 'control_type', 'cLiEnT')
setattr(job1, 'control_file', 'c1')
setattr(job1, 'id', 1)
setattr(job1, 'name', 'gilbert')
setattr(job1, 'keyvals', experimental_keyval)
setattr(job2, 'control_type', 'Server')
setattr(job2, 'control_file', 'c2')
setattr(job2, 'id', 2)
setattr(job2, 'name', 'sullivan')
setattr(job2, 'keyvals', experimental_keyval)
id_digits = 1
# Stub out subprocess.Popen and wait calls.
# Make them expect correct arguments.
def fake_readline():
return b''
mock_process_1 = self.mox.CreateMock(subprocess.Popen)
mock_process_2 = self.mox.CreateMock(subprocess.Popen)
fake_stdout = self.mox.CreateMock(file)
fake_returncode = 0
mock_process_1.stdout = fake_stdout
mock_process_1.returncode = fake_returncode
mock_process_2.stdout = fake_stdout
mock_process_2.returncode = fake_returncode
self.mox.StubOutWithMock(os, 'makedirs')
self.mox.StubOutWithMock(utils, 'write_keyval')
self.mox.StubOutWithMock(subprocess, 'Popen')
os.makedirs(job1_results_dir)
utils.write_keyval(job1_results_dir, experimental_keyval)
arglist_1 = [
autoserv_command, '-p', '-r', job1_results_dir, '-m', remote,
'--no_console_prefix', '-l', 'gilbert', '-c'
]
subprocess.Popen(mox.And(StartsWithList(arglist_1),
ContainsSublist(expected_args_sublist)),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).AndReturn(mock_process_1)
mock_process_1.stdout.readline().AndReturn(b'')
mock_process_1.wait().AndReturn(0)
os.makedirs(job2_results_dir)
utils.write_keyval(job2_results_dir, experimental_keyval)
arglist_2 = [
autoserv_command, '-p', '-r', job2_results_dir, '-m', remote,
'--no_console_prefix', '-l', 'sullivan', '-s'
]
subprocess.Popen(mox.And(StartsWithList(arglist_2),
ContainsSublist(expected_args_sublist)),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).AndReturn(mock_process_2)
mock_process_2.stdout.readline().AndReturn(b'')
mock_process_2.wait().AndReturn(0)
# Test run_job.
self.mox.ReplayAll()
code, job_res = test_runner_utils.run_job(job1, remote, autotest_path,
results_dir, fast_mode,
id_digits, 0, None, args)
self.assertEqual(job_res, job1_results_dir)
self.assertEqual(code, 0)
code, job_res = test_runner_utils.run_job(job2, remote, autotest_path,
results_dir, fast_mode,
id_digits, 0, None, args)
self.assertEqual(job_res, job2_results_dir)
self.assertEqual(code, 0)
self.mox.UnsetStubs()
self.mox.VerifyAll()
self.mox.ResetAll()
def expect_job_scheduling(self, recorder,
tests_to_skip=[], ignore_deps=False,
raises=False, suite_deps=[], suite=None,
extra_keyvals={}):
"""Expect jobs to be scheduled for 'tests' in |self.files|.
@param recorder: object with a record_entry to be used to record test
results.
@param tests_to_skip: [list, of, test, names] that we expect to skip.
@param ignore_deps: If true, ignore tests' dependencies.
@param raises: If True, expect exceptions.
@param suite_deps: If True, add suite level dependencies.
@param extra_keyvals: Extra keyvals set to tests.
"""
record_job_id = suite and suite._results_dir
if record_job_id:
self.mox.StubOutWithMock(suite, '_remember_job_keyval')
recorder.record_entry(
StatusContains.CreateFromStrings('INFO', 'Start %s' % self._TAG),
log_in_subdir=False)
tests = self.files.values()
n = 1
for test in tests:
if test.name in tests_to_skip:
continue
dependencies = []
if not ignore_deps:
dependencies.extend(test.dependencies)
if suite_deps:
dependencies.extend(suite_deps)
dependencies.append(self._BOARD)
build = self._BUILDS[provision.CROS_VERSION_PREFIX]
keyvals = {
'build': build,
'suite': self._TAG,
'builds': SuiteTest._BUILDS,
'experimental':test.experimental,
}
keyvals.update(extra_keyvals)
job_mock = self.afe.create_job(
control_file=test.text,
name=mox.And(mox.StrContains(build),
mox.StrContains(test.name)),
control_type=mox.IgnoreArg(),
meta_hosts=[self._BOARD],
dependencies=dependencies,
keyvals=keyvals,
max_runtime_mins=24*60,
timeout_mins=1440,
parent_job_id=None,
reboot_before=mox.IgnoreArg(),
run_reset=mox.IgnoreArg(),
priority=priorities.Priority.DEFAULT,
synch_count=test.sync_count,
require_ssp=test.require_ssp
)
if raises:
job_mock.AndRaise(error.NoEligibleHostException())
recorder.record_entry(
StatusContains.CreateFromStrings('START', test.name),
log_in_subdir=False)
recorder.record_entry(
StatusContains.CreateFromStrings('TEST_NA', test.name),
log_in_subdir=False)
recorder.record_entry(
StatusContains.CreateFromStrings('END', test.name),
log_in_subdir=False)
else:
fake_job = FakeJob(id=n)
job_mock.AndReturn(fake_job)
if record_job_id:
suite._remember_job_keyval(fake_job)
n += 1
def testAdvancedUsageFails(self):
"""Note: this test is reliant on In and ContainsKeyValue."""
test_dict = {"mock" : "obj", "testing" : "isCOOL"}
self.failIf(mox.And(mox.In("NOTFOUND"),
mox.ContainsKeyValue("mock", "obj")) == test_dict)
def testClauseOneFails(self):
"""And should be False if the first Comparator returns False."""
self.failIf(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')
