def set_up_package_adapter_and_replay_all(self):
mock_depcache_adapter = self.mox.CreateMock(DepCacheAdapter)
self.va = VersionAdapter(FakeVersion._create('1.2.4', []))
mock_depcache_adapter.get_candidate_version(
mox.Func(lambda pa: pa.name == 'afake')).AndReturn(self.va)
self.mox.ReplayAll()
self.p = PackageAdapterFactory(
mock_depcache_adapter).create_package_adapter(self.fake)
def _test_vm_state_change(self, action, from_state, to_state):
self._instance_data = self._get_instance_data()
vmutils.VMUtils.set_vm_state(mox.Func(self._check_instance_name),
to_state)
self._mox.ReplayAll()
action(self._instance_data)
self._mox.VerifyAll()
def test_property_name_to_value(self):
self.assertEqual(
{
'cat': 5,
'dog': mox.Func(lambda v: v in [10, 15]),
'mouse': 'happy'
},
datastore_viewer._property_name_to_value(
[self.entity1, self.entity2]))
def assert_request_is_correct(self, trigger_args, expected_query):
request_args = ('POST',
mox.Func(create_query_assertion(expected_query)),
'{"param2": "value2", "param1": "value1"}')
stub_connection(self.mox, request_args=request_args)
self.mox.ReplayAll()
channel = p()['test-channel']
channel.trigger(*trigger_args)
self.mox.VerifyAll()
def test_invokes_checker_one_time_with_cache_containing_one_package_half_installed(
self):
self.mock_depcache_adapter.get_candidate_version(
mox.Func(lambda o: o.name == 'afake')).AndReturn(
self.version_adapter)
self.mock_checker.check(mox.IgnoreArg()).AndReturn(None)
self.mox.ReplayAll()
self.ca.run(self.mock_checker, self.mock_policy,
self.package_adapter_factory)
def test_scheduler_includes_launch_index(self):
fake_context = context.RequestContext('user', 'project')
instance_opts = {'fake_opt1': 'meow'}
request_spec = {'instance_uuids': ['fake-uuid1', 'fake-uuid2'],
'instance_properties': instance_opts}
instance1 = {'uuid': 'fake-uuid1'}
instance2 = {'uuid': 'fake-uuid2'}
def _has_launch_index(expected_index):
"""Return a function that verifies the expected index."""
def _check_launch_index(value):
if 'instance_properties' in value:
if 'launch_index' in value['instance_properties']:
index = value['instance_properties']['launch_index']
if index == expected_index:
return True
return False
return _check_launch_index
self.mox.StubOutWithMock(self.driver, '_schedule')
self.mox.StubOutWithMock(self.driver, '_provision_resource')
expected_filter_properties = {'retry': {'num_attempts': 1,
'hosts': []}}
self.driver._schedule(fake_context, request_spec,
expected_filter_properties).AndReturn(['host1', 'host2'])
# instance 1
self.driver._provision_resource(
fake_context, 'host1',
mox.Func(_has_launch_index(0)), expected_filter_properties,
None, None, None, None,
instance_uuid='fake-uuid1',
legacy_bdm_in_spec=False).AndReturn(instance1)
# instance 2
self.driver._provision_resource(
fake_context, 'host2',
mox.Func(_has_launch_index(1)), expected_filter_properties,
None, None, None, None,
instance_uuid='fake-uuid2',
legacy_bdm_in_spec=False).AndReturn(instance2)
self.mox.ReplayAll()
self.driver.schedule_run_instance(fake_context, request_spec,
None, None, None, None, {}, False)
def test_list_tables_noann(self, name, ft_space, ownerid):
session = MockSession(None, None, 1)
perms = self.mox.CreateMock(MockPermissionsHandler)
store = MockFeatureTable(None)
store.perms = perms
self.mox.StubOutWithMock(session.qs, 'projection')
self.mox.StubOutWithMock(session.qs, 'findAllByQuery')
params = omero.sys.ParametersI()
# Need to reconstruct the dict to get the conditions in the
# same order
kvs = {}
if name:
kvs['name'] = name
params.addString('name', name)
if ft_space:
kvs['path'] = ft_space
params.addString('path', ft_space)
if ownerid > -1:
kvs['details.owner.id'] = ownerid
params.addLong('details_owner_id', ownerid)
q = ('FROM OriginalFile')
gotwhere = False
for k in kvs:
if not gotwhere:
q += ' WHERE '
gotwhere = True
else:
q += ' AND '
if k == 'details.owner.id':
q += 'details.owner.id = :details_owner_id'
else:
q += '%s = :%s' % (k, k)
if name or ft_space or ownerid > -1:
mf = MockOriginalFile(1L, name, ft_space)
session.qs.findAllByQuery(
q,
mox.Func(lambda o: TestFeatureTable.parameters_equal(
params, o))).AndReturn([mf])
self.mox.ReplayAll()
if name or ft_space or ownerid > -1:
result = OmeroTablesFeatureStore.list_tables(
session, name, ft_space, None, ownerid, None)
assert len(result) == 1
assert result[0] == (1L, name, ft_space, None)
else:
with pytest.raises(OmeroTablesFeatureStore.OmeroTableException):
result = OmeroTablesFeatureStore.list_tables(
session, name, ft_space, None, ownerid, None)
self.mox.VerifyAll()
def testOSXEnumerateRunningServicesSingle(self):
self.osx.client_utils_osx.OSXVersion().AndReturn(self.mock_version)
self.mock_version.VersionAsMajorMinor().AndReturn([10, 7, 1])
self.action.GetRunningLaunchDaemons().AndReturn(testdata.JOB)
self.action.SendReply(mox.Func(self.ValidResponseProtoSingle))
self.mox.ReplayAll()
self.action.Run(None)
self.mox.VerifyAll()
def expect_request(self, method, path, params, response=None, raises=None):
self.expected_calls.request(
method,
path,
params,
{
'User-Agent': self.EXPECTED_USER_AGENT,
'Host': self.HOST,
'Content-type': 'application/x-www-form-urlencoded',
'Authorization': mox.Func((lambda s: s.startswith('Basic '))),
'Date': mox.Func((lambda s: bool(email.utils.parsedate_tz(s))))
},
)
meth = self.expected_calls.getresponse()
if raises is not None:
meth.AndRaise(raises)
else:
meth.AndReturn(response)
self.expected_calls.close()
def expect_get_posts(self):
post = data.BlogPost()
post.id = util.Struct(text='tag:blogger.com,1999:blog-111.post-222')
feed = data.BlogFeed()
feed.entry = [post]
def check_path(query):
return query.custom_parameters['path'] == '/path/to/post'
self.client.get_posts('111', query=mox.Func(check_path)).AndReturn(feed)
def test_write_with(self):
self.client.batch(
mox.Func(lambda feed: len(feed.entry) == 1 and feed.entry[0].cell.
row == '2' and feed.entry[0].cell.col == '4'),
force=True)
self.mox.ReplayAll()
with self.worksheet:
self.worksheet[1][3] = 'nico'
def test_get_info(self):
self._instance_data = self._get_instance_data()
summary_info = {'NumberOfProcessors': 2,
'EnabledState': constants.HYPERV_VM_STATE_ENABLED,
'MemoryUsage': 1000,
'UpTime': 1}
m = vmutils.VMUtils.vm_exists(mox.Func(self._check_instance_name))
m.AndReturn(True)
func = mox.Func(self._check_instance_name)
m = vmutils.VMUtils.get_vm_summary_info(func)
m.AndReturn(summary_info)
self._mox.ReplayAll()
info = self._conn.get_info(self._instance_data)
self._mox.VerifyAll()
self.assertEquals(info["state"], power_state.RUNNING)
def testGetShadowMap(self):
test_shadow = ('cn=test,ou=People,dc=example,dc=com',
{'uid': ['test'],
'shadowLastChange': ['11296'],
'shadowMax': ['99999'],
'shadowWarning': ['7'],
'shadowInactive': ['-1'],
'shadowExpire': ['-1'],
'shadowFlag': ['134537556'],
'modifyTimestamp': ['20070227012807Z'],
'userPassword': ['{CRYPT}p4ssw0rd']})
config = dict(self.config)
attrlist = ['uid', 'shadowLastChange',
'shadowMin', 'shadowMax',
'shadowWarning', 'shadowInactive',
'shadowExpire', 'shadowFlag',
'userPassword', 'modifyTimestamp']
mock_rlo = self.mox.CreateMock(ldap.ldapobject.ReconnectLDAPObject)
mock_rlo.simple_bind_s(
cred='TEST_BIND_PASSWORD',
who='TEST_BIND_DN')
mock_rlo.search_ext(base='TEST_BASE',
filterstr='TEST_FILTER',
scope=ldap.SCOPE_ONELEVEL,
attrlist=mox.SameElementsAs(attrlist),
serverctrls=mox.Func(self.compareSPRC())).AndReturn('TEST_RES')
mock_rlo.result3('TEST_RES',
all=0,
timeout='TEST_TIMELIMIT').AndReturn(
(ldap.RES_SEARCH_ENTRY, [test_shadow], None, []))
mock_rlo.result3('TEST_RES',
all=0,
timeout='TEST_TIMELIMIT').AndReturn(
(ldap.RES_SEARCH_RESULT, None, None, []))
self.mox.StubOutWithMock(ldap, 'ldapobject')
ldap.ldapobject.ReconnectLDAPObject(
uri='TEST_URI',
retry_max='TEST_RETRY_MAX',
retry_delay='TEST_RETRY_DELAY').AndReturn(mock_rlo)
self.mox.ReplayAll()
source = ldapsource.LdapSource(config)
data = source.GetShadowMap()
self.assertEqual(1, len(data))
ent = data.PopItem()
self.assertEqual('test', ent.name)
self.assertEqual('p4ssw0rd', ent.passwd)
def test_non_verbose(self):
# libc6 - never
self.reporter.report(mox.Func(lambda o: o.package_name == 'libspf'))
# libfoobar - never
# git-core - never
self.mox.ReplayAll()
self.finishSetUp()
checker = Checker(self.facter)
policy = Policy(self.apt_pkg_adapter, self.facter, self.config)
self.cache_adapter.run(checker, policy, self.package_adapter_factory)
def test_loading_valid_file(self):
fake_file = [
'\n', 'package:val\n', 'acCepT-OrigiN: val2\n',
' track-oriGin : a spaced val \n', 'track-version:foo'
]
self.c.add(mox.Func(lambda stanza: stanza.get('package') == 'val'))
self.mox.ReplayAll()
ret = self.cp.load(fake_file, self.c)
self.assertEquals(len(ret), 1)
self.assertEquals(ret[0].get('package'), 'val')
def _test_pre_live_migration(self, cow, with_volumes):
self.flags(use_cow_images=cow)
instance_data = self._get_instance_data()
instance = db.instance_create(self._context, instance_data)
instance['system_metadata'] = {}
network_info = fake_network.fake_get_instance_nw_info(self.stubs,
spectacular=True)
m = livemigrationutils.LiveMigrationUtils.check_live_migration_config()
m.AndReturn(True)
if cow:
m = basevolumeutils.BaseVolumeUtils.volume_in_mapping(mox.IsA(str),
None)
m.AndReturn(False)
m = vhdutils.VHDUtils.get_vhd_info(mox.Func(self._check_img_path))
m.AndReturn({'MaxInternalSize': 1024})
fake.PathUtils.copyfile(mox.IsA(str), mox.IsA(str))
vhdutils.VHDUtils.resize_vhd(mox.IsA(str), mox.IsA(object))
if with_volumes:
block_device_info = db_fakes.get_fake_block_device_info(
self._volume_target_portal, self._volume_id)
mapping = driver.block_device_info_get_mapping(block_device_info)
data = mapping[0]['connection_info']['data']
target_lun = data['target_lun']
target_iqn = data['target_iqn']
target_portal = data['target_portal']
fake_mounted_disk = "fake_mounted_disk"
fake_device_number = 0
self._mock_login_storage_target(target_iqn, target_lun,
target_portal,
fake_mounted_disk,
fake_device_number)
else:
block_device_info = None
self._mox.ReplayAll()
self._conn.pre_live_migration(self._context, instance,
block_device_info, network_info)
self._mox.VerifyAll()
if cow:
self.assertTrue(self._fetched_image is not None)
else:
self.assertTrue(self._fetched_image is None)
def test_twitter_profile_image_urlopen_fails(self):
url = 'https://api.twitter.com/1.1/users/show.json?screen_name=ryan'
urllib2.urlopen(mox.Func(lambda req: req.get_full_url() == url),
timeout=999).AndRaise(urllib2.URLError(''))
self.mox.ReplayAll()
appengine_config.APP_ID = 'twitter-webfinger'
appengine_config.DOMAIN = 'twitter.com'
req = webapp2.Request.blank('/user.json?uri=acct:[email protected]')
handler = user.UserHandler(req, self.response)
self.assertEquals(None, handler.template_vars().get('picture_url'))
def testHttpError(self):
urllib2.urlopen(mox.Func(self.VerifyRequest)).AndRaise(
urllib2.HTTPError('http://whatever', 500, 'a server error', {},
StringIO.StringIO('does not matter')))
self.mox.ReplayAll()
rpc = self.trans.send_rpc(my_method.remote, self.request)
rpc.wait()
self.assertEquals(remote.RpcState.SERVER_ERROR, rpc.state)
self.assertEquals('HTTP Error 500: a server error', rpc.error_message)
self.assertEquals(None, rpc.error_name)
def testRetryDecoratorFails(self):
"""Tests that a wrapped function retries til the timeout, then fails."""
delay_sec = 10
@retry.retry(Exception, delay_sec=delay_sec)
def fail():
raise Exception()
self.mox.StubOutWithMock(time, 'sleep')
time.sleep(mox.Func(lambda x: abs(x - delay_sec) <= .5 * delay_sec))
self.mox.ReplayAll()
self.assertRaises(Exception, fail)
def testErrorCheckedOnResultAttribute(self):
urllib2.urlopen(mox.Func(self.VerifyRequest)).AndRaise(
urllib2.HTTPError('http://whatever', 500, 'a server error', {},
StringIO.StringIO('does not matter')))
self.mox.ReplayAll()
rpc = self.trans.send_rpc(my_method.remote, self.request)
rpc.wait()
self.assertRaisesWithRegexpMatch(remote.ServerError,
'HTTP Error 500: a server error',
getattr, rpc, 'response')
def testIncrementalUpdate(self):
"""An incremental update reads a partial map and merges it."""
# Unlike in a full update, we create a cache map and a source map, and
# let it merge them. If it goes to write the merged map, we're good.
# Also check that timestamps were updated, as in testFullUpdate above.
def compare_function(map_object):
return len(map_object) == 2
original_modify_stamp = 1
new_modify_stamp = 2
updater = map_updater.MapUpdater(config.MAP_PASSWORD,
self.workdir, {},
can_do_incremental=True)
updater.WriteModifyTimestamp(original_modify_stamp)
cache_map_entry = passwd.PasswdMapEntry({
'name': 'bar',
'uid': 20,
'gid': 20
})
cache_map = passwd.PasswdMap([cache_map_entry])
cache_map.SetModifyTimestamp(original_modify_stamp)
cache_mock = self.mox.CreateMock(caches.Cache)
cache_mock.GetMap().AndReturn(cache_map)
cache_mock.WriteMap(map_data=mox.Func(compare_function)).AndReturn(0)
source_map_entry = passwd.PasswdMapEntry({
'name': 'foo',
'uid': 10,
'gid': 10
})
source_map = passwd.PasswdMap([source_map_entry])
source_map.SetModifyTimestamp(new_modify_stamp)
source_mock = self.mox.CreateMock(source.Source)
source_mock.GetMap(config.MAP_PASSWORD,
location=None,
since=original_modify_stamp).AndReturn(source_map)
self.mox.ReplayAll()
self.assertEqual(
0,
updater.UpdateCacheFromSource(cache_mock,
source_mock,
incremental=True,
force_write=False,
location=None))
self.assertEqual(updater.GetModifyTimestamp(), new_modify_stamp)
self.assertNotEqual(updater.GetUpdateTimestamp(), None)
def test_adds_latest_listener_docs(self):
self.add_sample_listener_docs()
uploader.time.time().AndReturn(1234.0)
uploader.time.time().AndReturn(1234.0)
self.fake_db.__setitem__(payload_telemetry_doc_id,
mox.Func(self.ptlm_with_listener_docs))
self.mocker.ReplayAll()
self.uploader.payload_telemetry(payload_telemetry_string,
payload_telemetry_metadata)
self.mocker.VerifyAll()
def _setup_create_instance_mocks(self,
setup_vif_mocks_func=None,
boot_from_volume=False):
vmutils.VMUtils.create_vm(mox.Func(self._check_vm_name), mox.IsA(int),
mox.IsA(int), mox.IsA(bool))
if not boot_from_volume:
m = vmutils.VMUtils.attach_ide_drive(mox.Func(self._check_vm_name),
mox.IsA(str), mox.IsA(int),
mox.IsA(int), mox.IsA(str))
m.WithSideEffects(self._add_ide_disk).InAnyOrder()
func = mox.Func(self._check_vm_name)
m = vmutils.VMUtils.create_scsi_controller(func)
m.InAnyOrder()
vmutils.VMUtils.create_nic(mox.Func(self._check_vm_name), mox.IsA(str),
mox.IsA(str)).InAnyOrder()
if setup_vif_mocks_func:
setup_vif_mocks_func()
def testOSXEnumerateRunningServicesAll(self):
self.osx.client_utils_osx.OSXVersion().AndReturn(self.mock_version)
self.mock_version.VersionAsMajorMinor().AndReturn([10, 7])
self.action.GetRunningLaunchDaemons().AndReturn(testdata.JOBS)
num_results = len(testdata.JOBS) - testdata.FILTERED_COUNT
for _ in range(0, num_results):
self.action.SendReply(mox.Func(self.ValidResponseProto))
self.mox.ReplayAll()
self.action.Run(None)
self.mox.VerifyAll()
def test_adds_latest_listener_docs(self):
self.add_sample_listener_docs()
uploader.time.time().AndReturn(1300001234.0)
uploader.time.time().AndReturn(1300001234.0)
self.expect_ptlm_update_func(payload_telemetry_doc_id,
mox.Func(self.ptlm_with_listener_docs))
self.mocker.ReplayAll()
self.uploader.payload_telemetry(payload_telemetry_string,
payload_telemetry_metadata)
self.mocker.VerifyAll()
def _setup_spawn_instance_mocks(self,
cow,
setup_vif_mocks_func=None,
with_exception=False,
block_device_info=None,
boot_from_volume=False):
m = vmutils.VMUtils.vm_exists(mox.IsA(str))
m.WithSideEffects(self._set_vm_name).AndReturn(False)
m = basevolumeutils.BaseVolumeUtils.volume_in_mapping(
mox.IsA(str), block_device_info)
m.AndReturn(boot_from_volume)
if not boot_from_volume:
m = vhdutils.VHDUtils.get_vhd_info(mox.Func(self._check_img_path))
m.AndReturn({'MaxInternalSize': 1024})
if cow:
fake.PathUtils.copyfile(mox.IsA(str), mox.IsA(str))
vhdutils.VHDUtils.resize_vhd(mox.IsA(str), mox.IsA(object))
vhdutils.VHDUtils.create_differencing_vhd(
mox.IsA(str), mox.IsA(str))
else:
vhdutils.VHDUtils.resize_vhd(mox.IsA(str), mox.IsA(object))
fake.PathUtils.copyfile(mox.IsA(str), mox.IsA(str))
self._setup_create_instance_mocks(setup_vif_mocks_func,
boot_from_volume)
# TODO(alexpilotti) Based on where the exception is thrown
# some of the above mock calls need to be skipped
if with_exception:
m = vmutils.VMUtils.vm_exists(mox.Func(self._check_vm_name))
m.AndReturn(True)
vmutils.VMUtils.destroy_vm(mox.Func(self._check_vm_name))
else:
vmutils.VMUtils.set_vm_state(mox.Func(self._check_vm_name),
constants.HYPERV_VM_STATE_ENABLED)
def test_reboot(self):
network_info = fake_network.fake_get_instance_nw_info(self.stubs,
spectacular=True)
self._instance_data = self._get_instance_data()
vmutils.VMUtils.set_vm_state(mox.Func(self._check_instance_name),
constants.HYPERV_VM_STATE_REBOOT)
self._mox.ReplayAll()
self._conn.reboot(self._context, self._instance_data, network_info,
None)
self._mox.VerifyAll()
def testGetPasswdMap(self):
test_posix_account = ('cn=test,ou=People,dc=example,dc=com',
{'uidNumber': [1000],
'gidNumber': [1000],
'uid': ['Testguy McTest'],
'cn': ['test'],
'homeDirectory': ['/home/test'],
'loginShell': ['/bin/sh'],
'userPassword': ['p4ssw0rd'],
'modifyTimestamp': ['20070227012807Z']})
config = dict(self.config)
attrlist = ['uid', 'uidNumber', 'gidNumber',
'gecos', 'cn', 'homeDirectory',
'fullName',
'loginShell', 'modifyTimestamp']
mock_rlo = self.mox.CreateMock(ldap.ldapobject.ReconnectLDAPObject)
mock_rlo.simple_bind_s(
cred='TEST_BIND_PASSWORD',
who='TEST_BIND_DN')
mock_rlo.search_ext(base='TEST_BASE',
filterstr='TEST_FILTER',
scope=ldap.SCOPE_ONELEVEL,
attrlist=mox.SameElementsAs(attrlist),
serverctrls=mox.Func(self.compareSPRC())).AndReturn('TEST_RES')
mock_rlo.result3('TEST_RES',
all=0,
timeout='TEST_TIMELIMIT').AndReturn(
(ldap.RES_SEARCH_ENTRY, [test_posix_account], None, []))
mock_rlo.result3('TEST_RES',
all=0,
timeout='TEST_TIMELIMIT').AndReturn(
(ldap.RES_SEARCH_RESULT, None, None, []))
self.mox.StubOutWithMock(ldap, 'ldapobject')
ldap.ldapobject.ReconnectLDAPObject(
uri='TEST_URI',
retry_max='TEST_RETRY_MAX',
retry_delay='TEST_RETRY_DELAY').AndReturn(mock_rlo)
self.mox.ReplayAll()
source = ldapsource.LdapSource(config)
data = source.GetPasswdMap()
self.assertEqual(1, len(data))
first = data.PopItem()
self.assertEqual('Testguy McTest', first.name)
def testGetGroupMapBis(self):
test_posix_group = ('cn=test,ou=Group,dc=example,dc=com',
{'gidNumber': [1000],
'cn': ['testgroup'],
'member': ['cn=testguy,ou=People,dc=example,dc=com',
'cn=fooguy,ou=People,dc=example,dc=com',
'cn=barguy,ou=People,dc=example,dc=com'],
'modifyTimestamp': ['20070227012807Z']})
config = dict(self.config)
config['rfc2307bis'] = 1
attrlist = ['cn', 'gidNumber', 'member',
'modifyTimestamp']
mock_rlo = self.mox.CreateMock(ldap.ldapobject.ReconnectLDAPObject)
mock_rlo.simple_bind_s(
cred='TEST_BIND_PASSWORD',
who='TEST_BIND_DN')
mock_rlo.search_ext(base='TEST_BASE',
filterstr='TEST_FILTER',
scope=ldap.SCOPE_ONELEVEL,
attrlist=mox.SameElementsAs(attrlist),
serverctrls=mox.Func(self.compareSPRC())).AndReturn('TEST_RES')
mock_rlo.result3('TEST_RES',
all=0,
timeout='TEST_TIMELIMIT').AndReturn(
(ldap.RES_SEARCH_ENTRY, [test_posix_group], None, []))
mock_rlo.result3('TEST_RES',
all=0,
timeout='TEST_TIMELIMIT').AndReturn(
(ldap.RES_SEARCH_RESULT, None, None, []))
self.mox.StubOutWithMock(ldap, 'ldapobject')
ldap.ldapobject.ReconnectLDAPObject(
uri='TEST_URI',
retry_max='TEST_RETRY_MAX',
retry_delay='TEST_RETRY_DELAY').AndReturn(mock_rlo)
self.mox.ReplayAll()
source = ldapsource.LdapSource(config)
data = source.GetGroupMap()
self.assertEqual(1, len(data))
ent = data.PopItem()
self.assertEqual('testgroup', ent.name)
self.assertEqual(3, len(ent.members))
def testUnorderedGroupWithComparator(self):
"""Unordered groups should work with comparators"""
def VerifyOne(cmd):
if not isinstance(cmd, str):
self.fail('Unexpected type passed to comparator: ' + str(cmd))
return cmd == 'test'
def VerifyTwo(cmd):
return True
mock_obj = self.mox.CreateMockAnything()
mock_obj.Foo(['test'], mox.Func(VerifyOne), bar=1).InAnyOrder().\
AndReturn('yes test')
mock_obj.Foo(['test'], mox.Func(VerifyTwo), bar=1).InAnyOrder().\
AndReturn('anything')
self.mox.ReplayAll()
mock_obj.Foo(['test'], 'anything', bar=1)
mock_obj.Foo(['test'], 'test', bar=1)
self.mox.VerifyAll()
