Merge lp:~tylesmit/neutron/quantum-client-library into lp:neutron/diablo

[Tyler Smith]

A refactoring of the MiniClient into a more stable and robust API Client library. The test_scripts/tests.py, and quantum/cli.py have been rewritten to use the new library.

In addition, there are unit tests included that test the library's functionality.

[Somik Behera (somikbehera)]

Hi Tyler, Good work on Quantum Client lib, this abstraction will be very helpful to enable others to build upon Quantum in a convenient manner. I like your decorators too!

I did have a few comments regarding issues we will need to work to get this branch ready for merge into the Quantum trunk:

1) We should get lp:quantum trunk merged into your development branch and resolve conflicts. I see quite a few merge conflicts in this merge prop that need to be addressed. I would suggest doing a bzr merge lp:quantum into your dev branch and then merge prop again, and launchpad shouldn't show these conflicts.

2) Regarding the use of HTTPS connections. I see that you have made it very convenient for users to use HTTPS, which is good. But the default way of making HTTPS connection in python essentially "trusts" any and all certificates without verifying its authenticity.

We should definitely have the "easy" but not secure HTTPS option for testing and for folks who are on secure management networks, but then they should be using HTTP :) but thats a different story. I think in addition to the HTTPS mechanism you coded up, we should also support true HTTPS authentication were we verifyt he server authenticity with a certificate. Take a look here - http://code.activestate.com/recipes/117004-ssl-client-authentication-over-https/

3) I think once we made these changes and run you unit tests, we will be good.

Good work! We are getting very close.

review: Needs Fixing (netstack-core)

[Ying Liu (yinliu2)]

Hi Tyler,

Great job!
New client lib and unit tests look good to me.

Just two comments:
1. It seems that quantum code in your local branch is out of date, which is not sync with latest lp:quantum. Therefore, before the merge, you can check out the latest lp:quantum, sync with it and make sure that it works with new client library.
2. For unit tests, probably we can have more negative tests, e.g. delete network which is not existed or delete a network which is in use.

Other than these, the new code look good to me. Good job!

review: Needs Fixing (community)

[Salvatore Orlando (salvatore-orlando)]

On unit tests:
Tyler probably branched out from lp:~netstack/quantum/quantum-unit-tests, which was still in progress.
This might explain why the list of unit tests is incomplete. The full list of unit tests is in the above mentioned branch, which will be proposed for merge in a few hours. Implemented API unit tests are listed at wiki.openstack.org/QuantumUnitTestStatus.

setting back to WIP until comments are addressed.

[lp:~tylesmit/neutron/quantum-client-library]

23. By Salvatore Orlando on 2011-07-22

Merging branch lp:~netstack/quantum/quantum-unit-tests

Provides functionality as specified by blueprint https://blueprints.launchpad.net/quantum/+spec/api-spec-unit-tests

24. By Salvatore Orlando on 2011-07-22

Merging branch lp:~salvatore-orlando/quantum/bug802892
Fixing bug #802892

25. By Salvatore Orlando on 2011-07-22

Apply fix for bug #797419
merging lp:~salvatore-orlando/quantum/bug797419

26. By Tyler Smith on 2011-07-23

Merge in the client-library branch

27. By Tyler Smith on 2011-07-23

Adding some negative unit tests for the client library

[Sumit Naiksatam (snaiksat)]

Tyler, nice work. A couple of points,

(1) is this library meant to also provide a way to access the extensions exposed by plugins? If so, how?

(2) A nit - the company affiliations/credits in the banner at the top of the new files are not consistent (in places it says Citrix, in some it's OpenStack, and still others the license banner is missing)

review: Needs Information

[Tyler Smith (tylesmit)]

Hi Sumit, thanks.

(1) The library as it is only has methods for the high-level API operations outlined in the spec (http://wiki.openstack.org/QuantumAPISpec). There is a do_request method that can be used to to send any arbitrary query to Quantum server, but it's much less friendly than the high-level methods. A plugin could sub-class the Client and add its own methods (although I'm not sure how well this would work out long-term). Do you have any suggestions?

(2) The repo has been broken since I've tried merging lp:quantum back into (I'm new to bzr, so it's taking some getting used to). I'm working on getting it straightened out. When I do I'll only be adding 2 files. For quantum/client.py I have kept the Citrix banner because I refactored the MiniClient into it, so I retained the header. For the other file, a unit tests file, I'm finding out now how to properly credit it.

[dan wendlandt (danwent)]

On Tue, Jul 26, 2011 at 7:38 AM, Tyler Smith <email address hidden> wrote:

> Hi Sumit, thanks.
>
> (1) The library as it is only has methods for the high-level API operations
> outlined in the spec (http://wiki.openstack.org/QuantumAPISpec). There is
> a do_request method that can be used to to send any arbitrary query to
> Quantum server, but it's much less friendly than the high-level methods. A
> plugin could sub-class the Client and add its own methods (although I'm not
> sure how well this would work out long-term). Do you have any suggestions?
>

I think having some kind of generic "do_request" call makes sense.

>
> (2) The repo has been broken since I've tried merging lp:quantum back into
> (I'm new to bzr, so it's taking some getting used to). I'm working on
> getting it straightened out. When I do I'll only be adding 2 files. For
> quantum/client.py I have kept the Citrix banner because I refactored the
> MiniClient into it, so I retained the header. For the other file, a unit
> tests file, I'm finding out now how to properly credit it.
>

yes, bzr kind of sucks if you're used to something else. We can try and
help you out, but many of us are new to bzr as well (soon all openstack
projects will be shifting to github.com).

As for copyright, I think a standard thing to do is: (a) if you copy a
large part of a file, retain the copyrights notices that existed in the
original file and (b) if you make substantial changes to a file, add your
own copyright in addition to those that exist.

> --
>
> https://code.launchpad.net/~tylesmit/quantum/quantum-client-library/+merge/68247
> Your team Netstack Core Developers is subscribed to branch lp:quantum.
>

--
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Dan Wendlandt
Nicira Networks, Inc.
www.nicira.com | www.openvswitch.org
Sr. Product Manager
cell: 650-906-2650
~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Salvatore Orlando (salvatore-orlando)]

> On Tue, Jul 26, 2011 at 7:38 AM, Tyler Smith <email address hidden> wrote:
>
> > Hi Sumit, thanks.
> >
> > (1) The library as it is only has methods for the high-level API operations
> > outlined in the spec (http://wiki.openstack.org/QuantumAPISpec). There is
> > a do_request method that can be used to to send any arbitrary query to
> > Quantum server, but it's much less friendly than the high-level methods. A
> > plugin could sub-class the Client and add its own methods (although I'm not
> > sure how well this would work out long-term). Do you have any suggestions?
> >
>
> I think having some kind of generic "do_request" call makes sense.

I agree client apps can directly use do_request for submitting requests related to api extensions. We can probably try and make do_request a bit more user-friendly if it turns out to complex to us.
In the medium-long term I would however expect plugins to extend the quantum client library; not sure however whether "extended" client libraries should still be regarded as a part of Quantum.

>
>
> >
> > (2) The repo has been broken since I've tried merging lp:quantum back into
> > (I'm new to bzr, so it's taking some getting used to). I'm working on
> > getting it straightened out. When I do I'll only be adding 2 files. For
> > quantum/client.py I have kept the Citrix banner because I refactored the
> > MiniClient into it, so I retained the header. For the other file, a unit
> > tests file, I'm finding out now how to properly credit it.
> >
>
> yes, bzr kind of sucks if you're used to something else. We can try and
> help you out, but many of us are new to bzr as well (soon all openstack
> projects will be shifting to github.com).
>
> As for copyright, I think a standard thing to do is: (a) if you copy a
> large part of a file, retain the copyrights notices that existed in the
> original file and (b) if you make substantial changes to a file, add your
> own copyright in addition to those that exist.
>

I agree with Dan on Copyrights. Thiese are the general guidelines, but we don't have an "official" rule. My personal approach is:
- if you copy the file, keep the original copyright
- if you modify a part of it without altering the purpose of the file itself, add yourself as an author, do not touch copyright
- if you modify it in a way that it does something different wrt what it did before, apply your copyright
- and, of course, if you create it, use your copyright!

>
>
>
> > --
> >
> > https://code.launchpad.net/~tylesmit/quantum/quantum-client-
> library/+merge/68247
> > Your team Netstack Core Developers is subscribed to branch lp:quantum.
> >
>
>
>
> --
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~
> Dan Wendlandt
> Nicira Networks, Inc.
> www.nicira.com | www.openvswitch.org
> Sr. Product Manager
> cell: 650-906-2650
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Sumit Naiksatam (snaiksat)]

Thanks Tyler for the suggestion on the use of do_request(), we will explore it. In my opinion that would be a good and generic enough way for accessing extensions. Of course, if there is a way to make it easier to use, all the better.

I also agree that private extensions to the client library are always an option, and to Salvatore's point, those library extensions might not (or rather should not) necessarily be a part of Quantum.

In general, given that one of the main reasons for having the client library is to have a uniform/consistent way for potentials clients to access the Quantum API (and not to duplicate efforts), I think the do_request() mechanism (and any effort at enhancing it) will serve the community well.

On the point of credits, I agree with Dan & Salvatore's guidelines, I have personally been following exactly those rules of thumb. In this particular case, Tyler, I was suggesting that you take credit for the work you have put in (even if it means a minor modification to a particular file). :-)

[Ying Liu (yinliu2)]

Regarding to the client-library extension, we can keep two options open.

By default, "do_request()" can be used. Agree with Sumit, this provides a consistent way to access quantum services through quantum client library.

However, if vendors (or extension providers) like to have more user friendly client, they could provide extended client library, which may not be a part of Quantum.

Best,
Ying

> -----Original Message-----
> From: <email address hidden> [mailto:<email address hidden>] On Behalf Of
> Sumit Naiksatam (snaiksat)
> Sent: Tuesday, July 26, 2011 9:29 AM
> To: <email address hidden>
> Subject: Re: [Merge] lp:~tylesmit/quantum/quantum-client-library
> intolp:quantum
>
> Thanks Tyler for the suggestion on the use of do_request(), we will
> explore it. In my opinion that would be a good and generic enough way
> for accessing extensions. Of course, if there is a way to make it
> easier to use, all the better.
>
> I also agree that private extensions to the client library are always
> an option, and to Salvatore's point, those library extensions might not
> (or rather should not) necessarily be a part of Quantum.
>
> In general, given that one of the main reasons for having the client
> library is to have a uniform/consistent way for potentials clients to
> access the Quantum API (and not to duplicate efforts), I think the
> do_request() mechanism (and any effort at enhancing it) will serve the
> community well.
>
> On the point of credits, I agree with Dan & Salvatore's guidelines, I
> have personally been following exactly those rules of thumb. In this
> particular case, Tyler, I was suggesting that you take credit for the
> work you have put in (even if it means a minor modification to a
> particular file). :-)
> --
> https://code.launchpad.net/~tylesmit/quantum/quantum-client-
> library/+merge/68247
> You are reviewing the proposed merge of lp:~tylesmit/quantum/quantum-
> client-library into lp:quantum.

[dan wendlandt (danwent)]

On Tue, Jul 26, 2011 at 10:14 AM, Ying Liu <email address hidden> wrote:

> Regarding to the client-library extension, we can keep two options open.
>
> By default, "do_request()" can be used. Agree with Sumit, this provides a
> consistent way to access quantum services through quantum client library.
>
> However, if vendors (or extension providers) like to have more user
> friendly client, they could provide extended client library, which may not
> be a part of Quantum.
>

+1

>
> Best,
> Ying
>
> > -----Original Message-----
> > From: <email address hidden> [mailto:<email address hidden>] On Behalf Of
> > Sumit Naiksatam (snaiksat)
> > Sent: Tuesday, July 26, 2011 9:29 AM
> > To: <email address hidden>
> > Subject: Re: [Merge] lp:~tylesmit/quantum/quantum-client-library
> > intolp:quantum
> >
> > Thanks Tyler for the suggestion on the use of do_request(), we will
> > explore it. In my opinion that would be a good and generic enough way
> > for accessing extensions. Of course, if there is a way to make it
> > easier to use, all the better.
> >
> > I also agree that private extensions to the client library are always
> > an option, and to Salvatore's point, those library extensions might not
> > (or rather should not) necessarily be a part of Quantum.
> >
> > In general, given that one of the main reasons for having the client
> > library is to have a uniform/consistent way for potentials clients to
> > access the Quantum API (and not to duplicate efforts), I think the
> > do_request() mechanism (and any effort at enhancing it) will serve the
> > community well.
> >
> > On the point of credits, I agree with Dan & Salvatore's guidelines, I
> > have personally been following exactly those rules of thumb. In this
> > particular case, Tyler, I was suggesting that you take credit for the
> > work you have put in (even if it means a minor modification to a
> > particular file). :-)
> > --
> > https://code.launchpad.net/~tylesmit/quantum/quantum-client-
> > library/+merge/68247
> > You are reviewing the proposed merge of lp:~tylesmit/quantum/quantum-
> > client-library into lp:quantum.
>
> --
>
> https://code.launchpad.net/~tylesmit/quantum/quantum-client-library/+merge/68247
> Your team Netstack Core Developers is subscribed to branch lp:quantum.
>

--
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Dan Wendlandt
Nicira Networks, Inc.
www.nicira.com | www.openvswitch.org
Sr. Product Manager
cell: 650-906-2650
~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Tyler Smith (tylesmit)]

