Adapated plugin infrastructure to allow API to pass options to plugins

Now using in-memory sqlite db for tests on FakePlugin
teardown() now 'resets' the in-memory db
Adding unit tests for APIs

diff --cc quantum/api/__init__.py
index 3bf7f113ad808e8a50bd4dbba16231dde1d59541,fc34767333873c34c8b7da1a404ce11d1e3afca8..40dd058babb40f385a06882c355f775eb244e9e8
--- 1/quantum/api/__init__.py
--- 2/quantum/api/__init__.py
+++ b/quantum/api/__init__.py
@@@ -40,19 -41,20 +41,20 @@@ class APIRouterV01(wsgi.Router)
      Routes requests on the Quantum API to the appropriate controller
      """
  
--    def __init__(self, ext_mgr=None):
++    def __init__(self, options=None):
          mapper = routes.Mapper()
--        self._setup_routes(mapper)
++        self._setup_routes(mapper, options)
          super(APIRouterV01, self).__init__(mapper)
  
--    def _setup_routes(self, mapper):
- 
++    def _setup_routes(self, mapper, options):
+         # Loads the quantum plugin
 -        plugin = manager.QuantumManager().get_plugin()
++        plugin = manager.QuantumManager(options).get_plugin()
          uri_prefix = '/tenants/{tenant_id}/'
          mapper.resource('network', 'networks',
-                         controller=networks.Controller(),
+                         controller=networks.Controller(plugin),
                          path_prefix=uri_prefix)
          mapper.resource('port', 'ports',
-                         controller=ports.Controller(),
+                         controller=ports.Controller(plugin),
                          parent_resource=dict(member_name='network',
                                               collection_name=uri_prefix +\
                                                   'networks'))

diff --cc quantum/api/networks.py
index e629d40d52a8b1b86c7b763a86f96b4d1112ecf4,e8d3db51bcc7b5263f03a6cb379ee7eb70d14184..b36e2edd9d9abee5e6abeb7f353a7cb7482ceadc
--- 1/quantum/api/networks.py
--- 2/quantum/api/networks.py
+++ b/quantum/api/networks.py
@@@ -78,9 -78,9 +78,9 @@@ class Controller(common.QuantumControll
                                             self._network_ops_param_list)
          except exc.HTTPError as e:
              return faults.Fault(e)
-         network = self.network_manager.\
+         network = self._plugin.\
                         create_network(tenant_id,
 -                                      request_params['network-name'])
 +                                      request_params['net-name'])
          builder = networks_view.get_view_builder(request)
          result = builder.build(network)
          return dict(networks=result)

diff --cc quantum/api/ports.py
index 2a38fbe3948c2d824272f975da4f83a17ba5a63a,b2d4016e53df20c1f63ae0c210a6d0abccaf3931..f9f39c400ce0450dcc549d9e6de5f8b8bf73e05c
--- 1/quantum/api/ports.py
--- 2/quantum/api/ports.py
+++ b/quantum/api/ports.py
@@@ -141,9 -140,10 +141,7 @@@ class Controller(common.QuantumControll
          except exception.PortNotFound as e:
              return faults.Fault(faults.PortNotFound(e))
  
--    #TODO - Complete implementation of these APIs
      def attach_resource(self, request, tenant_id, network_id, id):
--        content_type = request.best_match_content_type()
 -        print "Content type:%s" % content_type
          try:
              request_params = \
                  self._parse_request_params(request,

diff --cc quantum/cli.py
Simple merge

diff --cc quantum/common/utils.py
index 3a2455963f5d6776ae6906aa6f9349791f3c6926,3a2455963f5d6776ae6906aa6f9349791f3c6926..ea6241e21b5d1fcbc3bcb3ec6d54a34c83c2de57
--- 1/quantum/common/utils.py
--- 2/quantum/common/utils.py
+++ b/quantum/common/utils.py
@@@ -190,7 -190,7 +190,7 @@@ def parse_isotime(timestr)
      return datetime.datetime.strptime(timestr, TIME_FORMAT)
  
  
--def getPluginFromConfig(file="config.ini"):
++def get_plugin_from_config(file="config.ini"):
          Config = ConfigParser.ConfigParser()
          Config.read(file)
          return Config.get("PLUGIN", "provider")

diff --cc quantum/db/api.py
index 8981661107bc00e72bb9333bbcf303a8a3a8ee07,59459cadb4216af5c6b145732e5ac710937aa454..212308e8fcbccc3086c188eff9f32669ad45b45c
--- 1/quantum/db/api.py
--- 2/quantum/db/api.py
+++ b/quantum/db/api.py
@@@ -42,6 -42,6 +42,13 @@@ def configure_db(options)
          register_models()
  
  
++def unconfigure_db():
++    unregister_models()
++    # Unset the engine
++    global _ENGINE
++    _ENGINE = None
++
++
  def get_session(autocommit=True, expire_on_commit=False):
      """Helper method to grab session"""
      global _MAKER, _ENGINE
@@@ -72,10 -72,9 +79,10 @@@ def network_create(tenant_id, name)
      net = None
      try:
          net = session.query(models.Network).\
-           filter_by(name=name, tenant_id=tenant_id).\
+           filter_by(tenant_id=tenant_id, name=name).\
            one()
 -        raise Exception("Network with name \"%s\" already exists" % name)
 +        raise Exception("Network with name %(name)s already " \
 +                        "exists for tenant %(tenant_id)s" % locals())
      except exc.NoResultFound:
          with session.begin():
              net = models.Network(tenant_id, name)
@@@ -155,25 -154,16 +162,26 @@@ def port_get(port_id)
          raise Exception("No port found with id = %s " % port_id)
  
  
 +def port_set_state(port_id, new_state):
 +    port = port_get(port_id)
 +    if port:
 +        session = get_session()
 +        port.state = new_state
 +        session.merge(port)
 +        session.flush()
 +        return port
 +
 +
  def port_set_attachment(port_id, new_interface_id):
      session = get_session()
-     ports = None
-     try:
-         ports = session.query(models.Port).\
-           filter_by(interface_id=new_interface_id).\
-           all()
-     except exc.NoResultFound:
-         pass
+     ports = []
+     if new_interface_id != "":
+         try:
+             ports = session.query(models.Port).\
+             filter_by(interface_id=new_interface_id).\
+             all()
+         except exc.NoResultFound:
+             pass
      if len(ports) == 0:
          port = port_get(port_id)
          port.interface_id = new_interface_id

diff --cc quantum/manager.py
index a42f15c68c49283848e6e266e62631e14a31358e,6ab46d5fef565f95f8e2492a164158296ad0f114..14b7f979cafbac8d23711b0e9c7107021489d2a9
--- 1/quantum/manager.py
--- 2/quantum/manager.py
+++ b/quantum/manager.py
@@@ -25,8 -25,8 +25,9 @@@ class
  The caller should make sure that QuantumManager is a singleton.
  """
  import gettext
 +import logging
  import os
