def test_tacker_context_overwrite(self): ctx1 = context.Context('user_id', 'tenant_id') self.assertEqual(ctx1.request_id, local.store.context.request_id) # If overwrite is not specified, request_id should be updated. ctx2 = context.Context('user_id', 'tenant_id') self.assertNotEqual(ctx2.request_id, ctx1.request_id) self.assertEqual(ctx2.request_id, local.store.context.request_id) # If overwrite is specified, request_id should be kept. ctx3 = context.Context('user_id', 'tenant_id', overwrite=False) self.assertNotEqual(ctx3.request_id, ctx2.request_id) self.assertEqual(ctx2.request_id, local.store.context.request_id)
def setUp(self): super(PolicyFileTestCase, self).setUp() policy.reset() self.addCleanup(policy.reset) self.context = context.Context('fake', 'fake', is_admin=False) self.target = {} self.tempdir = self.useFixture(fixtures.TempDir())
def test_tacker_context_to_dict_with_name(self): ctx = context.Context('user_id', 'tenant_id', tenant_name='tenant_name', user_name='user_name') ctx_dict = ctx.to_dict() self.assertEqual('user_name', ctx_dict['user_name']) self.assertEqual('tenant_name', ctx_dict['tenant_name']) self.assertEqual('tenant_name', ctx_dict['project_name'])
def setUp(self): super(TackerPolicyTestCase, self).setUp() self.skipTest("Not ready yet") policy.reset() policy.init() self.addCleanup(policy.reset) self.admin_only_legacy = "role:admin" self.admin_or_owner_legacy = "role:admin or tenant_id:%(tenant_id)s" # Add a Fake 'something' resource to RESOURCE_ATTRIBUTE_MAP attributes.RESOURCE_ATTRIBUTE_MAP.update(FAKE_RESOURCE) self.rules = dict((k, common_policy.parse_rule(v)) for k, v in { "context_is_admin": "role:admin", "admin_or_network_owner": "rule:context_is_admin or " "tenant_id:%(network:tenant_id)s", "admin_or_owner": ("rule:context_is_admin or " "tenant_id:%(tenant_id)s"), "admin_only": "rule:context_is_admin", "regular_user": "******", "shared": "field:networks:shared=True", "external": "field:networks:router:external=True", "default": '@', "create_network": "rule:admin_or_owner", "create_network:shared": "rule:admin_only", "update_network": '@', "update_network:shared": "rule:admin_only", "get_network": "rule:admin_or_owner or " "rule:shared or " "rule:external", "create_port:mac": "rule:admin_or_network_owner", "create_something": "rule:admin_or_owner", "create_something:attr": "rule:admin_or_owner", "create_something:attr:sub_attr_1": "rule:admin_or_owner", "create_something:attr:sub_attr_2": "rule:admin_only", "get_firewall_policy": "rule:admin_or_owner or " "rule:shared", "get_firewall_rule": "rule:admin_or_owner or " "rule:shared" }.items()) def fakepolicyinit(): common_policy.set_rules(common_policy.Rules(self.rules)) def remove_fake_resource(): del attributes.RESOURCE_ATTRIBUTE_MAP["%ss" % FAKE_RESOURCE_NAME] self.patcher = mock.patch.object(tacker.policy, 'init', new=fakepolicyinit) self.patcher.start() self.addCleanup(remove_fake_resource) self.context = context.Context('fake', 'fake', roles=['user']) plugin_klass = importutils.import_class( "tacker.db.db_base_plugin_v2.TackerDbPluginV2") self.manager_patcher = mock.patch('tacker.manager.TackerManager') fake_manager = self.manager_patcher.start() fake_manager_instance = fake_manager.return_value fake_manager_instance.plugin = plugin_klass()
def _test_nonadmin_action_on_attr(self, action, attr, value, exception=None): user_context = context.Context('', "user", roles=['user']) self._test_action_on_attr(user_context, action, attr, value, exception)
def setUp(self): super(PolicyTestCase, self).setUp() self.skipTest("Not ready yet") policy.reset() self.addCleanup(policy.reset) # NOTE(vish): preload rules to circumvent reloading from file policy.init() rules = { "true": '@', "example:allowed": '@', "example:denied": '!', "example:get_http": "http:http://www.example.com", "example:my_file": "role:compute_admin or tenant_id:%(tenant_id)s", "example:early_and_fail": "! and @", "example:early_or_success": "@ or !", "example:lowercase_admin": "role:admin or role:sysadmin", "example:uppercase_admin": "role:ADMIN or role:sysadmin", } # NOTE(vish): then overload underlying rules common_policy.set_rules( common_policy.Rules( dict((k, common_policy.parse_rule(v)) for k, v in rules.items()))) self.context = context.Context('fake', 'fake', roles=['member']) self.target = {}
def __call__(self, req): # Determine the user ID user_id = req.headers.get('X_USER_ID') if not user_id: LOG.debug(_("X_USER_ID is not found in request")) return webob.exc.HTTPUnauthorized() # Determine the tenant tenant_id = req.headers.get('X_PROJECT_ID') # Suck out the roles roles = [r.strip() for r in req.headers.get('X_ROLES', '').split(',')] # Human-friendly names tenant_name = req.headers.get('X_PROJECT_NAME') user_name = req.headers.get('X_USER_NAME') # Use request_id if already set req_id = req.environ.get(request_id.ENV_REQUEST_ID) # Create a context with the authentication data ctx = context.Context(user_id, tenant_id, roles=roles, user_name=user_name, tenant_name=tenant_name, request_id=req_id) # Inject the context... req.environ['tacker.context'] = ctx return self.application
def test_tacker_context_get_admin_context_not_update_local_store(self): ctx = context.Context('user_id', 'tenant_id') req_id_before = local.store.context.request_id self.assertEqual(ctx.request_id, req_id_before) ctx_admin = context.get_admin_context() self.assertEqual(req_id_before, local.store.context.request_id) self.assertNotEqual(req_id_before, ctx_admin.request_id)
def test_tacker_context_get_admin_context_not_update_local_store(self): ctx = context.Context('user_id', 'tenant_id') req_id_before = oslo_context.get_current().request_id self.assertEqual(req_id_before, ctx.request_id) ctx_admin = context.get_admin_context() self.assertEqual(req_id_before, oslo_context.get_current().request_id) self.assertNotEqual(req_id_before, ctx_admin.request_id)
def test_ignore_case_role_check(self): lowercase_action = "example:lowercase_admin" uppercase_action = "example:uppercase_admin" # NOTE(dprince) we mix case in the Admin role here to ensure # case is ignored admin_context = context.Context('admin', 'fake', roles=['AdMiN']) policy.enforce(admin_context, lowercase_action, self.target) policy.enforce(admin_context, uppercase_action, self.target)
def test_tacker_context_elevated_retains_request_id(self): ctx = context.Context('user_id', 'tenant_id') self.assertFalse(ctx.is_admin) req_id_before = ctx.request_id elevated_ctx = ctx.elevated() self.assertTrue(elevated_ctx.is_admin) self.assertEqual(req_id_before, elevated_ctx.request_id)
def test_tacker_context_create_with_name(self): ctx = context.Context('user_id', 'tenant_id', tenant_name='tenant_name', user_name='user_name') # Check name is set self.assertEqual('user_name', ctx.user_name) self.assertEqual('tenant_name', ctx.tenant_name) # Check user/tenant contains its ID even if user/tenant_name is passed self.assertEqual('user_id', ctx.user) self.assertEqual('tenant_id', ctx.tenant)
def test_tacker_context_create(self): ctx = context.Context('user_id', 'tenant_id') self.assertEqual('user_id', ctx.user_id) self.assertEqual('tenant_id', ctx.project_id) self.assertEqual('tenant_id', ctx.tenant_id) self.assertThat(ctx.request_id, matchers.StartsWith('req-')) self.assertEqual('user_id', ctx.user) self.assertEqual('tenant_id', ctx.tenant) self.assertIsNone(ctx.user_name) self.assertIsNone(ctx.tenant_name)
def deserialize_context(self, ctxt): rpc_ctxt_dict = ctxt.copy() user_id = rpc_ctxt_dict.pop('user_id', None) if not user_id: user_id = rpc_ctxt_dict.pop('user', None) tenant_id = rpc_ctxt_dict.pop('tenant_id', None) if not tenant_id: tenant_id = rpc_ctxt_dict.pop('project_id', None) return context.Context(user_id, tenant_id, load_admin_roles=False, **rpc_ctxt_dict)
def test_tacker_context_to_dict(self): ctx = context.Context('user_id', 'tenant_id') ctx_dict = ctx.to_dict() self.assertEqual('user_id', ctx_dict['user_id']) self.assertEqual('tenant_id', ctx_dict['project_id']) self.assertEqual(ctx.request_id, ctx_dict['request_id']) self.assertEqual('user_id', ctx_dict['user']) self.assertEqual('tenant_id', ctx_dict['tenant']) self.assertIsNone(ctx_dict['user_name']) self.assertIsNone(ctx_dict['tenant_name']) self.assertIsNone(ctx_dict['project_name'])
def setUp(self): super(DefaultPolicyTestCase, self).setUp() policy.reset() policy.init() self.addCleanup(policy.reset) self.rules = { "default": '', "example:exist": '!', } self._set_rules('default') self.context = context.Context('fake', 'fake')
def test_tacker_context_create_with_request_id(self): ctx = context.Context('user_id', 'tenant_id', request_id='req_id_xxx') self.assertEqual('req_id_xxx', ctx.request_id)
def test_tacker_context_create_logs_unknown_kwarg(self): with mock.patch.object(context.LOG, 'debug') as mock_log: context.Context('user_id', 'tenant_id', foo=None) self.assertEqual(1, mock_log.call_count)
class TestMgmtProxyDriver(test_rpc.TestMgmtRpcDriver): _TENANT_ID = _uuid() _CONTEXT = context.Context('', _TENANT_ID) _NETWORK_ID = _uuid(), _SUBNET_ID = _uuid() _DEVICE_PORT_ID = _uuid() _DEVICE = { 'id': _uuid(), 'mgmt_address': 'device-address', 'service_context': [{ 'network_id': _NETWORK_ID, 'port_id': _DEVICE_PORT_ID, 'role': 'mgmt', }], } _PORT_ID = _uuid() _IP_ADDRESS = '1.1.1.1' _PORT = { 'id': _PORT_ID, 'fixed_ips': [{ 'subnet_id': _SUBNET_ID, 'ip_address': _IP_ADDRESS, }], } _PROXY_ID = [_uuid(), _uuid(), _uuid(), _uuid()] _NS_PROXY_ID = [_uuid(), _uuid(), _uuid(), _uuid()] def setUp(self): super(TestMgmtProxyDriver, self).setUp() self.mock_proxy_api_p = mock.patch( 'tacker.vm.proxy_api.ServiceVMPluginApi') self.mock_proxy_api = self.mock_proxy_api_p.start() mock_proxy_api_instance = mock.Mock() self.mock_proxy_api.return_value = mock_proxy_api_instance self.mock_proxy_api_instance = mock_proxy_api_instance mock_proxy_api_instance.create_namespace_agent.return_value = ( self._PORT_ID) mock_proxy_api_instance.create_rpc_proxy = mock.Mock( side_effect=self._PROXY_ID) mock_proxy_api_instance.create_rpc_namespace_proxy = mock.Mock( side_effect=self._NS_PROXY_ID) self.plugin.proxy_api = proxy_api.ServiceVMPluginApi('fake-topic') self.plugin._core_plugin.get_port.return_value = self._PORT self.mgmt_driver = proxy.AgentRpcProxyMGMTDriver() def test_mgmt_create_post_delete_post(self): mgmt_driver = self.mgmt_driver mock_instance = self.mock_proxy_api_instance mgmt_driver.mgmt_create_post(self.plugin, self._CONTEXT, self._DEVICE) mock_instance.create_namespace_agent.assert_called_once_with( self.plugin._core_plugin, self._CONTEXT, self._NETWORK_ID) target = 'topic=%s,server=%s' % (topics.SERVICEVM_AGENT, self._DEVICE['id']) mock_instance.create_rpc_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, target, target, 'receive'), mock.call(self._CONTEXT, self._PORT_ID, target, target, 'send') ]) dst_transport_url = cfg.CONF.dst_transport_url % { 'host': self._IP_ADDRESS } mock_instance.create_rpc_namespace_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url, target, 'receive'), mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url, target, 'send') ]) mgmt_address = mgmt_driver.mgmt_address(self.plugin, self._CONTEXT, self._DEVICE) self.assertEqual( mgmt_address, '%s.%s' % (topics.SERVICEVM_AGENT, self._DEVICE['id'])) mgmt_driver.mgmt_call(self.plugin, self._CONTEXT, self._DEVICE, self._KWARGS) msg = { 'args': self._KWARGS['kwargs'], 'namespace': None, 'method': 'action-name' } self.mock_rpc_proxy_cast.assert_called_once_with( self._CONTEXT, msg, topic='device-address') mgmt_driver.mgmt_delete_post(self.plugin, self._CONTEXT, self._DEVICE) mock_instance.destroy_rpc_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[1]), mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[0]) ]) mock_instance.destroy_rpc_namespace_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[1]), mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[0]) ]) mock_instance.destroy_namespace_agent.assert_called_once_with( self.plugin._core_plugin, self._CONTEXT, self._PORT_ID) def test_mgmt_service_create_pre_delete_post(self): mgmt_driver = self.mgmt_driver mock_instance = self.mock_proxy_api_instance mgmt_driver.mgmt_create_post(self.plugin, self._CONTEXT, self._DEVICE) mock_instance.create_namespace_agent.assert_called_once_with( self.plugin._core_plugin, self._CONTEXT, self._NETWORK_ID) target = 'topic=%s,server=%s' % (topics.SERVICEVM_AGENT, self._DEVICE['id']) mock_instance.create_rpc_proxy.assert_has_calls([ mock.call(self._CONTEXT, mock.ANY, target, target, 'receive'), mock.call(self._CONTEXT, mock.ANY, target, target, 'send') ]) dst_transport_url = cfg.CONF.dst_transport_url % { 'host': self._IP_ADDRESS } mock_instance.create_rpc_namespace_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url, target, 'receive'), mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url, target, 'send') ]) mock_instance.create_rpc_proxy.reset_mock() mock_instance.create_rpc_namespace_proxy.reset_mock() mgmt_driver.mgmt_service_create_pre(self.plugin, self._CONTEXT, self._DEVICE, self._SERVICE_INSTANCE) target = 'topic=%s-%s,server=%s' % (topics.SERVICEVM_AGENT, self._DEVICE['id'], self._SERVICE_INSTANCE['id']) mock_instance.create_rpc_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, target, target, 'receive'), mock.call(self._CONTEXT, self._PORT_ID, target, target, 'send') ]) dst_transport_url = cfg.CONF.dst_transport_url % { 'host': self._IP_ADDRESS } mock_instance.create_rpc_namespace_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url, target, 'receive'), mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url, target, 'send') ]) mgmt_service_address = mgmt_driver.mgmt_service_address( self.plugin, self._CONTEXT, self._DEVICE, self._SERVICE_INSTANCE) self.assertEqual( mgmt_service_address, '%s-%s.%s' % (topics.SERVICEVM_AGENT, self._DEVICE['id'], self._SERVICE_INSTANCE['id'])) mgmt_driver.mgmt_service_call(self.plugin, self._CONTEXT, self._DEVICE, self._SERVICE_INSTANCE, self._KWARGS) msg = { 'args': self._KWARGS['kwargs'], 'namespace': None, 'method': 'action-name' } self.mock_rpc_proxy_cast.assert_called_once_with( self._CONTEXT, msg, topic='service-instance-address') mgmt_driver.mgmt_service_delete_post(self.plugin, self._CONTEXT, self._DEVICE, self._SERVICE_INSTANCE) mock_instance.destroy_rpc_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[3]), mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[2]) ]) mock_instance.destroy_rpc_namespace_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[3]), mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[2]) ]) mock_instance.destroy_rpc_proxy.reset.mock() mock_instance.destroy_rpc_namespace_proxy.reset_mock() mgmt_driver.mgmt_delete_post(self.plugin, self._CONTEXT, self._DEVICE) mock_instance.destroy_rpc_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[1]), mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[0]) ]) mock_instance.destroy_rpc_namespace_proxy.assert_has_calls([ mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[1]), mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[0]) ]) mock_instance.destroy_namespace_agent.assert_called_once_with( self.plugin._core_plugin, self._CONTEXT, self._PORT_ID)
class TestVMService(base.BaseTestCase): ctxt = context.Context('user', 'tenant') network_id = str(uuid.uuid4()) subnet_id = str(uuid.uuid4()) port_id = str(uuid.uuid4()) mac_address = '00:00:00:00:00:01' netmask = '/24' network_address = '192.168.1.0' cidr = network_address + netmask ip_address = '192.168.1.3' gw_address = '192.168.1.1' port = { 'id': port_id, 'network_id': network_id, 'mac_address': mac_address, 'fixed_ips': [{'subnet_id': subnet_id, 'ip_address': ip_address, 'subnet': { 'cidr': cidr, 'ip_version': 4, 'gateway_ip': gw_address}}] } def setUp(self): super(TestVMService, self).setUp() conf = cfg.CONF # NOTE(yamahata): work around. rpc driver-dependent config variables # remove this line once tacker are fully ported to oslo.messaging from tacker.openstack.common import rpc conf.unregister_opts(rpc.rpc_opts) conf.register_opts(transport._transport_opts) conf.set_override('rpc_backend', 'tacker.openstack.common.rpc.impl_fake') self.addCleanup(mock.patch.stopall) self.mock_get_transport_p = mock.patch('oslo.messaging.get_transport') self.mock_get_transport = self.mock_get_transport_p.start() self.mock_import_object_p = mock.patch( 'tacker.openstack.common.importutils.import_object') self.mock_import_object = self.mock_import_object_p.start() self.vif_driver = mock.create_autospec( tacker.agent.linux.interface.NullDriver) self.mock_import_object.return_value = self.vif_driver self.agent = agent.ServiceVMAgent('host', conf=conf) self.mock_process_manager_p = mock.patch.object( tacker.agent.linux.external_process, 'ProcessManager') self.mock_process_manager = self.mock_process_manager_p.start() self.mock_process_manager_instance = ( self.mock_process_manager.return_value) self.mock_device_exists_p = mock.patch( 'tacker.agent.linux.ip_lib.device_exists') self.mock_device_exists = self.mock_device_exists_p.start() self.mock_device_exists.return_value = False self.mock_ipwrapper_p = mock.patch.object(tacker.agent.linux.ip_lib, 'IPWrapper') self.mock_ipwrapper = self.mock_ipwrapper_p.start() self.mock_ipwrapper_instance = self.mock_ipwrapper.return_value self.mock_rpc_client_p = mock.patch.object(oslo.messaging.rpc, 'RPCClient') self.mock_rpc_client = self.mock_rpc_client_p.start() self.mock_rpc_client_instance = self.mock_rpc_client.return_value def test_create_destroy_namespace_agent(self): self.agent.create_namespace_agent(self.ctxt, self.port) self.vif_driver.plug.assert_called_once_with( self.network_id, self.port_id, mock.ANY, self.mac_address, namespace=mock.ANY) self.vif_driver.init_l3.assert_called_once_with( mock.ANY, [self.ip_address + self.netmask], namespace=mock.ANY) self.mock_ipwrapper.assert_called_once_with( mock.ANY, namespace=mock.ANY) self.mock_ipwrapper_instance.netns.execute.assert_called_once_with( ['route', 'add', 'default', 'gw', self.gw_address], check_exit_code=False) self.assertTrue(self.mock_process_manager_instance.enable.called) self.agent.destroy_namespace_agent(self.ctxt, self.port_id) self.vif_driver.unplug.assert_called_once_with(mock.ANY, namespace=mock.ANY) self.mock_process_manager_instance.disable.assert_called_once_with() def test_create_rpc_proxy_wrong_port_id(self): func = lambda: self.agent.create_rpc_proxy( self.ctxt, self.port_id, 'topic=src_topic,server=src_server', 'topic=dst_topic,server=dst_server', 'wrong-direction') self.assertRaises(RuntimeError, func) def test_create_rpc_proxy_wrong_direction(self): self.agent.create_namespace_agent(self.ctxt, self.port) func = lambda: self.agent.create_rpc_proxy( self.ctxt, self.port_id, 'topic=src_topic,server=src_server', 'topic=dst_topic,server=dst_server', 'wrong-direction') self.assertRaises(RuntimeError, func) self.agent.destroy_namespace_agent(self.ctxt, self.port_id) def test_create_destroy_rpc_proxy_send(self): self.agent.create_namespace_agent(self.ctxt, self.port) with mock.patch('oslo.messaging.proxy.get_proxy_server' ) as mock_get_proxy_server: mock_transport = self.mock_get_transport.return_value mock_instance = mock_get_proxy_server.return_value proxy_id = self.agent.create_rpc_proxy( self.ctxt, self.port_id, 'topic=src_topic,server=src_server', 'topic=dst_topic,server=dst_server', 'send') src_target = target.Target(topic='src_topic', server='src_server') dst_target = target.Target(topic='dst_topic', server='dst_server') mock_get_proxy_server.assert_called_once_with( mock_transport, src_target, None, mock_transport, dst_target, None, executor=mock.ANY) mock_instance.start.assert_called_once_with() self.agent.destroy_rpc_proxy(self.ctxt, self.port_id, proxy_id) mock_instance.stop.assert_called_once_with() mock_instance.wait.assert_called_once_with() self.agent.destroy_namespace_agent(self.ctxt, self.port_id) def test_create_destroy_rpc_proxy_receive(self): self.agent.create_namespace_agent(self.ctxt, self.port) with mock.patch('oslo.messaging.proxy.get_proxy_server' ) as mock_get_proxy_server: mock_transport = self.mock_get_transport.return_value mock_instance = mock_get_proxy_server.return_value proxy_id = self.agent.create_rpc_proxy( self.ctxt, self.port_id, 'topic=src_topic,server=src_server', 'topic=dst_topic,server=dst_server', 'receive') src_target = target.Target(topic='src_topic', server='src_server') dst_target = target.Target(topic='dst_topic', server='dst_server') mock_get_proxy_server.assert_called_once_with( mock_transport, dst_target, None, mock_transport, src_target, None, executor=mock.ANY) mock_instance.start.assert_called_once_with() self.agent.destroy_rpc_proxy(self.ctxt, self.port_id, proxy_id) mock_instance.stop.assert_called_once_with() mock_instance.wait.assert_called_once_with() self.agent.destroy_namespace_agent(self.ctxt, self.port_id) def test_create_destroy_rpc_proxy(self): self.mock_device_exists.return_value = False self.agent.create_namespace_agent(self.ctxt, self.port) with mock.patch('oslo.messaging.proxy.get_proxy_server' ) as mock_get_proxy_server: mock_transport = self.mock_get_transport.return_value proxy_id_send = self.agent.create_rpc_proxy( self.ctxt, self.port_id, 'topic=src_topic_send,server=src_server_send', 'topic=dst_topic_send,server=dst_server_send', 'send') src_target_send = target.Target(topic='src_topic_send', server='src_server_send') dst_target_send = target.Target(topic='dst_topic_send', server='dst_server_send') self.agent.create_rpc_proxy( self.ctxt, self.port_id, 'topic=src_topic_receive,server=src_server_receive', 'topic=dst_topic_receive,server=dst_server_receive', 'receive') src_target_recv = target.Target(topic='src_topic_receive', server='src_server_receive') dst_target_recv = target.Target(topic='dst_topic_receive', server='dst_server_receive') self.agent.destroy_rpc_proxy(self.ctxt, self.port_id, proxy_id_send) self.agent.destroy_namespace_agent(self.ctxt, self.port_id) mock_get_proxy_server.assert_has_calls([ mock.call(mock_transport, src_target_send, None, mock_transport, dst_target_send, None, executor=mock.ANY), mock.call().start(), mock.call(mock_transport, dst_target_recv, None, mock_transport, src_target_recv, None, executor=mock.ANY), mock.call().start(), mock.call().stop(), mock.call().wait(), mock.call().stop(), mock.call().wait()]) def _test_create_destroy_rpc_namespace_proxy_direction(self, direction): self.agent.create_namespace_agent(self.ctxt, self.port) src_target = 'topic=src_topic,server=src_server' dst_transport_url = 'rabbit://*****:*****@host:5672' dst_target = 'topic=dst_topic,server=dst_server' ns_proxy_id = self.agent.create_rpc_namespace_proxy( self.ctxt, self.port_id, src_target, dst_transport_url, dst_target, direction) kwargs = { 'src_target': src_target, 'dst_transport_url': dst_transport_url, 'dst_target': dst_target, 'direction': direction, } self.mock_rpc_client_instance.call.assert_called_once_with( {}, 'create_rpc_namespace_proxy', **kwargs) self.agent.destroy_rpc_namespace_proxy(self.ctxt, self.port_id, ns_proxy_id) self.mock_rpc_client_instance.call.assert_has_calls([ mock.call({}, 'create_rpc_namespace_proxy', **kwargs), mock.call({}, 'destroy_rpc_namespace_proxy', namespace_proxy_id=ns_proxy_id)]) self.agent.destroy_namespace_agent(self.ctxt, self.port_id) def test_create_destroy_rpc_namespace_proxy_send(self): self._test_create_destroy_rpc_namespace_proxy_direction('send') def test_create_destroy_rpc_namespace_proxy_receive(self): self._test_create_destroy_rpc_namespace_proxy_direction('receive') def test_create_destroy_rpc_namespace_proxy(self): self.agent.create_namespace_agent(self.ctxt, self.port) src_target_send = 'topic=src_topic_send,server=src_server_send' dst_transport_url_send = 'rabbit://*****:*****@sendhost:5672' dst_target_send = 'topic=dst_topic_send,server=dst_server_send' direction_send = 'send' ns_proxy_id_send = self.agent.create_rpc_namespace_proxy( self.ctxt, self.port_id, src_target_send, dst_transport_url_send, dst_target_send, direction_send) kwargs_send = { 'src_target': src_target_send, 'dst_transport_url': dst_transport_url_send, 'dst_target': dst_target_send, 'direction': direction_send, } src_target_recv = 'topic=src_topic_recv,server=src_server_recv' dst_transport_url_recv = 'rabbit://*****:*****@recvhost:5672' dst_target_recv = 'topic=dst_topic_recv,server=dst_server_recv' direction_recv = 'receive' self.agent.create_rpc_namespace_proxy( self.ctxt, self.port_id, src_target_recv, dst_transport_url_recv, dst_target_recv, direction_recv) kwargs_recv = { 'src_target': src_target_recv, 'dst_transport_url': dst_transport_url_recv, 'dst_target': dst_target_recv, 'direction': direction_recv, } self.agent.destroy_rpc_namespace_proxy(self.ctxt, self.port_id, ns_proxy_id_send) self.agent.destroy_namespace_agent(self.ctxt, self.port_id) self.mock_rpc_client_instance.call.assert_has_calls([ mock.call({}, 'create_rpc_namespace_proxy', **kwargs_send), mock.call({}, 'create_rpc_namespace_proxy', **kwargs_recv), mock.call({}, 'destroy_rpc_namespace_proxy', namespace_proxy_id=ns_proxy_id_send), mock.call({}, 'destroy_namespace_agent')])
def test_context_with_tacker_context(self): ctxt = context.Context('fake_user', 'fake_tenant') self.req.environ['tacker.context'] = ctxt self.assertEqual(self.req.context, ctxt)
def test_context_with_tacker_context(self): self.skip("Not ready yet") ctxt = context.Context('fake_user', 'fake_tenant') self.req.environ['tacker.context'] = ctxt self.assertEqual(ctxt, self.req.context)