Due to the issues I ran into (and ended up creating), I uploaded a fixed branch to:

https://code.launchpad.net/~tylesmit/quantum/quantum-client-library-proper

And the merge request:

https://code.launchpad.net/~tylesmit/quantum/quantum-client-library-proper/+merge/69698

[dan wendlandt (danwent)]

Thanks Tyler,

I just wanted to confirm with you that your new merge prop means that we
should change the status of merge prop 68247 to "Rejected" so that no one is
confused about two branches currently being proposed for the same thing.
 Thanks,

Dan

On Thu, Jul 28, 2011 at 11:01 AM, Tyler Smith <email address hidden> wrote:

> Due to the issues I ran into (and ended up creating), I uploaded a fixed
> branch to:
>
> https://code.launchpad.net/~tylesmit/quantum/quantum-client-library-proper
>
> And the merge request:
>
>
> https://code.launchpad.net/~tylesmit/quantum/quantum-client-library-proper/+merge/69698
> --
>
> https://code.launchpad.net/~tylesmit/quantum/quantum-client-library/+merge/68247
> Your team Netstack Core Developers is subscribed to branch lp:quantum.
>

--
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Dan Wendlandt
Nicira Networks, Inc.
www.nicira.com | www.openvswitch.org
Sr. Product Manager
cell: 650-906-2650
~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Tyler Smith (tylesmit)]

Yes, please reject this merge request.

[Salvatore Orlando (salvatore-orlando)]

Rejected as superseded by: https://code.launchpad.net/~tylesmit/quantum/quantum-client-library-proper/+merge/69698

Unmerged revisions

27. By Tyler Smith on 2011-07-23

Adding some negative unit tests for the client library

26. By Tyler Smith on 2011-07-23

Merge in the client-library branch

=== modified file 'quantum/cli.py'
--- quantum/cli.py	2011-07-05 16:50:30 +0000
+++ quantum/cli.py	2011-07-23 18:23:02 +0000
@@ -26,61 +26,9 @@
 
 from manager import QuantumManager
 from optparse import OptionParser
-from quantum.common.wsgi import Serializer
+from client import Client
 
 FORMAT = "json"
-CONTENT_TYPE = "application/" + FORMAT
-
-
-### --- Miniclient (taking from the test directory)
-### TODO(bgh): move this to a library within quantum
-class MiniClient(object):
-    """A base client class - derived from Glance.BaseClient"""
-    action_prefix = '/v0.1/tenants/{tenant_id}'
-
-    def __init__(self, host, port, use_ssl):
-        self.host = host
-        self.port = port
-        self.use_ssl = use_ssl
-        self.connection = None
-
-    def get_connection_type(self):
-        if self.use_ssl:
-            return httplib.HTTPSConnection
-        else:
-            return httplib.HTTPConnection
-
-    def do_request(self, tenant, method, action, body=None,
-                   headers=None, params=None):
-        action = MiniClient.action_prefix + action
-        action = action.replace('{tenant_id}', tenant)
-        if type(params) is dict:
-            action += '?' + urllib.urlencode(params)
-        try:
-            connection_type = self.get_connection_type()
-            headers = headers or {}
-            # Open connection and send request
-            c = connection_type(self.host, self.port)
-            c.request(method, action, body, headers)
-            res = c.getresponse()
-            status_code = self.get_status_code(res)
-            if status_code in (httplib.OK, httplib.CREATED,
-                               httplib.ACCEPTED, httplib.NO_CONTENT):
-                return res
-            else:
-                raise Exception("Server returned error: %s" % res.read())
-        except (socket.error, IOError), e:
-            raise Exception("Unable to connect to server. Got error: %s" % e)
-
-    def get_status_code(self, response):
-        if hasattr(response, 'status_int'):
-            return response.status_int
-        else:
-            return response.status
-### -- end of miniclient
-
-### -- Core CLI functions
-
 
 def list_nets(manager, *args):
     tenant_id = args[0]
@@ -91,61 +39,50 @@
         name = net["net-name"]
         print "\tNetwork ID:%s \n\tNetwork Name:%s \n" % (id, name)
 
-
 def api_list_nets(client, *args):
     tenant_id = args[0]
-    res = client.do_request(tenant_id, 'GET', "/networks." + FORMAT)
-    resdict = json.loads(res.read())
-    LOG.debug(resdict)
+    res = client.list_networks()
+    LOG.debug(res)
     print "Virtual Networks on Tenant:%s\n" % tenant_id
-    for n in resdict["networks"]:
+    for n in res["networks"]:
         net_id = n["id"]
         print "\tNetwork ID:%s\n" % (net_id)
         # TODO(bgh): we should make this call pass back the name too
         # name = n["net-name"]
         # LOG.info("\tNetwork ID:%s \n\tNetwork Name:%s \n" % (id, name))
 
-
 def create_net(manager, *args):
     tid, name = args
     new_net_id = manager.create_network(tid, name)
     print "Created a new Virtual Network with ID:%s\n" % new_net_id
 
-
 def api_create_net(client, *args):
     tid, name = args
     data = {'network': {'network-name': '%s' % name}}
-    body = Serializer().serialize(data, CONTENT_TYPE)
-    res = client.do_request(tid, 'POST', "/networks." + FORMAT, body=body)
-    rd = json.loads(res.read())
-    LOG.debug(rd)
+    res = client.create_network(data)
+    LOG.debug(res)
     nid = None
     try:
-        nid = rd["networks"]["network"]["id"]
+        nid = res["networks"]["network"]["id"]
     except Exception, e:
         print "Failed to create network"
         # TODO(bgh): grab error details from ws request result
         return
     print "Created a new Virtual Network with ID:%s\n" % nid
 
-
 def delete_net(manager, *args):
     tid, nid = args
     manager.delete_network(tid, nid)
     print "Deleted Virtual Network with ID:%s" % nid
 
-
 def api_delete_net(client, *args):
     tid, nid = args
-    res = client.do_request(tid, 'DELETE', "/networks/" + nid + "." + FORMAT)
-    status = res.status
-    if status != 202:
+    try:
+        res = client.delete_network(nid)
+        print "Deleted Virtual Network with ID:%s" % nid
+    except Exception, e:
         print "Failed to delete network"
-        output = res.read()
-        print output
-    else:
-        print "Deleted Virtual Network with ID:%s" % nid
-
+        LOG.error("Failed to delete network: %s" % e)
 
 def detail_net(manager, *args):
     tid, nid = args
@@ -154,46 +91,44 @@
     for iface in iface_list:
         print "\tRemote interface:%s" % iface
 
-
 def api_detail_net(client, *args):
     tid, nid = args
-    res = client.do_request(tid, 'GET',
-      "/networks/%s/ports.%s" % (nid, FORMAT))
-    output = res.read()
-    if res.status != 200:
-        LOG.error("Failed to list ports: %s" % output)
-        return
-    rd = json.loads(output)
-    LOG.debug(rd)
+    try:
+        res = client.list_network_details(nid)["networks"]["network"]
+    except Exception, e:
+        LOG.error("Failed to get network details: %s" % e)
+        return
+
+    try:
+        ports = client.list_ports(nid)
+    except Exception, e:
+        LOG.error("Failed to list ports: %s" % e)
+        return
+    print "Network %s (%s)" % (res['name'], res['id'])
     print "Remote Interfaces on Virtual Network:%s\n" % nid
-    for port in rd["ports"]:
+    for port in ports["ports"]:
         pid = port["id"]
-        res = client.do_request(tid, 'GET',
-          "/networks/%s/ports/%s/attachment.%s" % (nid, pid, FORMAT))
-        output = res.read()
-        rd = json.loads(output)
-        LOG.debug(rd)
-        remote_iface = rd["attachment"]
+        res = client.list_port_attachments(nid, pid)
+        LOG.debug(res)
+        remote_iface = res["attachment"]
         print "\tRemote interface:%s" % remote_iface
 
-
 def rename_net(manager, *args):
     tid, nid, name = args
     manager.rename_network(tid, nid, name)
     print "Renamed Virtual Network with ID:%s" % nid
 
-
 def api_rename_net(client, *args):
     tid, nid, name = args
     data = {'network': {'network-name': '%s' % name}}
-    body = Serializer().serialize(data, CONTENT_TYPE)
-    res = client.do_request(tid, 'PUT', "/networks/%s.%s" % (nid, FORMAT),
-      body=body)
-    resdict = json.loads(res.read())
-    LOG.debug(resdict)
+    try:
+        res = client.update_network(nid, data)
+    except Exception, e:
+        LOG.error("Failed to rename network %s: %s" % (nid,e))
+        return
+    LOG.debug(res)
     print "Renamed Virtual Network with ID:%s" % nid
 
-
 def list_ports(manager, *args):
     tid, nid = args
     ports = manager.get_all_ports(tid, nid)
@@ -201,61 +136,52 @@
     for port in ports:
         print "\tVirtual Port:%s" % port["port-id"]
 
-
 def api_list_ports(client, *args):
     tid, nid = args
-    res = client.do_request(tid, 'GET',
-      "/networks/%s/ports.%s" % (nid, FORMAT))
-    output = res.read()
-    if res.status != 200:
-        LOG.error("Failed to list ports: %s" % output)
+    try:
+        ports = client.list_ports(nid)
+    except Exception, e:
+        LOG.error("Failed to list ports: %s" % e)
         return
-    rd = json.loads(output)
-    LOG.debug(rd)
+
+    LOG.debug(ports)
     print "Ports on Virtual Network:%s\n" % nid
-    for port in rd["ports"]:
+    for port in ports["ports"]:
         print "\tVirtual Port:%s" % port["id"]
 
-
 def create_port(manager, *args):
     tid, nid = args
     new_port = manager.create_port(tid, nid)
     print "Created Virtual Port:%s " \
           "on Virtual Network:%s" % (new_port, nid)
 
-
 def api_create_port(client, *args):
     tid, nid = args
-    res = client.do_request(tid, 'POST',
-      "/networks/%s/ports.%s" % (nid, FORMAT))
-    output = res.read()
-    if res.status != 200:
-        LOG.error("Failed to create port: %s" % output)
+    try:
+        res = client.create_port(nid)
+    except Exception, e:
+        LOG.error("Failed to create port: %s" % e)
         return
-    rd = json.loads(output)
-    new_port = rd["ports"]["port"]["id"]
+    new_port = res["ports"]["port"]["id"]
     print "Created Virtual Port:%s " \
           "on Virtual Network:%s" % (new_port, nid)
 
-
 def delete_port(manager, *args):
     tid, nid, pid = args
-    manager.delete_port(tid, nid, pid)
     LOG.info("Deleted Virtual Port:%s " \
           "on Virtual Network:%s" % (pid, nid))
 
-
 def api_delete_port(client, *args):
     tid, nid, pid = args
-    res = client.do_request(tid, 'DELETE',
-      "/networks/%s/ports/%s.%s" % (nid, pid, FORMAT))
-    output = res.read()
-    if res.status != 202:
-        LOG.error("Failed to delete port: %s" % output)
+    try:
+        res = client.delete_port(nid, pid)
+    except Exception, e:
+        LOG.error("Failed to delete port: %s" % e)
         return
     LOG.info("Deleted Virtual Port:%s " \
           "on Virtual Network:%s" % (pid, nid))
-
+    print "Deleted Virtual Port:%s " \
+          "on Virtual Network:%s" % (pid, nid)
 
 def detail_port(manager, *args):
     tid, nid, pid = args
@@ -263,115 +189,111 @@
     print "Virtual Port:%s on Virtual Network:%s " \
           "contains remote interface:%s" % (pid, nid, port_detail)
 
-
 def api_detail_port(client, *args):
     tid, nid, pid = args
-    res = client.do_request(tid, 'GET',
-      "/networks/%s/ports/%s.%s" % (nid, pid, FORMAT))
-    output = res.read()
-    if res.status != 200:
-        LOG.error("Failed to get port details: %s" % output)
+    try:
+        port = client.list_port_details(nid, pid)["ports"]["port"]
+    except Exception, e:
+        LOG.error("Failed to get port details: %s" % e)
         return
-    rd = json.loads(output)
-    port = rd["ports"]["port"]
+
     id = port["id"]
     attachment = port["attachment"]
     LOG.debug(port)
     print "Virtual Port:%s on Virtual Network:%s " \
           "contains remote interface:%s" % (pid, nid, attachment)
 
-
 def plug_iface(manager, *args):
     tid, nid, pid, vid = args
     manager.plug_interface(tid, nid, pid, vid)
     print "Plugged remote interface:%s " \
       "into Virtual Network:%s" % (vid, nid)
 
-
 def api_plug_iface(client, *args):
-    tid, nid, pid, vid = args
-    data = {'port': {'attachment-id': '%s' % vid}}
-    body = Serializer().serialize(data, CONTENT_TYPE)
-    res = client.do_request(tid, 'PUT',
-      "/networks/%s/ports/%s/attachment.%s" % (nid, pid, FORMAT), body=body)
-    output = res.read()
-    LOG.debug(output)
-    if res.status != 202:
+    tid, nid, pid, vid = args 
+    try:
+        data = {'port': {'attachment-id': '%s' % vid}}
+        res = client.attach_resource(nid, pid, data)
+    except Exception, e:
         LOG.error("Failed to plug iface \"%s\" to port \"%s\": %s" % (vid,
           pid, output))
         return