+ 
  gettext.install('quantum', unicode=1)
  
  from common import utils
@@@ -44,22 -43,21 +45,27 @@@ def find_config(basepath)
  
  
  class QuantumManager(object):
--    def __init__(self, config=None):
--        if config == None:
++    def __init__(self, options=None, config_file=None):
++        if config_file == None:
              self.configuration_file = find_config(
                  os.path.abspath(os.path.dirname(__file__)))
          else:
--            self.configuration_file = config
--        plugin_location = utils.getPluginFromConfig(self.configuration_file)
--        plugin_klass = utils.import_class(plugin_location)
-         LOG.debug("Plugin location:%s", plugin_location)
++            self.configuration_file = config_file
++        # If no options have been provided, create an empty dict
++        if not options:
++            options = {}
++        if not 'plugin_provider' in options:
++            options['plugin_provider'] = \
++                utils.get_plugin_from_config(self.configuration_file)
++        LOG.debug("Plugin location:%s", options['plugin_provider'])
++        plugin_klass = utils.import_class(options['plugin_provider'])
          if not issubclass(plugin_klass, QuantumPluginBase):
              raise Exception("Configured Quantum plug-in " \
                              "didn't pass compatibility test")
          else:
 -            print("Successfully imported Quantum plug-in." \
 -                  "All compatibility tests passed\n")
 -        self.plugin = plugin_klass()
 +            LOG.debug("Successfully imported Quantum plug-in." \
 +                      "All compatibility tests passed")
