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()