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, neutron 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 test_auth_version_discovery_v2(self, mrequests): # emulate Keystone version discovery mrequests.register_uri('GET', auth.BASE_URL, text=auth.V3_VERSION_LIST) neutron_shell = openstack_shell.NeutronShell('2.0') self.addCleanup(self.mox.UnsetStubs) self.mox.StubOutWithMock(clientmanager.ClientManager, '__init__') self.mox.StubOutWithMock(neutron_shell, 'run_subcommand') clientmanager.ClientManager.__init__( token='', url='', auth_url=auth.BASE_URL, tenant_name='test', tenant_id='tenant_id', username='******', user_id='', password='******', region_name='', api_version={'network': '2.0'}, auth_strategy='keystone', service_type='network', endpoint_type='publicURL', insecure=False, ca_cert=None, timeout=None, raise_errors=False, retries=0, auth=mox.IsA(v2_auth.Password), session=mox.IsA(session.Session), log_credentials=True) neutron_shell.run_subcommand(['quota-list']) self.mox.ReplayAll() cmdline = ('--os-username test ' '--os-password test ' '--os-tenant-name test ' '--os-auth-url %s ' '--os-auth-strategy keystone quota-list' % auth.BASE_URL) neutron_shell.run(cmdline.split()) self.mox.VerifyAll()
def _mock_unscoped_client(self, user): plugin = self._create_password_auth() plugin.get_access(mox.IsA(session.Session)). \ AndReturn(self.data.unscoped_access_info) plugin.auth_url = settings.OPENSTACK_KEYSTONE_URL return self.ks_client_module.Client(session=mox.IsA(session.Session), auth=plugin)
def test_strip_credentials_from_log(self): def verify_no_credentials(kwargs): return ('REDACTED' in kwargs['body']) and ( self.client.password not in kwargs['body']) def verify_credentials(body): return 'REDACTED' not in body and self.client.password in body self.mox.StubOutWithMock(self.client, "request") self.mox.StubOutWithMock(utils, "http_log_req") res200 = get_response(200) utils.http_log_req(mox.IgnoreArg(), mox.IgnoreArg(), mox.Func( verify_no_credentials)) self.client.request( mox.IsA(str), mox.IsA(str), body=mox.Func(verify_credentials), headers=mox.IgnoreArg() ).AndReturn((res200, json.dumps(KS_TOKEN_RESULT))) utils.http_log_req(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) self.client.request( mox.IsA(str), mox.IsA(str), headers=mox.IsA(dict) ).AndReturn((res200, '')) self.mox.ReplayAll() self.client.do_request('/resource', 'GET')
def test_match_list_false(self): self.mox.StubOutWithMock(search._Matcher, '_matches') search._Matcher._matches(mox.IsA(basestring)).AndReturn(False) search._Matcher._matches(mox.IsA(basestring)).AndReturn(False) self.mox.ReplayAll() matcher = search._Matcher('artist', u'bar', lambda x: x) self.assertFalse(matcher.match(self.str)) self.mox.VerifyAll()
def _mock_unscoped_client(self, unscoped): plugin = self._create_token_auth(None, token=unscoped.auth_token, url=settings.OPENSTACK_KEYSTONE_URL) plugin.get_access(mox.IsA(session.Session)).AndReturn(unscoped) return self.ks_client_module.Client(session=mox.IsA(session.Session), auth=plugin)
def test_match_list_false(self): self.mox.StubOutWithMock(search._Matcher, '_matches') # ensure that both tags are checked search._Matcher._matches(mox.IsA(basestring)).AndReturn(False) search._Matcher._matches(mox.IsA(basestring)).AndReturn(False) self.mox.ReplayAll() matcher = search._Matcher('artist', u'bar', lambda x: x) assert not matcher.match(self.strack) self.mox.VerifyAll()
def test_delete_tokens_for_instance_encoding(self): self.mox.StubOutWithMock(self.manager.mc, "delete") self.mox.StubOutWithMock(self.manager.mc, "get") self.manager.mc.get(mox.IsA(str)).AndReturn('["token"]') self.manager.mc.delete(mox.IsA(str)).AndReturn(True) self.manager.mc.delete(mox.IsA(str)).AndReturn(True) self.mox.ReplayAll() self.manager.delete_tokens_for_instance(self.context, self.u_instance)
def test_websso_login_with_auth_in_url(self): settings.OPENSTACK_KEYSTONE_URL =\ 'http://auth.openstack.org/identity/v3' projects = [self.data.project_one, self.data.project_two] domains = [] form_data = {'token': self.data.unscoped_access_info.auth_token} unscoped_auth = v3_auth.Token( auth_url=settings.OPENSTACK_KEYSTONE_URL, token=self.data.federated_unscoped_access_info.auth_token, project_id=None, reauthenticate=False) unscoped_auth.get_access(mox.IsA(session.Session)).AndReturn( self.data.federated_unscoped_access_info) unscoped_auth.auth_url = settings.OPENSTACK_KEYSTONE_URL unscoped_auth.auth_url = settings.OPENSTACK_KEYSTONE_URL client = self.ks_client_module.Client( session=mox.IsA(session.Session), auth=unscoped_auth) client.auth = self.mox.CreateMockAnything() client.auth.domains().AndReturn(domains) unscoped_auth.auth_url = settings.OPENSTACK_KEYSTONE_URL client = self.ks_client_module.Client( session=mox.IsA(session.Session), auth=unscoped_auth) client.federation = self.mox.CreateMockAnything() client.federation.projects = self.mox.CreateMockAnything() client.federation.projects.list().AndReturn(projects) plugin = v3_auth.Token( auth_url=settings.OPENSTACK_KEYSTONE_URL, token=self.data.unscoped_access_info.auth_token, project_id=self.data.project_one.id, reauthenticate=False) self.scoped_token_auth = plugin plugin.get_access(mox.IsA(session.Session)).AndReturn( self.data.unscoped_access_info) self.ks_client_module.Client( session=mox.IsA(session.Session), auth=plugin) self.mox.ReplayAll() url = reverse('websso') # POST to the page to log in. response = self.client.post(url, form_data) self.assertRedirects(response, settings.LOGIN_REDIRECT_URL)
def test_authorize_console_encoding(self): self.mox.StubOutWithMock(self.manager.mc, "set") self.mox.StubOutWithMock(self.manager.mc, "get") self.manager.mc.set(mox.IsA(str), mox.IgnoreArg(), mox.IgnoreArg() ).AndReturn(True) self.manager.mc.get(mox.IsA(str)).AndReturn(None) self.manager.mc.set(mox.IsA(str), mox.IgnoreArg()).AndReturn(True) self.mox.ReplayAll() self.manager.authorize_console(self.context, self.u_token, 'novnc', '127.0.0.1', '8080', 'host', self.u_instance)
def test_double_add(self): timeout_id = 1 self.mox.StubOutWithMock(GLib, 'timeout_add_seconds') self.mox.StubOutWithMock(GLib, 'source_remove') GLib.timeout_add_seconds(mox.IsA(int), mox.IsA( types.MethodType)).AndReturn(timeout_id) self.mox.ReplayAll() self.mc.add('foo', 'bar') assert self.mc.get('foo') == 'bar' self.mc.add('foo', 'bar') assert self.mc.get('foo') == 'bar' self.mox.VerifyAll()
def _mock_scoped_client_for_tenant(self, auth_ref, tenant_id, url=None, client=True): if url is None: url = settings.OPENSTACK_KEYSTONE_URL plugin = self._create_token_auth( tenant_id, token=self.data.unscoped_access_info.auth_token, url=url) plugin.get_access(mox.IsA(session.Session)).AndReturn(auth_ref) if client: return self.ks_client_module.Client( session=mox.IsA(session.Session), auth=plugin)
def _mock_unscoped_token_client(self, unscoped, auth_url=None, client=True, plugin=None): if not auth_url: auth_url = settings.OPENSTACK_KEYSTONE_URL if unscoped and not plugin: plugin = self._create_token_auth( None, token=unscoped.auth_token, url=auth_url) plugin.get_access(mox.IsA(session.Session)).AndReturn(unscoped) plugin.auth_url = auth_url if client: return self.ks_client_module.Client( session=mox.IsA(session.Session), auth=plugin)
def test_check_token_encoding(self): self.mox.StubOutWithMock(self.manager.mc, "get") self.manager.mc.get(mox.IsA(str)).AndReturn(None) self.mox.ReplayAll() self.manager.check_token(self.context, self.u_token)
def test_match_list_true(self): self.mox.StubOutWithMock(search._Matcher, '_matches') search._Matcher._matches(mox.IsA(str)).AndReturn(True) self.mox.ReplayAll() matcher = search._Matcher('artist', 'bar', lambda x: x) assert matcher.match(self.strack) self.mox.VerifyAll()
def _setup_destroy_mocks(self, destroy_disks=True): m = vmutils.VMUtils.vm_exists(mox.Func(self._check_instance_name)) m.AndReturn(True) serialconsoleops.SerialConsoleOps.stop_console_handler(mox.IsA(str)) func = mox.Func(self._check_instance_name) vmutils.VMUtils.set_vm_state(func, constants.HYPERV_VM_STATE_DISABLED) vmutils.VMUtils.destroy_vm(func) if destroy_disks: m = fake.PathUtils.get_instance_dir(mox.IsA(str), create_dir=False, remove_dir=True) m.AndReturn(self._test_instance_dir)
def _test_scheduler_api(self, method, rpc_method, **kwargs): ctxt = context.RequestContext('fake_user', 'fake_project') rpcapi = scheduler_rpcapi.SchedulerAPI() self.assertIsNotNone(rpcapi.client) self.assertEqual(rpcapi.client.target.topic, CONF.scheduler_topic) expected_retval = 'foo' if rpc_method == 'call' else None expected_version = kwargs.pop('version', None) expected_fanout = kwargs.pop('fanout', None) expected_kwargs = kwargs.copy() self.mox.StubOutWithMock(rpcapi, 'client') rpcapi.client.can_send_version( mox.IsA(str)).MultipleTimes().AndReturn(True) prepare_kwargs = {} if expected_fanout: prepare_kwargs['fanout'] = True if expected_version: prepare_kwargs['version'] = expected_version rpcapi.client.prepare(**prepare_kwargs).AndReturn(rpcapi.client) rpc_method = getattr(rpcapi.client, rpc_method) rpc_method(ctxt, method, **expected_kwargs).AndReturn('foo') self.mox.ReplayAll() # NOTE(markmc): MultipleTimes() is OnceOrMore() not ZeroOrMore() rpcapi.client.can_send_version('I fool you mox') retval = getattr(rpcapi, method)(ctxt, **kwargs) self.assertEqual(retval, expected_retval)
def test_list_external_nets_empty_with_column(self): resources = "networks" cmd = network.ListExternalNetwork(test_cli20.MyApp(sys.stdout), None) self.mox.StubOutWithMock(cmd, "get_client") self.mox.StubOutWithMock(self.client.httpclient, "request") self.mox.StubOutWithMock(network.ListNetwork, "extend_list") network.ListNetwork.extend_list(mox.IsA(list), mox.IgnoreArg()) cmd.get_client().MultipleTimes().AndReturn(self.client) reses = {resources: []} resstr = self.client.serialize(reses) # url method body query = "router%3Aexternal=True&id=myfakeid" args = ['-c', 'id', '--', '--id', 'myfakeid'] path = getattr(self.client, resources + "_path") self.client.httpclient.request( test_cli20.MyUrlComparator(test_cli20.end_url(path, query), self.client), 'GET', body=None, headers=mox.ContainsKeyValue('X-Auth-Token', test_cli20.TOKEN)).AndReturn( (test_cli20.MyResp(200), resstr)) self.mox.ReplayAll() cmd_parser = cmd.get_parser("list_" + resources) shell.run_command(cmd, cmd_parser, args) self.mox.VerifyAll() self.mox.UnsetStubs() _str = self.fake_stdout.make_string() self.assertEqual('\n', _str)
def test_unshelve_volume_backed(self, mock_notify, mock_image_meta): instance = self._create_fake_instance_obj() node = test_compute.NODENAME limits = {} filter_properties = {'limits': limits} instance.task_state = task_states.UNSHELVING instance.save() image_meta = {'properties': {'base_image_ref': uuids.image_id}} mock_image_meta.return_value = image_meta self.mox.StubOutWithMock(self.compute, '_notify_about_instance_usage') self.mox.StubOutWithMock(self.compute, '_prep_block_device') self.mox.StubOutWithMock(self.compute.driver, 'spawn') self.mox.StubOutWithMock(self.compute, '_get_power_state') self.mox.StubOutWithMock(self.rt, 'instance_claim') self.mox.StubOutWithMock(self.compute.network_api, 'setup_instance_network_on_host') tracking = {'last_state': instance.task_state} def check_save(expected_task_state=None): if tracking['last_state'] == task_states.UNSHELVING: self.assertEqual(task_states.SPAWNING, instance.task_state) tracking['last_state'] = instance.task_state elif tracking['last_state'] == task_states.SPAWNING: self.assertEqual(123, instance.power_state) self.assertEqual(vm_states.ACTIVE, instance.vm_state) self.assertIsNone(instance.task_state) self.assertIsNone(instance.key_data) self.assertFalse(instance.auto_disk_config) self.assertIsNone(instance.task_state) tracking['last_state'] = instance.task_state else: self.fail('Unexpected save!') self.compute._notify_about_instance_usage(self.context, instance, 'unshelve.start') self.compute._prep_block_device(self.context, instance, mox.IgnoreArg(), do_check_attach=False).AndReturn('fake_bdm') self.compute.network_api.setup_instance_network_on_host( self.context, instance, self.compute.host) self.rt.instance_claim(self.context, instance, node, limits).AndReturn( claims.Claim(self.context, instance, self.rt, _fake_resources(), objects.InstancePCIRequests(requests=[]))) self.compute.driver.spawn(self.context, instance, mox.IsA(objects.ImageMeta), injected_files=[], admin_password=None, network_info=[], block_device_info='fake_bdm') self.compute._get_power_state(self.context, instance).AndReturn(123) self.compute._notify_about_instance_usage(self.context, instance, 'unshelve.end') self.mox.ReplayAll() with mock.patch.object(instance, 'save') as mock_save: mock_save.side_effect = check_save self.compute.unshelve_instance(self.context, instance, image=None, filter_properties=filter_properties, node=node)
def _test_list_networks(self, cmd, detail=False, tags=(), fields_1=(), fields_2=(), page_size=None, sort_key=(), sort_dir=(), base_args=None, query=''): resources = "networks" self.mox.StubOutWithMock(network.ListNetwork, "extend_list") network.ListNetwork.extend_list(mox.IsA(list), mox.IgnoreArg()) self._test_list_resources(resources, cmd, detail, tags, fields_1, fields_2, page_size=page_size, sort_key=sort_key, sort_dir=sort_dir, base_args=base_args, query=query)
def _mock_attach_config_drive(self, instance, config_drive_format): instance['config_drive'] = True self._mox.StubOutWithMock(fake.PathUtils, 'lookup_configdrive_path') m = fake.PathUtils.lookup_configdrive_path( mox.Func(self._check_instance_name)) if config_drive_format in constants.DISK_FORMAT_MAP: m.AndReturn(self._test_instance_dir + '/configdrive.' + config_drive_format) else: m.AndReturn(None) m = vmutils.VMUtils.attach_ide_drive( mox.Func(self._check_instance_name), mox.IsA(str), mox.IsA(int), mox.IsA(int), mox.IsA(str)) m.WithSideEffects(self._add_disk).InAnyOrder()
def test_list_subnetpool_pagination(self): cmd = subnetpool.ListSubnetPool(test_cli20.MyApp(sys.stdout), None) self.mox.StubOutWithMock(subnetpool.ListSubnetPool, "extend_list") subnetpool.ListSubnetPool.extend_list(mox.IsA(list), mox.IgnoreArg()) self._test_list_resources_with_pagination("subnetpools", cmd) self.mox.VerifyAll() self.mox.UnsetStubs()
def _test_list_resources_with_formatter(self, fmt): resources = 'networks' cmd = network.ListNetwork(MyApp(sys.stdout), None) # ListNetwork has its own extend_list, so we need to stub out it # to avoid an extra API call. self.mox.StubOutWithMock(network.ListNetwork, "extend_list") network.ListNetwork.extend_list(mox.IsA(list), mox.IgnoreArg()) self._test_list_resources(resources, cmd, output_format=fmt)
def test_list_bgp_speaker_pagination(self): # List all BGP Speakers with pagination support. cmd = bgp_speaker.ListSpeakers(test_cli20.MyApp(sys.stdout), None) self.mox.StubOutWithMock(bgp_speaker.ListSpeakers, "extend_list") bgp_speaker.ListSpeakers.extend_list(mox.IsA(list), mox.IgnoreArg()) self._test_list_resources_with_pagination("bgp_speakers", cmd) self.mox.VerifyAll() self.mox.UnsetStubs()
def test_copy_image_to_volume(self): """resize_image common case usage.""" drv = self._driver volume = db_fakes.get_fake_volume_info() fake_get_supported_type = lambda x: constants.VHD_TYPE_FIXED self.stubs.Set(drv, 'local_path', self.fake_local_path) self.stubs.Set(windows_utils.WindowsUtils, 'get_supported_vhd_type', fake_get_supported_type) self.mox.StubOutWithMock(os, 'unlink') self.mox.StubOutWithMock(image_utils, 'create_temporary_file') self.mox.StubOutWithMock(image_utils, 'fetch_to_vhd') self.mox.StubOutWithMock(vhdutils.VHDUtils, 'convert_vhd') self.mox.StubOutWithMock(vhdutils.VHDUtils, 'resize_vhd') self.mox.StubOutWithMock(windows_utils.WindowsUtils, 'change_disk_status') fake_temp_path = r'C:\fake\temp\file' if (CONF.image_conversion_dir and not os.path.exists(CONF.image_conversion_dir)): os.makedirs(CONF.image_conversion_dir) image_utils.create_temporary_file(suffix='.vhd').AndReturn( fake_temp_path) fake_volume_path = self.fake_local_path(volume) image_utils.fetch_to_vhd(None, None, None, fake_temp_path, mox.IgnoreArg()) windows_utils.WindowsUtils.change_disk_status(volume['name'], mox.IsA(bool)) vhdutils.VHDUtils.convert_vhd(fake_temp_path, fake_volume_path, constants.VHD_TYPE_FIXED) vhdutils.VHDUtils.resize_vhd(fake_volume_path, volume['size'] << 30) windows_utils.WindowsUtils.change_disk_status(volume['name'], mox.IsA(bool)) os.unlink(mox.IsA(str)) self.mox.ReplayAll() drv.copy_image_to_volume(None, volume, None, None)
def test_list_security_group_rules_limit(self): resources = "security_group_rules" cmd = securitygroup.ListSecurityGroupRule(test_cli20.MyApp(sys.stdout), None) self.mox.StubOutWithMock(securitygroup.ListSecurityGroupRule, "extend_list") securitygroup.ListSecurityGroupRule.extend_list( mox.IsA(list), mox.IgnoreArg()) self._test_list_resources(resources, cmd, page_size=1000)
def _mock_plugin(self, unscoped, auth_url=None): if not auth_url: auth_url = settings.OPENSTACK_KEYSTONE_URL plugin = self._create_token_auth(None, token=unscoped.auth_token, url=auth_url) plugin.get_access(mox.IsA(session.Session)).AndReturn(unscoped) plugin.auth_url = settings.OPENSTACK_KEYSTONE_URL return plugin
def test_list_address_scope_pagination(self): # address_scope-list. cmd = address_scope.ListAddressScope(test_cli20.MyApp(sys.stdout), None) self.mox.StubOutWithMock(address_scope.ListAddressScope, "extend_list") address_scope.ListAddressScope.extend_list(mox.IsA(list), mox.IgnoreArg()) self._test_list_resources_with_pagination("address_scopes", cmd) self.mox.VerifyAll() self.mox.UnsetStubs()
def _mock_scoped_for_domain(self, projects): url = settings.OPENSTACK_KEYSTONE_URL plugin = self._create_token_auth( project_id=None, domain_name=DEFAULT_DOMAIN, token=self.data.unscoped_access_info.auth_token, url=url) plugin.get_access(mox.IsA(session.Session)).AndReturn( self.data.domain_scoped_access_info) # if no projects or no enabled projects for user, but domain scoped # token client auth gets set to domain scoped auth otherwise it's set # to the project scoped auth and that happens in a different mock enabled_projects = [project for project in projects if project.enabled] if not projects or not enabled_projects: return self.ks_client_module.Client( session=mox.IsA(session.Session), auth=plugin)
def _mock_unscoped_list_projects_fail(self, client, user): plugin = self._create_token_auth( project_id=None, domain_name=DEFAULT_DOMAIN, token=self.data.unscoped_access_info.auth_token, url=settings.OPENSTACK_KEYSTONE_URL) plugin.get_access(mox.IsA(session.Session)).AndReturn( self.data.domain_scoped_access_info) client.projects = self.mox.CreateMockAnything() client.projects.list(user=user.id).AndRaise( keystone_exceptions.AuthorizationFailure)