def test_multiple_plugins_specified_for_service_type(self):
        cfg.CONF.set_override("service_plugins",
                              ["quantum.tests.unit.dummy_plugin."
                               "QuantumDummyPlugin",
                               "quantum.tests.unit.dummy_plugin."
                               "QuantumDummyPlugin"])

        try:
            QuantumManager.get_instance().get_service_plugins()
            self.assertTrue(False,
                            "Shouldn't load multiple plugins "
                            "for the same type")
        except Exception as e:
            LOG.debug(str(e))

    def setUp(self):
        plugin = 'quantum.quantum_plugin_base_v2.QuantumPluginBaseV2'

        # Ensure 'stale' patched copies of the plugin are never returned
        QuantumManager._instance = None

        # Ensure existing ExtensionManager is not used
        PluginAwareExtensionManager._instance = None

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

        # Create the default configurations
        args = ['--config-file', etcdir('quantum.conf.test')]
        config.parse(args=args)

        # Update the plugin and extensions path
        cfg.CONF.set_override('core_plugin', plugin)
        cfg.CONF.set_override('api_extensions_path', EXTDIR)

        self._plugin_patcher = mock.patch(plugin, autospec=True)
        self.plugin = self._plugin_patcher.start()

        # Instantiate mock plugin and enable the V2attributes extension
        QuantumManager.get_plugin().supported_extension_aliases = ["v2attrs"]

        api = router.APIRouter()
        self.api = webtest.TestApp(api)

 def get_resources(cls):
     controller = UdpChannelsController(QuantumManager.get_plugin())
     parent_resource = dict(member_name="network",
         collection_name="extensions/udp/tenants/" +\
                         ":(tenant_id)/networks")
     return [extensions.ResourceExtension('channels', controller,
         parent=parent_resource)]

 def get_resources(cls):
     """Returns Ext Resources."""
     parent_resource = dict(member_name="tenant",
                            collection_name="extensions/csco/tenants")
     controller = CredentialController(QuantumManager.get_plugin())
     return [extensions.ResourceExtension('credentials', controller,
                                          parent=parent_resource)]

    def setUp(self):

        """ Set up function """

        super(QosExtensionTest, self).setUp()
        parent_resource = dict(member_name="tenant",
                               collection_name="extensions/csco/tenants")
        controller = qos.QosController(QuantumManager.get_plugin())
        res_ext = extensions.ResourceExtension('qos', controller,
                                               parent=parent_resource)

        self.test_app = setup_extensions_test_app(
            SimpleExtensionManager(res_ext))
        self.contenttype = 'application/json'
        self.qos_path = '/extensions/csco/tenants/tt/qos'
        self.qos_second_path = '/extensions/csco/tenants/tt/qos/'
        self.test_qos_data = {
            'qos': {
                'qos_name': 'cisco_test_qos',
                'qos_desc': {
                    'PPS': 50,
                    'TTL': 5,
                },
            },
        }
        self._l2network_plugin = l2network_plugin.L2Network()

    def setUp(self):
        super(ProvidernetExtensionTestCase, self).setUp()

        plugin = "quantum.quantum_plugin_base_v2.QuantumPluginBaseV2"
        # Ensure 'stale' patched copies of the plugin are never returned
        QuantumManager._instance = None

        # Ensure existing ExtensionManager is not used
        extensions.PluginAwareExtensionManager._instance = None

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

        # Update the plugin and extensions path
        cfg.CONF.set_override("core_plugin", 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
        QuantumManager.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.addCleanup(cfg.CONF.reset)
        self.addCleanup(self._restore_attribute_map)
        self.api = webtest.TestApp(router.APIRouter())

 def get_resources(self):
     resource = base.create_resource(
         "packet_filters", "packet_filter", QuantumManager.get_plugin(), PACKET_FILTER_ATTR_MAP
     )
     qresource = quota.CountableResource("packet_filter", quota._count_resource, "quota_packet_filter")
     quota.QUOTAS.register_resource(qresource)
     return [extensions.ResourceExtension("packet_filters", resource)]

 def setUp(self):
     self.httpPatch = patch('httplib.HTTPConnection', create=True,
                            new=HTTPConnectionMock)
     self.httpPatch.start()
     test_l3_plugin.L3NatDBTestCase.setUp = new_L3_setUp
     super(RouterDBTestCase, self).setUp()
     self.plugin_obj = QuantumManager.get_plugin()

 def get_resources(cls):
     """ Returns Ext Resources """
     controller = QuotaSetsController(QuantumManager.get_plugin())
     return [extensions.ResourceExtension(
         Quotasv2.get_alias(),
         controller,
         collection_actions={'tenant': 'GET'})]

    def setUp(self, plugin=None):
        super(PortSecurityTestCase, self).setUp()

        # Check if a plugin supports security groups
        plugin_obj = QuantumManager.get_plugin()
        self._skip_security_group = ('security-group' not in
                                     plugin_obj.supported_extension_aliases)

 def get_resources(cls):
     controller = PortsMetadataController(QuantumManager.get_plugin())
     parent_resource = {
         "member_name": "network",
         "collection_name":
             "extensions/attributes/tenants/:(tenant_id)/networks"}
     return [extensions.ResourceExtension('ports', controller,
         parent=parent_resource)]

 def get_resources(cls):
     """ Returns all defined resources """
     controller = StatsController(QuantumManager.get_plugin())
     parent_resource = dict(member_name="port",
                            collection_name="extensions/ovs/tenants/" + \
                            ":(tenant_id)/networks/:(network_id)/ports")
     return [extensions.ResourceExtension('stats', controller,
                                          parent=parent_resource)]

 def get_instance(cls):
     if cls._instance is None:
         plugin_provider = cfg.CONF.core_plugin
         if plugin_provider in ENABLED_EXTS:
             for model in ENABLED_EXTS[plugin_provider]["ext_db_models"]:
                 LOG.debug("loading model %s", model)
                 model_class = importutils.import_class(model)
         cls._instance = cls(get_extensions_path(), QuantumManager.get_plugin())
     return cls._instance

 def get_resources(cls):
     """Returns Ext Resources."""
     controller = resource.Resource(
         QuotaSetsController(QuantumManager.get_plugin()),
         faults=base.FAULT_MAP)
     return [extensions.ResourceExtension(
         Quotasv2.get_alias(),
         controller,
         collection_actions={'tenant': 'GET'})]

    def _get_plugin_ref(self):
        plugin_obj = QuantumManager.get_plugin()
        if getattr(plugin_obj, "_master"):
            plugin_ref = plugin_obj
        else:
            plugin_ref = getattr(plugin_obj, "_model").\
                _plugins[const.VSWITCH_PLUGIN]

        return plugin_ref

 def test_network_admin_state(self):
     name = 'network_test'
     admin_status_up = False
     tenant_id = 'tenant_test'
     network = {'network': {'name': name,
                            'admin_state_up': admin_status_up,
                            'tenant_id': tenant_id}}
     plugin = QuantumManager.get_plugin()
     self.assertEqual(plugin._network_admin_state(network), network)

 def test_ports_vif_details(self):
     cfg.CONF.set_default('allow_overlapping_ips', True)
     plugin = QuantumManager.get_plugin()
     with contextlib.nested(self.port(), self.port()) as (port1, port2):
         ctx = context.get_admin_context()
         ports = plugin.get_ports(ctx)
         self.assertEqual(len(ports), 2)
         for port in ports:
             self.assertEqual(port['binding:vif_type'],
                              portbindings.VIF_TYPE_HYPERV)

 def test_core_plugin_supports_services(self):
     cfg.CONF.set_override("core_plugin",
                           "quantum.tests.unit.test_quantum_manager."
                           "MultiServiceCorePlugin")
     mgr = QuantumManager.get_instance()
     svc_plugins = mgr.get_service_plugins()
     self.assertEqual(3, len(svc_plugins))
     self.assertIn(constants.CORE, svc_plugins.keys())
     self.assertIn(constants.LOADBALANCER, svc_plugins.keys())
     self.assertIn(constants.DUMMY, svc_plugins.keys())

 def get_resources(cls):
     """ Returns Ext Resource """
     parent_resource = dict(member_name="tenant",
                            collection_name="extensions/csco/tenants")
     member_actions = {'schedule_host': "PUT",
                       'associate_port': "PUT"}
     controller = NovatenantsController(QuantumManager.get_plugin())
     return [extensions.ResourceExtension('novatenants', controller,
                                          parent=parent_resource,
                                          member_actions=member_actions)]

 def get_resources(cls):
     """ Returns all defined resources """
     parent_resource = dict(member_name="tenant",
                            collection_name="extensions/csco/tenants")
     member_actions = {'associate_portprofile': "PUT",
                       'disassociate_portprofile': "PUT"}
     controller = PortprofilesController(QuantumManager.get_plugin())
     return [extensions.ResourceExtension('portprofiles', controller,
                                          parent=parent_resource,
                                          member_actions=member_actions)]