-         self.plugin = plugin_klass()
++        self.plugin = plugin_klass(options)
  
-     def get_manager(self):
+     def get_plugin(self):
          return self.plugin

diff --cc quantum/plugins/SamplePlugin.py
index 623042a122175b8e982267ee62ee59b535c60e28,376456a6c81dae207c152684f9128cd265a68dbb..1f2b1ce61dd65c9573aaab5e017b0c628c0a3a66
--- 1/quantum/plugins/SamplePlugin.py
--- 2/quantum/plugins/SamplePlugin.py
+++ b/quantum/plugins/SamplePlugin.py
@@@ -233,25 -227,45 +233,29 @@@ class FakePlugin(object)
      client/cli/api development
      """
  
 -    #static data for networks and ports
 -    _port_dict_1 = {
 -                   1: {'port-id': 1,
 -                        'port-state': 'DOWN',
 -                        'attachment': None},
 -                   2: {'port-id': 2,
 -                        'port-state': 'UP',
 -                        'attachment': None}}
 -    _port_dict_2 = {
 -                   1: {'port-id': 1,
 -                        'port-state': 'UP',
 -                        'attachment': 'SomeFormOfVIFID'},
 -                   2: {'port-id': 2,
 -                        'port-state': 'DOWN',
 -                        'attachment': None}}
 -    _networks = {'001':
 -                    {
 -                    'net-id': '001',
 -                    'net-name': 'pippotest',
 -                    'net-ports': _port_dict_1},
 -                    '002':
 -                    {
 -                    'net-id': '002',
 -                    'net-name': 'cicciotest',
 -                    'net-ports': _port_dict_2}}
 -
--    def __init__(self):
-         db_options = {"sql_connection": "sqlite:///fake_plugin.sqllite"}
-         db.configure_db(db_options)
 -        FakePlugin._net_counter = len(FakePlugin._networks)
++    def __init__(self, options):
++        # use supplied options for configuring db
++        if not options:
++            options = {"sql_connection": "sqlite:///fake_plugin.sqllite"}
++        elif not 'sql_connection' in options:
++            options['sql_connection'] = "sqlite:///fake_plugin.sqllite"
++        db.configure_db(options)
 +        FakePlugin._net_counter = 0
  
      def _get_network(self, tenant_id, network_id):
 -        network = FakePlugin._networks.get(network_id)
 +        network = db.network_get(network_id)
          if not network:
              raise exc.NetworkNotFound(net_id=network_id)
          return network
  
      def _get_port(self, tenant_id, network_id, port_id):
          net = self._get_network(tenant_id, network_id)
-         try: 
 -        port = net['net-ports'].get(int(port_id))
 -        if not port:
++        try:
 +            port = db.port_get(port_id)
 +        except:
 +            raise exc.PortNotFound(net_id=network_id, port_id=port_id)
 +        # Port must exist and belong to the appropriate network.
 +        if port['network_id'] != net['uuid']:
              raise exc.PortNotFound(net_id=network_id, port_id=port_id)
          return port
  

diff --cc quantum/quantum_plugin_base.py
index 8e3f1f8e152b0ce0d8ec359a41373c67514009b5,8e3f1f8e152b0ce0d8ec359a41373c67514009b5..e82c55253185e6ab01865cd5457b7b9ff3f6f12a
--- 1/quantum/quantum_plugin_base.py
--- 2/quantum/quantum_plugin_base.py
+++ b/quantum/quantum_plugin_base.py
@@@ -22,6 -22,6 +22,7 @@@ QuantumPluginBase provides the definiti
  methods that needs to be implemented by a Quantum Plug-in.
  """
  
++import inspect
  from abc import ABCMeta, abstractmethod
  
  
@@@ -29,6 -29,6 +30,14 @@@ class QuantumPluginBase(object)
  
      __metaclass__ = ABCMeta
  
++    @abstractmethod
++    def __init__(self, options):
++        """
++        Initializes the Quantum plugin using provided options.
++
++        """
++        pass
++
      @abstractmethod
      def get_all_networks(self, tenant_id):
          """
@@@ -242,7 -242,7 +251,17 @@@
          """
          if cls is QuantumPluginBase:
              for method in cls.__abstractmethods__:
