def testAuthFail(self):
mock_exc = glue.util.ExecError(returncode=self.RETURN_AUTH_FAIL)
glue.util.GetPlistFromExec(
mox.In(self.PATH), stdin=mox.StrContains(self.mock_pass)).AndRaise(
mock_exc)
self.mox.ReplayAll()
self.assertRaises(
glue.InputError,
glue.ApplyEncryption,
self.mock_fvclient, self.mock_user, self.mock_pass)
self.mox.VerifyAll()
def test_get_endpoint_url_failed(self):
self.mox.StubOutWithMock(self.client, "request")
self.client.auth_token = TOKEN
res200 = get_response(200)
res401 = get_response(401)
self.client.request(
mox.StrContains(AUTH_URL + '/tokens/%s/endpoints' % TOKEN), 'GET',
headers=mox.IsA(dict)
).AndReturn((res401, ''))
self.client.request(
AUTH_URL + '/tokens', 'POST',
body=mox.IsA(str), headers=mox.IsA(dict)
).AndReturn((res200, json.dumps(KS_TOKEN_RESULT)))
self.client.request(
mox.StrContains(ENDPOINT_URL + '/resource'), 'GET',
headers=mox.ContainsKeyValue('X-Auth-Token', TOKEN)
).AndReturn((res200, ''))
self.mox.ReplayAll()
self.client.do_request('/resource', 'GET')
def test_get_noauth(self):
self.mox.StubOutWithMock(self.client, "request")
res200 = get_response(200)
self.client.request(
mox.StrContains(ENDPOINT_URL + '/resource'), 'GET',
headers=mox.IsA(dict),
).AndReturn((res200, ''))
self.mox.ReplayAll()
self.client.do_request('/resource', 'GET')
self.assertEqual(self.client.endpoint_url, ENDPOINT_URL)
def testOk(self):
self.mox.StubOutWithMock(glue.corestorage, 'GetRecoveryPartition')
glue.corestorage.GetRecoveryPartition().AndReturn('/dev/disk0s3')
self.mox.StubOutWithMock(glue.corestorage, 'GetState')
glue.corestorage.GetState().AndReturn(glue.corestorage.State.none)
self.mox.StubOutWithMock(glue.os, 'path')
glue.os.path.exists(mox.StrContains('FileVaultMaster')).AndReturn(False)
self.mox.ReplayAll()
glue.CheckEncryptionPreconditions()
self.mox.VerifyAll()
def testKeychainPresent(self):
self.mox.StubOutWithMock(glue.corestorage, 'GetRecoveryPartition')
glue.corestorage.GetRecoveryPartition().AndReturn('/dev/disk0s3')
self.mox.StubOutWithMock(glue.corestorage, 'GetState')
glue.corestorage.GetState().AndReturn(glue.corestorage.State.none)
self.mox.StubOutWithMock(glue.os, 'path')
glue.os.path.exists(mox.StrContains('FileVaultMaster')).AndReturn(True)
self.mox.ReplayAll()
self.assertRaises(glue.OptionError, glue.CheckEncryptionPreconditions)
self.mox.VerifyAll()
def testFindModules(self):
"""Tests that we can return modules correctly when mocking out glob."""
self.mox.StubOutWithMock(glob, 'glob')
fake_command_file = 'cros_command_test.py'
filtered_file = 'cros_command_unittest.py'
mydir = 'mydir'
glob.glob(mox.StrContains(mydir)).AndReturn(
[fake_command_file, filtered_file])
self.mox.ReplayAll()
self.assertEqual(commands._FindModules(mydir), [fake_command_file])
self.mox.VerifyAll()
def testResolveWithFailureURLError(self):
"""Ensure we rehash on a failed ping on a bad_host after urlerror."""
# Retry mock just return the original method.
retry.retry = retry_mock
self.mox.StubOutWithMock(dev_server, '_get_dev_server_list')
bad_host, good_host = 'http://bad_host:99', 'http://good_host:8080'
dev_server._get_dev_server_list().MultipleTimes().AndReturn(
[bad_host, good_host])
# Mock out bad ping failure to bad_host by raising devserver exception.
urllib2.urlopen(mox.StrContains(bad_host),
data=None).MultipleTimes().AndRaise(
urllib2.URLError('urlopen connection timeout'))
# Good host is good.
to_return = StringIO.StringIO('{"free_disk": 1024}')
urllib2.urlopen(mox.StrContains(good_host),
data=None).AndReturn(to_return)
self.mox.ReplayAll()
host = dev_server.ImageServer.resolve(0) # Using 0 as it'll hash to 0.
self.assertEquals(host.url(), good_host)
self.mox.VerifyAll()
def test_what_provides_unsupported(self):
"""Test searching for package providing an unsupported type."""
self._catch_callbacks()
self.backend.error("not-supported", mox.StrContains("not implemented"),
True)
self.backend.finished()
self.mox.ReplayAll()
self.backend._open_cache()
self.backend.dispatch_command("what-provides", [
"None", enums.PROVIDES_PLASMA_SERVICE,
"plasma4(dataengine-weather)"
])
def testGenericFail(self):
self.mox.StubOutWithMock(logging, 'error')
mock_exc = glue.util.ExecError(returncode=1)
glue.util.GetPlistFromExec(mox.In(self.PATH),
stdin=mox.StrContains(
self.mock_pass)).AndRaise(mock_exc)
logging.error(mox.IsA(basestring), mox.IsA(basestring),
mox.IgnoreArg())
self.mox.ReplayAll()
self.assertRaises(glue.Error, glue.ApplyEncryption, self.mock_fvclient,
self.mock_user, self.mock_pass)
self.mox.VerifyAll()
def test_what_provides_modalias(self):
"""Test searching for package providing a driver."""
# invalid query
self._catch_callbacks()
self.backend.error("not-supported",
mox.StrContains("search term is invalid"), True)
self.backend.finished()
self.mox.ReplayAll()
self.backend._open_cache()
self.backend.dispatch_command(
"what-provides", ["None", enums.PROVIDES_MODALIAS, "pci:1"])
# no match
self._catch_callbacks()
self.backend.finished()
self.mox.ReplayAll()
self.backend._open_cache()
self.backend.dispatch_command("what-provides", [
"None", enums.PROVIDES_MODALIAS,
"modalias(pci:v0000DEADd0000BEEFsv00sd00bc02sc00i00)"
])
# match
self._catch_callbacks("package")
self.backend.package("silly-driver;0.1-0;all;", enums.INFO_AVAILABLE,
mox.IsA(str))
self.backend.finished()
self.mox.ReplayAll()
self.backend._open_cache()
self.backend.dispatch_command("what-provides", [
"None", enums.PROVIDES_MODALIAS,
"modalias(pci:v0000DEADd0000BEEFsv00sd00bc03sc00i00)"
])
# second match
self._catch_callbacks("package")
self.backend.package("silly-driver;0.1-0;all;", enums.INFO_AVAILABLE,
mox.IsA(str))
self.backend.finished()
self.mox.ReplayAll()
self.backend._open_cache()
self.backend.dispatch_command("what-provides", [
"None", enums.PROVIDES_MODALIAS,
"modalias(pci:v0000DEADd0000FACEsv00sd00bc03sc00i00)"
])
def testOk(self):
pl = plistlib.readPlistFromString(self.OUTPUT)
glue.util.GetPlistFromExec(mox.IsA(tuple),
stdin=mox.StrContains(
self.mock_pass)).AndReturn(pl)
self.mock_fvclient.SetOwner(self.mock_user)
self.mox.ReplayAll()
result = glue.ApplyEncryption(self.mock_fvclient, self.mock_user,
self.mock_pass)
self.assertEquals(('217CEC95-018C-4CA5-964F-4E7235CA2937',
'DLEV-ZYT9-ODLA-PVML-66DV-HZ8R'), result)
self.mox.VerifyAll()
def testGatherPageData_Download_WithoutDisposition(self):
aid = self.attachment.attachment_id
path = '/p/proj/issues/attachment?aid=%s&signed_aid=signed_%d' % (
aid, aid)
self.mox.StubOutWithMock(gcs_helpers, 'MaybeCreateDownload')
gcs_helpers.MaybeCreateDownload(
'app_default_bucket',
'/pid/attachments/object_id',
self.attachment.filename).AndReturn(False)
self.mox.StubOutWithMock(gcs_helpers, 'SignUrl')
gcs_helpers.SignUrl(
'app_default_bucket',
'/pid/attachments/object_id'
).AndReturn('googleusercontent.com/...')
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.StrContains('googleusercontent.com'),
mox.Not(mox.StrContains('-download'))), abort=True)
self.mox.ReplayAll()
self.servlet.GatherPageData(mr)
self.mox.VerifyAll()
def testUnparseableManifestPath(self):
"""Ensure we don't explode if we encounter an unparseable path."""
since_date = datetime.datetime(year=2015, month=2, day=1)
board = 'link'
build_name = 'link-depthcharge-pgo-codename-release-suffix-part-two'
manifest = 'build-name/%s/pass/25/1234.0.0.xml' % build_name
self._ExpectGlob(['some/paths'])
self.mox.StubOutWithMock(manifest_versions, '_SystemOutput')
manifest_versions._SystemOutput(
mox.StrContains('log')).MultipleTimes().AndReturn(manifest)
self.mox.ReplayAll()
br_man = self.mv.ManifestsSinceDate(since_date, board)
# We should skip the manifest that we passed in, as we can't parse it,
# so we should get no manifests back.
self.assertEquals(br_man, {})
def test_refresh_token(self):
self.mox.StubOutWithMock(self.client, "request")
self.client.auth_token = TOKEN
self.client.endpoint_url = ENDPOINT_URL
res200 = get_response(200)
res401 = get_response(401)
# If a token is expired, tacker server retruns 401
self.client.request(
mox.StrContains(ENDPOINT_URL + '/resource'), 'GET',
headers=mox.ContainsKeyValue('X-Auth-Token', TOKEN)
).AndReturn((res401, ''))
self.client.request(
AUTH_URL + '/tokens', 'POST',
body=mox.IsA(str), headers=mox.IsA(dict)
).AndReturn((res200, json.dumps(KS_TOKEN_RESULT)))
self.client.request(
mox.StrContains(ENDPOINT_URL + '/resource'), 'GET',
headers=mox.ContainsKeyValue('X-Auth-Token', TOKEN)
).AndReturn((res200, ''))
self.mox.ReplayAll()
self.client.do_request('/resource', 'GET')
def testInitJob_GoogleStorage(self):
mapreduce_state = self.create_mapreduce_state(params={
"filesystem": "gs",
"gs_bucket_name": "foo",
"gs_acl": "public"
})
m = mox.Mox()
m.StubOutWithMock(files.gs, "create")
files.gs.create(mox.StrContains("/gs/foo"),
mox.IgnoreArg(),
acl="public")
m.ReplayAll()
output_writers.FileOutputWriter.init_job(mapreduce_state)
m.UnsetStubs()
m.VerifyAll()
self.assertTrue(mapreduce_state.writer_state)
def testManifestsSinceDate(self):
"""Ensure we can get manifests for a board since N days ago."""
since_date = datetime.datetime(year=2015, month=2, day=1)
board = 'x86-alex'
self._ExpectGlob(['some/paths'])
self.mox.StubOutWithMock(manifest_versions, '_SystemOutput')
manifest_versions._SystemOutput(
mox.StrContains('log')).MultipleTimes().AndReturn(
self._MANIFESTS_STRING)
self.mox.ReplayAll()
br_man = self.mv.ManifestsSinceDate(since_date, board)
for pair in br_man.keys():
self.assertTrue(pair, self._BRANCHES)
for manifest_list in br_man.itervalues():
self.assertTrue(manifest_list)
self.assertEquals(br_man[('release', '20')][-1], '2057.0.10')
def _CallRunGS(self, str_should_contain, attempts=1):
"""Helper that wraps a RunGS for tests."""
for attempt in range(attempts):
if attempt == gsutil_util.GSUTIL_ATTEMPTS:
# We can't mock more than we can attempt.
return
# Return 1's for all but last attempt.
if attempt != attempts - 1:
mock_process = self._bad_mock_process
else:
mock_process = self._good_mock_process
subprocess.Popen(mox.StrContains(str_should_contain),
shell=True,
stdout=subprocess.PIPE).AndReturn(mock_process)
mock_process.communicate().AndReturn(('Does not matter', None))
def test_refresh_token_no_auth_url(self):
self.mox.StubOutWithMock(self.client, "request")
self.client.auth_url = None
self.client.auth_token = TOKEN
self.client.endpoint_url = ENDPOINT_URL
res401 = get_response(401)
# If a token is expired, neutron server returns 401
self.client.request(mox.StrContains(ENDPOINT_URL + '/resource'),
'GET',
headers=mox.ContainsKeyValue(
'X-Auth-Token', TOKEN)).AndReturn((res401, ''))
self.mox.ReplayAll()
self.assertRaises(exceptions.NoAuthURLProvided, self.client.do_request,
'/resource', 'GET')
def testStartBackendNonviewableCall(self):
self.mox.StubOutWithMock(urlfetch, 'create_rpc')
self.mox.StubOutWithMock(urlfetch, 'make_fetch_call')
self.mox.StubOutWithMock(modules, 'get_hostname')
a_fake_rpc = testing_helpers.Blank(callback=None)
urlfetch.create_rpc(
deadline=settings.backend_deadline).AndReturn(a_fake_rpc)
modules.get_hostname(module='besearch')
urlfetch.make_fetch_call(a_fake_rpc,
mox.StrContains(urls.BACKEND_NONVIEWABLE),
follow_redirects=False,
headers=mox.IsA(dict))
self.mox.ReplayAll()
processed_invalidations_up_to = 12345
frontendsearchpipeline._StartBackendNonviewableCall(
789, 111L, 2, processed_invalidations_up_to)
self.mox.VerifyAll()
def test_get_endpoint_url_other(self):
self.client = client.HTTPClient(
username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD,
auth_url=AUTH_URL, region_name=REGION, endpoint_type='otherURL')
self.mox.StubOutWithMock(self.client, "request")
self.client.auth_token = TOKEN
res200 = get_response(200)
self.client.request(
mox.StrContains(AUTH_URL + '/tokens/%s/endpoints' % TOKEN), 'GET',
headers=mox.IsA(dict)
).AndReturn((res200, json.dumps(ENDPOINTS_RESULT)))
self.mox.ReplayAll()
self.assertRaises(exceptions.EndpointTypeNotFound,
self.client.do_request,
'/resource',
'GET')
def test_get_token(self):
self.mox.StubOutWithMock(self.client, "request")
res200 = get_response(200)
self.client.request(
AUTH_URL + '/tokens', 'POST',
body=self.auth_body, headers=mox.IsA(dict)
).AndReturn((res200, json.dumps(KS_TOKEN_RESULT)))
self.client.request(
mox.StrContains(ENDPOINT_URL + '/resource'), 'GET',
headers=mox.ContainsKeyValue('X-Auth-Token', TOKEN)
).AndReturn((res200, ''))
self.mox.ReplayAll()
self.client.do_request('/resource', 'GET')
self.assertEqual(self.client.endpoint_url, ENDPOINT_URL)
self.assertEqual(self.client.auth_token, TOKEN)
def test_use_given_endpoint_url(self):
self.client = client.HTTPClient(
username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD,
auth_url=AUTH_URL, region_name=REGION,
endpoint_url=ENDPOINT_OVERRIDE)
self.assertEqual(self.client.endpoint_url, ENDPOINT_OVERRIDE)
self.mox.StubOutWithMock(self.client, "request")
self.client.auth_token = TOKEN
res200 = get_response(200)
self.client.request(
mox.StrContains(ENDPOINT_OVERRIDE + '/resource'), 'GET',
headers=mox.ContainsKeyValue('X-Auth-Token', TOKEN)
).AndReturn((res200, ''))
self.mox.ReplayAll()
self.client.do_request('/resource', 'GET')
self.assertEqual(self.client.endpoint_url, ENDPOINT_OVERRIDE)
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 testStartBackendSearchCall(self):
self.mox.StubOutWithMock(urlfetch, 'create_rpc')
self.mox.StubOutWithMock(urlfetch, 'make_fetch_call')
self.mox.StubOutWithMock(modules, 'get_hostname')
a_fake_rpc = testing_helpers.Blank(callback=None)
urlfetch.create_rpc(
deadline=settings.backend_deadline).AndReturn(a_fake_rpc)
modules.get_hostname(module='besearch')
urlfetch.make_fetch_call(a_fake_rpc,
mox.StrContains(urls.BACKEND_SEARCH),
follow_redirects=False,
headers=mox.IsA(dict))
self.mox.ReplayAll()
processed_invalidations_up_to = 12345
mr = testing_helpers.MakeMonorailRequest(
path='/p/proj/issues/list?q=foo')
mr.me_user_id = 111L
frontendsearchpipeline._StartBackendSearchCall(
mr, ['proj'], (2, 'priority=high'), processed_invalidations_up_to)
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 test_what_provides_codec(self):
"""Test searching for package providing a codec."""
# invalid query
self._catch_callbacks()
self.backend.error("not-supported", mox.StrContains("search term is invalid"), True)
self.backend.finished()
self.mox.ReplayAll()
self.backend._open_cache()
self.backend.dispatch_command("what-provides",
["None", enums.PROVIDES_CODEC, "audio/mpeg"])
self._catch_callbacks("package")
self.backend.package("gstreamer0.10-silly;0.1-0;all;",
enums.INFO_AVAILABLE,
mox.IsA(str))
self.backend.finished()
self.mox.ReplayAll()
self.backend._open_cache()
self.backend.dispatch_command("what-provides",
["None", enums.PROVIDES_CODEC, "gstreamer0.10(decoder-audio/ac3)"])
def _CommonMarkAsStableTest(self, chrome_rev, new_version, old_ebuild_path,
new_ebuild_path, commit_string_indicator):
"""Common function used for test functions for MarkChromeEBuildAsStable.
This function stubs out others calls, and runs MarkChromeEBuildAsStable
with the specified args.
Args:
chrome_rev: standard chrome_rev argument
new_version: version we are revving up to
old_ebuild_path: path to the stable ebuild
new_ebuild_path: path to the to be created path
commit_string_indicator: a string that the commit message must contain
"""
self.mox.StubOutWithMock(cros_build_lib, 'RunCommand')
self.mox.StubOutWithMock(portage_utilities.EBuild, 'CommitChange')
stable_candidate = cros_mark_chrome_as_stable.ChromeEBuild(
old_ebuild_path)
unstable_ebuild = cros_mark_chrome_as_stable.ChromeEBuild(
self.unstable)
chrome_version = new_version
commit = None
overlay_dir = self.mock_chrome_dir
cros_build_lib.RunCommand(['git', 'add', new_ebuild_path],
cwd=overlay_dir)
cros_build_lib.RunCommand(['git', 'rm', old_ebuild_path],
cwd=overlay_dir)
portage_utilities.EBuild.CommitChange(
mox.StrContains(commit_string_indicator), overlay_dir)
self.mox.ReplayAll()
cros_mark_chrome_as_stable.MarkChromeEBuildAsStable(
stable_candidate, unstable_ebuild, chrome_rev, chrome_version,
commit, overlay_dir)
self.mox.VerifyAll()
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 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 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()
