def setUp(self):
plugin = 'neutron.tests.unit.extensions.test_l3.TestNoL3NatPlugin'
l3_plugin = ('networking_ovn.l3.l3_ovn.OVNL3RouterPlugin')
service_plugins = {'l3_plugin_name': l3_plugin}
# For these tests we need to enable overlapping ips
cfg.CONF.set_default('allow_overlapping_ips', True)
cfg.CONF.set_default('max_routes', 3)
ext_mgr = test_extraroute.ExtraRouteTestExtensionManager()
super(test_l3.L3BaseForIntTests,
self).setUp(plugin=plugin,
ext_mgr=ext_mgr,
service_plugins=service_plugins)
l3_gw_mgr = test_l3_gw.TestExtensionManager()
test_extensions.setup_extensions_middleware(l3_gw_mgr)
self.l3_inst = directory.get_plugin(plugin_constants.L3)
self._start_mock('networking_ovn.l3.l3_ovn.OVNL3RouterPlugin._ovn',
new_callable=mock.PropertyMock,
return_value=fakes.FakeOvsdbNbOvnIdl())
self._start_mock('networking_ovn.l3.l3_ovn.OVNL3RouterPlugin._sb_ovn',
new_callable=mock.PropertyMock,
return_value=fakes.FakeOvsdbSbOvnIdl())
self._start_mock(
'networking_ovn.l3.l3_ovn_scheduler.'
'OVNGatewayScheduler._schedule_gateway',
return_value='hv1')
self._start_mock(
'networking_ovn.l3.l3_ovn.OVNL3RouterPlugin.'
'_get_v4_network_of_all_router_ports',
return_value=[])
self.setup_notification_driver()
def setUp(self):
super(_TestMaintenanceHelper, self).setUp()
self._ovn_client = self.mech_driver._ovn_client
self._l3_ovn_client = self.l3_plugin._ovn_client
ext_mgr = test_extraroute.ExtraRouteTestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
sg_mgr = test_securitygroup.SecurityGroupTestExtensionManager()
self._sg_api = test_extensions.setup_extensions_middleware(sg_mgr)
self.maint = maintenance.DBInconsistenciesPeriodics(self._ovn_client)
self.context = n_context.get_admin_context()
def setUp(self, plugin=None, service_plugins=None, ext_mgr=None):
service_plugins = {
'gateway_device_plugin_name': DB_GATEWAY_DEVICE_PLUGIN_KLASS
}
gw_dev_mgr = GatewayDeviceTestExtensionManager()
super(GatewayDeviceTestCase,
self).setUp(service_plugins=service_plugins, ext_mgr=gw_dev_mgr)
self.ext_api = test_ex.setup_extensions_middleware(gw_dev_mgr)
network = self._make_network(self.fmt, 'net1', True)
self._subnet = self._make_subnet(self.fmt, network, "10.0.0.1",
'10.0.0.0/24')
self._subnet_id = self._subnet['subnet']['id']
router1 = self._make_router(self.fmt, uuidutils.generate_uuid(),
'router1', True)
self._router_id = router1['router']['id']
router2 = self._make_router(self.fmt, uuidutils.generate_uuid(),
'router2', True)
self._router_id_in_use = router2['router']['id']
self._router_interface_action('add', self._router_id_in_use,
self._subnet_id, None)
# for network_vlan gateway device setting
res = self._create_network(self.fmt, 'gateway_network_vlan', True)
self._network_id = self.deserialize(self.fmt, res)['network']['id']
def setUp(self):
super(TestOvnNbSync, self).setUp()
ext_mgr = test_extraroute.ExtraRouteTestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.create_lswitches = []
self.create_lswitch_ports = []
self.create_lrouters = []
self.create_lrouter_ports = []
self.create_lrouter_routes = []
self.update_lrouter_ports = []
self.create_acls = []
self.delete_lswitches = []
self.delete_lswitch_ports = []
self.delete_lrouters = []
self.delete_lrouter_ports = []
self.delete_lrouter_routes = []
self.delete_acls = []
self.create_address_sets = []
self.delete_address_sets = []
self.update_address_sets = []
self.expected_dhcp_options_rows = []
self.reset_lport_dhcpv4_options = []
self.stale_lport_dhcpv4_options = []
self.orphaned_lport_dhcpv4_options = []
self.lport_dhcpv4_disabled = {}
self.missed_dhcpv4_options = []
self.dirty_dhcpv4_options = []
def setUp(self, plugin=None, service_plugins=None, ext_mgr=None):
service_plugins = {
'gateway_device_plugin_name': DB_GATEWAY_DEVICE_PLUGIN_KLASS}
gw_dev_mgr = GatewayDeviceTestExtensionManager()
super(GatewayDeviceTestCase,
self).setUp(service_plugins=service_plugins,
ext_mgr=gw_dev_mgr)
self.ext_api = test_ex.setup_extensions_middleware(gw_dev_mgr)
network = self._make_network(self.fmt, 'net1', True)
self._subnet = self._make_subnet(self.fmt, network, "10.0.0.1",
'10.0.0.0/24')
self._subnet_id = self._subnet['subnet']['id']
router1 = self._make_router(self.fmt, str(uuid.uuid4()),
'router1', True)
self._router_id = router1['router']['id']
router2 = self._make_router(self.fmt, str(uuid.uuid4()),
'router2', True)
self._router_id_in_use = router2['router']['id']
self._router_interface_action('add', self._router_id_in_use,
self._subnet_id, None)
# for network_vlan gateway device setting
res = self._create_network(self.fmt, 'gateway_network_vlan',
True)
self._network_id = self.deserialize(self.fmt, res)['network']['id']
def setUp(self, plugin=None, ext_mgr=None):
service_plugins = {'l2gw_plugin_name': MN_PLUGIN_KLASS,
'gateway_device_plugin_name':
test_gw.DB_GATEWAY_DEVICE_PLUGIN_KLASS}
l2gw_provider = (l2gw_consts.L2GW + ':' +
mido_const.MIDONET_L2GW_PROVIDER +
':' + MN_DRIVER_KLASS + ':default')
mock.patch.object(provconf.NeutronModule, 'service_providers',
return_value=[l2gw_provider]).start()
manager = st_db.ServiceTypeManager.get_instance()
manager.add_provider_configuration(
l2gw_consts.L2GW, provconf.ProviderConfiguration())
l2_gw_mgr = MidonetL2GatewayTestExtensionManager()
super(MidonetL2GatewayTestCase, self).setUp(
service_plugins=service_plugins, ext_mgr=l2_gw_mgr)
self.ext_api = test_ex.setup_extensions_middleware(l2_gw_mgr)
network = self._make_network(self.fmt, 'net1', True)
self._network_id = network['network']['id']
self._subnet = self._make_subnet(self.fmt, network, "10.0.0.1",
'10.0.0.0/24')
self._subnet_id = self._subnet['subnet']['id']
router1 = self._make_router('json', str(uuid.uuid4()),
'router1', True)
self._router_id = router1['router']['id']
router2 = self._make_router('json', str(uuid.uuid4()),
'router2', True)
self._router_id2 = router2['router']['id']
def setUp(self):
super(ProvidernetExtensionTestCase, self).setUp()
plugin = 'neutron.neutron_plugin_base_v2.NeutronPluginBaseV2'
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
self.useFixture(fixture.APIDefinitionFixture())
# Update the plugin and extensions path
self.setup_coreplugin(plugin, load_plugins=False)
self._plugin_patcher = mock.patch(plugin, autospec=True)
self.plugin = self._plugin_patcher.start()
# Ensure Quota checks never fail because of mock
instance = self.plugin.return_value
instance.get_networks_count.return_value = 1
# Register mock plugin and enable the 'provider' extension
instance.supported_extension_aliases = ["provider"]
directory.add_plugin(constants.CORE, instance)
ext_mgr = ProviderExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.addCleanup(self._plugin_patcher.stop)
self.api = webtest.TestApp(router.APIRouter())
quota.QUOTAS._driver = None
cfg.CONF.set_override('quota_driver', 'neutron.quota.ConfDriver',
group='QUOTAS')
def setUp(self):
# Save the global RESOURCE_ATTRIBUTE_MAP
self.saved_attr_map = {}
for resource, attrs in attributes.RESOURCE_ATTRIBUTE_MAP.iteritems():
self.saved_attr_map[resource] = attrs.copy()
service_plugins = {
'lb_plugin_name': test_db_loadbalancer.DB_LB_PLUGIN_KLASS
}
#default provider should support agent scheduling
cfg.CONF.set_override('service_provider',
[('LOADBALANCER:lbaas:neutron_lbaas.services.'
'loadbalancer.drivers.haproxy.plugin_driver.'
'HaproxyOnHostPluginDriver:default')],
'service_providers')
# need to reload provider configuration
st_db.ServiceTypeManager._instance = None
super(LBaaSAgentSchedulerTestCase,
self).setUp(self.plugin_str, service_plugins=service_plugins)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.adminContext = context.get_admin_context()
# Add the resources to the global attribute map
# This is done here as the setup process won't
# initialize the main API router which extends
# the global attribute map
attributes.RESOURCE_ATTRIBUTE_MAP.update(agent.RESOURCE_ATTRIBUTE_MAP)
self.addCleanup(self.restore_attribute_map)
def setUp(self):
# Save the global RESOURCE_ATTRIBUTE_MAP
self.saved_attr_map = {}
for resource, attrs in attributes.RESOURCE_ATTRIBUTE_MAP.iteritems():
self.saved_attr_map[resource] = attrs.copy()
service_plugins = {
'lb_plugin_name': test_db_loadbalancer.DB_LB_PLUGIN_KLASS}
#default provider should support agent scheduling
cfg.CONF.set_override(
'service_provider',
[('LOADBALANCER:lbaas:neutron_lbaas.services.'
'loadbalancer.drivers.haproxy.plugin_driver.'
'HaproxyOnHostPluginDriver:default')],
'service_providers')
# need to reload provider configuration
st_db.ServiceTypeManager._instance = None
super(LBaaSAgentSchedulerTestCase, self).setUp(
self.plugin_str, service_plugins=service_plugins)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.adminContext = context.get_admin_context()
# Add the resources to the global attribute map
# This is done here as the setup process won't
# initialize the main API router which extends
# the global attribute map
attributes.RESOURCE_ATTRIBUTE_MAP.update(
agent.RESOURCE_ATTRIBUTE_MAP)
self.addCleanup(self.restore_attribute_map)
def setUp(self):
super(TestOvnNbSync, self).setUp()
ext_mgr = test_extraroute.ExtraRouteTestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.create_lswitches = []
self.create_lswitch_ports = []
self.create_lrouters = []
self.create_lrouter_ports = []
self.create_lrouter_routes = []
self.update_lrouter_ports = []
self.create_acls = []
self.delete_lswitches = []
self.delete_lswitch_ports = []
self.delete_lrouters = []
self.delete_lrouter_ports = []
self.delete_lrouter_routes = []
self.delete_acls = []
self.create_address_sets = []
self.delete_address_sets = []
self.update_address_sets = []
self.expected_dhcp_options_rows = []
self.reset_lport_dhcpv4_options = []
self.reset_lport_dhcpv6_options = []
self.stale_lport_dhcpv4_options = []
self.stale_lport_dhcpv6_options = []
self.orphaned_lport_dhcp_options = []
self.lport_dhcpv4_disabled = {}
self.lport_dhcpv6_disabled = {}
self.missed_dhcp_options = []
self.dirty_dhcp_options = []
def setUp(self):
# Save the global RESOURCE_ATTRIBUTE_MAP
self.saved_attr_map = {}
for res, attrs in six.iteritems(attributes.RESOURCE_ATTRIBUTE_MAP):
self.saved_attr_map[res] = attrs.copy()
service_plugins = {
'lb_plugin_name': test_db_loadbalancerv2.DB_LB_PLUGIN_CLASS
}
# default provider should support agent scheduling
self.set_override([
('LOADBALANCERV2:lbaas:neutron_lbaas.drivers.haproxy.'
'plugin_driver.HaproxyOnHostPluginDriver:default')
])
super(LBaaSAgentSchedulerTestCase,
self).setUp(self.plugin_str, service_plugins=service_plugins)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.adminContext = context.get_admin_context()
# Add the resources to the global attribute map
# This is done here as the setup process won't
# initialize the main API router which extends
# the global attribute map
attributes.RESOURCE_ATTRIBUTE_MAP.update(agent.RESOURCE_ATTRIBUTE_MAP)
self.lbaas_plugin = directory.get_plugin(plugin_const.LOADBALANCERV2)
self.core_plugin = directory.get_plugin()
self.addCleanup(self.restore_attribute_map)
def setUp(self,
core_plugin=None,
sc_plugin=None,
service_plugins=None,
ext_mgr=None,
gp_plugin=None):
if not sc_plugin:
sc_plugin = DB_GP_PLUGIN_KLASS
if not service_plugins:
service_plugins = {
'l3_plugin_name': 'router',
'gp_plugin_name': gp_plugin or GP_PLUGIN_KLASS,
'sc_plugin_name': sc_plugin
}
super(ServiceChainDbTestCase,
self).setUp(plugin=core_plugin,
ext_mgr=ext_mgr,
service_plugins=service_plugins)
self.plugin = importutils.import_object(sc_plugin)
if not ext_mgr:
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
engine = db_api.get_engine()
model_base.BASEV2.metadata.create_all(engine)
def setUp(self):
super(ProvidernetExtensionTestCase, self).setUp()
plugin = 'neutron.neutron_plugin_base_v2.NeutronPluginBaseV2'
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
self.useFixture(tools.AttributeMapMemento())
# Update the plugin and extensions path
self.setup_coreplugin(plugin)
cfg.CONF.set_override('allow_pagination', True)
cfg.CONF.set_override('allow_sorting', True)
self._plugin_patcher = mock.patch(plugin, autospec=True)
self.plugin = self._plugin_patcher.start()
# Ensure Quota checks never fail because of mock
instance = self.plugin.return_value
instance.get_networks_count.return_value = 1
# Instantiate mock plugin and enable the 'provider' extension
manager.NeutronManager.get_plugin().supported_extension_aliases = (
["provider"])
ext_mgr = ProviderExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.addCleanup(self._plugin_patcher.stop)
self.api = webtest.TestApp(router.APIRouter())
quota.QUOTAS._driver = None
cfg.CONF.set_override('quota_driver', 'neutron.quota.ConfDriver',
group='QUOTAS')
def setUp(self):
super(ProvidernetExtensionTestCase, self).setUp()
plugin = 'neutron.neutron_plugin_base_v2.NeutronPluginBaseV2'
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
self.useFixture(tools.AttributeMapMemento())
# Update the plugin and extensions path
self.setup_coreplugin(plugin)
cfg.CONF.set_override('allow_pagination', True)
cfg.CONF.set_override('allow_sorting', True)
self._plugin_patcher = mock.patch(plugin, autospec=True)
self.plugin = self._plugin_patcher.start()
# Ensure Quota checks never fail because of mock
instance = self.plugin.return_value
instance.get_networks_count.return_value = 1
# Instantiate mock plugin and enable the 'provider' extension
manager.NeutronManager.get_plugin().supported_extension_aliases = ([
"provider"
])
ext_mgr = ProviderExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.addCleanup(self._plugin_patcher.stop)
self.api = webtest.TestApp(router.APIRouter())
quota.QUOTAS._driver = None
cfg.CONF.set_override('quota_driver',
'neutron.quota.ConfDriver',
group='QUOTAS')
def setUp(self):
# Save the global RESOURCE_ATTRIBUTE_MAP
self.saved_attr_map = {}
for res, attrs in six.iteritems(attributes.RESOURCE_ATTRIBUTE_MAP):
self.saved_attr_map[res] = attrs.copy()
service_plugins = {
'lb_plugin_name': test_db_loadbalancerv2.DB_LB_PLUGIN_CLASS}
# default provider should support agent scheduling
self.set_override(
[('LOADBALANCERV2:lbaas:neutron_lbaas.drivers.haproxy.'
'plugin_driver.HaproxyOnHostPluginDriver:default')])
super(LBaaSAgentSchedulerTestCase, self).setUp(
self.plugin_str, service_plugins=service_plugins)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.adminContext = context.get_admin_context()
# Add the resources to the global attribute map
# This is done here as the setup process won't
# initialize the main API router which extends
# the global attribute map
attributes.RESOURCE_ATTRIBUTE_MAP.update(
agent.RESOURCE_ATTRIBUTE_MAP)
self.lbaas_plugin = manager.NeutronManager.get_service_plugins()[
plugin_const.LOADBALANCERV2]
self.core_plugin = manager.NeutronManager.get_plugin()
self.addCleanup(self.restore_attribute_map)
def setUp(self):
mock.patch('neutron.api.rpc.handlers.resources_rpc.'
'ResourcesPushRpcApi').start()
svc_plugins = {'port_forwarding': PLUGIN_NAME}
ext_mgr = test_fip_pf.ExtendFipPortForwardingExtensionManager()
super(FloatingIPPorForwardingTestCase,
self).setUp(ext_mgr=ext_mgr, service_plugins=svc_plugins)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self):
mock.patch('neutron.api.rpc.handlers.resources_rpc.'
'ResourcesPushRpcApi').start()
svc_plugins = {'port_forwarding': PLUGIN_NAME}
ext_mgr = test_fip_pf.ExtendFipPortForwardingExtensionManager()
super(FloatingIPPorForwardingTestCase, self).setUp(
ext_mgr=ext_mgr, service_plugins=svc_plugins)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self):
super(TestDFL3RouterPlugin, self).setUp()
self.l3p = directory.get_plugin('L3_ROUTER_NAT')
self.nb_api = self.l3p.nb_api
self.nb_api.get().unique_key = 5
self.nb_api.get().topic = 'topic'
self.ext_api = test_extensions.setup_extensions_middleware(
test_l3.L3TestExtensionManager())
def setUp(self):
self.addCleanup(self._cleanup)
test_db_base_plugin_v2.NeutronDbPluginV2TestCase.quota_db_driver = (
'neutron.db.quota.driver.DbQuotaDriver')
super(TestL3ResourcesEventHandler, self).setUp()
self.useFixture(fixture.APIDefinitionFixture())
ext_mgr = test_l3.L3TestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
quota.QUOTAS._driver = None
def setUp(self, **kwargs):
super().setUp(**kwargs)
self.chassis = self.add_fake_chassis('ovs-host1',
enable_chassis_as_gw=True)
self.l3_plugin = directory.get_plugin(plugin_constants.L3)
ext_mgr = test_l3.L3TestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.handler = event.RowEventHandler()
self.sb_api.idl.notify = self.handler.notify
def setUp(self):
super(QoSDriverTests, self).setUp()
self.qos_plug = qos_plugin.QoSPlugin()
directory.add_plugin('QOS', self.qos_plug)
ext_mgr = QoSTestExtensionManager()
self.resource_prefix_map = {'policies': '/qos'}
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
tenant_id = uuidutils.generate_uuid()
self.policy_data = {
'policy': {'name': 'test-policy', 'tenant_id': tenant_id}}
def setUp(self):
super(_TestMaintenanceHelper, self).setUp()
self._ovn_client = self.mech_driver._ovn_client
self._l3_ovn_client = self.l3_plugin._ovn_client
ext_mgr = test_extraroute.ExtraRouteTestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.maint = maintenance.DBInconsistenciesPeriodics(self._ovn_client)
self.context = n_context.get_admin_context()
# Always verify inconsistencies for all objects.
db_rev.INCONSISTENCIES_OLDER_THAN = -1
def setUp(self):
# Enable the test mechanism driver to ensure that
# we can successfully call through to all mechanism
# driver apis.
config.cfg.CONF.set_override('mechanism_drivers',
self._mechanism_drivers,
group='ml2')
self.setup_parent()
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.adminContext = context.get_admin_context()
def setUp(self, plugin=None, service_plugins=None, ext_mgr=None):
service_plugins = {'bgp_plugin_name': BGP_PLUGIN_KLASS}
bgp_mgr = BgpTestExtensionManager()
super(BgpTestCase, self).setUp(
service_plugins=service_plugins, ext_mgr=bgp_mgr)
self.ext_api = test_ex.setup_extensions_middleware(bgp_mgr)
self.bgp_plugin = bgp_plugin.MidonetBgpPlugin()
network = self._make_network(self.fmt, 'net1', True)
self._subnet = self._make_subnet(self.fmt, network, "192.168.0.1",
'192.168.0.0/24')
self._subnet_id = self._subnet['subnet']['id']
network = self._make_network(self.fmt, 'net2', True)
self._subnet = self._make_subnet(self.fmt, network, "192.168.1.1",
'192.168.1.0/24')
self._subnet_id2 = self._subnet['subnet']['id']
network = self._make_network(self.fmt, 'net3', True)
self._subnet = self._make_subnet(self.fmt, network, "192.168.2.1",
'192.168.2.0/24')
self._subnet_id3 = self._subnet['subnet']['id']
port = self._make_port(self.fmt, network['network']['id'])
self._port_id = port['port']['id']
self._port_fixed_ip = port['port']['fixed_ips'][0]['ip_address']
router1 = self._make_router(self.fmt, str(uuid.uuid4()),
'router1', True)
self._router_id = router1['router']['id']
router2 = self._make_router(self.fmt, str(uuid.uuid4()),
'router2', True)
self._router_id2 = router2['router']['id']
self._router_interface_action('add', self._router_id, self._subnet_id,
None)
self._router_interface_action('add', self._router_id, self._subnet_id2,
None)
self._router_interface_action('add', self._router_id, self._subnet_id3,
None)
self._router_interface_action('add', self._router_id2, None,
self._port_id)
# for non-router use case
ext_net = self._make_network(self.fmt, 'ext_net2', True)
self._set_net_external(ext_net['network']['id'])
self._ext_net_id = ext_net['network']['id']
self._ext_subnet = self._make_subnet(self.fmt, ext_net, "100.65.0.1",
'100.65.0.0/24')
self._ext_subnet_id = self._ext_subnet['subnet']['id']
edge_router = self._make_router(self.fmt, str(uuid.uuid4()),
'edge_router', True)
self._edge_router_id = edge_router['router']['id']
self._router_interface_action('add', self._edge_router_id,
self._ext_subnet_id, None)
def setUp(self, plugin=None, service_plugins=None, ext_mgr=None):
service_plugins = {'bgp_plugin_name': BGP_PLUGIN_KLASS}
bgp_mgr = BgpTestExtensionManager()
super(BgpTestCaseMixin, self).setUp(service_plugins=service_plugins,
ext_mgr=bgp_mgr)
self.ext_api = test_ex.setup_extensions_middleware(bgp_mgr)
self.bgp_plugin = bgp_plugin.MidonetBgpPlugin()
network = self._make_network(self.fmt, 'net1', True)
self._subnet = self._make_subnet(self.fmt, network, "192.168.0.1",
'192.168.0.0/24')
self._subnet_id = self._subnet['subnet']['id']
network = self._make_network(self.fmt, 'net2', True)
self._subnet = self._make_subnet(self.fmt, network, "192.168.1.1",
'192.168.1.0/24')
self._subnet_id2 = self._subnet['subnet']['id']
network = self._make_network(self.fmt, 'net3', True)
self._subnet = self._make_subnet(self.fmt, network, "192.168.2.1",
'192.168.2.0/24')
self._subnet_id3 = self._subnet['subnet']['id']
port = self._make_port(self.fmt, network['network']['id'])
self._port_id = port['port']['id']
self._port_fixed_ip = port['port']['fixed_ips'][0]['ip_address']
router1 = self._make_router(self.fmt, uuidutils.generate_uuid(),
'router1', True)
self._router_id = router1['router']['id']
router2 = self._make_router(self.fmt, uuidutils.generate_uuid(),
'router2', True)
self._router_id2 = router2['router']['id']
self._router_interface_action('add', self._router_id, self._subnet_id,
None)
self._router_interface_action('add', self._router_id, self._subnet_id2,
None)
self._router_interface_action('add', self._router_id, self._subnet_id3,
None)
self._router_interface_action('add', self._router_id2, None,
self._port_id)
# for non-router use case
ext_net = self._make_network(self.fmt, 'ext_net2', True)
self._set_net_external(ext_net['network']['id'])
self._ext_net_id = ext_net['network']['id']
self._ext_subnet = self._make_subnet(self.fmt, ext_net, "100.65.0.1",
'100.65.0.0/24')
self._ext_subnet_id = self._ext_subnet['subnet']['id']
edge_router = self._make_router(self.fmt, uuidutils.generate_uuid(),
'edge_router', True)
self._edge_router_id = edge_router['router']['id']
self._router_interface_action('add', self._edge_router_id,
self._ext_subnet_id, None)
def setUp(self, plugin=None, service_plugins=None, ext_mgr=None):
ext_mgr = TaasExtensionManager()
service_plugins = {'taas_plugin_name': DB_TAAS_PLUGIN_KLASS}
taas_provider = (taas_const.TAAS + ':BSN:' + BSN_TAAS_DRIVER_KLASS
+ ':default')
mock.patch.object(provconf.NeutronModule, 'service_providers',
return_value=[taas_provider]).start()
manager = sdb.ServiceTypeManager.get_instance()
manager.add_provider_configuration(
taas_const.TAAS, provconf.ProviderConfiguration())
super(TestBSNTaasCase,
self).setUp(service_plugins=service_plugins,
ext_mgr=ext_mgr)
self.ext_api = test_ex.setup_extensions_middleware(ext_mgr)
def setUp(self):
super(TestOvnNbSync, self).setUp()
ext_mgr = test_extraroute.ExtraRouteTestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.create_lswitches = []
self.create_lswitch_ports = []
self.create_lrouters = []
self.create_lrouter_ports = []
self.create_lrouter_routes = []
self.delete_lswitches = []
self.delete_lswitch_ports = []
self.delete_lrouters = []
self.delete_lrouter_ports = []
self.delete_lrouter_routes = []
def setUp(self, plugin=None, service_plugins=None, ext_mgr=None):
ext_mgr = TaasExtensionManager()
service_plugins = {'taas_plugin_name': DB_TAAS_PLUGIN_KLASS}
taas_provider = (taas_const.TAAS + ':BSN:' + BSN_TAAS_DRIVER_KLASS +
':default')
mock.patch.object(provconf.NeutronModule,
'service_providers',
return_value=[taas_provider]).start()
manager = sdb.ServiceTypeManager.get_instance()
manager.add_provider_configuration(taas_const.TAAS,
provconf.ProviderConfiguration())
super(TestBSNTaasCase, self).setUp(service_plugins=service_plugins,
ext_mgr=ext_mgr)
self.ext_api = test_ex.setup_extensions_middleware(ext_mgr)
def setUp(self):
mock.patch('neutron.api.rpc.handlers.resources_rpc.'
'ResourcesPushRpcApi').start()
svc_plugins = ('neutron.services.conntrack_helper.plugin.Plugin',
'neutron.tests.unit.extensions.'
'test_l3_conntrack_helper.'
'TestL3ConntrackHelperServicePlugin')
plugin = ('neutron.tests.unit.extensions.test_l3.TestL3NatIntPlugin')
ext_mgr = ExtendL3ConntrackHelperExtensionManager()
super(L3NConntrackHelperTestCase,
self).setUp(ext_mgr=ext_mgr,
service_plugins=svc_plugins,
plugin=plugin)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self):
super(TestOvnNbSync, self).setUp()
ext_mgr = test_extraroute.ExtraRouteTestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.create_lswitches = []
self.create_lswitch_ports = []
self.create_lrouters = []
self.create_lrouter_ports = []
self.create_lrouter_routes = []
self.delete_lswitches = []
self.delete_lswitch_ports = []
self.delete_lrouters = []
self.delete_lrouter_ports = []
self.delete_lrouter_routes = []
def setUp(self):
# This is needed because otherwise a failure will occur due to
# nonexisting core_plugin
self.setup_coreplugin(test_db_base_plugin_v2.DB_PLUGIN_KLASS)
cfg.CONF.set_override(
'service_plugins',
["%s.%s" % (dp.__name__, dp.DummyServicePlugin.__name__)])
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
ext_mgr = TestServiceTypeExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.api = webtest.TestApp(self.ext_mdw)
self.resource_name = servicetype.RESOURCE_NAME.replace('-', '_')
super(ServiceTypeExtensionTestCaseBase, self).setUp()
def setUp(self):
# This is needed because otherwise a failure will occur due to
# nonexisting core_plugin
self.setup_coreplugin(test_db_base_plugin_v2.DB_PLUGIN_KLASS)
cfg.CONF.set_override('service_plugins',
["%s.%s" % (dp.__name__,
dp.DummyServicePlugin.__name__)])
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
ext_mgr = TestServiceTypeExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.api = webtest.TestApp(self.ext_mdw)
self.resource_name = servicetype.RESOURCE_NAME.replace('-', '_')
super(ServiceTypeExtensionTestCaseBase, self).setUp()
def setUp(self):
# Enable the test mechanism driver to ensure that
# we can successfully call through to all mechanism
# driver apis.
cfg.CONF.set_override('mechanism_drivers', ['logger_plus', 'test'],
group='ml2')
cfg.CONF.set_override('network_vlan_ranges', ['physnet1:1000:1099'],
group='ml2_type_vlan')
extensions.append_api_extensions_path(
gbpservice.neutron.extensions.__path__)
super(Ml2PlusPluginV2TestCase, self).setUp(PLUGIN_NAME)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.port_create_status = 'DOWN'
self.plugin = directory.get_plugin()
def setUp(self):
# Enable the test mechanism driver to ensure that
# we can successfully call through to all mechanism
# driver apis.
cfg.CONF.set_override('mechanism_drivers',
['logger_plus', 'test'], group='ml2')
cfg.CONF.set_override('network_vlan_ranges',
['physnet1:1000:1099'], group='ml2_type_vlan')
extensions.append_api_extensions_path(
gbpservice.neutron.extensions.__path__)
super(Ml2PlusPluginV2TestCase, self).setUp(PLUGIN_NAME)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.port_create_status = 'DOWN'
self.plugin = directory.get_plugin()
def setUp(self):
service_plugins = {
'lb_plugin_name': test_db_loadbalancerv2.DB_LB_PLUGIN_CLASS}
# default provider should support agent scheduling
self.set_override(
[('LOADBALANCERV2:lbaas:neutron_lbaas.drivers.haproxy.'
'plugin_driver.HaproxyOnHostPluginDriver:default')])
super(LBaaSAgentSchedulerTestCase, self).setUp(
self.plugin_str, service_plugins=service_plugins)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.adminContext = context.get_admin_context()
self.lbaas_plugin = directory.get_plugin(plugin_const.LOADBALANCERV2)
self.core_plugin = directory.get_plugin()
def setUp(self):
# Enable the test mechanism driver to ensure that
# we can successfully call through to all mechanism
# driver apis.
config.cfg.CONF.set_override('mechanism_drivers',
['logger', 'apic_aim'],
'ml2')
config.cfg.CONF.set_override('extension_drivers',
['apic_aim'],
'ml2')
config.cfg.CONF.set_override('type_drivers',
['opflex', 'local', 'vlan'],
'ml2')
config.cfg.CONF.set_override('tenant_network_types',
['opflex'],
'ml2')
config.cfg.CONF.set_override('network_vlan_ranges',
['physnet1:1000:1099'],
group='ml2_type_vlan')
service_plugins = {
'L3_ROUTER_NAT':
'gbpservice.neutron.services.apic_aim.l3_plugin.ApicL3Plugin'}
super(ApicAimTestCase, self).setUp(PLUGIN_NAME,
service_plugins=service_plugins)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.port_create_status = 'DOWN'
self.saved_keystone_client = ksc_client.Client
ksc_client.Client = FakeKeystoneClient
engine = db_api.get_engine()
aim_model_base.Base.metadata.create_all(engine)
self.plugin = manager.NeutronManager.get_plugin()
self.plugin.start_rpc_listeners()
self.driver = self.plugin.mechanism_manager.mech_drivers[
'apic_aim'].obj
self.l3_plugin = manager.NeutronManager.get_service_plugins()[
service_constants.L3_ROUTER_NAT]
self.aim_mgr = aim_manager.AimManager()
self._app_profile_name = 'NeutronAP'
self._tenant_name = self._map_name({'id': 'test-tenant',
'name': 'TestTenantName'})
self._unrouted_vrf_name = 'UnroutedVRF'
def setUp(self, plugin=None, service_plugins=None, ext_mgr=None):
service_plugins = {
'gateway_device_plugin_name': DB_GATEWAY_DEVICE_PLUGIN_KLASS}
gw_dev_mgr = GatewayDeviceTestExtensionManager()
super(GatewayDeviceTestCaseWithML2,
self).setUp(service_plugins=service_plugins,
ext_mgr=gw_dev_mgr)
self.ext_api = test_ex.setup_extensions_middleware(gw_dev_mgr)
network = self._make_network(self.fmt, 'net1', True)
self._subnet = self._make_subnet(self.fmt, network, "10.0.0.1",
'10.0.0.0/24')
self._subnet_id = self._subnet['subnet']['id']
self._network_id = self._make_network(self.fmt,
'gateway_network_vlan', True)[
'network']['id']
def setUp(self, core_plugin=None, sc_plugin=None, service_plugins=None,
ext_mgr=None, gp_plugin=None):
if not sc_plugin:
sc_plugin = DB_GP_PLUGIN_KLASS
if not service_plugins:
service_plugins = {
'l3_plugin_name': 'router',
'gp_plugin_name': gp_plugin or GP_PLUGIN_KLASS,
'sc_plugin_name': sc_plugin}
super(ServiceChainDbTestCase, self).setUp(
plugin=core_plugin, ext_mgr=ext_mgr,
service_plugins=service_plugins
)
self.plugin = importutils.import_object(sc_plugin)
if not ext_mgr:
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
engine = db_api.get_engine()
model_base.BASEV2.metadata.create_all(engine)
def setUp(self):
mock.patch('neutron.api.rpc.handlers.resources_rpc.'
'ResourcesPushRpcApi').start()
svc_plugins = ('neutron.services.ndp_proxy.plugin.NDPProxyPlugin',)
plugin = ('neutron.tests.unit.extensions.'
'test_l3_ndp_proxy.TestL3NDPProxyIntPlugin')
ext_mgr = ExtendL3NDPPRroxyExtensionManager()
super(L3NDPProxyTestCase, self).setUp(
ext_mgr=ext_mgr, service_plugins=svc_plugins, plugin=plugin)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
self.ext_net = self._make_network(self.fmt, 'ext-net', True)
self.ext_net_id = self.ext_net['network']['id']
self._set_net_external(self.ext_net_id)
self._ext_subnet_v4 = self._make_subnet(
self.fmt, self.ext_net, gateway="10.0.0.1",
cidr="10.0.0.0/24")
self._ext_subnet_v4_id = self._ext_subnet_v4['subnet']['id']
self._ext_subnet_v6 = self._make_subnet(
self.fmt, self.ext_net, gateway="2001::1:1",
cidr="2001::1:0/112",
ip_version=constants.IP_VERSION_6,
ipv6_ra_mode=constants.DHCPV6_STATEFUL,
ipv6_address_mode=constants.DHCPV6_STATEFUL)
self._ext_subnet_v6_id = self._ext_subnet_v6['subnet']['id']
self.router1 = self._make_router(self.fmt, self.tenant_id)
self.router1_id = self.router1['router']['id']
self.private_net = self._make_network(self.fmt, 'private-net', True)
self.private_subnet = self._make_subnet(
self.fmt, self.private_net, gateway="2001::2:1",
cidr="2001::2:0/112",
ip_version=constants.IP_VERSION_6,
ipv6_ra_mode=constants.DHCPV6_STATEFUL,
ipv6_address_mode=constants.DHCPV6_STATEFUL)
self._update_router(
self.router1_id,
{'external_gateway_info': {'network_id': self.ext_net_id},
'enable_ndp_proxy': True})
self._router_interface_action(
'add', self.router1_id,
self.private_subnet['subnet']['id'], None)
def setUp(self, plugin=None, ext_mgr=None):
service_plugins = {'l2gw_plugin_name': MN_PLUGIN_KLASS,
'gateway_device_plugin_name':
test_gw.DB_GATEWAY_DEVICE_PLUGIN_KLASS}
l2gw_provider = (l2gw_consts.L2GW + ':' +
mido_const.MIDONET_L2GW_PROVIDER +
':' + MN_DRIVER_KLASS + ':default')
mock.patch.object(provconf.NeutronModule, 'service_providers',
return_value=[l2gw_provider]).start()
manager = st_db.ServiceTypeManager.get_instance()
manager.add_provider_configuration(
l2gw_consts.L2GW, provconf.ProviderConfiguration())
l2_gw_mgr = MidonetL2GatewayTestExtensionManager()
super(MidonetL2GatewayTestCaseMixin, self).setUp(
service_plugins=service_plugins, ext_mgr=l2_gw_mgr)
self.ext_api = test_ex.setup_extensions_middleware(l2_gw_mgr)
network = self._make_network(self.fmt, 'net1', True)
self._network_id = network['network']['id']
self._subnet = self._make_subnet(self.fmt, network, "10.0.0.1",
'10.0.0.0/24')
self._subnet_id = self._subnet['subnet']['id']
network2 = self._make_network(self.fmt, 'net2', True)
self._network_id2 = network2['network']['id']
self._subnet2 = self._make_subnet(self.fmt, network2, "20.0.0.1",
'20.0.0.0/24')
self._subnet_id2 = self._subnet2['subnet']['id']
router1 = self._make_router('json', uuidutils.generate_uuid(),
'router1', True)
self._router_id = router1['router']['id']
router2 = self._make_router('json', uuidutils.generate_uuid(),
'router2', True)
self._router_id2 = router2['router']['id']
# for network_vlan gateway device setting
res = self._create_network(self.fmt, 'gateway_network_vlan', True)
self._vlan_network_id = self.deserialize(
self.fmt, res)['network']['id']
def setUp(self):
service_plugins = {
'lb_plugin_name': test_db_loadbalancer.DB_LB_PLUGIN_KLASS}
lbaas_provider = (constants.LOADBALANCER + ':lbaas:' +
MN_DRIVER_KLASS + ':default')
mock.patch.object(provconf.NeutronModule, 'service_providers',
return_value=[lbaas_provider]).start()
manager = st_db.ServiceTypeManager.get_instance()
manager.add_provider_configuration(
constants.LOADBALANCER, provconf.ProviderConfiguration())
ext_mgr = LoadbalancerTestExtensionManager()
super(LoadbalancerTestCase, self).setUp(
service_plugins=service_plugins, ext_mgr=ext_mgr)
self.ext_api = test_ex.setup_extensions_middleware(ext_mgr)
# Subnet and router must always exist and associated
network = self._make_network(self.fmt, 'net1', True)
self._subnet = self._make_subnet(self.fmt, network, "10.0.0.1",
'10.0.0.0/24')
self._subnet_id = self._subnet['subnet']['id']
router = self._make_router(self.fmt, self._tenant_id, 'router1', True)
self._router_id = router['router']['id']
self._router_interface_action('add', self._router_id, self._subnet_id,
None)
# Also prepare external network and subnet which are needed for VIP
ext_network = self._make_network(self.fmt, 'ext_net1', True)
self._set_net_external(ext_network['network']['id'])
self._ext_subnet = self._make_subnet(self.fmt, ext_network,
"200.0.0.1", '200.0.0.0/24')
# Router must have gateway set for VIP - Pool association
self._add_external_gateway_to_router(self._router_id,
ext_network['network']['id'])
# Override the default subnet ID used in the upstream load balancer
# tests so that the midonet-specific tests use the specific subnet
# created in the setup
test_db_loadbalancer._subnet_id = self._subnet_id
def setUp(self, plugin=None, ext_mgr=None):
service_plugins = {
"l2gw_plugin_name": MN_PLUGIN_KLASS,
"gateway_device_plugin_name": test_gw.DB_GATEWAY_DEVICE_PLUGIN_KLASS,
}
l2gw_provider = l2gw_consts.L2GW + ":l2gw:" + MN_DRIVER_KLASS + ":default"
mock.patch.object(provconf.NeutronModule, "service_providers", return_value=[l2gw_provider]).start()
manager = st_db.ServiceTypeManager.get_instance()
manager.add_provider_configuration(l2gw_consts.L2GW, provconf.ProviderConfiguration())
l2_gw_mgr = MidonetL2GatewayTestExtensionManager()
super(MidonetL2GatewayTestCase, self).setUp(service_plugins=service_plugins, ext_mgr=l2_gw_mgr)
self.ext_api = test_ex.setup_extensions_middleware(l2_gw_mgr)
network = self._make_network(self.fmt, "net1", True)
self._network_id = network["network"]["id"]
self._subnet = self._make_subnet(self.fmt, network, "10.0.0.1", "10.0.0.0/24")
self._subnet_id = self._subnet["subnet"]["id"]
router1 = self._make_router("json", str(uuid.uuid4()), "router1", True)
self._router_id = router1["router"]["id"]
router2 = self._make_router("json", str(uuid.uuid4()), "router2", True)
self._router_id2 = router2["router"]["id"]
def setUp(self, plugin=None, service_plugins=None, ext_mgr=None):
service_plugins = {
'logging_resource_plugin_name': LOGGING_PLUGIN_KLASS,
'fwaas_plugin_name': 'midonet_firewall'
}
log_res_mgr = LoggingResourceTestExtensionManager()
super(LoggingResourceTestCaseMixin,
self).setUp(service_plugins=service_plugins, ext_mgr=log_res_mgr)
self.ext_api = test_ex.setup_extensions_middleware(log_res_mgr)
router1 = self._make_router(self.fmt, uuidutils.generate_uuid(),
'router1', True)
self._router_id1 = router1['router']['id']
router2 = self._make_router(self.fmt, uuidutils.generate_uuid(),
'router2', True)
self._router_id2 = router2['router']['id']
self._tenant_id1 = uuidutils.generate_uuid()
self._tenant_id2 = uuidutils.generate_uuid()
fw1 = self._create_firewall(self._tenant_id1)
self._fw_id1 = fw1['firewall']['id']
fw2 = self._create_firewall(self._tenant_id1)
self._fw_id2 = fw2['firewall']['id']
def setUp(self):
ext_mgr = test_l3.L3TestExtensionManager()
super(TestBigSwitchML2Router, self).setUp(ext_mgr=ext_mgr)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self):
ext_mgr = test_sg.SecurityGroupTestExtensionManager()
super(TestBigSwitchML2SecurityGroups, self).setUp(ext_mgr=ext_mgr)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def _setUpExtension(self, plugin, service_type,
resource_attribute_map, extension_class,
resource_prefix, plural_mappings=None,
translate_resource_name=False,
allow_pagination=False, allow_sorting=False,
supported_extension_aliases=None,
use_quota=False,
):
self._resource_prefix = resource_prefix
self._plural_mappings = plural_mappings or {}
self._translate_resource_name = translate_resource_name
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
# Save the global RESOURCE_ATTRIBUTE_MAP
self._saved_attr_map = attributes.RESOURCE_ATTRIBUTE_MAP.copy()
# Restore the global RESOURCE_ATTRIBUTE_MAP
self.addCleanup(self._resotre_attr_map)
# Create the default configurations
self.config_parse()
#just stubbing core plugin with plugin
self.setup_coreplugin(plugin)
cfg.CONF.set_override('core_plugin', plugin)
if service_type:
cfg.CONF.set_override('service_plugins', [plugin])
self._plugin_patcher = mock.patch(plugin, autospec=True)
self.plugin = self._plugin_patcher.start()
instance = self.plugin.return_value
if service_type:
instance.get_plugin_type.return_value = service_type
if supported_extension_aliases is not None:
instance.supported_extension_aliases = supported_extension_aliases
if allow_pagination:
cfg.CONF.set_override('allow_pagination', True)
# instance.__native_pagination_support = True
native_pagination_attr_name = ("_%s__native_pagination_support"
% instance.__class__.__name__)
setattr(instance, native_pagination_attr_name, True)
if allow_sorting:
cfg.CONF.set_override('allow_sorting', True)
# instance.__native_sorting_support = True
native_sorting_attr_name = ("_%s__native_sorting_support"
% instance.__class__.__name__)
setattr(instance, native_sorting_attr_name, True)
if use_quota:
quota.QUOTAS._driver = None
cfg.CONF.set_override('quota_driver', 'neutron.quota.ConfDriver',
group='QUOTAS')
class ExtensionTestExtensionManager(object):
def get_resources(self):
# Add the resources to the global attribute map
# This is done here as the setup process won't
# initialize the main API router which extends
# the global attribute map
attributes.RESOURCE_ATTRIBUTE_MAP.update(
resource_attribute_map)
return extension_class.get_resources()
def get_actions(self):
return []
def get_request_extensions(self):
return []
ext_mgr = ExtensionTestExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.api = webtest.TestApp(self.ext_mdw)
def setUp(self):
super(TestMidonetAgent, self).setUp()
self.adminContext = context.get_admin_context()
ext_mgr = test_agent.AgentTestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self):
ext_mgr = test_l3.L3TestExtensionManager()
super(TestMidonetRouterML2, self).setUp(ext_mgr=ext_mgr)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setup_extension(self, plugin, service_type,
extension_class,
resource_prefix, plural_mappings=None,
translate_resource_name=False,
allow_pagination=False, allow_sorting=False,
supported_extension_aliases=None,
use_quota=False):
self._resource_prefix = resource_prefix
self._plural_mappings = plural_mappings or {}
self._translate_resource_name = translate_resource_name
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
self.useFixture(fixture.APIDefinitionFixture())
# Create the default configurations
self.config_parse()
core_plugin = CORE_PLUGIN if service_type else plugin
self.setup_coreplugin(core_plugin, load_plugins=False)
if service_type:
cfg.CONF.set_override('service_plugins', [plugin])
self._plugin_patcher = mock.patch(plugin, autospec=True)
self.plugin = self._plugin_patcher.start()
instance = self.plugin.return_value
if service_type:
instance.get_plugin_type.return_value = service_type
manager.init()
if supported_extension_aliases is not None:
instance.supported_extension_aliases = supported_extension_aliases
if allow_pagination:
# instance.__native_pagination_support = True
native_pagination_attr_name = ("_%s__native_pagination_support"
% instance.__class__.__name__)
setattr(instance, native_pagination_attr_name, True)
if allow_sorting:
# instance.__native_sorting_support = True
native_sorting_attr_name = ("_%s__native_sorting_support"
% instance.__class__.__name__)
setattr(instance, native_sorting_attr_name, True)
if use_quota:
quota.QUOTAS._driver = None
cfg.CONF.set_override('quota_driver', 'neutron.quota.ConfDriver',
group='QUOTAS')
setattr(instance, 'path_prefix', resource_prefix)
class ExtensionTestExtensionManager(object):
def get_resources(self):
return extension_class.get_resources()
def get_actions(self):
return []
def get_request_extensions(self):
return []
ext_mgr = ExtensionTestExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.api = webtest.TestApp(self.ext_mdw)
def setUp(self, plugin=None, ext_mgr=None):
super(PhysicalAttachmentPointTestCase, self).setUp()
ext_mgr = PAPExtensionManager()
extensions.PluginAwareExtensionManager._instance = None
self.ext_api = test_ext.setup_extensions_middleware(ext_mgr)
def setUp(self):
ext_mgr = test_l3.L3TestExtensionManager()
super(TestBigSwitchML2Router, self).setUp(ext_mgr=ext_mgr)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self, plugin=None):
super(TestNsxPolicies, self).setUp()
ext_mgr = NsxPolExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self):
ext_mgr = test_sg.SecurityGroupTestExtensionManager()
super(TestBigSwitchML2SecurityGroups, self).setUp(ext_mgr=ext_mgr)
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self, plugin=None, ext_mgr=None):
super(TestContrailSecurityGroups, self).setUp(self._plugin_name,
ext_mgr)
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self, plugin=None):
cfg.CONF.set_override('api_extensions_path', vmware.NSXEXT_PATH)
super(TestQoSQueue, self).setUp()
ext_mgr = QoSTestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self):
super(TestL3ResourcesEventHandler, self).setUp()
self.useFixture(fixture.APIDefinitionFixture())
ext_mgr = test_l3.L3TestExtensionManager()
self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
def setUp(self):
super(TestOVNQosDriver, self).setUp()
qos_mgr = QoSTestExtensionManager()
self.resource_prefix_map = {'policies': '/qos'}
self.qos_api = test_extensions.setup_extensions_middleware(qos_mgr)
def setUp(self, plugin=None, ext_mgr=None):
ext_mgr = AgentMembershipExtensionManager()
super(AgentMembershipTestCase, self).setUp()
self.ext_api = test_ex.setup_extensions_middleware(ext_mgr)