--                if any(method in base.__dict__ for base in klass.__mro__):
++                method_ok = False
++                for base in klass.__mro__:
++                    if method in base.__dict__:
++                        fn_obj = base.__dict__[method]
++                        if inspect.isfunction(fn_obj):
++                            abstract_fn_obj = cls.__dict__[method]
++                            arg_count = fn_obj.func_code.co_argcount
++                            expected_arg_count = \
++                                abstract_fn_obj.func_code.co_argcount
++                            method_ok = arg_count == expected_arg_count
++                if method_ok:
                      continue
                  return NotImplemented
              return True

diff --cc tests/unit/test_api.py
index 6e4fe1960dd3673b33bd3511b1962f843652fcbc,0000000000000000000000000000000000000000..f6997a2cf96951588732bcd2f870294df2fa1251
mode 100644,000000..100644
--- 1/tests/unit/test_api.py
--- /dev/null
+++ b/tests/unit/test_api.py
@@@ -1,152 -1,0 +1,283 @@@
- LOG = logging.getLogger('quantum.tests.test_api')
- 
- 
- class APIPortsTest(unittest.TestCase):
-     def setUp(self):
-         self.api = server.APIRouterV01()
-         self.tenant_id = "test_tenant"
-         self.network_name = "test_network"
- 
-     def tearDown(self):
-         """Clear the test environment"""
-         # Remove all the networks.
-         network_req = testlib.create_network_list_request(self.tenant_id)
-         network_res = network_req.get_response(self.api)
-         network_data = Serializer().deserialize(network_res.body,
-                                                 "application/xml")
-         for network in network_data["networks"].values():
-             network_delete_req = testlib. \
-                 create_network_delete_request(self.tenant_id, network['id'])
-             network_delete_req.get_response(self.api)
 +# vim: tabstop=4 shiftwidth=4 softtabstop=4
 +
 +# Copyright 2010-2011 ????
 +# All Rights Reserved.
 +#
 +#    Licensed under the Apache License, Version 2.0 (the "License"); you may
 +#    not use this file except in compliance with the License. You may obtain
 +#    a copy of the License at
 +#
 +#         http://www.apache.org/licenses/LICENSE-2.0
 +#
 +#    Unless required by applicable law or agreed to in writing, software
 +#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 +#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 +#    License for the specific language governing permissions and limitations
 +#    under the License.
 +#    @author: Brad Hall, Nicira Networks
 +#    @author: Salvatore Orlando, Citrix Systems
 +
 +import logging
 +import unittest
 +
 +import tests.unit.testlib as testlib
 +
 +from quantum import api as server
++from quantum.db import api as db
 +from quantum.common.wsgi import Serializer
 +
-     def _test_delete_port(self, format):
-         LOG.debug("_test_delete_port - format:%s - START", format)
 +
 +#    Fault names copied here for reference
 +#
 +#    _fault_names = {
 +#            400: "malformedRequest",
 +#            401: "unauthorized",
 +#            420: "networkNotFound",
 +#            421: "networkInUse",
 +#            430: "portNotFound",
 +#            431: "requestedStateInvalid",
 +#            432: "portInUse",
 +#            440: "alreadyAttached",
 +#            470: "serviceUnavailable",
 +#            471: "pluginFault"}
 +
-         port_state = "ACTIVE"
-         LOG.debug("Creating network and port")
-         network_req = testlib.create_new_network_request(self.tenant_id,
-                                                          self.network_name,
-                                                          format)
++
++LOG = logging.getLogger('quantum.tests.test_api')
++
++
++class APITest(unittest.TestCase):
++
++    def _create_network(self, format):
++        LOG.debug("Creating network")
 +        content_type = "application/" + format
-         network_id = network_data['networks']['network']['id']
-         port_req = testlib.create_new_port_request(self.tenant_id,
-                                                    network_id, port_state,
-                                                    format)
++        network_req = testlib.new_network_request(self.tenant_id,
++                                                  self.network_name,
++                                                  format)
 +        network_res = network_req.get_response(self.api)
 +        self.assertEqual(network_res.status_int, 200)
 +        network_data = Serializer().deserialize(network_res.body,
 +                                                content_type)
