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)