-    print "Plugged interface \"%s\" to port:%s on network:%s" % (vid, pid,
-      nid)
-
-
-def unplug_iface(manager, *args):
+    LOG.debug(res)
+    print "Plugged interface \"%s\" to port:%s on network:%s" % (vid, pid, nid)
+
+def unplug_iface(manager,  *args):
     tid, nid, pid = args
     manager.unplug_interface(tid, nid, pid)
     print "UnPlugged remote interface " \
       "from Virtual Port:%s Virtual Network:%s" % (pid, nid)
 
-
 def api_unplug_iface(client, *args):
     tid, nid, pid = args
-    data = {'port': {'attachment-id': ''}}
-    body = Serializer().serialize(data, CONTENT_TYPE)
-    res = client.do_request(tid, 'DELETE',
-      "/networks/%s/ports/%s/attachment.%s" % (nid, pid, FORMAT), body=body)
-    output = res.read()
-    LOG.debug(output)
-    if res.status != 202:
-        LOG.error("Failed to unplug iface from port \"%s\": %s" % \
-            (pid, output))
+    try:
+        res = client.detach_resource(nid, pid)
+    except Exception, e:
+        LOG.error("Failed to unplug iface from port \"%s\": %s" % (pid, e))
         return
+    LOG.debug(res)
     print "Unplugged interface from port:%s on network:%s" % (pid, nid)
 
-
 commands = {
   "list_nets": {
     "func": list_nets,
     "api_func": api_list_nets,
-    "args": ["tenant-id"]},
+    "args": ["tenant-id"]
+    },
   "create_net": {
     "func": create_net,
     "api_func": api_create_net,
-    "args": ["tenant-id", "net-name"]},
+    "args": ["tenant-id", "net-name"]
+    },
   "delete_net": {
     "func": delete_net,
     "api_func": api_delete_net,
-    "args": ["tenant-id", "net-id"]},
+    "args": ["tenant-id", "net-id"]
+    },
   "detail_net": {
     "func": detail_net,
     "api_func": api_detail_net,
-    "args": ["tenant-id", "net-id"]},
+    "args": ["tenant-id", "net-id"]
+    },
   "rename_net": {
     "func": rename_net,
     "api_func": api_rename_net,
-    "args": ["tenant-id", "net-id", "new-name"]},
+    "args": ["tenant-id", "net-id", "new-name"]
+    },
   "list_ports": {
     "func": list_ports,
     "api_func": api_list_ports,
-    "args": ["tenant-id", "net-id"]},
+    "args": ["tenant-id", "net-id"]
+    },
   "create_port": {
     "func": create_port,
     "api_func": api_create_port,
-    "args": ["tenant-id", "net-id"]},
+    "args": ["tenant-id", "net-id"]
+    },
   "delete_port": {
     "func": delete_port,
     "api_func": api_delete_port,
-    "args": ["tenant-id", "net-id", "port-id"]},
+    "args": ["tenant-id", "net-id", "port-id"]
+    },
   "detail_port": {
     "func": detail_port,
     "api_func": api_detail_port,
-    "args": ["tenant-id", "net-id", "port-id"]},
+    "args": ["tenant-id", "net-id", "port-id"]
+    },
   "plug_iface": {
     "func": plug_iface,
     "api_func": api_plug_iface,
-    "args": ["tenant-id", "net-id", "port-id", "iface-id"]},
+    "args": ["tenant-id", "net-id", "port-id", "iface-id"]
+    },
   "unplug_iface": {
     "func": unplug_iface,
     "api_func": api_unplug_iface,
-    "args": ["tenant-id", "net-id", "port-id"]}, }
-
+    "args": ["tenant-id", "net-id", "port-id"]
+    },
+  }
 
 def help():
     print "\nCommands:"
@@ -379,7 +301,6 @@
         print "    %s %s" % (k,
           " ".join(["<%s>" % y for y in commands[k]["args"]]))
 
-
 def build_args(cmd, cmdargs, arglist):
     args = []
     orig_arglist = arglist[:]
@@ -401,7 +322,6 @@
         return None
     return args
 
-
 if __name__ == "__main__":
     usagestr = "Usage: %prog [OPTIONS] <command> [args]"
     parser = OptionParser(usage=usagestr)
@@ -440,8 +360,9 @@
         sys.exit(1)
     LOG.debug("Executing command \"%s\" with args: %s" % (cmd, args))
     if not options.load_plugin:
-        client = MiniClient(options.host, options.port, options.ssl)
-        if "api_func" not in commands[cmd]:
+        client = Client(options.host, options.port, options.ssl,
+            args[0], FORMAT)
+        if not commands[cmd].has_key("api_func"):
             LOG.error("API version of \"%s\" is not yet implemented" % cmd)
             sys.exit(1)
         commands[cmd]["api_func"](client, *args)

=== added file 'quantum/client.py'
--- quantum/client.py	1970-01-01 00:00:00 +0000
+++ quantum/client.py	2011-07-23 18:23:02 +0000
@@ -0,0 +1,254 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Citrix Systems
+# 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.
+
+import httplib
+import socket
+import urllib
+from quantum.common.wsgi import Serializer
+
+class api_call(object):
+    """A Decorator to add support for format and tenant overriding"""
+    def __init__(self, f):
+        self.f = f
+
+    def __get__(self, instance, owner):
+        def with_params(*args, **kwargs):
+            # Backup the format and tenant, then temporarily change them if needed
+            (format, tenant) = (instance.format, instance.tenant)
+
+            if 'format' in kwargs:
+                instance.format = kwargs['format']
+            if 'tenant' in kwargs:
+                instance.tenant = kwargs['tenant']
+
+            ret = self.f(instance, *args)
+            (instance.format, instance.tenant) = (format, tenant)
+            return ret
+        return with_params
+
+class Client(object):
+
+    """A base client class - derived from Glance.BaseClient"""
+
+    action_prefix = '/v0.1/tenants/{tenant_id}'
+    
+    """Action query strings"""
+    networks_path = "/networks"
+    network_path = "/networks/%s"
+    ports_path = "/networks/%s/ports"
+    port_path = "/networks/%s/ports/%s"
+    attachment_path = "/networks/%s/ports/%s/attachment"
+
+    def __init__(self, host, port, use_ssl,
+        tenant=None, format="xml", testingStub=None):
+        """
+        Creates a new client to some service.
+
+        :param host: The host where service resides
+        :param port: The port where service resides
+        :param use_ssl: Should we use HTTPS?
+        :param tenant: The tenant ID to make requests with
+        :param format: The format to query the server with
+        :param testingStub: A class that stubs basic server attributes for tests
+        """
+        self.host = host
+        self.port = port
+        self.use_ssl = use_ssl
+        self.tenant = tenant
+        self.format = format
+        self.connection = None
+        self.testingStub = testingStub
+
+    def get_connection_type(self):
+        """
+        Returns the proper connection type
+        """
+        if self.testingStub:
+            return self.testingStub
+        if self.use_ssl:
+            return httplib.HTTPSConnection
+        else:
+            return httplib.HTTPConnection
+
+    def do_request(self, method, action, body=None,
+                   headers=None, params=None):
+        """
+        Connects to the server and issues a request.  
+        Returns the result data, or raises an appropriate exception if
+        HTTP status code is not 2xx
+
+        :param method: HTTP method ("GET", "POST", "PUT", etc...)
+        :param body: string of data to send, or None (default)
+        :param headers: mapping of key/value pairs to add as headers
+        :param params: dictionary of key/value pairs to add to append
+                             to action
+
+        """
+        
+        # Ensure we have a tenant id
+        if not self.tenant:
+            raise Exception("Tenant ID not set")
+
+        # Add format and tenant_id
+        action += ".%s" % self.format
+        action = Client.action_prefix + action
+        action = action.replace('{tenant_id}',self.tenant)
+
+        if type(params) is dict:
+            action += '?' + urllib.urlencode(params)
+
+        try:
+            connection_type = self.get_connection_type()
+            headers = headers or {}
+            
+            # Open connection and send request
+            c = connection_type(self.host, self.port)
+            c.request(method, action, body, headers)
+            res = c.getresponse()
+            status_code = self.get_status_code(res)
+            if status_code in (httplib.OK,
+                               httplib.CREATED,
+                               httplib.ACCEPTED,
+                               httplib.NO_CONTENT):
+                return self.deserialize(res)
+            else:
+                raise Exception("Server returned error: %s" % res.read())
+
+        except (socket.error, IOError), e:
+            raise Exception("Unable to connect to "
+                            "server. Got error: %s" % e)
+
+    def get_status_code(self, response):
+        """
+        Returns the integer status code from the response, which
+        can be either a Webob.Response (used in testing) or httplib.Response
+        """
+        if hasattr(response, 'status_int'):
+            return response.status_int
+        else:
+            return response.status
+
+    def serialize(self, data):
+        if type(data) is dict:
+            return Serializer().serialize(data, self.content_type())
+
+    def deserialize(self, data):
+        if self.get_status_code(data) == 202:
+            return data.read()
+        return Serializer().deserialize(data.read(), self.content_type())
+
+    def content_type(self, format=None):
+        if not format:
+            format = self.format
+        return "application/%s" % (format)
+
+    @api_call
+    def list_networks(self):
+        """
+        Queries the server for a list of networks
+        """
+        return self.do_request("GET", self.networks_path)
+
+    @api_call
+    def list_network_details(self, network):
+        """
+        Queries the server for the details of a certain network
+        """
+        return self.do_request("GET", (self.network_path%network))
+
+    @api_call
+    def create_network(self, body=None):
+        """
+        Creates a new network on the server
+        """
+        body = self.serialize(body)
+        return self.do_request("POST", self.networks_path, body=body)
+
+    @api_call
+    def update_network(self, network, body=None):
+        """
+        Updates a network on the server
+        """
+        body = self.serialize(body)
+        return self.do_request("PUT", self.network_path % (network),body=body)
+
+    @api_call
+    def delete_network(self, network):
+        """
+        Deletes a network on the server
+        """
+        return self.do_request("DELETE", self.network_path % (network))
+
+    @api_call
+    def list_ports(self, network):
+        """
+        Queries the server for a list of ports on a given network
+        """
+        return self.do_request("GET", self.ports_path % (network))
+
+    @api_call
+    def list_port_details(self, network, port):
+        """
+        Queries the server for a list of ports on a given network
+        """
+        return self.do_request("GET", self.port_path % (network,port))
+
+    @api_call
+    def create_port(self, network):
+        """
+        Creates a new port on a network on the server
+        """
+        return self.do_request("POST", self.ports_path % (network))
+
+    @api_call
+    def delete_port(self, network, port):
+        """
+        Deletes a port from a network on the server
+        """
+        return self.do_request("DELETE", self.port_path % (network,port))
+
+    @api_call
+    def set_port_state(self, network, port, body=None):
+        """
+        Sets the state of a port on the server
+        """
+        body = self.serialize(body)
+        return self.do_request("PUT",
+            self.port_path % (network,port), body=body)
+
+    @api_call
+    def list_port_attachments(self, network, port):
+        """
+        Deletes a port from a network on the server
+        """
+        return self.do_request("GET", self.attachment_path % (network,port))
+    
+    @api_call
+    def attach_resource(self, network, port, body=None):
+        """
+        Deletes a port from a network on the server
+        """
+        body = self.serialize(body)
+        return self.do_request("PUT",
+            self.attachment_path % (network,port), body=body)
+
+    @api_call
+    def detach_resource(self, network, port):
+        """
+        Deletes a port from a network on the server
+        """
+        return self.do_request("DELETE", self.attachment_path % (network,port))

=== added directory 'tests'
=== removed directory 'tests'
=== added file 'tests/__init__.py'
=== removed file 'tests/__init__.py'
=== added directory 'tests/unit'
=== removed directory 'tests/unit'
=== added file 'tests/unit/__init__.py'
--- tests/unit/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/unit/__init__.py	2011-07-23 18:23:02 +0000
@@ -0,0 +1,32 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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.
+
+# See http://code.google.com/p/python-nose/issues/detail?id=373
+# The code below enables nosetests to work with i18n _() blocks
+import __builtin__
+import unittest
+setattr(__builtin__, '_', lambda x: x)
+
+
+class BaseTest(unittest.TestCase):
+
+    def setUp(self):
+        pass
+
+
+def setUp():
+    pass