-         port_id = port_data['ports']['port']['id']
++        return network_data['networks']['network']['id']
++
++    def _create_port(self, network_id, port_state, format):
++        LOG.debug("Creating port for network %s", network_id)
++        content_type = "application/%s" % format
++        port_req = testlib.new_port_request(self.tenant_id, network_id,
++                                            port_state, format)
 +        port_res = port_req.get_response(self.api)
 +        self.assertEqual(port_res.status_int, 200)
 +        port_data = Serializer().deserialize(port_res.body, content_type)
-         delete_port_req = testlib.create_port_delete_request(self.tenant_id,
-                                                              network_id,
-                                                              port_id,
-                                                              format)
++        return port_data['ports']['port']['id']
++
++    def _test_create_network(self, format):
++        LOG.debug("_test_create_network - format:%s - START", format)
++        content_type = "application/%s" % format
++        network_id = self._create_network(format)
++        show_network_req = testlib.show_network_request(self.tenant_id,
++                                                        network_id,
++                                                        format)
++        show_network_res = show_network_req.get_response(self.api)
++        self.assertEqual(show_network_res.status_int, 200)
++        network_data = Serializer().deserialize(show_network_res.body,
++                                                content_type)
++        self.assertEqual(network_id,
++                         network_data['networks']['network']['id'])
++        LOG.debug("_test_create_network - format:%s - END", format)
++
++    def _test_show_network(self, format):
++        LOG.debug("_test_show_network - format:%s - START", format)
++        content_type = "application/%s" % format
++        network_id = self._create_network(format)
++        show_network_req = testlib.show_network_request(self.tenant_id,
++                                                        network_id,
++                                                        format)
++        show_network_res = show_network_req.get_response(self.api)
++        self.assertEqual(show_network_res.status_int, 200)
++        print show_network_res.body
++        network_data = Serializer().deserialize(show_network_res.body,
++                                                content_type)
++        self.assertEqual({'id': network_id, 'name': self.network_name},
++                         network_data['networks']['network'])
++        LOG.debug("_test_show_network - format:%s - END", format)
++
++    def _test_delete_network(self, format):
++        LOG.debug("_test_delete_network - format:%s - START", format)
++        content_type = "application/%s" % format
++        network_id = self._create_network(format)
++        LOG.debug("Deleting network %(network_id)s"\
++                  " of tenant %(tenant_id)s", locals())
++        delete_network_req = testlib.network_delete_request(self.tenant_id,
++                                                            network_id,
++                                                            format)
++        delete_network_res = delete_network_req.get_response(self.api)
++        self.assertEqual(delete_network_res.status_int, 202)
++        list_network_req = testlib.network_list_request(self.tenant_id, format)
++        list_network_res = list_network_req.get_response(self.api)
++        network_list_data = Serializer().deserialize(list_network_res.body,
++                                                     content_type)
++        network_count = len(network_list_data['networks'])
++        self.assertEqual(network_count, 0)
++        LOG.debug("_test_delete_network - format:%s - END", format)
++
++    def _test_delete_network_in_use(self, format):
++        LOG.debug("_test_delete_network_in_use - format:%s - START", format)
++        content_type = "application/%s" % format
++        port_state = "ACTIVE"
++        attachment_id = "test_attachment"
++        network_id = self._create_network(format)
++        LOG.debug("Deleting network %(network_id)s"\
++                  " of tenant %(tenant_id)s", locals())
++        port_id = self._create_port(network_id, port_state, format)
++        #plug an attachment into the port
++        LOG.debug("Putting attachment into port %s", port_id)
++        attachment_req = testlib.put_attachment_request(self.tenant_id,
++                                                        network_id,
++                                                        port_id,
++                                                        attachment_id)
++        attachment_res = attachment_req.get_response(self.api)
++        self.assertEquals(attachment_res.status_int, 202)
++
++        LOG.debug("Deleting network %(network_id)s"\
++                  " of tenant %(tenant_id)s", locals())
++        delete_network_req = testlib.network_delete_request(self.tenant_id,
++                                                            network_id,
++                                                            format)
++        delete_network_res = delete_network_req.get_response(self.api)
++        self.assertEqual(delete_network_res.status_int, 421)
++        LOG.debug("_test_delete_network_in_use - format:%s - END", format)
++
++    def _test_create_port(self, format):
++        LOG.debug("_test_create_port - format:%s - START", format)
++        content_type = "application/%s" % format
++        port_state = "ACTIVE"
++        network_id = self._create_network(format)
++        port_id = self._create_port(network_id, port_state, format)
++        show_port_req = testlib.show_port_request(self.tenant_id, network_id,
++                                                  port_id, format)
++        show_port_res = show_port_req.get_response(self.api)
++        self.assertEqual(show_port_res.status_int, 200)
++        port_data = Serializer().deserialize(show_port_res.body, content_type)
++        self.assertEqual(port_id, port_data['ports']['port']['id'])
++        LOG.debug("_test_create_port - format:%s - END", format)
++
++    def _test_delete_port(self, format):
++        LOG.debug("_test_delete_port - format:%s - START", format)
++        content_type = "application/%s" % format
++        port_state = "ACTIVE"
++        network_id = self._create_network(format)
++        port_id = self._create_port(network_id, port_state, format)
 +        LOG.debug("Deleting port %(port_id)s for network %(network_id)s"\
 +                  " of tenant %(tenant_id)s", locals())