=== removed file 'tests/unit/__init__.py'
--- tests/unit/__init__.py	2011-06-08 08:52:51 +0000
+++ tests/unit/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2011 OpenStack LLC.
-# 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.
-
-# See http://code.google.com/p/python-nose/issues/detail?id=373
-# The code below enables nosetests to work with i18n _() blocks
-import __builtin__
-import unittest
-setattr(__builtin__, '_', lambda x: x)
-
-
-class BaseTest(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-
-def setUp():
-    pass

=== added file 'tests/unit/api.py'
--- tests/unit/api.py	1970-01-01 00:00:00 +0000
+++ tests/unit/api.py	2011-07-23 18:23:02 +0000
@@ -0,0 +1,603 @@
+import logging
+import unittest
+import re
+
+from quantum.common.wsgi import Serializer
+from quantum.client import Client
+
+LOG = logging.getLogger('quantum.tests.test_api')
+
+# Set a couple tenants to use for testing
+TENANT_1 = 'totore'
+TENANT_2 = 'totore2'
+
+class ServerStub():
+    """This class stubs a basic server for the API client to talk to"""
+
+    class Response(object):
+        """This class stubs a basic response to send the API client"""
+        def __init__(self, content = None, status = None):
+            self.content = content
+            self.status = status
+
+        def read(self):
+            return self.content
+
+        def status(self):
+            return status
+            
+    # To test error codes, set the host to 10.0.0.1, and the port to the code
+    def __init__(self, host, port):
+        self.host = host
+        self.port = port
+
+    def request(self, method, action, body, headers):
+        self.method = method
+        self.action = action
+        self.body = body
+
+    def status(self, status=None):
+        return status or 200
+
+    def getresponse(self):
+        res = self.Response(status = self.status())
+
+        # If the host is 10.0.0.1, return the port as an error code
+        if self.host == "10.0.0.1":
+            res.status = self.port
+            return res
+
+        # Extract important information from the action string to assure sanity
+        match = re.search('tenants/(.+?)/(.+)\.(json|xml)$', self.action)
+
+        (tenant,path,format) = (match.group(1),match.group(2),match.group(3))
+
+        data = {'data': {'method':self.method, 'action':self.action,
+                'body':self.body,'tenant':tenant, 'path':path, 'format':format}}
+        
+        # Serialize it to the proper format so the API client can deserialize it
+        if data['data']['format'] == 'json':
+            res.content = Serializer().serialize(data, "application/json")
+        else:
+            res.content = Serializer().serialize(data, "application/xml")
+        return res
+
+class APITest(unittest.TestCase):
+
+    def setUp(self):
+        """ Setups a test environment for the API client """
+        HOST = '127.0.0.1'
+        PORT = 9696
+        USE_SSL = False
+
+        self.client = Client(HOST,PORT,USE_SSL,TENANT_1,'json',ServerStub)
+
+    def _assert_sanity(self, call, status, method, path, data=[], params={}):
+        """ Perform common assertions to test the sanity of client requests """
+
+        # Handle an error case first
+        if status != 200:
+            (self.client.host,self.client.port) = ("10.0.0.1", status)
+            self.assertRaises(Exception, call, *data, **params)
+            return
+
+        # Not an error case
+        # Make the call, then get the data from the root node and strip its data
+        data = call(*data, **params)['data']
+        for k in data:
+            if data[k]:
+                data[k] = data[k].strip()
+
+        self.assertEqual(data['method'], method)
+        self.assertEqual(data['format'], params['format'])
+        self.assertEqual(data['tenant'], params['tenant'])
+        self.assertEqual(data['path'], path)
+
+
+    def _test_list_networks(self, tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_list_networks - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.list_networks,
+                            status,
+                            "GET",
+                            "networks",
+                            data = [],
+                            params = {'tenant':tenant, 'format':format},)
+
+        LOG.debug("_test_list_networks - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_list_network_details(self,
+                                   tenant=TENANT_1,format='json',status=200):
+        LOG.debug("_test_list_network_details - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.list_network_details,
+                            status,
+                            "GET",
+                            "networks/001",
+                            data = ["001"],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_list_network_details - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_create_network(self, tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_create_network - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.create_network,
+                            status,
+                            "POST",
+                            "networks",
+                            data = [{'network': {'net-name': 'testNetwork'}}],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_create_network - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_update_network(self, tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_update_network - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.update_network,
+                            status,
+                            "PUT",
+                            "networks/001",
+                            data = [
+                                "001",
+                                {'network': {'net-name': 'newName'}}
+                            ],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_update_network - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_delete_network(self, tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_delete_network - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.delete_network,
+                            status,
+                            "DELETE",
+                            "networks/001",
+                            data = ["001"],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_delete_network - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_list_ports(self, tenant = TENANT_1, format = 'json', status=200):
+        LOG.debug("_test_list_ports - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.list_ports,
+                            status,
+                            "GET",
+                            "networks/001/ports",
+                            data = ["001"],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_list_ports - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_list_port_details(self,
+                                tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_list_port_details - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.list_port_details,
+                            status,
+                            "GET",
+                            "networks/001/ports/001",
+                            data = ["001","001"],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_list_port_details - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_create_port(self, tenant = TENANT_1, format = 'json', status=200):
+        LOG.debug("_test_create_port - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.create_port,
+                            status,
+                            "POST",
+                            "networks/001/ports",
+                            data = ["001"],
+                            params = {'tenant':tenant, 'format':format})
+
+
+        LOG.debug("_test_create_port - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_delete_port(self, tenant = TENANT_1, format = 'json', status=200):
+        LOG.debug("_test_delete_port - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.delete_port,
+                            status,
+                            "DELETE",
+                            "networks/001/ports/001",
+                            data = ["001","001"],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_delete_port - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+
+    def _test_set_port_state(self, tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_set_port_state - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.set_port_state,
+                            status,
+                            "PUT",
+                            "networks/001/ports/001",
+                            data = ["001","001",{'port':{'state':'ACTIVE'}}],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_set_port_state - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_list_port_attachments(self,
+                                    tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_list_port_attachments - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.list_port_attachments,
+                            status,
+                            "GET",
+                            "networks/001/ports/001/attachment",
+                            data = ["001","001"],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_list_port_attachments - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_attach_resource(self, tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_attach_resource - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.attach_resource,
+                            status,
+                            "PUT",
+                            "networks/001/ports/001/attachment",
+                            data = ["001","001",{'resource':{'id':'1234'}}],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_attach_resource - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+    def _test_detach_resource(self, tenant=TENANT_1, format='json', status=200):
+        LOG.debug("_test_detach_resource - tenant:%s "\
+                  "- format:%s - START", format, tenant)
+
+        self._assert_sanity(self.client.detach_resource,
+                            status,
+                            "DELETE",
+                            "networks/001/ports/001/attachment",
+                            data = ["001","001"],
+                            params = {'tenant':tenant, 'format':format})
+
+        LOG.debug("_test_detach_resource - tenant:%s "\
+                  "- format:%s - END", format, tenant)
+
+
+    def test_list_networks_json(self):
+        self._test_list_networks(format='json')
+
+    def test_list_networks_xml(self):
+        self._test_list_networks(format='xml')
+
+    def test_list_networks_alt_tenant(self):
+        self._test_list_networks(tenant=TENANT_2)
+
+    def test_list_networks_error_470(self):
+        self._test_list_networks(status=470)
+
+    def test_list_networks_error_401(self):
+        self._test_list_networks(status=401)
+
+
+
+    def test_list_network_details_json(self):
+        self._test_list_network_details(format='json')
+
+    def test_list_network_details_xml(self):
+        self._test_list_network_details(format='xml')
+
+    def test_list_network_details_alt_tenant(self):
+        self._test_list_network_details(tenant=TENANT_2)
+
+    def test_list_network_details_error_470(self):
+        self._test_list_network_details(status=470)
+
+    def test_list_network_details_error_401(self):
+        self._test_list_network_details(status=401)
+
+    def test_list_network_details_error_420(self):
+        self._test_list_network_details(status=420)
+
+
+
+    def test_create_network_json(self):
+        self._test_create_network(format='json')
+
+    def test_create_network_xml(self):
+        self._test_create_network(format='xml')
+
+    def test_create_network_alt_tenant(self):
+        self._test_create_network(tenant=TENANT_2)
+
+    def test_create_network_error_470(self):
+        self._test_create_network(status=470)
+
+    def test_create_network_error_401(self):
+        self._test_create_network(status=401)
+
+    def test_create_network_error_400(self):
+        self._test_create_network(status=400)
+
+    def test_create_network_error_422(self):
+        self._test_create_network(status=422)
+
+
+
+
+    def test_update_network_json(self):
+        self._test_update_network(format='json')
+
+    def test_update_network_xml(self):
+        self._test_update_network(format='xml')
+
+    def test_update_network_alt_tenant(self):
+        self._test_update_network(tenant=TENANT_2)
+
+    def test_update_network_error_470(self):
+        self._test_update_network(status=470)
+
+    def test_update_network_error_401(self):
+        self._test_update_network(status=401)
+
+    def test_update_network_error_400(self):
+        self._test_update_network(status=400)
+
+    def test_update_network_error_420(self):
+        self._test_update_network(status=420)
+
+    def test_update_network_error_422(self):
+        self._test_update_network(status=422)
+
+
+
+    def test_delete_network_json(self):
+        self._test_delete_network(format='json')
+
+    def test_delete_network_xml(self):
+        self._test_delete_network(format='xml')
+
+    def test_delete_network_alt_tenant(self):
+        self._test_delete_network(tenant=TENANT_2)
+
+    def test_delete_network_error_470(self):
+        self._test_delete_network(status=470)
+
+    def test_delete_network_error_401(self):
+        self._test_delete_network(status=401)
+
+    def test_delete_network_error_420(self):
+        self._test_delete_network(status=420)
+
+    def test_delete_network_error_421(self):
+        self._test_delete_network(status=421)
+
+
+
+    def test_list_ports_json(self):
+        self._test_list_ports(format='json')
+
+    def test_list_ports_xml(self):
+        self._test_list_ports(format='xml')
+
+    def test_list_ports_alt_tenant(self):
+        self._test_list_ports(tenant=TENANT_2)
+
+    def test_list_ports_error_470(self):
+        self._test_list_ports(status=470)
+
+    def test_list_ports_error_401(self):
+        self._test_list_ports(status=401)
+
+    def test_list_ports_error_420(self):
+        self._test_list_ports(status=420)
+
+
+
+    def test_list_port_details_json(self):
+        self._test_list_ports(format='json')
+
+    def test_list_port_details_xml(self):
+        self._test_list_ports(format='xml')
+
+    def test_list_port_details_alt_tenant(self):
+        self._test_list_ports(tenant=TENANT_2)
+
+    def test_list_port_details_error_470(self):
+        self._test_list_port_details(status=470)
+
+    def test_list_port_details_error_401(self):
+        self._test_list_ports(status=401)
+
+    def test_list_port_details_error_420(self):
+        self._test_list_ports(status=420)
+
+    def test_list_port_details_error_430(self):
+        self._test_list_ports(status=430)
+
+
+
+    def test_create_port_json(self):
+        self._test_create_port(format='json')
+
+    def test_create_port_xml(self):
+        self._test_create_port(format='xml')
+
+    def test_create_port_alt_tenant(self):
+        self._test_create_port(tenant=TENANT_2)
+
+    def test_create_port_error_470(self):
+        self._test_create_port(status=470)
+
+    def test_create_port_error_401(self):
+        self._test_create_port(status=401)
+
+    def test_create_port_error_400(self):
+        self._test_create_port(status=400)
+
+    def test_create_port_error_420(self):
+        self._test_create_port(status=420)
+
+    def test_create_port_error_430(self):
+        self._test_create_port(status=430)
+
+    def test_create_port_error_431(self):
+        self._test_create_port(status=431)
+
+
+
+    def test_delete_port_json(self):
+        self._test_delete_port(format='json')
+
+    def test_delete_port_xml(self):
+        self._test_delete_port(format='xml')
+
+    def test_delete_port_alt_tenant(self):
+        self._test_delete_port(tenant=TENANT_2)
+
+    def test_delete_port_error_470(self):
+        self._test_delete_port(status=470)
+
+    def test_delete_port_error_401(self):
+        self._test_delete_port(status=401)
+
+    def test_delete_port_error_420(self):
+        self._test_delete_port(status=420)
+
+    def test_delete_port_error_430(self):
+        self._test_delete_port(status=430)
+
+    def test_delete_port_error_432(self):
+        self._test_delete_port(status=432)
+
+
+
+    def test_set_port_state_json(self):
+        self._test_set_port_state(format='json')
+
+    def test_set_port_state_xml(self):
+        self._test_set_port_state(format='xml')
+
+    def test_set_port_state_alt_tenant(self):
+        self._test_set_port_state(tenant=TENANT_2)
+
+    def test_set_port_state_error_470(self):
+        self._test_set_port_state(status=470)
+
+    def test_set_port_state_error_401(self):
+        self._test_set_port_state(status=401)
+
+    def test_set_port_state_error_400(self):
+        self._test_set_port_state(status=400)
+
+    def test_set_port_state_error_420(self):
+        self._test_set_port_state(status=420)
+
+    def test_set_port_state_error_430(self):
+        self._test_set_port_state(status=430)
+
+    def test_set_port_state_error_431(self):
+        self._test_set_port_state(status=431)
+
+
+
+    def test_list_port_attachments_json(self):
+        self._test_list_port_attachments(format='json')
+
+    def test_list_port_attachments_xml(self):
+        self._test_list_port_attachments(format='xml')
+
+    def test_list_port_attachments_alt_tenant(self):
+        self._test_list_port_attachments(tenant=TENANT_2)
+
+    def test_list_port_attachments_error_470(self):
+        self._test_list_port_attachments(status=470)
+
+    def test_list_port_attachments_error_401(self):
+        self._test_list_port_attachments(status=401)
+
+    def test_list_port_attachments_error_400(self):
+        self._test_list_port_attachments(status=400)
+
+    def test_list_port_attachments_error_420(self):
+        self._test_list_port_attachments(status=420)
+
+    def test_list_port_attachments_error_430(self):
+        self._test_list_port_attachments(status=430)
+
+
+
+    def test_attach_resource_json(self):
+        self._test_attach_resource(format='json')
+
+    def test_attach_resource_xml(self):
+        self._test_attach_resource(format='xml')
+
+    def test_attach_resource_alt_tenant(self):
+        self._test_attach_resource(tenant=TENANT_2)
+
+    def test_attach_resource_error_470(self):
+        self._test_attach_resource(status=470)
+
+    def test_attach_resource_error_401(self):
+        self._test_attach_resource(status=401)
+
+    def test_attach_resource_error_400(self):
+        self._test_attach_resource(status=400)
+
+    def test_attach_resource_error_420(self):
+        self._test_attach_resource(status=420)
+
+    def test_attach_resource_error_430(self):
+        self._test_attach_resource(status=430)
+
+    def test_attach_resource_error_432(self):
+        self._test_attach_resource(status=432)
+
+    def test_attach_resource_error_440(self):
+        self._test_attach_resource(status=440)
+
+
+
+    def test_detach_resource_json(self):
+        self._test_detach_resource(format='json')
+
+    def test_detach_resource_xml(self):
+        self._test_detach_resource(format='xml')
+
+    def test_detach_resource_alt_tenant(self):
+        self._test_detach_resource(tenant=TENANT_2)
+
+    def test_detach_resource_error_470(self):
+        self._test_detach_resource(status=470)
+
+    def test_detach_resource_error_401(self):
+        self._test_detach_resource(status=401)
+
+    def test_detach_resource_error_420(self):
+        self._test_detach_resource(status=420)
+
+    def test_detach_resource_error_430(self):
+        self._test_detach_resource(status=430)
+

=== added file 'tests/unit/test_api.py'
--- tests/unit/test_api.py	1970-01-01 00:00:00 +0000
+++ tests/unit/test_api.py	2011-07-23 18:23:02 +0000
@@ -0,0 +1,831 @@
+# 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_api as testlib
+
+from quantum import api as server
+from quantum.db import api as db
+from quantum.common.wsgi import Serializer
+
+
+LOG = logging.getLogger('quantum.tests.test_api')
+
+
+class APITest(unittest.TestCase):
+
+    def _create_network(self, format, name=None, custom_req_body=None,
+                        expected_res_status=200):
+        LOG.debug("Creating network")
+        content_type = "application/" + format
+        if name:
+            net_name = name
+        else:
+            net_name = self.network_name
+        network_req = testlib.new_network_request(self.tenant_id,
+                                                  net_name, format,
+                                                  custom_req_body)
+        network_res = network_req.get_response(self.api)
+        self.assertEqual(network_res.status_int, expected_res_status)
+        if expected_res_status == 200:
+            network_data = Serializer().deserialize(network_res.body,
+                                                    content_type)
+            return network_data['networks']['network']['id']
+
+    def _create_port(self, network_id, port_state, format,
+                     custom_req_body=None, expected_res_status=200):
+        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,
+                                            custom_req_body)
+        port_res = port_req.get_response(self.api)
+        self.assertEqual(port_res.status_int, expected_res_status)
+        if expected_res_status == 200:
+            port_data = Serializer().deserialize(port_res.body, content_type)
+            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_create_network_badrequest(self, format):
+        LOG.debug("_test_create_network_badrequest - format:%s - START",
+                  format)
+        bad_body = {'network': {'bad-attribute': 'very-bad'}}
+        self._create_network(format, custom_req_body=bad_body,
+                             expected_res_status=400)
+        LOG.debug("_test_create_network_badrequest - format:%s - END",
+                  format)
+
+    def _test_list_networks(self, format):
+        LOG.debug("_test_list_networks - format:%s - START", format)
+        content_type = "application/%s" % format
+        self._create_network(format, "net_1")
+        self._create_network(format, "net_2")
+        list_network_req = testlib.network_list_request(self.tenant_id,
+                                                        format)
+        list_network_res = list_network_req.get_response(self.api)
+        self.assertEqual(list_network_res.status_int, 200)
+        network_data = Serializer().deserialize(list_network_res.body,
+                                                content_type)
+        # Check network count: should return 2
+        self.assertEqual(len(network_data['networks']), 2)
+        LOG.debug("_test_list_networks - 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)
+        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_show_network_not_found(self, format):
+        LOG.debug("_test_show_network_not_found - format:%s - START", format)
+        show_network_req = testlib.show_network_request(self.tenant_id,
+                                                        "A_BAD_ID",
+                                                        format)
+        show_network_res = show_network_req.get_response(self.api)
+        self.assertEqual(show_network_res.status_int, 420)
+        LOG.debug("_test_show_network_not_found - format:%s - END", format)
+
+    def _test_rename_network(self, format):
+        LOG.debug("_test_rename_network - format:%s - START", format)
+        content_type = "application/%s" % format
+        new_name = 'new_network_name'
+        network_id = self._create_network(format)
+        update_network_req = testlib.update_network_request(self.tenant_id,
+                                                            network_id,
+                                                            new_name,
+                                                            format)
+        update_network_res = update_network_req.get_response(self.api)
+        self.assertEqual(update_network_res.status_int, 202)
+        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({'id': network_id, 'name': new_name},
+                         network_data['networks']['network'])
+        LOG.debug("_test_rename_network - format:%s - END", format)
+
+    def _test_rename_network_badrequest(self, format):
+        LOG.debug("_test_rename_network_badrequest - format:%s - START",
+                  format)
+        network_id = self._create_network(format)
+        bad_body = {'network': {'bad-attribute': 'very-bad'}}
+        update_network_req = testlib.\
+                             update_network_request(self.tenant_id,
+                                                    network_id, format,
+                                                    custom_req_body=bad_body)
+        update_network_res = update_network_req.get_response(self.api)
+        self.assertEqual(update_network_res.status_int, 400)
+        LOG.debug("_test_rename_network_badrequest - format:%s - END",
+                  format)
+
+    def _test_rename_network_not_found(self, format):
+        LOG.debug("_test_rename_network_not_found - format:%s - START",
+                  format)
+        new_name = 'new_network_name'
+        update_network_req = testlib.update_network_request(self.tenant_id,
+                                                            "A BAD ID",
+                                                            new_name,
+                                                            format)
+        update_network_res = update_network_req.get_response(self.api)
+        self.assertEqual(update_network_res.status_int, 420)
+        LOG.debug("_test_rename_network_not_found - 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_list_ports(self, format):
+        LOG.debug("_test_list_ports - format:%s - START", format)
+        content_type = "application/%s" % format
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        self._create_port(network_id, port_state, format)
+        self._create_port(network_id, port_state, format)
+        list_port_req = testlib.port_list_request(self.tenant_id,
+                                                   network_id, format)
+        list_port_res = list_port_req.get_response(self.api)
+        self.assertEqual(list_port_res.status_int, 200)
+        port_data = Serializer().deserialize(list_port_res.body,
+                                                content_type)
+        # Check port count: should return 2
+        self.assertEqual(len(port_data['ports']), 2)
+        LOG.debug("_test_list_ports - format:%s - END", format)
+
+    def _test_show_port(self, format):
+        LOG.debug("_test_show_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({'id': port_id, 'state': port_state},
+                         port_data['ports']['port'])
+        LOG.debug("_test_show_port - format:%s - END", format)
+
+    def _test_show_port_networknotfound(self, format):
+        LOG.debug("_test_show_port_networknotfound - format:%s - START",
+                  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,
+                                                        "A_BAD_ID", port_id,
+                                                        format)
+        show_port_res = show_port_req.get_response(self.api)
+        self.assertEqual(show_port_res.status_int, 420)
+        LOG.debug("_test_show_port_networknotfound - format:%s - END",
+                  format)
+
+    def _test_show_port_portnotfound(self, format):
+        LOG.debug("_test_show_port_portnotfound - format:%s - START", format)
+        network_id = self._create_network(format)
+        show_port_req = testlib.show_port_request(self.tenant_id,
+                                                        network_id,
+                                                        "A_BAD_ID",
+                                                        format)
+        show_port_res = show_port_req.get_response(self.api)
+        self.assertEqual(show_port_res.status_int, 430)
+        LOG.debug("_test_show_port_portnotfound - 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_create_port_networknotfound(self, format):
+        LOG.debug("_test_create_port_networknotfound - format:%s - START",
+                  format)
+        port_state = "ACTIVE"
+        self._create_port("A_BAD_ID", port_state, format,
+                          expected_res_status=420)
+        LOG.debug("_test_create_port_networknotfound - format:%s - END",
+                  format)
+
+    def _test_create_port_badrequest(self, format):
+        LOG.debug("_test_create_port_badrequest - format:%s - START", format)
+        bad_body = {'bad-resource': {'bad-attribute': 'bad-value'}}
+        network_id = self._create_network(format)
+        port_state = "ACTIVE"
+        self._create_port(network_id, port_state, format,
+                          custom_req_body=bad_body, expected_res_status=400)
+        LOG.debug("_test_create_port_badrequest - 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())
+        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)
+        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)
+
+    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 _test_delete_port_networknotfound(self, format):
+        LOG.debug("_test_delete_port_networknotfound - format:%s - START",
+                  format)
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        port_id = self._create_port(network_id, port_state, format)
+        delete_port_req = testlib.port_delete_request(self.tenant_id,
+                                                      "A_BAD_ID", port_id,
+                                                      format)
+        delete_port_res = delete_port_req.get_response(self.api)
+        self.assertEqual(delete_port_res.status_int, 420)
+        LOG.debug("_test_delete_port_networknotfound - format:%s - END",
+                  format)
+
+    def _test_set_port_state(self, format):
+        LOG.debug("_test_set_port_state - format:%s - START", format)
+        content_type = "application/%s" % format
+        port_state = 'DOWN'
+        new_port_state = 'ACTIVE'
+        network_id = self._create_network(format)
+        port_id = self._create_port(network_id, port_state, format)
+        update_port_req = testlib.update_port_request(self.tenant_id,
+                                                        network_id, port_id,
+                                                        new_port_state,
+                                                        format)
+        update_port_res = update_port_req.get_response(self.api)
+        self.assertEqual(update_port_res.status_int, 200)
+        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)
+        network_data = Serializer().deserialize(show_port_res.body,
+                                                content_type)
+        self.assertEqual({'id': port_id, 'state': new_port_state},
+                         network_data['ports']['port'])
+        LOG.debug("_test_set_port_state - format:%s - END", format)
+
+    def _test_set_port_state_networknotfound(self, format):
+        LOG.debug("_test_set_port_state_networknotfound - format:%s - START",
+                  format)
+        port_state = 'DOWN'
+        new_port_state = 'ACTIVE'
+        network_id = self._create_network(format)
+        port_id = self._create_port(network_id, port_state, format)
+        update_port_req = testlib.update_port_request(self.tenant_id,
+                                                        "A_BAD_ID", port_id,
+                                                        new_port_state,
+                                                        format)
+        update_port_res = update_port_req.get_response(self.api)
+        self.assertEqual(update_port_res.status_int, 420)
+        LOG.debug("_test_set_port_state_networknotfound - format:%s - END",
+                  format)
+
+    def _test_set_port_state_portnotfound(self, format):
+        LOG.debug("_test_set_port_state_portnotfound - format:%s - START",
+                  format)
+        port_state = 'DOWN'
+        new_port_state = 'ACTIVE'
+        network_id = self._create_network(format)
+        self._create_port(network_id, port_state, format)
+        update_port_req = testlib.update_port_request(self.tenant_id,
+                                                        network_id,
+                                                        "A_BAD_ID",
+                                                        new_port_state,
+                                                        format)
+        update_port_res = update_port_req.get_response(self.api)
+        self.assertEqual(update_port_res.status_int, 430)
+        LOG.debug("_test_set_port_state_portnotfound - format:%s - END",
+                  format)
+
+    def _test_set_port_state_stateinvalid(self, format):
+        LOG.debug("_test_set_port_state_stateinvalid - format:%s - START",
+                  format)
+        port_state = 'DOWN'
+        new_port_state = 'A_BAD_STATE'
+        network_id = self._create_network(format)
+        port_id = self._create_port(network_id, port_state, format)
+        update_port_req = testlib.update_port_request(self.tenant_id,
+                                                        network_id, port_id,
+                                                        new_port_state,
+                                                        format)
+        update_port_res = update_port_req.get_response(self.api)
+        self.assertEqual(update_port_res.status_int, 431)
+        LOG.debug("_test_set_port_state_stateinvalid - format:%s - END",
+                  format)
+
+    def _test_show_attachment(self, format):
+        LOG.debug("_test_show_attachment - format:%s - START", format)
+        content_type = "application/%s" % format
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        interface_id = "test_interface"
+        port_id = self._create_port(network_id, port_state, format)
+        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
+                                                            network_id,
+                                                            port_id,
+                                                            interface_id,
+                                                            format)
+        put_attachment_res = put_attachment_req.get_response(self.api)
+        self.assertEqual(put_attachment_res.status_int, 202)
+        get_attachment_req = testlib.get_attachment_request(self.tenant_id,
+                                                            network_id,
+                                                            port_id,
+                                                            format)
+        get_attachment_res = get_attachment_req.get_response(self.api)
+        attachment_data = Serializer().deserialize(get_attachment_res.body,
+                                                   content_type)
+        self.assertEqual(attachment_data['attachment'], interface_id)
+        LOG.debug("_test_show_attachment - format:%s - END", format)
+
+    def _test_show_attachment_networknotfound(self, format):
+        LOG.debug("_test_show_attachment_networknotfound - format:%s - START",
+                  format)
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        port_id = self._create_port(network_id, port_state, format)
+        get_attachment_req = testlib.get_attachment_request(self.tenant_id,
+                                                            "A_BAD_ID",
+                                                            port_id,
+                                                            format)
+        get_attachment_res = get_attachment_req.get_response(self.api)
+        self.assertEqual(get_attachment_res.status_int, 420)
+        LOG.debug("_test_show_attachment_networknotfound - format:%s - END",
+                  format)
+
+    def _test_show_attachment_portnotfound(self, format):
+        LOG.debug("_test_show_attachment_portnotfound - format:%s - START",
+                  format)
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        self._create_port(network_id, port_state, format)
+        get_attachment_req = testlib.get_attachment_request(self.tenant_id,
+                                                            network_id,
+                                                            "A_BAD_ID",
+                                                            format)
+        get_attachment_res = get_attachment_req.get_response(self.api)
+        self.assertEqual(get_attachment_res.status_int, 430)
+        LOG.debug("_test_show_attachment_portnotfound - format:%s - END",
+                  format)
+
+    def _test_put_attachment(self, format):
+        LOG.debug("_test_put_attachment - format:%s - START", format)
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        interface_id = "test_interface"
+        port_id = self._create_port(network_id, port_state, format)
+        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
+                                                            network_id,
+                                                            port_id,
+                                                            interface_id,
+                                                            format)
+        put_attachment_res = put_attachment_req.get_response(self.api)
+        self.assertEqual(put_attachment_res.status_int, 202)
+        LOG.debug("_test_put_attachment - format:%s - END", format)
+
+    def _test_put_attachment_networknotfound(self, format):
+        LOG.debug("_test_put_attachment_networknotfound - format:%s - START",
+                  format)
+        port_state = 'DOWN'
+        interface_id = "test_interface"
+        network_id = self._create_network(format)
+        port_id = self._create_port(network_id, port_state, format)
+        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
+                                                            "A_BAD_ID",
+                                                            port_id,
+                                                            interface_id,
+                                                            format)
+        put_attachment_res = put_attachment_req.get_response(self.api)
+        self.assertEqual(put_attachment_res.status_int, 420)
+        LOG.debug("_test_put_attachment_networknotfound - format:%s - END",
+                  format)
+
+    def _test_put_attachment_portnotfound(self, format):
+        LOG.debug("_test_put_attachment_portnotfound - format:%s - START",
+                  format)
+        port_state = 'DOWN'
+        interface_id = "test_interface"
+        network_id = self._create_network(format)
+        self._create_port(network_id, port_state, format)
+        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
+                                                            network_id,
+                                                            "A_BAD_ID",
+                                                            interface_id,
+                                                            format)
+        put_attachment_res = put_attachment_req.get_response(self.api)
+        self.assertEqual(put_attachment_res.status_int, 430)
+        LOG.debug("_test_put_attachment_portnotfound - format:%s - END",
+                  format)
+
+    def _test_delete_attachment(self, format):
+        LOG.debug("_test_delete_attachment - format:%s - START", format)
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        interface_id = "test_interface"
+        port_id = self._create_port(network_id, port_state, format)
+        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
+                                                            network_id,
+                                                            port_id,
+                                                            interface_id,
+                                                            format)
+        put_attachment_res = put_attachment_req.get_response(self.api)
+        self.assertEqual(put_attachment_res.status_int, 202)
+        del_attachment_req = testlib.delete_attachment_request(self.tenant_id,
+                                                               network_id,
+                                                               port_id,
+                                                               format)
+        del_attachment_res = del_attachment_req.get_response(self.api)
+        self.assertEqual(del_attachment_res.status_int, 202)
+        LOG.debug("_test_delete_attachment - format:%s - END", format)
+
+    def _test_delete_attachment_networknotfound(self, format):
+        LOG.debug("_test_delete_attachment_networknotfound -" \
+                  " format:%s - START", format)
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        port_id = self._create_port(network_id, port_state, format)
+        del_attachment_req = testlib.delete_attachment_request(self.tenant_id,
+                                                               "A_BAD_ID",
+                                                               port_id,
+                                                               format)
+        del_attachment_res = del_attachment_req.get_response(self.api)
+        self.assertEqual(del_attachment_res.status_int, 420)
+        LOG.debug("_test_delete_attachment_networknotfound -" \
+                  " format:%s - END", format)
+
+    def _test_delete_attachment_portnotfound(self, format):
+        LOG.debug("_test_delete_attachment_portnotfound - " \
+                  " format:%s - START", format)
+        port_state = "ACTIVE"
+        network_id = self._create_network(format)
+        self._create_port(network_id, port_state, format)
+        del_attachment_req = testlib.delete_attachment_request(self.tenant_id,
+                                                               network_id,
+                                                               "A_BAD_ID",
+                                                               format)
+        del_attachment_res = del_attachment_req.get_response(self.api)
+        self.assertEqual(del_attachment_res.status_int, 430)
+        LOG.debug("_test_delete_attachment_portnotfound - " \
+                  "format:%s - END", format)
+
+    def setUp(self):
+        options = {}
+        options['plugin_provider'] = 'quantum.plugins.SamplePlugin.FakePlugin'
+        self.api = server.APIRouterV01(options)
+        self.tenant_id = "test_tenant"
+        self.network_name = "test_network"
+
+    def tearDown(self):
+        """Clear the test environment"""
+        # Remove database contents
+        db.clear_db()
+
+    def test_list_networks_json(self):
+        self._test_list_networks('json')
+
+    def test_list_networks_xml(self):
+        self._test_list_networks('xml')
+
+    def test_create_network_json(self):
+        self._test_create_network('json')
+
+    def test_create_network_xml(self):
+        self._test_create_network('xml')
+
+    def test_create_network_badrequest_json(self):
+        self._test_create_network_badrequest('json')
+
+    def test_create_network_badreqyest_xml(self):
+        self._test_create_network_badrequest('xml')
+
+    def test_show_network_not_found_json(self):
+        self._test_show_network_not_found('json')
+
+    def test_show_network_not_found_xml(self):
+        self._test_show_network_not_found('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_rename_network_json(self):
+        self._test_rename_network('json')
+
+    def test_rename_network_xml(self):
+        self._test_rename_network('xml')
+
+    def test_rename_network_badrequest_json(self):
+        self._test_rename_network_badrequest('json')
+
+    def test_rename_network_badrequest_xml(self):
+        self._test_rename_network_badrequest('xml')
+
+    def test_rename_network_not_found_json(self):
+        self._test_rename_network_not_found('json')
+
+    def test_rename_network_not_found_xml(self):
+        self._test_rename_network_not_found('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_list_ports_json(self):
+        self._test_list_ports('json')
+
+    def test_list_ports_xml(self):
+        self._test_list_ports('xml')
+
+    def test_show_port_json(self):
+        self._test_show_port('json')
+
+    def test_show_port_xml(self):
+        self._test_show_port('xml')
+
+    def test_show_port_networknotfound_json(self):
+        self._test_show_port_networknotfound('json')
+
+    def test_show_port_networknotfound_xml(self):
+        self._test_show_port_networknotfound('xml')
+
+    def test_show_port_portnotfound_json(self):
+        self._test_show_port_portnotfound('json')
+
+    def test_show_port_portnotfound_xml(self):
+        self._test_show_port_portnotfound('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_create_port_networknotfound_json(self):
+        self._test_create_port_networknotfound('json')
+
+    def test_create_port_networknotfound_xml(self):
+        self._test_create_port_networknotfound('xml')
+
+    def test_create_port_badrequest_json(self):
+        self._test_create_port_badrequest('json')
+
+    def test_create_port_badrequest_xml(self):
+        self._test_create_port_badrequest('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_in_use_xml(self):
+        self._test_delete_port_in_use('xml')
+
+    def test_delete_port_in_use_json(self):
+        self._test_delete_port_in_use('json')
+
+    def test_delete_port_networknotfound_xml(self):
+        self._test_delete_port_networknotfound('xml')
+
+    def test_delete_port_networknotfound_json(self):
+        self._test_delete_port_networknotfound('json')
+
+    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')
+
+    def test_set_port_state_xml(self):
+        self._test_set_port_state('xml')
+
+    def test_set_port_state_json(self):
+        self._test_set_port_state('json')
+
+    def test_set_port_state_networknotfound_xml(self):
+        self._test_set_port_state_networknotfound('xml')
+
+    def test_set_port_state_networknotfound_json(self):
+        self._test_set_port_state_networknotfound('json')
+
+    def test_set_port_state_portnotfound_xml(self):
+        self._test_set_port_state_portnotfound('xml')
+
+    def test_set_port_state_portnotfound_json(self):
+        self._test_set_port_state_portnotfound('json')
+
+    def test_set_port_state_stateinvalid_xml(self):
+        self._test_set_port_state_stateinvalid('xml')
+
+    def test_set_port_state_stateinvalid_json(self):
+        self._test_set_port_state_stateinvalid('json')
+
+    def test_show_attachment_xml(self):
+        self._test_show_attachment('xml')
+
+    def test_show_attachment_json(self):
+        self._test_show_attachment('json')
+
+    def test_show_attachment_networknotfound_xml(self):
+        self._test_show_attachment_networknotfound('xml')
+
+    def test_show_attachment_networknotfound_json(self):
+        self._test_show_attachment_networknotfound('json')
+
+    def test_show_attachment_portnotfound_xml(self):
+        self._test_show_attachment_portnotfound('xml')
+
+    def test_show_attachment_portnotfound_json(self):
+        self._test_show_attachment_portnotfound('json')
+
+    def test_put_attachment_xml(self):
+        self._test_put_attachment('xml')
+
+    def test_put_attachment_json(self):
+        self._test_put_attachment('json')
+
+    def test_put_attachment_networknotfound_xml(self):
+        self._test_put_attachment_networknotfound('xml')
+
+    def test_put_attachment_networknotfound_json(self):
+        self._test_put_attachment_networknotfound('json')
+
+    def test_put_attachment_portnotfound_xml(self):
+        self._test_put_attachment_portnotfound('xml')
+
+    def test_put_attachment_portnotfound_json(self):
+        self._test_put_attachment_portnotfound('json')
+
+    def test_delete_attachment_xml(self):
+        self._test_delete_attachment('xml')
+
+    def test_delete_attachment_json(self):
+        self._test_delete_attachment('json')
+
+    def test_delete_attachment_networknotfound_xml(self):
+        self._test_delete_attachment_networknotfound('xml')
+
+    def test_delete_attachment_networknotfound_json(self):
+        self._test_delete_attachment_networknotfound('json')
+
+    def test_delete_attachment_portnotfound_xml(self):
+        self._test_delete_attachment_portnotfound('xml')
+
+    def test_delete_attachment_portnotfound_json(self):
+        self._test_delete_attachment_portnotfound('json')

=== removed file 'tests/unit/test_api.py'
--- tests/unit/test_api.py	2011-07-21 15:34:58 +0000
+++ tests/unit/test_api.py	1970-01-01 00:00:00 +0000
@@ -1,831 +0,0 @@
-# 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_api as testlib
-
-from quantum import api as server
-from quantum.db import api as db
-from quantum.common.wsgi import Serializer
-
-
-LOG = logging.getLogger('quantum.tests.test_api')
-
-
-class APITest(unittest.TestCase):
-
-    def _create_network(self, format, name=None, custom_req_body=None,
-                        expected_res_status=200):
-        LOG.debug("Creating network")
-        content_type = "application/" + format
-        if name:
-            net_name = name
-        else:
-            net_name = self.network_name
-        network_req = testlib.new_network_request(self.tenant_id,
-                                                  net_name, format,
-                                                  custom_req_body)
-        network_res = network_req.get_response(self.api)
-        self.assertEqual(network_res.status_int, expected_res_status)
-        if expected_res_status == 200:
-            network_data = Serializer().deserialize(network_res.body,
-                                                    content_type)
-            return network_data['networks']['network']['id']
-
-    def _create_port(self, network_id, port_state, format,
-                     custom_req_body=None, expected_res_status=200):
-        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,
-                                            custom_req_body)
-        port_res = port_req.get_response(self.api)
-        self.assertEqual(port_res.status_int, expected_res_status)
-        if expected_res_status == 200:
-            port_data = Serializer().deserialize(port_res.body, content_type)
-            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_create_network_badrequest(self, format):
-        LOG.debug("_test_create_network_badrequest - format:%s - START",
-                  format)
-        bad_body = {'network': {'bad-attribute': 'very-bad'}}
-        self._create_network(format, custom_req_body=bad_body,
-                             expected_res_status=400)
-        LOG.debug("_test_create_network_badrequest - format:%s - END",
-                  format)
-
-    def _test_list_networks(self, format):
-        LOG.debug("_test_list_networks - format:%s - START", format)
-        content_type = "application/%s" % format
-        self._create_network(format, "net_1")
-        self._create_network(format, "net_2")
-        list_network_req = testlib.network_list_request(self.tenant_id,
-                                                        format)
-        list_network_res = list_network_req.get_response(self.api)
-        self.assertEqual(list_network_res.status_int, 200)
-        network_data = Serializer().deserialize(list_network_res.body,
-                                                content_type)
-        # Check network count: should return 2
-        self.assertEqual(len(network_data['networks']), 2)
-        LOG.debug("_test_list_networks - 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)
-        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_show_network_not_found(self, format):
-        LOG.debug("_test_show_network_not_found - format:%s - START", format)
-        show_network_req = testlib.show_network_request(self.tenant_id,
-                                                        "A_BAD_ID",
-                                                        format)
-        show_network_res = show_network_req.get_response(self.api)
-        self.assertEqual(show_network_res.status_int, 420)
-        LOG.debug("_test_show_network_not_found - format:%s - END", format)
-
-    def _test_rename_network(self, format):
-        LOG.debug("_test_rename_network - format:%s - START", format)
-        content_type = "application/%s" % format
-        new_name = 'new_network_name'
-        network_id = self._create_network(format)
-        update_network_req = testlib.update_network_request(self.tenant_id,
-                                                            network_id,
-                                                            new_name,
-                                                            format)
-        update_network_res = update_network_req.get_response(self.api)
-        self.assertEqual(update_network_res.status_int, 202)
-        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({'id': network_id, 'name': new_name},
-                         network_data['networks']['network'])
-        LOG.debug("_test_rename_network - format:%s - END", format)
-
-    def _test_rename_network_badrequest(self, format):
-        LOG.debug("_test_rename_network_badrequest - format:%s - START",
-                  format)
-        network_id = self._create_network(format)
-        bad_body = {'network': {'bad-attribute': 'very-bad'}}
-        update_network_req = testlib.\
-                             update_network_request(self.tenant_id,
-                                                    network_id, format,
-                                                    custom_req_body=bad_body)
-        update_network_res = update_network_req.get_response(self.api)
-        self.assertEqual(update_network_res.status_int, 400)
-        LOG.debug("_test_rename_network_badrequest - format:%s - END",
-                  format)
-
-    def _test_rename_network_not_found(self, format):
-        LOG.debug("_test_rename_network_not_found - format:%s - START",
-                  format)
-        new_name = 'new_network_name'
-        update_network_req = testlib.update_network_request(self.tenant_id,
-                                                            "A BAD ID",
-                                                            new_name,
-                                                            format)
-        update_network_res = update_network_req.get_response(self.api)
-        self.assertEqual(update_network_res.status_int, 420)
-        LOG.debug("_test_rename_network_not_found - 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_list_ports(self, format):
-        LOG.debug("_test_list_ports - format:%s - START", format)
-        content_type = "application/%s" % format
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        self._create_port(network_id, port_state, format)
-        self._create_port(network_id, port_state, format)
-        list_port_req = testlib.port_list_request(self.tenant_id,
-                                                   network_id, format)
-        list_port_res = list_port_req.get_response(self.api)
-        self.assertEqual(list_port_res.status_int, 200)
-        port_data = Serializer().deserialize(list_port_res.body,
-                                                content_type)
-        # Check port count: should return 2
-        self.assertEqual(len(port_data['ports']), 2)
-        LOG.debug("_test_list_ports - format:%s - END", format)
-
-    def _test_show_port(self, format):
-        LOG.debug("_test_show_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({'id': port_id, 'state': port_state},
-                         port_data['ports']['port'])
-        LOG.debug("_test_show_port - format:%s - END", format)
-
-    def _test_show_port_networknotfound(self, format):
-        LOG.debug("_test_show_port_networknotfound - format:%s - START",
-                  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,
-                                                        "A_BAD_ID", port_id,
-                                                        format)
-        show_port_res = show_port_req.get_response(self.api)
-        self.assertEqual(show_port_res.status_int, 420)
-        LOG.debug("_test_show_port_networknotfound - format:%s - END",
-                  format)
-
-    def _test_show_port_portnotfound(self, format):
-        LOG.debug("_test_show_port_portnotfound - format:%s - START", format)
-        network_id = self._create_network(format)
-        show_port_req = testlib.show_port_request(self.tenant_id,
-                                                        network_id,
-                                                        "A_BAD_ID",
-                                                        format)
-        show_port_res = show_port_req.get_response(self.api)
-        self.assertEqual(show_port_res.status_int, 430)
-        LOG.debug("_test_show_port_portnotfound - 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_create_port_networknotfound(self, format):
-        LOG.debug("_test_create_port_networknotfound - format:%s - START",
-                  format)
-        port_state = "ACTIVE"
-        self._create_port("A_BAD_ID", port_state, format,
-                          expected_res_status=420)
-        LOG.debug("_test_create_port_networknotfound - format:%s - END",
-                  format)
-
-    def _test_create_port_badrequest(self, format):
-        LOG.debug("_test_create_port_badrequest - format:%s - START", format)
-        bad_body = {'bad-resource': {'bad-attribute': 'bad-value'}}
-        network_id = self._create_network(format)
-        port_state = "ACTIVE"
-        self._create_port(network_id, port_state, format,
-                          custom_req_body=bad_body, expected_res_status=400)
-        LOG.debug("_test_create_port_badrequest - 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())
-        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)
-        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)
-
-    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 _test_delete_port_networknotfound(self, format):
-        LOG.debug("_test_delete_port_networknotfound - format:%s - START",
-                  format)
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        port_id = self._create_port(network_id, port_state, format)
-        delete_port_req = testlib.port_delete_request(self.tenant_id,
-                                                      "A_BAD_ID", port_id,
-                                                      format)
-        delete_port_res = delete_port_req.get_response(self.api)
-        self.assertEqual(delete_port_res.status_int, 420)
-        LOG.debug("_test_delete_port_networknotfound - format:%s - END",
-                  format)
-
-    def _test_set_port_state(self, format):
-        LOG.debug("_test_set_port_state - format:%s - START", format)
-        content_type = "application/%s" % format
-        port_state = 'DOWN'
-        new_port_state = 'ACTIVE'
-        network_id = self._create_network(format)
-        port_id = self._create_port(network_id, port_state, format)
-        update_port_req = testlib.update_port_request(self.tenant_id,
-                                                        network_id, port_id,
-                                                        new_port_state,
-                                                        format)
-        update_port_res = update_port_req.get_response(self.api)
-        self.assertEqual(update_port_res.status_int, 200)
-        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)
-        network_data = Serializer().deserialize(show_port_res.body,
-                                                content_type)
-        self.assertEqual({'id': port_id, 'state': new_port_state},
-                         network_data['ports']['port'])
-        LOG.debug("_test_set_port_state - format:%s - END", format)
-
-    def _test_set_port_state_networknotfound(self, format):
-        LOG.debug("_test_set_port_state_networknotfound - format:%s - START",
-                  format)
-        port_state = 'DOWN'
-        new_port_state = 'ACTIVE'
-        network_id = self._create_network(format)
-        port_id = self._create_port(network_id, port_state, format)
-        update_port_req = testlib.update_port_request(self.tenant_id,
-                                                        "A_BAD_ID", port_id,
-                                                        new_port_state,
-                                                        format)
-        update_port_res = update_port_req.get_response(self.api)
-        self.assertEqual(update_port_res.status_int, 420)
-        LOG.debug("_test_set_port_state_networknotfound - format:%s - END",
-                  format)
-
-    def _test_set_port_state_portnotfound(self, format):
-        LOG.debug("_test_set_port_state_portnotfound - format:%s - START",
-                  format)
-        port_state = 'DOWN'
-        new_port_state = 'ACTIVE'
-        network_id = self._create_network(format)
-        self._create_port(network_id, port_state, format)
-        update_port_req = testlib.update_port_request(self.tenant_id,
-                                                        network_id,
-                                                        "A_BAD_ID",
-                                                        new_port_state,
-                                                        format)
-        update_port_res = update_port_req.get_response(self.api)
-        self.assertEqual(update_port_res.status_int, 430)
-        LOG.debug("_test_set_port_state_portnotfound - format:%s - END",
-                  format)
-
-    def _test_set_port_state_stateinvalid(self, format):
-        LOG.debug("_test_set_port_state_stateinvalid - format:%s - START",
-                  format)
-        port_state = 'DOWN'
-        new_port_state = 'A_BAD_STATE'
-        network_id = self._create_network(format)
-        port_id = self._create_port(network_id, port_state, format)
-        update_port_req = testlib.update_port_request(self.tenant_id,
-                                                        network_id, port_id,
-                                                        new_port_state,
-                                                        format)
-        update_port_res = update_port_req.get_response(self.api)
-        self.assertEqual(update_port_res.status_int, 431)
-        LOG.debug("_test_set_port_state_stateinvalid - format:%s - END",
-                  format)
-
-    def _test_show_attachment(self, format):
-        LOG.debug("_test_show_attachment - format:%s - START", format)
-        content_type = "application/%s" % format
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        interface_id = "test_interface"
-        port_id = self._create_port(network_id, port_state, format)
-        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
-                                                            network_id,
-                                                            port_id,
-                                                            interface_id,
-                                                            format)
-        put_attachment_res = put_attachment_req.get_response(self.api)
-        self.assertEqual(put_attachment_res.status_int, 202)
-        get_attachment_req = testlib.get_attachment_request(self.tenant_id,
-                                                            network_id,
-                                                            port_id,
-                                                            format)
-        get_attachment_res = get_attachment_req.get_response(self.api)
-        attachment_data = Serializer().deserialize(get_attachment_res.body,
-                                                   content_type)
-        self.assertEqual(attachment_data['attachment'], interface_id)
-        LOG.debug("_test_show_attachment - format:%s - END", format)
-
-    def _test_show_attachment_networknotfound(self, format):
-        LOG.debug("_test_show_attachment_networknotfound - format:%s - START",
-                  format)
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        port_id = self._create_port(network_id, port_state, format)
-        get_attachment_req = testlib.get_attachment_request(self.tenant_id,
-                                                            "A_BAD_ID",
-                                                            port_id,
-                                                            format)
-        get_attachment_res = get_attachment_req.get_response(self.api)
-        self.assertEqual(get_attachment_res.status_int, 420)
-        LOG.debug("_test_show_attachment_networknotfound - format:%s - END",
-                  format)
-
-    def _test_show_attachment_portnotfound(self, format):
-        LOG.debug("_test_show_attachment_portnotfound - format:%s - START",
-                  format)
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        self._create_port(network_id, port_state, format)
-        get_attachment_req = testlib.get_attachment_request(self.tenant_id,
-                                                            network_id,
-                                                            "A_BAD_ID",
-                                                            format)
-        get_attachment_res = get_attachment_req.get_response(self.api)
-        self.assertEqual(get_attachment_res.status_int, 430)
-        LOG.debug("_test_show_attachment_portnotfound - format:%s - END",
-                  format)
-
-    def _test_put_attachment(self, format):
-        LOG.debug("_test_put_attachment - format:%s - START", format)
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        interface_id = "test_interface"
-        port_id = self._create_port(network_id, port_state, format)
-        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
-                                                            network_id,
-                                                            port_id,
-                                                            interface_id,
-                                                            format)
-        put_attachment_res = put_attachment_req.get_response(self.api)
-        self.assertEqual(put_attachment_res.status_int, 202)
-        LOG.debug("_test_put_attachment - format:%s - END", format)
-
-    def _test_put_attachment_networknotfound(self, format):
-        LOG.debug("_test_put_attachment_networknotfound - format:%s - START",
-                  format)
-        port_state = 'DOWN'
-        interface_id = "test_interface"
-        network_id = self._create_network(format)
-        port_id = self._create_port(network_id, port_state, format)
-        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
-                                                            "A_BAD_ID",
-                                                            port_id,
-                                                            interface_id,
-                                                            format)
-        put_attachment_res = put_attachment_req.get_response(self.api)
-        self.assertEqual(put_attachment_res.status_int, 420)
-        LOG.debug("_test_put_attachment_networknotfound - format:%s - END",
-                  format)
-
-    def _test_put_attachment_portnotfound(self, format):
-        LOG.debug("_test_put_attachment_portnotfound - format:%s - START",
-                  format)
-        port_state = 'DOWN'
-        interface_id = "test_interface"
-        network_id = self._create_network(format)
-        self._create_port(network_id, port_state, format)
-        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
-                                                            network_id,
-                                                            "A_BAD_ID",
-                                                            interface_id,
-                                                            format)
-        put_attachment_res = put_attachment_req.get_response(self.api)
-        self.assertEqual(put_attachment_res.status_int, 430)
-        LOG.debug("_test_put_attachment_portnotfound - format:%s - END",
-                  format)
-
-    def _test_delete_attachment(self, format):
-        LOG.debug("_test_delete_attachment - format:%s - START", format)
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        interface_id = "test_interface"
-        port_id = self._create_port(network_id, port_state, format)
-        put_attachment_req = testlib.put_attachment_request(self.tenant_id,
-                                                            network_id,
-                                                            port_id,
-                                                            interface_id,
-                                                            format)
-        put_attachment_res = put_attachment_req.get_response(self.api)
-        self.assertEqual(put_attachment_res.status_int, 202)
-        del_attachment_req = testlib.delete_attachment_request(self.tenant_id,
-                                                               network_id,
-                                                               port_id,
-                                                               format)
-        del_attachment_res = del_attachment_req.get_response(self.api)
-        self.assertEqual(del_attachment_res.status_int, 202)
-        LOG.debug("_test_delete_attachment - format:%s - END", format)
-
-    def _test_delete_attachment_networknotfound(self, format):
-        LOG.debug("_test_delete_attachment_networknotfound -" \
-                  " format:%s - START", format)
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        port_id = self._create_port(network_id, port_state, format)
-        del_attachment_req = testlib.delete_attachment_request(self.tenant_id,
-                                                               "A_BAD_ID",
-                                                               port_id,
-                                                               format)
-        del_attachment_res = del_attachment_req.get_response(self.api)
-        self.assertEqual(del_attachment_res.status_int, 420)
-        LOG.debug("_test_delete_attachment_networknotfound -" \
-                  " format:%s - END", format)
-
-    def _test_delete_attachment_portnotfound(self, format):
-        LOG.debug("_test_delete_attachment_portnotfound - " \
-                  " format:%s - START", format)
-        port_state = "ACTIVE"
-        network_id = self._create_network(format)
-        self._create_port(network_id, port_state, format)
-        del_attachment_req = testlib.delete_attachment_request(self.tenant_id,
-                                                               network_id,
-                                                               "A_BAD_ID",
-                                                               format)
-        del_attachment_res = del_attachment_req.get_response(self.api)
-        self.assertEqual(del_attachment_res.status_int, 430)
-        LOG.debug("_test_delete_attachment_portnotfound - " \
-                  "format:%s - END", format)
-
-    def setUp(self):
-        options = {}
-        options['plugin_provider'] = 'quantum.plugins.SamplePlugin.FakePlugin'
-        self.api = server.APIRouterV01(options)
-        self.tenant_id = "test_tenant"
-        self.network_name = "test_network"
-
-    def tearDown(self):
-        """Clear the test environment"""
-        # Remove database contents
-        db.clear_db()
-
-    def test_list_networks_json(self):
-        self._test_list_networks('json')
-
-    def test_list_networks_xml(self):
-        self._test_list_networks('xml')
-
-    def test_create_network_json(self):
-        self._test_create_network('json')
-
-    def test_create_network_xml(self):
-        self._test_create_network('xml')
-
-    def test_create_network_badrequest_json(self):
-        self._test_create_network_badrequest('json')
-
-    def test_create_network_badreqyest_xml(self):
-        self._test_create_network_badrequest('xml')
-
-    def test_show_network_not_found_json(self):
-        self._test_show_network_not_found('json')
-
-    def test_show_network_not_found_xml(self):
-        self._test_show_network_not_found('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_rename_network_json(self):
-        self._test_rename_network('json')
-
-    def test_rename_network_xml(self):
-        self._test_rename_network('xml')
-
-    def test_rename_network_badrequest_json(self):
-        self._test_rename_network_badrequest('json')
-
-    def test_rename_network_badrequest_xml(self):
-        self._test_rename_network_badrequest('xml')
-
-    def test_rename_network_not_found_json(self):
-        self._test_rename_network_not_found('json')
-
-    def test_rename_network_not_found_xml(self):
-        self._test_rename_network_not_found('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_list_ports_json(self):
-        self._test_list_ports('json')
-
-    def test_list_ports_xml(self):
-        self._test_list_ports('xml')
-
-    def test_show_port_json(self):
-        self._test_show_port('json')
-
-    def test_show_port_xml(self):
-        self._test_show_port('xml')
-
-    def test_show_port_networknotfound_json(self):
-        self._test_show_port_networknotfound('json')
-
-    def test_show_port_networknotfound_xml(self):
-        self._test_show_port_networknotfound('xml')
-
-    def test_show_port_portnotfound_json(self):
-        self._test_show_port_portnotfound('json')
-
-    def test_show_port_portnotfound_xml(self):
-        self._test_show_port_portnotfound('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_create_port_networknotfound_json(self):
-        self._test_create_port_networknotfound('json')
-
-    def test_create_port_networknotfound_xml(self):
-        self._test_create_port_networknotfound('xml')
-
-    def test_create_port_badrequest_json(self):
-        self._test_create_port_badrequest('json')
-
-    def test_create_port_badrequest_xml(self):
-        self._test_create_port_badrequest('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_in_use_xml(self):
-        self._test_delete_port_in_use('xml')
-
-    def test_delete_port_in_use_json(self):
-        self._test_delete_port_in_use('json')
-
-    def test_delete_port_networknotfound_xml(self):
-        self._test_delete_port_networknotfound('xml')
-
-    def test_delete_port_networknotfound_json(self):
-        self._test_delete_port_networknotfound('json')
-
-    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')
-
-    def test_set_port_state_xml(self):
-        self._test_set_port_state('xml')
-
-    def test_set_port_state_json(self):
-        self._test_set_port_state('json')
-
-    def test_set_port_state_networknotfound_xml(self):
-        self._test_set_port_state_networknotfound('xml')
-
-    def test_set_port_state_networknotfound_json(self):
-        self._test_set_port_state_networknotfound('json')
-
-    def test_set_port_state_portnotfound_xml(self):
-        self._test_set_port_state_portnotfound('xml')
-
-    def test_set_port_state_portnotfound_json(self):
-        self._test_set_port_state_portnotfound('json')
-
-    def test_set_port_state_stateinvalid_xml(self):
-        self._test_set_port_state_stateinvalid('xml')
-
-    def test_set_port_state_stateinvalid_json(self):
-        self._test_set_port_state_stateinvalid('json')
-
-    def test_show_attachment_xml(self):
-        self._test_show_attachment('xml')
-
-    def test_show_attachment_json(self):
-        self._test_show_attachment('json')
-
-    def test_show_attachment_networknotfound_xml(self):
-        self._test_show_attachment_networknotfound('xml')
-
-    def test_show_attachment_networknotfound_json(self):
-        self._test_show_attachment_networknotfound('json')
-
-    def test_show_attachment_portnotfound_xml(self):
-        self._test_show_attachment_portnotfound('xml')
-
-    def test_show_attachment_portnotfound_json(self):
-        self._test_show_attachment_portnotfound('json')
-
-    def test_put_attachment_xml(self):
-        self._test_put_attachment('xml')
-
-    def test_put_attachment_json(self):
-        self._test_put_attachment('json')
-
-    def test_put_attachment_networknotfound_xml(self):
-        self._test_put_attachment_networknotfound('xml')
-
-    def test_put_attachment_networknotfound_json(self):
-        self._test_put_attachment_networknotfound('json')
-
-    def test_put_attachment_portnotfound_xml(self):
-        self._test_put_attachment_portnotfound('xml')
-
-    def test_put_attachment_portnotfound_json(self):
-        self._test_put_attachment_portnotfound('json')
-
-    def test_delete_attachment_xml(self):
-        self._test_delete_attachment('xml')
-
-    def test_delete_attachment_json(self):
-        self._test_delete_attachment('json')
-
-    def test_delete_attachment_networknotfound_xml(self):
-        self._test_delete_attachment_networknotfound('xml')
-
-    def test_delete_attachment_networknotfound_json(self):
-        self._test_delete_attachment_networknotfound('json')
-
-    def test_delete_attachment_portnotfound_xml(self):
-        self._test_delete_attachment_portnotfound('xml')
-
-    def test_delete_attachment_portnotfound_json(self):
-        self._test_delete_attachment_portnotfound('json')

=== added file 'tests/unit/testlib_api.py'
--- tests/unit/testlib_api.py	1970-01-01 00:00:00 +0000
+++ tests/unit/testlib_api.py	2011-07-23 18:23:02 +0000
@@ -0,0 +1,130 @@
+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
+
+
+def network_list_request(tenant_id, format='xml'):
+    method = 'GET'
+    path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals()
+    content_type = "application/%s" % format
+    return create_request(path, None, content_type, method)
+
+
+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='new_name',
+                        format='xml', custom_req_body=None):
+    method = 'POST'
+    path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals()
+    data = custom_req_body or {'network': {'net-name': '%s' % network_name}}
+    content_type = "application/%s" % format
+    body = Serializer().serialize(data, content_type)
+    return create_request(path, body, content_type, method)
+
+
+def update_network_request(tenant_id, network_id, network_name, format='xml',
+                           custom_req_body=None):
+    method = 'PUT'
+    path = "/tenants/%(tenant_id)s/networks" \
+           "/%(network_id)s.%(format)s" % locals()
+    data = custom_req_body or {'network': {'net-name': '%s' % network_name}}
+    content_type = "application/%s" % format
+    body = Serializer().serialize(data, content_type)
+    return create_request(path, body, content_type, method)
+
+
+def network_delete_request(tenant_id, network_id, format='xml'):
+    method = 'DELETE'
+    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 port_list_request(tenant_id, network_id, format='xml'):
+    method = 'GET'
+    path = "/tenants/%(tenant_id)s/networks/" \
+           "%(network_id)s/ports.%(format)s" % locals()
+    content_type = "application/%s" % format
+    return create_request(path, None, content_type, method)
+
+
+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', custom_req_body=None):
+    method = 'POST'
+    path = "/tenants/%(tenant_id)s/networks/" \
+           "%(network_id)s/ports.%(format)s" % locals()
+    data = custom_req_body or {'port': {'port-state': '%s' % port_state}}
+    content_type = "application/%s" % format
+    body = Serializer().serialize(data, content_type)
+    return create_request(path, body, content_type, method)
+
+
+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()
+    content_type = "application/%s" % format
+    return create_request(path, None, content_type, method)
+
+
+def update_port_request(tenant_id, network_id, port_id, port_state,
+                        format='xml', custom_req_body=None):
+    method = 'PUT'
+    path = "/tenants/%(tenant_id)s/networks" \
+           "/%(network_id)s/ports/%(port_id)s.%(format)s" % locals()
+    data = custom_req_body or {'port': {'port-state': '%s' % port_state}}
+    content_type = "application/%s" % format
+    body = Serializer().serialize(data, content_type)
+    return create_request(path, body, content_type, method)
+
+
+def get_attachment_request(tenant_id, network_id, port_id, format='xml'):
+    method = 'GET'
+    path = "/tenants/%(tenant_id)s/networks/" \
+           "%(network_id)s/ports/%(port_id)s/attachment.%(format)s" % locals()
+    content_type = "application/%s" % format
+    return create_request(path, None, content_type, method)
+
+
+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}}
+    content_type = "application/%s" % format
+    body = Serializer().serialize(data, content_type)
+    return create_request(path, body, content_type, method)
+
+
+def delete_attachment_request(tenant_id, network_id, port_id,
+                              attachment_id, format='xml'):
+    method = 'DELETE'
+    path = "/tenants/%(tenant_id)s/networks/" \
+           "%(network_id)s/ports/%(port_id)s/attachment.%(format)s" % locals()
+    content_type = "application/%s" % format
+    return create_request(path, None, content_type, method)

=== removed file 'tests/unit/testlib_api.py'
--- tests/unit/testlib_api.py	2011-07-18 22:51:22 +0000
+++ tests/unit/testlib_api.py	1970-01-01 00:00:00 +0000
@@ -1,130 +0,0 @@
-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
-
-
-def network_list_request(tenant_id, format='xml'):
-    method = 'GET'
-    path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals()
-    content_type = "application/%s" % format
-    return create_request(path, None, content_type, method)
-
-
-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='new_name',
-                        format='xml', custom_req_body=None):
-    method = 'POST'
-    path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals()
-    data = custom_req_body or {'network': {'net-name': '%s' % network_name}}
-    content_type = "application/%s" % format
-    body = Serializer().serialize(data, content_type)
-    return create_request(path, body, content_type, method)
-
-
-def update_network_request(tenant_id, network_id, network_name, format='xml',
-                           custom_req_body=None):
-    method = 'PUT'
-    path = "/tenants/%(tenant_id)s/networks" \
-           "/%(network_id)s.%(format)s" % locals()
-    data = custom_req_body or {'network': {'net-name': '%s' % network_name}}
-    content_type = "application/%s" % format
-    body = Serializer().serialize(data, content_type)
-    return create_request(path, body, content_type, method)
-
-
-def network_delete_request(tenant_id, network_id, format='xml'):
-    method = 'DELETE'
-    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 port_list_request(tenant_id, network_id, format='xml'):
-    method = 'GET'
-    path = "/tenants/%(tenant_id)s/networks/" \
-           "%(network_id)s/ports.%(format)s" % locals()
-    content_type = "application/%s" % format
-    return create_request(path, None, content_type, method)
-
-
-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', custom_req_body=None):
-    method = 'POST'
-    path = "/tenants/%(tenant_id)s/networks/" \
-           "%(network_id)s/ports.%(format)s" % locals()
-    data = custom_req_body or {'port': {'port-state': '%s' % port_state}}
-    content_type = "application/%s" % format
-    body = Serializer().serialize(data, content_type)
-    return create_request(path, body, content_type, method)
-
-
-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()
-    content_type = "application/%s" % format
-    return create_request(path, None, content_type, method)
-
-
-def update_port_request(tenant_id, network_id, port_id, port_state,
-                        format='xml', custom_req_body=None):
-    method = 'PUT'
-    path = "/tenants/%(tenant_id)s/networks" \
-           "/%(network_id)s/ports/%(port_id)s.%(format)s" % locals()
-    data = custom_req_body or {'port': {'port-state': '%s' % port_state}}
-    content_type = "application/%s" % format
-    body = Serializer().serialize(data, content_type)
-    return create_request(path, body, content_type, method)
-
-
-def get_attachment_request(tenant_id, network_id, port_id, format='xml'):
-    method = 'GET'
-    path = "/tenants/%(tenant_id)s/networks/" \
-           "%(network_id)s/ports/%(port_id)s/attachment.%(format)s" % locals()
-    content_type = "application/%s" % format
-    return create_request(path, None, content_type, method)
-
-
-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}}
-    content_type = "application/%s" % format
-    body = Serializer().serialize(data, content_type)
-    return create_request(path, body, content_type, method)
-
-
-def delete_attachment_request(tenant_id, network_id, port_id,
-                              attachment_id, format='xml'):
-    method = 'DELETE'
-    path = "/tenants/%(tenant_id)s/networks/" \
-           "%(network_id)s/ports/%(port_id)s/attachment.%(format)s" % locals()
-    content_type = "application/%s" % format
-    return create_request(path, None, content_type, method)