-         list_port_req = testlib.create_port_list_request(self.tenant_id,
-                                                          network_id,
-                                                          format)
++        delete_port_req = testlib.port_delete_request(self.tenant_id,
++                                                      network_id, port_id,
++                                                      format)
 +        delete_port_res = delete_port_req.get_response(self.api)
 +        self.assertEqual(delete_port_res.status_int, 202)
-     def _test_delete_port_in_use(self):
-         # Test for portinuse
-         #rv = self.port.create(req, tenant, network_id)
-         #port_id = rv["ports"]["port"]["id"]
-         #req = testlib.create_attachment_request(tenant, network_id,
-         #  port_id, "fudd")
-         #rv = self.port.attach_resource(req, tenant, network_id, port_id)
-         #self.assertEqual(rv.status_int, 202)
-         #rv = self.port.delete("", tenant, network_id, port_id)
-         #self.assertEqual(rv.wrapped_exc.status_int, 432)
-         pass
- 
++        list_port_req = testlib.port_list_request(self.tenant_id, network_id,
++                                                  format)
 +        list_port_res = list_port_req.get_response(self.api)
 +        port_list_data = Serializer().deserialize(list_port_res.body,
 +                                                  content_type)
 +        port_count = len(port_list_data['ports'])
 +        self.assertEqual(port_count, 0)
 +        LOG.debug("_test_delete_port - format:%s - END", format)
 +
++    def _test_delete_port_in_use(self, format):
++        LOG.debug("_test_delete_port_in_use - format:%s - START", format)
++        content_type = "application/" + format
++        port_state = "ACTIVE"
++        attachment_id = "test_attachment"
++        network_id = self._create_network(format)
++        port_id = self._create_port(network_id, port_state, format)
++        #plug an attachment into the port
++        LOG.debug("Putting attachment into port %s", port_id)
++        attachment_req = testlib.put_attachment_request(self.tenant_id,
++                                                        network_id,
++                                                        port_id,
++                                                        attachment_id)
++        attachment_res = attachment_req.get_response(self.api)
++        self.assertEquals(attachment_res.status_int, 202)
++        LOG.debug("Deleting port %(port_id)s for network %(network_id)s"\
++                  " of tenant %(tenant_id)s", locals())
++        delete_port_req = testlib.port_delete_request(self.tenant_id,
++                                                      network_id, port_id,
++                                                      format)
++        delete_port_res = delete_port_req.get_response(self.api)
++        self.assertEqual(delete_port_res.status_int, 432)
++        LOG.debug("_test_delete_port_in_use - format:%s - END", format)
++        pass
++
++    def _test_delete_port_with_bad_id(self, format):
++        LOG.debug("_test_delete_port_with_bad_id - format:%s - START", format)
++        port_state = "ACTIVE"
++        network_id = self._create_network(format)
++        self._create_port(network_id, port_state, format)
++        # Test for portnotfound
++        delete_port_req = testlib.port_delete_request(self.tenant_id,
++                                                      network_id, "A_BAD_ID",
++                                                      format)
++        delete_port_res = delete_port_req.get_response(self.api)
++        self.assertEqual(delete_port_res.status_int, 430)
++        LOG.debug("_test_delete_port_with_bad_id - format:%s - END", format)
++
++    def setUp(self):
++        self.db_file = ':memory'
++        options = {}
++        options['plugin_provider'] = 'quantum.plugins.SamplePlugin.FakePlugin'
++        options['sql_connection'] = 'sqlite:///%s' % self.db_file
++        self.api = server.APIRouterV01(options)
++        self.tenant_id = "test_tenant"
++        self.network_name = "test_network"
++
++    def tearDown(self):
++        """Clear the test environment"""
++        # Unconfigure database engine
++        db.unconfigure_db()
++
++    def test_create_network_json(self):
++        self._test_create_network('json')
++
++    def test_create_network_xml(self):
++        self._test_create_network('xml')
++
++    def test_show_network_json(self):
++        self._test_show_network('json')
++
++    def test_show_network_xml(self):
++        self._test_show_network('xml')
++
++    def test_delete_network_json(self):
++        self._test_delete_network('json')
++
++    def test_delete_network_xml(self):
++        self._test_delete_network('xml')
++
++    def test_delete_network_in_use_json(self):
++        self._test_delete_network_in_use('json')
++
++    def test_delete_network_in_use_xml(self):
++        self._test_delete_network_in_use('xml')
++
++    def test_create_port_json(self):
++        self._test_create_port('json')
++
++    def test_create_port_xml(self):
++        self._test_create_port('xml')
++
 +    def test_delete_port_xml(self):
 +        self._test_delete_port('xml')
 +
 +    def test_delete_port_json(self):
 +        self._test_delete_port('json')
 +
-     def _test_delete_port_with_bad_id(self,format):
-         LOG.debug("_test_delete_port - format:%s - START", format)
-         content_type = "application/" + format
-         port_state = "ACTIVE"
-         LOG.debug("Creating network and port")
-         network_req = testlib.create_new_network_request(self.tenant_id,
-                                                          self.network_name,
-                                                          format)
-         network_res = network_req.get_response(self.api)
-         self.assertEqual(network_res.status_int, 200)
-         network_data = Serializer().deserialize(network_res.body,
-                                                 content_type)
-         network_id = network_data['networks']['network']['id']
-         port_req = testlib.create_new_port_request(self.tenant_id,
-                                                    network_id, port_state,
-                                                    format)
-         port_res = port_req.get_response(self.api)
-         self.assertEqual(port_res.status_int, 200)
++    def test_delete_port_in_use_xml(self):
++        self._test_delete_port_in_use('xml')
 +
-         # Test for portnotfound
-         delete_port_req = testlib.create_port_delete_request(self.tenant_id,
-                                                              network_id,
-                                                              "A_BAD_ID",
-                                                              format)
-         delete_port_res = delete_port_req.get_response(self.api)
-         self.assertEqual(delete_port_res.status_int, 430)
-         
++    def test_delete_port_in_use_json(self):
++        self._test_delete_port_in_use('json')
 +
-         self._test_delete_port_wth_bad_id('xml')
 +    def test_delete_port_with_bad_id_xml(self):
- 
++        self._test_delete_port_with_bad_id('xml')
 +
 +    def test_delete_port_with_bad_id_json(self):
 +        self._test_delete_port_with_bad_id('json')

diff --cc tests/unit/testlib.py
index 024b8202adacf741047ef869de29a1b28ca28198,0000000000000000000000000000000000000000..c78c700cbaccf2e04893c2d5234f116f01da73de
mode 100644,000000..100644
--- 1/tests/unit/testlib.py
--- /dev/null
+++ b/tests/unit/testlib.py
@@@ -1,71 -1,0 +1,89 @@@
- def create_network_list_request(tenant_id, format='xml'):
 +import webob
 +
 +from quantum.common.wsgi import Serializer
 +
 +
 +def create_request(path, body, content_type, method='GET'):
 +    req = webob.Request.blank(path)
 +    req.method = method
 +    req.headers = {}
 +    req.headers['Accept'] = content_type
 +    req.body = body
 +    return req
 +
 +
-     content_type = "application/" + format
++def network_list_request(tenant_id, format='xml'):
 +    method = 'GET'
 +    path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals()
- def create_new_network_request(tenant_id, network_name, format='xml'):
++    content_type = "application/%s" % format
 +    return create_request(path, None, content_type, method)
 +
 +
-     content_type = "application/" + format
++def show_network_request(tenant_id, network_id, format='xml'):
++    method = 'GET'
++    path = "/tenants/%(tenant_id)s/networks/" \
++           "%(network_id)s.%(format)s" % locals()
++    content_type = "application/%s" % format
++    return create_request(path, None, content_type, method)
++
++
++def new_network_request(tenant_id, network_name, format='xml'):
 +    method = 'POST'
 +    path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals()
 +    data = {'network': {'net-name': '%s' % network_name}}
- def create_network_delete_request(tenant_id, network_id, format='xml'):
++    content_type = "application/%s" % format
 +    body = Serializer().serialize(data, content_type)
 +    return create_request(path, body, content_type, method)
 +
 +
-     content_type = "application/" + format
++def network_delete_request(tenant_id, network_id, format='xml'):
 +    method = 'DELETE'
 +    path = "/tenants/%(tenant_id)s/networks/" \
 +           "%(network_id)s.%(format)s" % locals()
- def create_port_list_request(tenant_id, network_id, format='xml'):
++    content_type = "application/%s" % format
 +    return create_request(path, None, content_type, method)
 +
 +
-     content_type = "application/" + format
++def port_list_request(tenant_id, network_id, format='xml'):
 +    method = 'GET'
 +    path = "/tenants/%(tenant_id)s/networks/" \
 +           "%(network_id)s/ports.%(format)s" % locals()
- def create_new_port_request(tenant_id, network_id, port_state, format='xml'):
++    content_type = "application/%s" % format
 +    return create_request(path, None, content_type, method)
 +
 +
-     content_type = "application/" + format
++def show_port_request(tenant_id, network_id, port_id, format='xml'):
++    method = 'GET'
++    path = "/tenants/%(tenant_id)s/networks/%(network_id)s" \
++           "/ports/%(port_id)s.%(format)s" % locals()
++    content_type = "application/%s" % format
++    return create_request(path, None, content_type, method)
++
++
++def new_port_request(tenant_id, network_id, port_state, format='xml'):
 +    method = 'POST'
 +    path = "/tenants/%(tenant_id)s/networks/" \
 +           "%(network_id)s/ports.%(format)s" % locals()
 +    data = {'port': {'port-state': '%s' % port_state}}
- def create_port_delete_request(tenant_id, network_id, port_id, format='xml'):
++    content_type = "application/%s" % format
 +    body = Serializer().serialize(data, content_type)
 +    return create_request(path, body, content_type, method)
 +
 +
-     content_type = "application/" + format
++def port_delete_request(tenant_id, network_id, port_id, format='xml'):
 +    method = 'DELETE'
 +    path = "/tenants/%(tenant_id)s/networks/" \
 +           "%(network_id)s/ports/%(port_id)s.%(format)s" % locals()
- def create_attachment_request(tid, nid, pid, attachment_id):
-     path = "/v0.1/tenants/%s/networks/%s/ports/%s/attachment.json" % (tid,
-       nid, pid)
++    content_type = "application/%s" % format
 +    return create_request(path, None, content_type, method)
 +
 +
-     content_type = "application/json"
++def put_attachment_request(tenant_id, network_id, port_id,
++                              attachment_id, format='xml'):
++    method = 'PUT'
++    path = "/tenants/%(tenant_id)s/networks/" \
++           "%(network_id)s/ports/%(port_id)s/attachment.%(format)s" % locals()
 +    data = {'port': {'attachment-id': attachment_id}}
-     return create_request(path, body)
++    content_type = "application/%s" % format
 +    body = Serializer().serialize(data, content_type)
++    return create_request(path, body, content_type, method)