merged trunk

25 files changed, 2416 insertions, 567 deletions

diff --git a/nova/tests/__init__.py b/nova/tests/__init__.py
index e4ed75d37..720d5b0e6 100644
--- a/nova/tests/__init__.py
+++ b/nova/tests/__init__.py
@@ -59,6 +59,7 @@ def setup():
     network.create_networks(ctxt,
                             label='test',
                             cidr=FLAGS.fixed_range,
+                            multi_host=FLAGS.multi_host,
                             num_networks=FLAGS.num_networks,
                             network_size=FLAGS.network_size,
                             cidr_v6=FLAGS.fixed_range_v6,
@@ -66,9 +67,10 @@ def setup():
                             bridge=FLAGS.flat_network_bridge,
                             bridge_interface=bridge_interface,
                             vpn_start=FLAGS.vpn_start,
-                            vlan_start=FLAGS.vlan_start)
+                            vlan_start=FLAGS.vlan_start,
+                            dns1=FLAGS.flat_network_dns)
     for net in db.network_get_all(ctxt):
-        network.set_network_host(ctxt, net['id'])
+        network.set_network_host(ctxt, net)
 
     cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db)
     shutil.copyfile(testdb, cleandb)
diff --git a/nova/tests/api/openstack/test_common.py b/nova/tests/api/openstack/test_common.py
index 4c4d03995..f09270b34 100644
--- a/nova/tests/api/openstack/test_common.py
+++ b/nova/tests/api/openstack/test_common.py
@@ -247,3 +247,21 @@ class MiscFunctionsTest(test.TestCase):
         self.assertRaises(ValueError,
                           common.get_id_from_href,
                           fixture)
+
+    def test_get_version_from_href(self):
+        fixture = 'http://www.testsite.com/v1.1/images'
+        expected = '1.1'
+        actual = common.get_version_from_href(fixture)
+        self.assertEqual(actual, expected)
+
+    def test_get_version_from_href_2(self):
+        fixture = 'http://www.testsite.com/v1.1'
+        expected = '1.1'
+        actual = common.get_version_from_href(fixture)
+        self.assertEqual(actual, expected)
+
+    def test_get_version_from_href_default(self):
+        fixture = 'http://www.testsite.com/images'
+        expected = '1.0'
+        actual = common.get_version_from_href(fixture)
+        self.assertEqual(actual, expected)
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 697c62e5c..d459c694f 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -16,10 +16,11 @@
 #    under the License.
 
 import json
+import os.path
 import stubout
 import unittest
 import webob
-import os.path
+from xml.etree import ElementTree
 
 from nova import context
 from nova import flags
@@ -30,7 +31,8 @@ from nova.api.openstack import wsgi
 from nova.tests.api.openstack import fakes
 
 FLAGS = flags.FLAGS
-
+NS = "{http://docs.openstack.org/compute/api/v1.1}"
+ATOMNS = "{http://www.w3.org/2005/Atom}"
 response_body = "Try to say this Mr. Knox, sir..."
 
 
@@ -80,20 +82,99 @@ class StubExtensionManager(object):
 
 class ExtensionControllerTest(unittest.TestCase):
 
-    def test_index(self):
+    def setUp(self):
+        FLAGS.osapi_extensions_path = os.path.join(
+            os.path.dirname(__file__), "extensions")
+
+    def test_list_extensions_json(self):
         app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app)
         request = webob.Request.blank("/extensions")
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
 
-    def test_get_by_alias(self):
+        # Make sure we have all the extensions.
+        data = json.loads(response.body)
+        names = [x['name'] for x in data['extensions']]
+        names.sort()
+        self.assertEqual(names, ["FlavorExtraSpecs", "Floating_ips",
+            "Fox In Socks", "Hosts", "Multinic", "Volumes"])
+
+        # Make sure that at least Fox in Sox is correct.
+        (fox_ext,) = [
+            x for x in data['extensions'] if x['alias'] == 'FOXNSOX']
+        self.assertEqual(fox_ext, {
+                'namespace': 'http://www.fox.in.socks/api/ext/pie/v1.0',
+                'name': 'Fox In Socks',
+                'updated': '2011-01-22T13:25:27-06:00',
+                'description': 'The Fox In Socks Extension',
+                'alias': 'FOXNSOX',
+                'links': []
+            }
+        )
+
+    def test_get_extension_json(self):
         app = openstack.APIRouterV11()
         ext_midware = extensions.ExtensionMiddleware(app)
         request = webob.Request.blank("/extensions/FOXNSOX")
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
 
+        data = json.loads(response.body)
+        self.assertEqual(data['extension'], {
+                "namespace": "http://www.fox.in.socks/api/ext/pie/v1.0",
+                "name": "Fox In Socks",
+                "updated": "2011-01-22T13:25:27-06:00",
+                "description": "The Fox In Socks Extension",
+                "alias": "FOXNSOX",
+                "links": []
+            }
+        )
+
+    def test_list_extensions_xml(self):
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/extensions")
+        request.accept = "application/xml"
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        print response.body
+
+        root = ElementTree.XML(response.body)
+        self.assertEqual(root.tag.split('extensions')[0], NS)
+
+        # Make sure we have all the extensions.
+        exts = root.findall('{0}extension'.format(NS))
+        self.assertEqual(len(exts), 6)
+
+        # Make sure that at least Fox in Sox is correct.
+        (fox_ext,) = [x for x in exts if x.get('alias') == 'FOXNSOX']
+        self.assertEqual(fox_ext.get('name'), 'Fox In Socks')
+        self.assertEqual(fox_ext.get('namespace'),
+            'http://www.fox.in.socks/api/ext/pie/v1.0')
+        self.assertEqual(fox_ext.get('updated'), '2011-01-22T13:25:27-06:00')
+        self.assertEqual(fox_ext.findtext('{0}description'.format(NS)),
+            'The Fox In Socks Extension')
+
+    def test_get_extension_xml(self):
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/extensions/FOXNSOX")
+        request.accept = "application/xml"
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        print response.body
+
+        root = ElementTree.XML(response.body)
+        self.assertEqual(root.tag.split('extension')[0], NS)
+        self.assertEqual(root.get('alias'), 'FOXNSOX')
+        self.assertEqual(root.get('name'), 'Fox In Socks')
+        self.assertEqual(root.get('namespace'),
+            'http://www.fox.in.socks/api/ext/pie/v1.0')
+        self.assertEqual(root.get('updated'), '2011-01-22T13:25:27-06:00')
+        self.assertEqual(root.findtext('{0}description'.format(NS)),
+            'The Fox In Socks Extension')
+
 
 class ResourceExtensionTest(unittest.TestCase):
 
@@ -192,7 +273,7 @@ class ActionExtensionTest(unittest.TestCase):
 
     def test_invalid_action(self):
         body = dict(blah=dict(name="test"))
-        response = self._send_server_action_request("/asdf/1/action", body)
+        response = self._send_server_action_request("/fdsa/1/action", body)
         self.assertEqual(404, response.status_int)
 
 
@@ -244,3 +325,109 @@ class RequestExtensionTest(unittest.TestCase):
         response_data = json.loads(response.body)
         self.assertEqual('newblue', response_data['flavor']['googoose'])
         self.assertEqual("Pig Bands!", response_data['big_bands'])
+
+
+class ExtensionsXMLSerializerTest(unittest.TestCase):
+
+    def test_serialize_extenstion(self):
+        serializer = extensions.ExtensionsXMLSerializer()
+        data = {
+            'extension': {
+                'name': 'ext1',
+                'namespace': 'http://docs.rack.com/servers/api/ext/pie/v1.0',
+                'alias': 'RS-PIE',
+                'updated': '2011-01-22T13:25:27-06:00',
+                'description': 'Adds the capability to share an image.',
+                'links': [
+                    {
+                        'rel': 'describedby',
+                        'type': 'application/pdf',
+                        'href': 'http://docs.rack.com/servers/api/ext/cs.pdf'
+                    },
+                    {
+                        'rel': 'describedby',
+                        'type': 'application/vnd.sun.wadl+xml',
+                        'href': 'http://docs.rack.com/servers/api/ext/cs.wadl'
+                    }
+                ]
+            }
+        }
+
+        xml = serializer.serialize(data, 'show')
+        root = ElementTree.XML(xml)
+        ext_dict = data['extension']
+        self.assertEqual(root.findtext('{0}description'.format(NS)),
+            ext_dict['description'])
+
+        for key in ['name', 'namespace', 'alias', 'updated']:
+            self.assertEqual(root.get(key), ext_dict[key])
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(ext_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+    def test_serialize_extensions(self):
+        serializer = extensions.ExtensionsXMLSerializer()
+        data = {
+            "extensions": [
+                {
+                    "name": "Public Image Extension",
+                    "namespace": "http://foo.com/api/ext/pie/v1.0",
+                    "alias": "RS-PIE",
+                    "updated": "2011-01-22T13:25:27-06:00",
+                    "description": "Adds the capability to share an image.",
+                    "links": [
+                        {
+                            "rel": "describedby",
+                            "type": "application/pdf",
+                            "href": "http://foo.com/api/ext/cs-pie.pdf"
+                        },
+                        {
+                            "rel": "describedby",
+                            "type": "application/vnd.sun.wadl+xml",
+                            "href": "http://foo.com/api/ext/cs-pie.wadl"
+                        }
+                    ]
+                },
+                {
+                    "name": "Cloud Block Storage",
+                    "namespace": "http://foo.com/api/ext/cbs/v1.0",
+                    "alias": "RS-CBS",
+                    "updated": "2011-01-12T11:22:33-06:00",
+                    "description": "Allows mounting cloud block storage.",
+                    "links": [
+                        {
+                            "rel": "describedby",
+                            "type": "application/pdf",
+                            "href": "http://foo.com/api/ext/cs-cbs.pdf"
+                        },
+                        {
+                            "rel": "describedby",
+                            "type": "application/vnd.sun.wadl+xml",
+                            "href": "http://foo.com/api/ext/cs-cbs.wadl"
+                        }
+                    ]
+                }
+            ]
+        }
+
+        xml = serializer.serialize(data, 'index')
+        print xml
+        root = ElementTree.XML(xml)
+        ext_elems = root.findall('{0}extension'.format(NS))
+        self.assertEqual(len(ext_elems), 2)
+        for i, ext_elem in enumerate(ext_elems):
+            ext_dict = data['extensions'][i]
+            self.assertEqual(ext_elem.findtext('{0}description'.format(NS)),
+                ext_dict['description'])
+
+            for key in ['name', 'namespace', 'alias', 'updated']:
+                self.assertEqual(ext_elem.get(key), ext_dict[key])
+
+            link_nodes = ext_elem.findall('{0}link'.format(ATOMNS))
+            self.assertEqual(len(link_nodes), 2)
+            for i, link in enumerate(ext_dict['links']):
+                for key, value in link.items():
+                    self.assertEqual(link_nodes[i].get(key), value)
diff --git a/nova/tests/api/openstack/test_faults.py b/nova/tests/api/openstack/test_faults.py
index 4d86ffb26..6da27540a 100644
--- a/nova/tests/api/openstack/test_faults.py
+++ b/nova/tests/api/openstack/test_faults.py
@@ -16,6 +16,7 @@
 #    under the License.
 
 import json
+from xml.dom import minidom
 
 import webob
 import webob.dec
@@ -24,6 +25,7 @@ import webob.exc
 from nova import test
 from nova.api.openstack import common
 from nova.api.openstack import faults
+from nova.api.openstack import wsgi
 
 
 class TestFaults(test.TestCase):
@@ -139,3 +141,113 @@ class TestFaults(test.TestCase):
         self.assertEqual(resp.content_type, "application/xml")
         self.assertEqual(resp.status_int, 404)
         self.assertTrue('whut?' in resp.body)
+
+    def test_fault_has_status_int(self):
+        """Ensure the status_int is set correctly on faults"""
+        fault = faults.Fault(webob.exc.HTTPBadRequest(explanation='what?'))
+        self.assertEqual(fault.status_int, 400)
+
+    def test_v10_xml_serializer(self):
+        """Ensure that a v1.0 request responds with a v1.0 xmlns"""
+        request = webob.Request.blank('/',
+                                      headers={"Accept": "application/xml"})
+
+        fault = faults.Fault(webob.exc.HTTPBadRequest(explanation='scram'))
+        response = request.get_response(fault)
+
+        self.assertTrue(common.XML_NS_V10 in response.body)
+        self.assertEqual(response.content_type, "application/xml")
+        self.assertEqual(response.status_int, 400)
+
+    def test_v11_xml_serializer(self):
+        """Ensure that a v1.1 request responds with a v1.1 xmlns"""
+        request = webob.Request.blank('/v1.1',
+                                      headers={"Accept": "application/xml"})
+
+        fault = faults.Fault(webob.exc.HTTPBadRequest(explanation='scram'))
+        response = request.get_response(fault)
+
+        self.assertTrue(common.XML_NS_V11 in response.body)
+        self.assertEqual(response.content_type, "application/xml")
+        self.assertEqual(response.status_int, 400)
+
+
+class FaultsXMLSerializationTestV11(test.TestCase):
+    """Tests covering `nova.api.openstack.faults:Fault` class."""
+
+    def _prepare_xml(self, xml_string):
+        xml_string = xml_string.replace("  ", "")
+        xml_string = xml_string.replace("\n", "")
+        xml_string = xml_string.replace("\t", "")
+        return xml_string
+
+    def test_400_fault(self):
+        metadata = {'attributes': {"badRequest": 'code'}}
+        serializer = wsgi.XMLDictSerializer(metadata=metadata,
+                                            xmlns=common.XML_NS_V11)
+
+        fixture = {
+            "badRequest": {
+                "message": "scram",
+                "code": 400,
+            },
+        }
+
+        output = serializer.serialize(fixture)
+        actual = minidom.parseString(self._prepare_xml(output))
+
+        expected = minidom.parseString(self._prepare_xml("""
+                <badRequest code="400" xmlns="%s">
+                    <message>scram</message>
+                </badRequest>
+            """) % common.XML_NS_V11)
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_413_fault(self):
+        metadata = {'attributes': {"overLimit": 'code'}}
+        serializer = wsgi.XMLDictSerializer(metadata=metadata,
+                                            xmlns=common.XML_NS_V11)
+
+        fixture = {
+            "overLimit": {
+                "message": "sorry",
+                "code": 413,
+                "retryAfter": 4,
+            },
+        }
+
+        output = serializer.serialize(fixture)
+        actual = minidom.parseString(self._prepare_xml(output))
+
+        expected = minidom.parseString(self._prepare_xml("""
+                <overLimit code="413" xmlns="%s">
+                    <message>sorry</message>
+                    <retryAfter>4</retryAfter>
+                </overLimit>
+            """) % common.XML_NS_V11)
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_404_fault(self):
+        metadata = {'attributes': {"itemNotFound": 'code'}}
+        serializer = wsgi.XMLDictSerializer(metadata=metadata,
+                                            xmlns=common.XML_NS_V11)
+
+        fixture = {
+            "itemNotFound": {
+                "message": "sorry",
+                "code": 404,
+            },
+        }
+
+        output = serializer.serialize(fixture)
+        actual = minidom.parseString(self._prepare_xml(output))
+
+        expected = minidom.parseString(self._prepare_xml("""
+                <itemNotFound code="404" xmlns="%s">
+                    <message>sorry</message>
+                </itemNotFound>
+            """) % common.XML_NS_V11)
+
+        self.assertEqual(expected.toxml(), actual.toxml())
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 689647cc6..4ac35b26b 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -18,12 +18,14 @@
 import json
 import stubout
 import webob
+import xml.dom.minidom as minidom
 
+from nova.api.openstack import flavors
 import nova.db.api
-from nova import context
 from nova import exception
 from nova import test
 from nova.tests.api.openstack import fakes
+from nova import wsgi
 
 
 def stub_flavor(flavorid, name, memory_mb="256", local_gb="10"):
@@ -64,7 +66,6 @@ class FlavorsTest(test.TestCase):
                        return_instance_types)
         self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
                        return_instance_type_by_flavor_id)
-        self.context = context.get_admin_context()
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -146,61 +147,65 @@ class FlavorsTest(test.TestCase):
         req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
-        flavor = json.loads(res.body)["flavor"]
+        flavor = json.loads(res.body)
         expected = {
-            "id": "12",
-            "name": "flavor 12",
-            "ram": "256",
-            "disk": "10",
-            "links": [
-                {
-                    "rel": "self",
-                    "href": "http://localhost/v1.1/flavors/12",
-                },
-                {
-                    "rel": "bookmark",
-                    "href": "http://localhost/flavors/12",
-                },
-            ],
-        }
-        self.assertEqual(flavor, expected)
-
-    def test_get_flavor_list_v1_1(self):
-        req = webob.Request.blank('/v1.1/flavors')
-        req.environ['api.version'] = '1.1'
-        res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
-        flavor = json.loads(res.body)["flavors"]
-        expected = [
-            {
-                "id": "1",
-                "name": "flavor 1",
-                "links": [
-                    {
-                        "rel": "self",
-                        "href": "http://localhost/v1.1/flavors/1",
-                    },
-                    {
-                        "rel": "bookmark",
-                        "href": "http://localhost/flavors/1",
-                    },
-                ],
-            },
-            {
-                "id": "2",
-                "name": "flavor 2",
+            "flavor": {
+                "id": "12",
+                "name": "flavor 12",
+                "ram": "256",
+                "disk": "10",
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1/flavors/2",
+                        "href": "http://localhost/v1.1/flavors/12",
                     },
                     {
                         "rel": "bookmark",
-                        "href": "http://localhost/flavors/2",
+                        "href": "http://localhost/flavors/12",
                     },
                 ],
             },
-        ]
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "1",
+                    "name": "flavor 1",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/1",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/1",
+                        },
+                    ],
+                },
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
         self.assertEqual(flavor, expected)
 
     def test_get_flavor_list_detail_v1_1(self):
@@ -208,52 +213,273 @@ class FlavorsTest(test.TestCase):
         req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
-        flavor = json.loads(res.body)["flavors"]
-        expected = [
-            {
-                "id": "1",
-                "name": "flavor 1",
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "1",
+                    "name": "flavor 1",
+                    "ram": "256",
+                    "disk": "10",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/1",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/1",
+                        },
+                    ],
+                },
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "ram": "256",
+                    "disk": "10",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_empty_flavor_list_v1_1(self):
+        def _return_empty(self):
+            return {}
+        self.stubs.Set(nova.db.api, "instance_type_get_all", _return_empty)
+
+        req = webob.Request.blank('/v1.1/flavors')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavors = json.loads(res.body)["flavors"]
+        expected = []
+        self.assertEqual(flavors, expected)
+
+
+class FlavorsXMLSerializationTest(test.TestCase):
+
+    def test_show(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavor": {
+                "id": "12",
+                "name": "asdf",
                 "ram": "256",
                 "disk": "10",
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1/flavors/1",
+                        "href": "http://localhost/v1.1/flavors/12",
                     },
                     {
                         "rel": "bookmark",
-                        "href": "http://localhost/flavors/1",
+                        "href": "http://localhost/flavors/12",
                     },
                 ],
             },
-            {
-                "id": "2",
-                "name": "flavor 2",
-                "ram": "256",
-                "disk": "10",
+        }
+
+        output = serializer.serialize(input, 'show')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <flavor xmlns="http://docs.openstack.org/compute/api/v1.1"
+                xmlns:atom="http://www.w3.org/2005/Atom"
+                id="12"
+                name="asdf"
+                ram="256"
+                disk="10">
+            <atom:link href="http://localhost/v1.1/flavors/12" rel="self"/>
+            <atom:link href="http://localhost/flavors/12" rel="bookmark"/>
+        </flavor>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_show_handles_integers(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavor": {
+                "id": 12,
+                "name": "asdf",
+                "ram": 256,
+                "disk": 10,
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1/flavors/2",
+                        "href": "http://localhost/v1.1/flavors/12",
                     },
                     {
                         "rel": "bookmark",
-                        "href": "http://localhost/flavors/2",
+                        "href": "http://localhost/flavors/12",
                     },
                 ],
             },
-        ]
-        self.assertEqual(flavor, expected)
+        }
 
-    def test_get_empty_flavor_list_v1_1(self):
-        def _return_empty(self):
-            return {}
-        self.stubs.Set(nova.db.api, "instance_type_get_all",
-                       _return_empty)
+        output = serializer.serialize(input, 'show')
+        actual = minidom.parseString(output.replace("  ", ""))
 
-        req = webob.Request.blank('/v1.1/flavors')
-        res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
-        flavors = json.loads(res.body)["flavors"]
-        expected = []
-        self.assertEqual(flavors, expected)
+        expected = minidom.parseString("""
+        <flavor xmlns="http://docs.openstack.org/compute/api/v1.1"
+                xmlns:atom="http://www.w3.org/2005/Atom"
+                id="12"
+                name="asdf"
+                ram="256"
+                disk="10">
+            <atom:link href="http://localhost/v1.1/flavors/12" rel="self"/>
+            <atom:link href="http://localhost/flavors/12" rel="bookmark"/>
+        </flavor>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_detail(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavors": [
+                {
+                    "id": "23",
+                    "name": "flavor 23",
+                    "ram": "512",
+                    "disk": "20",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/23",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/23",
+                        },
+                    ],
+                },        {
+                    "id": "13",
+                    "name": "flavor 13",
+                    "ram": "256",
+                    "disk": "10",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/13",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/13",
+                        },
+                    ],
+                },
+            ],
+        }
+
+        output = serializer.serialize(input, 'detail')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
+                 xmlns:atom="http://www.w3.org/2005/Atom">
+            <flavor id="23"
+                    name="flavor 23"
+                    ram="512"
+                    disk="20">
+                <atom:link href="http://localhost/v1.1/flavors/23" rel="self"/>
+                <atom:link href="http://localhost/flavors/23" rel="bookmark"/>
+            </flavor>
+            <flavor id="13"
+                    name="flavor 13"
+                    ram="256"
+                    disk="10">
+                <atom:link href="http://localhost/v1.1/flavors/13" rel="self"/>
+                <atom:link href="http://localhost/flavors/13" rel="bookmark"/>
+            </flavor>
+        </flavors>
+        """.replace("  ", "") % locals())
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavors": [
+                {
+                    "id": "23",
+                    "name": "flavor 23",
+                    "ram": "512",
+                    "disk": "20",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/23",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/23",
+                        },
+                    ],
+                },        {
+                    "id": "13",
+                    "name": "flavor 13",
+                    "ram": "256",
+                    "disk": "10",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/13",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/13",
+                        },
+                    ],
+                },
+            ],
+        }
+
+        output = serializer.serialize(input, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
+                 xmlns:atom="http://www.w3.org/2005/Atom">
+            <flavor id="23" name="flavor 23">
+                <atom:link href="http://localhost/v1.1/flavors/23" rel="self"/>
+                <atom:link href="http://localhost/flavors/23" rel="bookmark"/>
+            </flavor>
+            <flavor id="13" name="flavor 13">
+                <atom:link href="http://localhost/v1.1/flavors/13" rel="self"/>
+                <atom:link href="http://localhost/flavors/13" rel="bookmark"/>
+            </flavor>
+        </flavors>
+        """.replace("  ", "") % locals())
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index_empty(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavors": [],
+        }
+
+        output = serializer.serialize(input, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
+                 xmlns:atom="http://www.w3.org/2005/Atom" />
+        """.replace("  ", "") % locals())
+
+        self.assertEqual(expected.toxml(), actual.toxml())
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index d9fb61e2a..31ca18497 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -103,8 +103,7 @@ class ImageMetaDataTest(test.TestCase):
         super(ImageMetaDataTest, self).tearDown()
 
     def test_index(self):
-        req = webob.Request.blank('/v1.1/images/1/meta')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/1/metadata')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(200, res.status_int)
@@ -114,8 +113,7 @@ class ImageMetaDataTest(test.TestCase):
             self.assertEqual(value, res_dict['metadata'][key])
 
     def test_show(self):
-        req = webob.Request.blank('/v1.1/images/1/meta/key1')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/1/metadata/key1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(200, res.status_int)
@@ -124,42 +122,66 @@ class ImageMetaDataTest(test.TestCase):
         self.assertEqual('value1', res_dict['meta']['key1'])
 
     def test_show_not_found(self):
-        req = webob.Request.blank('/v1.1/images/1/meta/key9')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/1/metadata/key9')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(404, res.status_int)
 
     def test_create(self):
-        req = webob.Request.blank('/v1.1/images/2/meta')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/2/metadata')
         req.method = 'POST'
         req.body = '{"metadata": {"key9": "value9"}}'
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
+
+        self.assertEqual(200, res.status_int)
+        actual_output = json.loads(res.body)
+
+        expected_output = {
+            'metadata': {
+                'key1': 'value1',
+                'key2': 'value2',
+                'key9': 'value9',
+            },
+        }
+
+        self.assertEqual(expected_output, actual_output)
+
+    def test_update_all(self):
+        req = webob.Request.blank('/v1.1/images/2/metadata')
+        req.method = 'PUT'
+        req.body = '{"metadata": {"key9": "value9"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+
         self.assertEqual(200, res.status_int)
-        self.assertEqual('value9', res_dict['metadata']['key9'])
-        # other items should not be modified
-        self.assertEqual('value1', res_dict['metadata']['key1'])
-        self.assertEqual('value2', res_dict['metadata']['key2'])
-        self.assertEqual(1, len(res_dict))
+        actual_output = json.loads(res.body)
+
+        expected_output = {
+            'metadata': {
+                'key9': 'value9',
+            },
+        }
+
+        self.assertEqual(expected_output, actual_output)
 
     def test_update_item(self):
-        req = webob.Request.blank('/v1.1/images/1/meta/key1')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/1/metadata/key1')
         req.method = 'PUT'
         req.body = '{"meta": {"key1": "zz"}}'
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
+
         self.assertEqual(200, res.status_int)
-        res_dict = json.loads(res.body)
-        self.assertTrue('meta' in res_dict)
-        self.assertEqual(len(res_dict['meta']), 1)
-        self.assertEqual('zz', res_dict['meta']['key1'])
+        actual_output = json.loads(res.body)
+        expected_output = {
+            'meta': {
+                'key1': 'zz',
+            },
+        }
+        self.assertEqual(actual_output, expected_output)
 
     def test_update_item_bad_body(self):
-        req = webob.Request.blank('/v1.1/images/1/meta/key1')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/1/metadata/key1')
         req.method = 'PUT'
         req.body = '{"key1": "zz"}'
         req.headers["content-type"] = "application/json"
@@ -167,8 +189,7 @@ class ImageMetaDataTest(test.TestCase):
         self.assertEqual(400, res.status_int)
 
     def test_update_item_too_many_keys(self):
-        req = webob.Request.blank('/v1.1/images/1/meta/key1')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/1/metadata/key1')
         req.method = 'PUT'
         req.body = '{"meta": {"key1": "value1", "key2": "value2"}}'
         req.headers["content-type"] = "application/json"
@@ -176,24 +197,38 @@ class ImageMetaDataTest(test.TestCase):
         self.assertEqual(400, res.status_int)
 
     def test_update_item_body_uri_mismatch(self):
-        req = webob.Request.blank('/v1.1/images/1/meta/bad')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/1/metadata/bad')
         req.method = 'PUT'
         req.body = '{"meta": {"key1": "value1"}}'
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, res.status_int)
 
+    def test_update_item_xml(self):
+        req = webob.Request.blank('/v1.1/images/1/metadata/key1')
+        req.method = 'PUT'
+        req.body = '<meta key="key1">five</meta>'
+        req.headers["content-type"] = "application/xml"
+        res = req.get_response(fakes.wsgi_app())
+
+        self.assertEqual(200, res.status_int)
+        actual_output = json.loads(res.body)
+        expected_output = {
+            'meta': {
+                'key1': 'five',
+            },
+        }
+        self.assertEqual(actual_output, expected_output)
+
     def test_delete(self):
-        req = webob.Request.blank('/v1.1/images/2/meta/key1')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/2/metadata/key1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(200, res.status_int)
+        self.assertEqual(204, res.status_int)
+        self.assertEqual('', res.body)
 
     def test_delete_not_found(self):
-        req = webob.Request.blank('/v1.1/images/2/meta/blah')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/2/metadata/blah')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(404, res.status_int)
@@ -203,8 +238,7 @@ class ImageMetaDataTest(test.TestCase):
         for num in range(FLAGS.quota_metadata_items + 1):
             data['metadata']['key%i' % num] = "blah"
         json_string = str(data).replace("\'", "\"")
-        req = webob.Request.blank('/v1.1/images/2/meta')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/2/metadata')
         req.method = 'POST'
         req.body = json_string
         req.headers["content-type"] = "application/json"
@@ -212,8 +246,7 @@ class ImageMetaDataTest(test.TestCase):
         self.assertEqual(400, res.status_int)
 
     def test_too_many_metadata_items_on_put(self):
-        req = webob.Request.blank('/v1.1/images/3/meta/blah')
-        req.environ['api.version'] = '1.1'
+        req = webob.Request.blank('/v1.1/images/3/metadata/blah')
         req.method = 'PUT'
         req.body = '{"meta": {"blah": "blah"}}'
         req.headers["content-type"] = "application/json"
@@ -221,9 +254,49 @@ class ImageMetaDataTest(test.TestCase):
         self.assertEqual(400, res.status_int)
 
 
+class ImageMetadataXMLDeserializationTest(test.TestCase):
+
+    deserializer = openstack.image_metadata.ImageMetadataXMLDeserializer()
+
+    def test_create(self):
+        request_body = """
+        <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
+            <meta key='123'>asdf</meta>
+            <meta key='567'>jkl;</meta>
+        </metadata>"""
+        output = self.deserializer.deserialize(request_body, 'create')
+        expected = {"body": {"metadata": {"123": "asdf", "567": "jkl;"}}}
+        self.assertEquals(output, expected)
+
+    def test_create_empty(self):
+        request_body = """
+        <metadata xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        output = self.deserializer.deserialize(request_body, 'create')
+        expected = {"body": {"metadata": {}}}
+        self.assertEquals(output, expected)
+
+    def test_update_all(self):
+        request_body = """
+        <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
+            <meta key='123'>asdf</meta>
+            <meta key='567'>jkl;</meta>
+        </metadata>"""
+        output = self.deserializer.deserialize(request_body, 'update_all')
+        expected = {"body": {"metadata": {"123": "asdf", "567": "jkl;"}}}
+        self.assertEquals(output, expected)
+
+    def test_update(self):
+        request_body = """
+        <meta xmlns="http://docs.openstack.org/compute/api/v1.1"
+              key='123'>asdf</meta>"""
+        output = self.deserializer.deserialize(request_body, 'update')
+        expected = {"body": {"meta": {"123": "asdf"}}}
+        self.assertEquals(output, expected)
+
+
 class ImageMetadataXMLSerializationTest(test.TestCase):
 
-    def test_index_xml(self):
+    def test_index(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
@@ -247,7 +320,7 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-    def test_index_xml_null(self):
+    def test_index_null(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
@@ -267,7 +340,7 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-    def test_index_xml_unicode(self):
+    def test_index_unicode(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
@@ -287,7 +360,7 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-    def test_show_xml(self):
+    def test_show(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'meta': {
@@ -305,7 +378,31 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-    def test_update_item_xml(self):
+    def test_update_all(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        fixture = {
+            'metadata': {
+                'key6': 'value6',
+                'key4': 'value4',
+            },
+        }
+        output = serializer.serialize(fixture, 'update_all')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
+                <meta key="key6">
+                    value6
+                </meta>
+                <meta key="key4">
+                    value4
+                </meta>
+            </metadata>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_update_item(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'meta': {
@@ -323,7 +420,7 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-    def test_create_xml(self):
+    def test_create(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
@@ -350,3 +447,8 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
         """.replace("  ", ""))
 
         self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_delete(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        output = serializer.serialize(None, 'delete')
+        self.assertEqual(output, '')
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 534460d46..87a695dde 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -538,7 +538,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         # because the element hasn't changed definition
         expected = minidom.parseString("""
             <itemNotFound code="404"
-                    xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
+                    xmlns="http://docs.openstack.org/compute/api/v1.1">
                 <message>
                     Image not found.
                 </message>
@@ -803,154 +803,206 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         self.assertDictListMatch(expected, response_list)
 
     def test_image_filter_with_name(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'name': 'testname'}
-        image_service.index(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images?name=testname')
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?name=testname')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.index(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_filter_with_status(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'status': 'ACTIVE'}
-        image_service.index(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images?status=ACTIVE')
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?status=ACTIVE')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.index(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_filter_with_property(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'property-test': '3'}
-        image_service.index(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images?property-test=3')
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?property-test=3')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_filter_server(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        # 'server' should be converted to 'property-instance_ref'
+        filters = {'property-instance_ref': 'http://localhost:8774/servers/12'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?server='
+                                      'http://localhost:8774/servers/12')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_filter_changes_since(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        filters = {'changes-since': '2011-01-24T17:08Z'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?changes-since='
+                                      '2011-01-24T17:08Z')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_filter_with_type(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        filters = {'property-image_type': 'BASE'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?type=BASE')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.index(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_filter_not_supported(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'status': 'ACTIVE'}
-        image_service.index(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images?status=ACTIVE&UNSUPPORTEDFILTER=testname')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?status=ACTIVE&'
+                                      'UNSUPPORTEDFILTER=testname')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
-        controller.index(request)
-        mocker.VerifyAll()
+        controller.detail(request)
+        self.mox.VerifyAll()
 
     def test_image_no_filters(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {}
         image_service.index(
             context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
+        self.mox.ReplayAll()
         request = webob.Request.blank(
             '/v1.1/images')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.index(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_detail_filter_with_name(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'name': 'testname'}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail?name=testname')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?name=testname')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_detail_filter_with_status(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'status': 'ACTIVE'}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail?status=ACTIVE')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?status=ACTIVE')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_detail_filter_with_property(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'property-test': '3'}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail?property-test=3')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?property-test=3')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
+
+    def test_image_detail_filter_server(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        # 'server' should be converted to 'property-instance_ref'
+        filters = {'property-instance_ref': 'http://localhost:8774/servers/12'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?server='
+                                      'http://localhost:8774/servers/12')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_detail_filter_changes_since(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        filters = {'changes-since': '2011-01-24T17:08Z'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?changes-since='
+                                      '2011-01-24T17:08Z')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_detail_filter_with_type(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        filters = {'property-image_type': 'BASE'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?type=BASE')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
 
     def test_image_detail_filter_not_supported(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'status': 'ACTIVE'}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail?status=ACTIVE&UNSUPPORTEDFILTER=testname')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?status=ACTIVE&'
+                                      'UNSUPPORTEDFILTER=testname')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_detail_no_filters(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_get_image_found(self):
         req = webob.Request.blank('/v1.0/images/123')
diff --git a/nova/tests/api/openstack/test_limits.py b/nova/tests/api/openstack/test_limits.py
index 76363450d..8a3fe681a 100644
--- a/nova/tests/api/openstack/test_limits.py
+++ b/nova/tests/api/openstack/test_limits.py
@@ -24,11 +24,12 @@ import stubout
 import time
 import unittest
 import webob
-
-from xml.dom.minidom import parseString
+from xml.dom import minidom
 
 import nova.context
 from nova.api.openstack import limits
+from nova.api.openstack import views
+from nova import test
 
 
 TEST_LIMITS = [
@@ -166,7 +167,7 @@ class LimitsControllerV10Test(BaseLimitTestSuite):
         request = self._get_index_request("application/xml")
         response = request.get_response(self.controller)
 
-        expected = parseString("""
+        expected = minidom.parseString("""
             <limits
                 xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
                 <rate/>
@@ -174,7 +175,7 @@ class LimitsControllerV10Test(BaseLimitTestSuite):
             </limits>
         """.replace("  ", ""))
 
-        body = parseString(response.body.replace("  ", ""))
+        body = minidom.parseString(response.body.replace("  ", ""))
 
         self.assertEqual(expected.toxml(), body.toxml())
 
@@ -184,7 +185,7 @@ class LimitsControllerV10Test(BaseLimitTestSuite):
         request = self._populate_limits(request)
         response = request.get_response(self.controller)
 
-        expected = parseString("""
+        expected = minidom.parseString("""
             <limits
                 xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
                 <rate>
@@ -196,7 +197,7 @@ class LimitsControllerV10Test(BaseLimitTestSuite):
                 <absolute/>
             </limits>
         """.replace("  ", ""))
-        body = parseString(response.body.replace("  ", ""))
+        body = minidom.parseString(response.body.replace("  ", ""))
 
         self.assertEqual(expected.toxml(), body.toxml())
 
@@ -210,6 +211,7 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
         """Run before each test."""
         BaseLimitTestSuite.setUp(self)
         self.controller = limits.create_resource('1.1')
+        self.maxDiff = None
 
     def _get_index_request(self, accept_header="application/json"):
         """Helper to set routing arguments."""
@@ -266,14 +268,14 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
                         "limit": [
                             {
                                 "verb": "GET",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "MINUTE",
                                 "value": 10,
                                 "remaining": 10,
                             },
                             {
                                 "verb": "POST",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "HOUR",
                                 "value": 5,
                                 "remaining": 5,
@@ -286,7 +288,7 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
                         "limit": [
                             {
                                 "verb": "GET",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "MINUTE",
                                 "value": 5,
                                 "remaining": 5,
@@ -328,7 +330,7 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
                         "limit": [
                             {
                                 "verb": "GET",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "MINUTE",
                                 "value": 10,
                                 "remaining": 10,
@@ -341,7 +343,7 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
                         "limit": [
                             {
                                 "verb": "GET",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "MINUTE",
                                 "value": 10,
                                 "remaining": 10,
@@ -458,7 +460,7 @@ class LimitMiddlewareTest(BaseLimitTestSuite):
         response = request.get_response(self.app)
         self.assertEqual(response.status_int, 403)
 
-        root = parseString(response.body).childNodes[0]
+        root = minidom.parseString(response.body).childNodes[0]
         expected = "Only 1 GET request(s) can be made to * every minute."
 
         details = root.getElementsByTagName("details")
@@ -904,3 +906,195 @@ class WsgiLimiterProxyTest(BaseLimitTestSuite):
             "made to /delayed every minute.")
 
         self.assertEqual((delay, error), expected)
+
+
+class LimitsViewBuilderV11Test(test.TestCase):
+
+    def setUp(self):
+        self.view_builder = views.limits.ViewBuilderV11()
+        self.rate_limits = [
+            {
+                "URI": "*",
+                "regex": ".*",
+                "value": 10,
+                "verb": "POST",
+                "remaining": 2,
+                "unit": "MINUTE",
+                "resetTime": 1311272226
+            },
+            {
+                "URI": "*/servers",
+                "regex": "^/servers",
+                "value": 50,
+                "verb": "POST",
+                "remaining": 10,
+                "unit": "DAY",
+                "resetTime": 1311272226
+            },
+        ]
+        self.absolute_limits = {
+            "metadata_items": 1,
+            "injected_files": 5,
+            "injected_file_content_bytes": 5,
+        }
+
+    def tearDown(self):
+        pass
+
+    def test_build_limits(self):
+        expected_limits = {
+            "limits": {
+                "rate": [
+                    {
+                        "uri": "*",
+                        "regex": ".*",
+                        "limit": [
+                            {
+                                "value": 10,
+                                "verb": "POST",
+                                "remaining": 2,
+                                "unit": "MINUTE",
+                                "next-available": "2011-07-21T18:17:06Z"
+                            },
+                        ]
+                    },
+                    {
+                        "uri": "*/servers",
+                        "regex": "^/servers",
+                        "limit": [
+                            {
+                                "value": 50,
+                                "verb": "POST",
+                                "remaining": 10,
+                                "unit": "DAY",
+                                "next-available": "2011-07-21T18:17:06Z"
+                            },
+                        ]
+                    },
+                ],
+                "absolute": {
+                    "maxServerMeta": 1,
+                    "maxImageMeta": 1,
+                    "maxPersonality": 5,
+                    "maxPersonalitySize": 5
+                }
+            }
+        }
+
+        output = self.view_builder.build(self.rate_limits,
+                                         self.absolute_limits)
+        self.assertDictMatch(output, expected_limits)
+
+    def test_build_limits_empty_limits(self):
+        expected_limits = {
+            "limits": {
+                "rate": [],
+                "absolute": {}
+            }
+        }
+
+        abs_limits = {}
+        rate_limits = []
+        output = self.view_builder.build(rate_limits, abs_limits)
+        self.assertDictMatch(output, expected_limits)
+
+
+class LimitsXMLSerializationTest(test.TestCase):
+
+    def setUp(self):
+        self.maxDiff = None
+
+    def tearDown(self):
+        pass
+
+    def test_index(self):
+        serializer = limits.LimitsXMLSerializer()
+
+        fixture = {
+            "limits": {
+                "rate": [
+                    {
+                        "uri": "*",
+                        "regex": ".*",
+                        "limit": [
+                            {
+                                "value": 10,
+                                "verb": "POST",
+                                "remaining": 2,
+                                "unit": "MINUTE",
+                                "next-available": "2011-12-15T22:42:45Z"
+                            },
+                        ]
+                    },
+                    {
+                        "uri": "*/servers",
+                        "regex": "^/servers",
+                        "limit": [
+                            {
+                                "value": 50,
+                                "verb": "POST",
+                                "remaining": 10,
+                                "unit": "DAY",
+                                "next-available": "2011-12-15T22:42:45Z"
+                            },
+                        ]
+                    },
+                ],
+                "absolute": {
+                    "maxServerMeta": 1,
+                    "maxImageMeta": 1,
+                    "maxPersonality": 5,
+                    "maxPersonalitySize": 10240
+                }
+            }
+        }
+
+        output = serializer.serialize(fixture, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <limits xmlns="http://docs.openstack.org/compute/api/v1.1">
+            <rates>
+                <rate uri="*" regex=".*">
+                    <limit value="10" verb="POST" remaining="2"
+                        unit="MINUTE"
+                        next-available="2011-12-15T22:42:45Z"/>
+                </rate>
+                <rate uri="*/servers" regex="^/servers">
+                    <limit value="50" verb="POST" remaining="10"
+                        unit="DAY"
+                        next-available="2011-12-15T22:42:45Z"/>
+                </rate>
+            </rates>
+            <absolute>
+                <limit name="maxServerMeta" value="1"/>
+                <limit name="maxPersonality" value="5"/>
+                <limit name="maxImageMeta" value="1"/>
+                <limit name="maxPersonalitySize" value="10240"/>
+            </absolute>
+        </limits>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index_no_limits(self):
+        serializer = limits.LimitsXMLSerializer()
+
+        fixture = {
+            "limits": {
+                "rate": [],
+                "absolute": {}
+            }
+        }
+
+        output = serializer.serialize(fixture, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <limits xmlns="http://docs.openstack.org/compute/api/v1.1">
+            <rates />
+            <absolute />
+        </limits>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index df951c5a0..821b055c4 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -30,8 +30,9 @@ from nova import flags
 from nova import test
 from nova import utils
 import nova.api.openstack
-from nova.api.openstack import servers
 from nova.api.openstack import create_instance_helper
+from nova.api.openstack import servers
+from nova.api.openstack import wsgi
 import nova.compute.api
 from nova.compute import instance_types
 from nova.compute import power_state
@@ -77,6 +78,12 @@ def return_virtual_interface_instance_nonexistant(interfaces):
     return _return_virtual_interface_by_instance
 
 
+def return_server_with_attributes(**kwargs):
+    def _return_server(context, id):
+        return stub_instance(id, **kwargs)
+    return _return_server
+
+
 def return_server_with_addresses(private, public):
     def _return_server(context, id):
         return stub_instance(id, private_address=private,
@@ -84,15 +91,15 @@ def return_server_with_addresses(private, public):
     return _return_server
 
 
-def return_server_with_interfaces(interfaces):
+def return_server_with_power_state(power_state):
     def _return_server(context, id):
-        return stub_instance(id, interfaces=interfaces)
+        return stub_instance(id, power_state=power_state)
     return _return_server
 
 
-def return_server_with_power_state(power_state):
+def return_server_with_uuid_and_power_state(power_state):
     def _return_server(context, id):
-        return stub_instance(id, power_state=power_state)
+        return stub_instance(id, uuid=FAKE_UUID, power_state=power_state)
     return _return_server
 
 
@@ -142,14 +149,15 @@ def instance_addresses(context, instance_id):
 
 def stub_instance(id, user_id=1, private_address=None, public_addresses=None,
                   host=None, power_state=0, reservation_id="",
-                  uuid=FAKE_UUID, interfaces=None):
+                  uuid=FAKE_UUID, image_ref="10", flavor_id="1",
+                  interfaces=None):
     metadata = []
     metadata.append(InstanceMetadata(key='seq', value=id))
 
     if interfaces is None:
         interfaces = []
 
-    inst_type = instance_types.get_instance_type_by_flavor_id(1)
+    inst_type = instance_types.get_instance_type_by_flavor_id(int(flavor_id))
 
     if public_addresses is None:
         public_addresses = list()
@@ -164,10 +172,12 @@ def stub_instance(id, user_id=1, private_address=None, public_addresses=None,
 
     instance = {
         "id": int(id),
+        "created_at": "2010-10-10T12:00:00Z",
+        "updated_at": "2010-11-11T11:00:00Z",
         "admin_pass": "",
         "user_id": user_id,
         "project_id": "",
-        "image_ref": "10",
+        "image_ref": image_ref,
         "kernel_id": "",
         "ramdisk_id": "",
         "launch_index": 0,
@@ -223,6 +233,7 @@ class MockSetAdminPassword(object):
 class ServersTest(test.TestCase):
 
     def setUp(self):
+        self.maxDiff = None
         super(ServersTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         fakes.FakeAuthManager.reset_fake_data()
@@ -299,24 +310,274 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict['server']['name'], 'server1')
 
     def test_get_server_by_id_v1_1(self):
+        image_bookmark = "http://localhost/images/10"
+        flavor_ref = "http://localhost/v1.1/flavors/1"
+        flavor_id = "1"
+        flavor_bookmark = "http://localhost/flavors/1"
+
+        public_ip = '192.168.0.3'
+        private_ip = '172.19.0.1'
+        interfaces = [
+            {
+                'network': {'label': 'public'},
+                'fixed_ips': [
+                    {'address': public_ip},
+                ],
+            },
+            {
+                'network': {'label': 'private'},
+                'fixed_ips': [
+                    {'address': private_ip},
+                ],
+            },
+        ]
+        new_return_server = return_server_with_attributes(
+            interfaces=interfaces)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+
         req = webob.Request.blank('/v1.1/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
-        self.assertEqual(res_dict['server']['id'], 1)
-        self.assertEqual(res_dict['server']['name'], 'server1')
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": FAKE_UUID,
+                "updated": "2010-11-11T11:00:00Z",
+                "created": "2010-10-10T12:00:00Z",
+                "progress": 0,
+                "name": "server1",
+                "status": "BUILD",
+                "hostId": '',
+                "image": {
+                    "id": "10",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": image_bookmark,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                  "links": [
+                                            {
+                          "rel": "bookmark",
+                          "href": flavor_bookmark,
+                      },
+                  ],
+                },
+                "addresses": {
+                    "public": [
+                        {
+                            "version": 4,
+                            "addr": public_ip,
+                        },
+                    ],
+                    "private": [
+                        {
+                            "version": 4,
+                            "addr": private_ip,
+                        },
+                    ],
+                },
+                "metadata": {
+                    "seq": "1",
+                },
+                "links": [
+                    {
+                        "rel": "self",
+                        #FIXME(wwolf) Do we want the links to be id or uuid?
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
+
+        self.assertDictMatch(res_dict, expected_server)
+
+    def test_get_server_with_active_status_by_id_v1_1(self):
+        image_bookmark = "http://localhost/images/10"
+        flavor_ref = "http://localhost/v1.1/flavors/1"
+        flavor_id = "1"
+        flavor_bookmark = "http://localhost/flavors/1"
+        private_ip = "192.168.0.3"
+        public_ip = "1.2.3.4"
+
+        interfaces = [
+            {
+                'network': {'label': 'public'},
+                'fixed_ips': [
+                    {'address': public_ip},
+                ],
+            },
+            {
+                'network': {'label': 'private'},
+                'fixed_ips': [
+                    {'address': private_ip},
+                ],
+            },
+        ]
+        new_return_server = return_server_with_attributes(
+            interfaces=interfaces, power_state=1)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": FAKE_UUID,
+                "updated": "2010-11-11T11:00:00Z",
+                "created": "2010-10-10T12:00:00Z",
+                "progress": 100,
+                "name": "server1",
+                "status": "ACTIVE",
+                "hostId": '',
+                "image": {
+                    "id": "10",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": image_bookmark,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                  "links": [
+                      {
+                          "rel": "bookmark",
+                          "href": flavor_bookmark,
+                      },
+                  ],
+                },
+                "addresses": {
+                    "public": [
+                        {
+                            "version": 4,
+                            "addr": public_ip,
+                        },
+                    ],
+                    "private": [
+                        {
+                            "version": 4,
+                            "addr": private_ip,
+                        },
+                    ],
+                },
+                "metadata": {
+                    "seq": "1",
+                },
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
 
-        expected_links = [
+        self.assertDictMatch(res_dict, expected_server)
+
+    def test_get_server_with_id_image_ref_by_id_v1_1(self):
+        image_ref = "10"
+        image_bookmark = "http://localhost/images/10"
+        flavor_ref = "http://localhost/v1.1/flavors/1"
+        flavor_id = "1"
+        flavor_bookmark = "http://localhost/flavors/1"
+        private_ip = "192.168.0.3"
+        public_ip = "1.2.3.4"
+
+        interfaces = [
             {
-                "rel": "self",
-                "href": "http://localhost/v1.1/servers/1",
+                'network': {'label': 'public'},
+                'fixed_ips': [
+                    {'address': public_ip},
+                ],
             },
             {
-                "rel": "bookmark",
-                "href": "http://localhost/servers/1",
+                'network': {'label': 'private'},
+                'fixed_ips': [
+                    {'address': private_ip},
+                ],
             },
         ]
+        new_return_server = return_server_with_attributes(
+            interfaces=interfaces, power_state=1, image_ref=image_ref,
+            flavor_id=flavor_id)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
 
-        self.assertEqual(res_dict['server']['links'], expected_links)
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": FAKE_UUID,
+                "updated": "2010-11-11T11:00:00Z",
+                "created": "2010-10-10T12:00:00Z",
+                "progress": 100,
+                "name": "server1",
+                "status": "ACTIVE",
+                "hostId": '',
+                "image": {
+                    "id": "10",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": image_bookmark,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                  "links": [
+                      {
+                          "rel": "bookmark",
+                          "href": flavor_bookmark,
+                      },
+                  ],
+                },
+                "addresses": {
+                    "public": [
+                        {
+                            "version": 4,
+                            "addr": public_ip,
+                        },
+                    ],
+                    "private": [
+                        {
+                            "version": 4,
+                            "addr": private_ip,
+                        },
+                    ],
+                },
+                "metadata": {
+                    "seq": "1",
+                },
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
+
+        self.assertDictMatch(res_dict, expected_server)
 
     def test_get_server_by_id_with_addresses_xml(self):
         private = "192.168.0.3"
@@ -433,6 +694,7 @@ class ServersTest(test.TestCase):
         self.assertEquals(ip.getAttribute('addr'), private)
 
     def test_get_server_by_id_with_addresses_v1_1(self):
+        FLAGS.use_ipv6 = True
         interfaces = [
             {
                 'network': {'label': 'network_1'},
@@ -447,9 +709,55 @@ class ServersTest(test.TestCase):
                     {'address': '172.19.0.1'},
                     {'address': '172.19.0.2'},
                 ],
+                'fixed_ipv6': '2001:4860::12',
             },
         ]
-        new_return_server = return_server_with_interfaces(interfaces)
+        new_return_server = return_server_with_attributes(
+            interfaces=interfaces)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['name'], 'server1')
+        addresses = res_dict['server']['addresses']
+        expected = {
+            'network_1': [
+                {'addr': '192.168.0.3', 'version': 4},
+                {'addr': '192.168.0.4', 'version': 4},
+            ],
+            'network_2': [
+                {'addr': '172.19.0.1', 'version': 4},
+                {'addr': '172.19.0.2', 'version': 4},
+                {'addr': '2001:4860::12', 'version': 6},
+            ],
+        }
+
+        self.assertEqual(addresses, expected)
+
+    def test_get_server_by_id_with_addresses_v1_1_ipv6_disabled(self):
+        FLAGS.use_ipv6 = False
+        interfaces = [
+            {
+                'network': {'label': 'network_1'},
+                'fixed_ips': [
+                    {'address': '192.168.0.3'},
+                    {'address': '192.168.0.4'},
+                ],
+            },
+            {
+                'network': {'label': 'network_2'},
+                'fixed_ips': [
+                    {'address': '172.19.0.1'},
+                    {'address': '172.19.0.2'},
+                ],
+                'fixed_ipv6': '2001:4860::12',
+            },
+        ]
+        new_return_server = return_server_with_attributes(
+            interfaces=interfaces)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
 
         req = webob.Request.blank('/v1.1/servers/1')
@@ -473,6 +781,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(addresses, expected)
 
     def test_get_server_addresses_v1_1(self):
+        FLAGS.use_ipv6 = True
         interfaces = [
             {
                 'network': {'label': 'network_1'},
@@ -492,6 +801,7 @@ class ServersTest(test.TestCase):
                     },
                     {'address': '172.19.0.2'},
                 ],
+                'fixed_ipv6': '2001:4860::12',
             },
         ]
 
@@ -514,6 +824,7 @@ class ServersTest(test.TestCase):
                     {'version': 4, 'addr': '172.19.0.1'},
                     {'version': 4, 'addr': '1.2.3.4'},
                     {'version': 4, 'addr': '172.19.0.2'},
+                    {'version': 6, 'addr': '2001:4860::12'},
                 ],
             },
         }
@@ -521,6 +832,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict, expected)
 
     def test_get_server_addresses_single_network_v1_1(self):
+        FLAGS.use_ipv6 = True
         interfaces = [
             {
                 'network': {'label': 'network_1'},
@@ -540,6 +852,7 @@ class ServersTest(test.TestCase):
                     },
                     {'address': '172.19.0.2'},
                 ],
+                'fixed_ipv6': '2001:4860::12',
             },
         ]
         _return_vifs = return_virtual_interface_by_instance(interfaces)
@@ -556,6 +869,7 @@ class ServersTest(test.TestCase):
                 {'version': 4, 'addr': '172.19.0.1'},
                 {'version': 4, 'addr': '1.2.3.4'},
                 {'version': 4, 'addr': '172.19.0.2'},
+                {'version': 6, 'addr': '2001:4860::12'},
             ],
         }
         self.assertEqual(res_dict, expected)
@@ -651,20 +965,20 @@ class ServersTest(test.TestCase):
         for i, s in enumerate(res_dict['servers']):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['name'], 'server%d' % i)
-            self.assertEqual(s.get('imageId', None), None)
+            self.assertEqual(s.get('image', None), None)
 
             expected_links = [
-            {
-                "rel": "self",
-                "href": "http://localhost/v1.1/servers/%d" % (i,),
-            },
-            {
-                "rel": "bookmark",
-                "href": "http://localhost/servers/%d" % (i,),
-            },
-        ]
+                {
+                    "rel": "self",
+                    "href": "http://localhost/v1.1/servers/%s" % s['id'],
+                },
+                {
+                    "rel": "bookmark",
+                    "href": "http://localhost/servers/%s" % s['id'],
+                },
+            ]
 
-        self.assertEqual(s['links'], expected_links)
+            self.assertEqual(s['links'], expected_links)
 
     def test_get_servers_with_limit(self):
         req = webob.Request.blank('/v1.0/servers?limit=3')
@@ -710,13 +1024,13 @@ class ServersTest(test.TestCase):
         req = webob.Request.blank('/v1.1/servers?marker=2')
         res = req.get_response(fakes.wsgi_app())
         servers = json.loads(res.body)['servers']
-        self.assertEqual([s['id'] for s in servers], [3, 4])
+        self.assertEqual([s['name'] for s in servers], ["server3", "server4"])
 
     def test_get_servers_with_limit_and_marker(self):
         req = webob.Request.blank('/v1.1/servers?limit=2&marker=1')
         res = req.get_response(fakes.wsgi_app())
         servers = json.loads(res.body)['servers']
-        self.assertEqual([s['id'] for s in servers], [2, 3])
+        self.assertEqual([s['name'] for s in servers], ['server2', 'server3'])
 
     def test_get_servers_with_bad_marker(self):
         req = webob.Request.blank('/v1.1/servers?limit=2&marker=asdf')
@@ -929,8 +1243,16 @@ class ServersTest(test.TestCase):
     def _setup_for_create_instance(self):
         """Shared implementation for tests below that create instance"""
         def instance_create(context, inst):
-            return {'id': 1, 'display_name': 'server_test',
-                    'uuid': FAKE_UUID}
+            inst_type = instance_types.get_instance_type_by_flavor_id(3)
+            image_ref = 'http://localhost/images/2'
+            return {'id': 1,
+                    'display_name': 'server_test',
+                    'uuid': FAKE_UUID,
+                    'instance_type': dict(inst_type),
+                    'image_ref': image_ref,
+                    'created_at': '2010-10-10T12:00:00Z',
+                    'updated_at': '2010-11-11T11:00:00Z',
+                   }
 
         def server_update(context, id, params):
             return instance_create(context, id)
@@ -1092,6 +1414,18 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_create_instance_no_server_entity(self):
+        self._setup_for_create_instance()
+
+        body = {}
+
+        req = webob.Request.blank('/v1.0/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 422)
+
     def test_create_instance_whitespace_name(self):
         self._setup_for_create_instance()
 
@@ -1118,8 +1452,26 @@ class ServersTest(test.TestCase):
     def test_create_instance_v1_1(self):
         self._setup_for_create_instance()
 
-        image_href = 'http://localhost/v1.1/images/2'
-        flavor_ref = 'http://localhost/v1.1/flavors/3'
+        image_href = 'http://localhost/images/2'
+        flavor_ref = 'http://localhost/flavors/3'
+        expected_flavor = {
+            "id": "3",
+            "links": [
+                {
+                    "rel": "bookmark",
+                    "href": 'http://localhost/flavors/3',
+                },
+            ],
+        }
+        expected_image = {
+            "id": "2",
+            "links": [
+                {
+                    "rel": "bookmark",
+                    "href": 'http://localhost/images/2',
+                },
+            ],
+        }
         body = {
             'server': {
                 'name': 'server_test',
@@ -1144,9 +1496,42 @@ class ServersTest(test.TestCase):
         server = json.loads(res.body)['server']
         self.assertEqual(16, len(server['adminPass']))
         self.assertEqual('server_test', server['name'])
-        self.assertEqual(1, server['id'])
-        self.assertEqual(flavor_ref, server['flavorRef'])
-        self.assertEqual(image_href, server['imageRef'])
+        self.assertEqual(expected_flavor, server['flavor'])
+        self.assertEqual(expected_image, server['image'])
+        self.assertEqual(res.status_int, 200)
+        #self.assertEqual(1, server['id'])
+
+    def test_create_instance_v1_1_invalid_flavor_href(self):
+        self._setup_for_create_instance()
+
+        image_href = 'http://localhost/v1.1/images/2'
+        flavor_ref = 'http://localhost/v1.1/flavors/asdf'
+        body = dict(server=dict(
+            name='server_test', imageRef=image_href, flavorRef=flavor_ref,
+            metadata={'hello': 'world', 'open': 'stack'},
+            personality={}))
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_create_instance_v1_1_bad_flavor_href(self):
+        self._setup_for_create_instance()
+
+        image_href = 'http://localhost/v1.1/images/2'
+        flavor_ref = 'http://localhost/v1.1/flavors/17'
+        body = dict(server=dict(
+            name='server_test', imageRef=image_href, flavorRef=flavor_ref,
+            metadata={'hello': 'world', 'open': 'stack'},
+            personality={}))
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
 
     def test_create_instance_v1_1_bad_href(self):
         self._setup_for_create_instance()
@@ -1167,8 +1552,26 @@ class ServersTest(test.TestCase):
     def test_create_instance_v1_1_local_href(self):
         self._setup_for_create_instance()
 
-        image_id = 2
-        flavor_ref = 'http://localhost/v1.1/flavors/3'
+        image_id = "2"
+        flavor_ref = 'http://localhost/flavors/3'
+        expected_flavor = {
+            "id": "3",
+            "links": [
+                {
+                    "rel": "bookmark",
+                    "href": 'http://localhost/flavors/3',
+                },
+            ],
+        }
+        expected_image = {
+            "id": "2",
+            "links": [
+                {
+                    "rel": "bookmark",
+                    "href": 'http://localhost/images/2',
+                },
+            ],
+        }
         body = {
             'server': {
                 'name': 'server_test',
@@ -1185,9 +1588,8 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
 
         server = json.loads(res.body)['server']
-        self.assertEqual(1, server['id'])
-        self.assertEqual(flavor_ref, server['flavorRef'])
-        self.assertEqual(image_id, server['imageRef'])
+        self.assertEqual(expected_flavor, server['flavor'])
+        self.assertEqual(expected_image, server['image'])
         self.assertEqual(res.status_int, 200)
 
     def test_create_instance_with_admin_pass_v1_0(self):
@@ -1412,6 +1814,24 @@ class ServersTest(test.TestCase):
             self.assertEqual(s['metadata']['seq'], str(i))
 
     def test_get_all_server_details_v1_1(self):
+        expected_flavor = {
+            "id": "1",
+            "links": [
+                {
+                    "rel": "bookmark",
+                    "href": 'http://localhost/flavors/1',
+                },
+            ],
+        }
+        expected_image = {
+            "id": "10",
+            "links": [
+                {
+                    "rel": "bookmark",
+                    "href": 'http://localhost/images/10',
+                },
+            ],
+        }
         req = webob.Request.blank('/v1.1/servers/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -1420,8 +1840,8 @@ class ServersTest(test.TestCase):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['hostId'], '')
             self.assertEqual(s['name'], 'server%d' % i)
-            self.assertEqual(s['imageRef'], 10)
-            self.assertEqual(s['flavorRef'], 'http://localhost/v1.1/flavors/1')
+            self.assertEqual(s['image'], expected_image)
+            self.assertEqual(s['flavor'], expected_flavor)
             self.assertEqual(s['status'], 'BUILD')
             self.assertEqual(s['metadata']['seq'], str(i))
 
@@ -1642,6 +2062,8 @@ class ServersTest(test.TestCase):
         state = power_state.BUILDING
         new_return_server = return_server_with_power_state(state)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        self.stubs.Set(nova.db, 'instance_get_by_uuid',
+                       return_server_with_uuid_and_power_state(state))
 
         req = webob.Request.blank('/v1.0/servers/1/action')
         req.method = 'POST'
@@ -1690,6 +2112,8 @@ class ServersTest(test.TestCase):
         state = power_state.BUILDING
         new_return_server = return_server_with_power_state(state)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        self.stubs.Set(nova.db, 'instance_get_by_uuid',
+                       return_server_with_uuid_and_power_state(state))
 
         req = webob.Request.blank('/v1.1/servers/1/action')
         req.method = 'POST'
@@ -1909,7 +2333,7 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.compute.api.API, 'resize', resize_mock)
 
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 400)
+        self.assertEqual(res.status_int, 500)
 
     def test_resized_server_has_correct_status(self):
         req = self.webreq('/1', 'GET')
@@ -2307,6 +2731,62 @@ b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""",
                           "http://localhost:8774/v1.1/images/1")
 
 
+class TextAddressesXMLSerialization(test.TestCase):
+
+    serializer = nova.api.openstack.ips.IPXMLSerializer()
+
+    def test_show(self):
+        fixture = {
+            'network_2': [
+                {'addr': '192.168.0.1', 'version': 4},
+                {'addr': 'fe80::beef', 'version': 6},
+            ],
+        }
+        output = self.serializer.serialize(fixture, 'show')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <network xmlns="http://docs.openstack.org/compute/api/v1.1"
+                     id="network_2">
+                <ip version="4" addr="192.168.0.1"/>
+                <ip version="6" addr="fe80::beef"/>
+            </network>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index(self):
+        fixture = {
+            'addresses': {
+                'network_1': [
+                    {'addr': '192.168.0.3', 'version': 4},
+                    {'addr': '192.168.0.5', 'version': 4},
+                ],
+                'network_2': [
+                    {'addr': '192.168.0.1', 'version': 4},
+                    {'addr': 'fe80::beef', 'version': 6},
+                ],
+            },
+        }
+        output = self.serializer.serialize(fixture, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <addresses xmlns="http://docs.openstack.org/compute/api/v1.1">
+                <network id="network_2">
+                    <ip version="4" addr="192.168.0.1"/>
+                    <ip version="6" addr="fe80::beef"/>
+                </network>
+                <network id="network_1">
+                    <ip version="4" addr="192.168.0.3"/>
+                    <ip version="4" addr="192.168.0.5"/>
+                </network>
+            </addresses>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+
 class TestServerInstanceCreation(test.TestCase):
 
     def setUp(self):
@@ -2609,3 +3089,249 @@ class TestGetKernelRamdiskFromImage(test.TestCase):
         kernel_id, ramdisk_id = create_instance_helper.CreateInstanceHelper. \
                                 _do_get_kernel_ramdisk_from_image(image_meta)
         return kernel_id, ramdisk_id
+
+
+class ServersViewBuilderV11Test(test.TestCase):
+
+    def setUp(self):
+        self.instance = self._get_instance()
+        self.view_builder = self._get_view_builder()
+
+    def tearDown(self):
+        pass
+
+    def _get_instance(self):
+        instance = {
+            "id": 1,
+            "created_at": "2010-10-10T12:00:00Z",
+            "updated_at": "2010-11-11T11:00:00Z",
+            "admin_pass": "",
+            "user_id": "",
+            "project_id": "",
+            "image_ref": "5",
+            "kernel_id": "",
+            "ramdisk_id": "",
+            "launch_index": 0,
+            "key_name": "",
+            "key_data": "",
+            "state": 0,
+            "state_description": "",
+            "memory_mb": 0,
+            "vcpus": 0,
+            "local_gb": 0,
+            "hostname": "",
+            "host": "",
+            "instance_type": {
+               "flavorid": 1,
+            },
+            "user_data": "",
+            "reservation_id": "",
+            "mac_address": "",
+            "scheduled_at": utils.utcnow(),
+            "launched_at": utils.utcnow(),
+            "terminated_at": utils.utcnow(),
+            "availability_zone": "",
+            "display_name": "test_server",
+            "display_description": "",
+            "locked": False,
+            "metadata": [],
+            #"address": ,
+            #"floating_ips": [{"address":ip} for ip in public_addresses]}
+            "uuid": "deadbeef-feed-edee-beef-d0ea7beefedd"}
+
+        return instance
+
+    def _get_view_builder(self):
+        base_url = "http://localhost/v1.1"
+        views = nova.api.openstack.views
+        address_builder = views.addresses.ViewBuilderV11()
+        flavor_builder = views.flavors.ViewBuilderV11(base_url)
+        image_builder = views.images.ViewBuilderV11(base_url)
+
+        view_builder = nova.api.openstack.views.servers.ViewBuilderV11(
+            address_builder,
+            flavor_builder,
+            image_builder,
+            base_url
+            )
+        return view_builder
+
+    def test_build_server(self):
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": self.instance['uuid'],
+                "name": "test_server",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
+
+        output = self.view_builder.build(self.instance, False)
+        self.assertDictMatch(output, expected_server)
+
+    def test_build_server_detail(self):
+        image_bookmark = "http://localhost/images/5"
+        flavor_bookmark = "http://localhost/flavors/1"
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": self.instance['uuid'],
+                "updated": "2010-11-11T11:00:00Z",
+                "created": "2010-10-10T12:00:00Z",
+                "progress": 0,
+                "name": "test_server",
+                "status": "BUILD",
+                "hostId": '',
+                "image": {
+                    "id": "5",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": image_bookmark,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                  "links": [
+                                            {
+                          "rel": "bookmark",
+                          "href": flavor_bookmark,
+                      },
+                  ],
+                },
+                "addresses": {},
+                "metadata": {},
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
+
+        output = self.view_builder.build(self.instance, True)
+        self.assertDictMatch(output, expected_server)
+
+    def test_build_server_detail_active_status(self):
+        #set the power state of the instance to running
+        self.instance['state'] = 1
+        image_bookmark = "http://localhost/images/5"
+        flavor_bookmark = "http://localhost/flavors/1"
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": self.instance['uuid'],
+                "updated": "2010-11-11T11:00:00Z",
+                "created": "2010-10-10T12:00:00Z",
+                "progress": 100,
+                "name": "test_server",
+                "status": "ACTIVE",
+                "hostId": '',
+                "image": {
+                    "id": "5",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": image_bookmark,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                  "links": [
+                                            {
+                          "rel": "bookmark",
+                          "href": flavor_bookmark,
+                      },
+                  ],
+                },
+                "addresses": {},
+                "metadata": {},
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
+
+        output = self.view_builder.build(self.instance, True)
+        self.assertDictMatch(output, expected_server)
+
+    def test_build_server_detail_with_metadata(self):
+
+        metadata = []
+        metadata.append(InstanceMetadata(key="Open", value="Stack"))
+        metadata.append(InstanceMetadata(key="Number", value=1))
+        self.instance['metadata'] = metadata
+
+        image_bookmark = "http://localhost/images/5"
+        flavor_bookmark = "http://localhost/flavors/1"
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": self.instance['uuid'],
+                "updated": "2010-11-11T11:00:00Z",
+                "created": "2010-10-10T12:00:00Z",
+                "progress": 0,
+                "name": "test_server",
+                "status": "BUILD",
+                "hostId": '',
+                "image": {
+                    "id": "5",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": image_bookmark,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                  "links": [
+                                            {
+                          "rel": "bookmark",
+                          "href": flavor_bookmark,
+                      },
+                  ],
+                },
+                "addresses": {},
+                "metadata": {
+                    "Open": "Stack",
+                    "Number": "1",
+                },
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
+
+        output = self.view_builder.build(self.instance, True)
+        self.assertDictMatch(output, expected_server)
diff --git a/nova/tests/api/openstack/test_versions.py b/nova/tests/api/openstack/test_versions.py
index fd8d50904..da964ee1f 100644
--- a/nova/tests/api/openstack/test_versions.py
+++ b/nova/tests/api/openstack/test_versions.py
@@ -21,6 +21,7 @@ import webob
 from nova import context
 from nova import test
 from nova.tests.api.openstack import fakes
+from nova.api.openstack import versions
 from nova.api.openstack import views
 
 
@@ -43,19 +44,21 @@ class VersionsTest(test.TestCase):
             {
                 "id": "v1.1",
                 "status": "CURRENT",
+                "updated": "2011-07-18T11:30:00Z",
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1",
+                        "href": "http://localhost/v1.1/",
                     }],
             },
             {
                 "id": "v1.0",
                 "status": "DEPRECATED",
+                "updated": "2010-10-09T11:30:00Z",
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.0",
+                        "href": "http://localhost/v1.0/",
                     }],
             },
         ]
@@ -69,15 +72,12 @@ class VersionsTest(test.TestCase):
         self.assertEqual(res.content_type, "application/xml")
 
         expected = """<versions>
-            <version id="v1.1" status="CURRENT">
-                <links>
-                    <link href="http://localhost/v1.1" rel="self"/>
-                </links>
+            <version id="v1.1" status="CURRENT" updated="2011-07-18T11:30:00Z">
+                <atom:link href="http://localhost/v1.1/" rel="self"/>
             </version>
-            <version id="v1.0" status="DEPRECATED">
-                <links>
-                    <link href="http://localhost/v1.0" rel="self"/>
-                </links>
+            <version id="v1.0" status="DEPRECATED"
+                 updated="2010-10-09T11:30:00Z">
+                <atom:link href="http://localhost/v1.0/" rel="self"/>
             </version>
         </versions>""".replace("  ", "").replace("\n", "")
 
@@ -85,21 +85,64 @@ class VersionsTest(test.TestCase):
 
         self.assertEqual(expected, actual)
 
+    def test_get_version_list_atom(self):
+        req = webob.Request.blank('/')
+        req.accept = "application/atom+xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, "application/atom+xml")
+
+        expected = """
+        <feed xmlns="http://www.w3.org/2005/Atom">
+            <title type="text">Available API Versions</title>
+            <updated>2011-07-18T11:30:00Z</updated>
+            <id>http://localhost/</id>
+            <author>
+                <name>Rackspace</name>
+                <uri>http://www.rackspace.com/</uri>
+            </author>
+            <link href="http://localhost/" rel="self"/>
+            <entry>
+                <id>http://localhost/v1.1/</id>
+                <title type="text">Version v1.1</title>
+                <updated>2011-07-18T11:30:00Z</updated>
+                <link href="http://localhost/v1.1/" rel="self"/>
+                <content type="text">
+                    Version v1.1 CURRENT (2011-07-18T11:30:00Z)
+                </content>
+            </entry>
+            <entry>
+                <id>http://localhost/v1.0/</id>
+                <title type="text">Version v1.0</title>
+                <updated>2010-10-09T11:30:00Z</updated>
+                <link href="http://localhost/v1.0/" rel="self"/>
+                <content type="text">
+                    Version v1.0 DEPRECATED (2010-10-09T11:30:00Z)
+                </content>
+            </entry>
+        </feed>
+        """.replace("  ", "").replace("\n", "")
+
+        actual = res.body.replace("  ", "").replace("\n", "")
+
+        self.assertEqual(expected, actual)
+
     def test_view_builder(self):
         base_url = "http://example.org/"
 
         version_data = {
             "id": "3.2.1",
             "status": "CURRENT",
-        }
+            "updated": "2011-07-18T11:30:00Z"}
 
         expected = {
             "id": "3.2.1",
             "status": "CURRENT",
+            "updated": "2011-07-18T11:30:00Z",
             "links": [
                 {
                     "rel": "self",
-                    "href": "http://example.org/3.2.1",
+                    "href": "http://example.org/3.2.1/",
                 },
             ],
         }
@@ -113,9 +156,99 @@ class VersionsTest(test.TestCase):
         base_url = "http://example.org/app/"
         version_number = "v1.4.6"
 
-        expected = "http://example.org/app/v1.4.6"
+        expected = "http://example.org/app/v1.4.6/"
 
         builder = views.versions.ViewBuilder(base_url)
         actual = builder.generate_href(version_number)
 
         self.assertEqual(actual, expected)
+
+    def test_xml_serializer(self):
+        versions_data = {
+            'versions': [
+                {
+                    "id": "2.7.1",
+                    "updated": "2011-07-18T11:30:00Z",
+                    "status": "DEPRECATED",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://test/2.7.1",
+                        },
+                    ],
+                },
+            ]
+        }
+
+        expected = """
+            <versions>
+                <version id="2.7.1" status="DEPRECATED"
+                 updated="2011-07-18T11:30:00Z">
+                    <atom:link href="http://test/2.7.1" rel="self"/>
+                </version>
+            </versions>""".replace("  ", "").replace("\n", "")
+
+        serializer = versions.VersionsXMLSerializer()
+        response = serializer.default(versions_data)
+        response = response.replace("  ", "").replace("\n", "")
+        self.assertEqual(expected, response)
+
+    def test_atom_serializer(self):
+        versions_data = {
+            'versions': [
+                {
+                    "id": "2.9.8",
+                    "updated": "2011-07-20T11:40:00Z",
+                    "status": "CURRENT",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://test/2.9.8",
+                        },
+                    ],
+                },
+            ]
+        }
+
+        expected = """
+            <feed xmlns="http://www.w3.org/2005/Atom">
+                <title type="text">
+                    Available API Versions
+                </title>
+                <updated>
+                    2011-07-20T11:40:00Z
+                </updated>
+                <id>
+                    http://test/
+                </id>
+                <author>
+                    <name>
+                        Rackspace
+                    </name>
+                    <uri>
+                        http://www.rackspace.com/
+                    </uri>
+                </author>
+                <link href="http://test/" rel="self"/>
+                <entry>
+                    <id>
+                        http://test/2.9.8
+                    </id>
+                    <title type="text">
+                        Version 2.9.8
+                    </title>
+                    <updated>
+                        2011-07-20T11:40:00Z
+                    </updated>
+                    <link href="http://test/2.9.8" rel="self"/>
+                    <content type="text">
+                        Version 2.9.8 CURRENT (2011-07-20T11:40:00Z)
+                    </content>
+                </entry>
+            </feed>""".replace("  ", "").replace("\n", "")
+
+        serializer = versions.VersionsAtomSerializer()
+        response = serializer.default(versions_data)
+        print response
+        response = response.replace("  ", "").replace("\n", "")
+        self.assertEqual(expected, response)
diff --git a/nova/tests/api/openstack/test_wsgi.py b/nova/tests/api/openstack/test_wsgi.py
index 5bdda7c7e..6dea78d17 100644
--- a/nova/tests/api/openstack/test_wsgi.py
+++ b/nova/tests/api/openstack/test_wsgi.py
@@ -256,6 +256,13 @@ class ResponseSerializerTest(test.TestCase):
         self.assertEqual(response.body, 'pew_json')
         self.assertEqual(response.status_int, 404)
 
+    def test_serialize_response_None(self):
+        response = self.serializer.serialize(None, 'application/json')
+        print response
+        self.assertEqual(response.headers['Content-Type'], 'application/json')
+        self.assertEqual(response.body, '')
+        self.assertEqual(response.status_int, 404)
+
     def test_serialize_response_dict_to_unknown_content_type(self):
         self.assertRaises(exception.InvalidContentType,
                           self.serializer.serialize,
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 7762df41c..19028a451 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -230,7 +230,7 @@ def stub_out_db_network_api(stubs):
                         continue
                     fixed_ip_fields['virtual_interface'] = FakeModel(vif[0])
 
-    def fake_instance_type_get_by_id(context, id):
+    def fake_instance_type_get(context, id):
         if flavor_fields['id'] == id:
             return FakeModel(flavor_fields)
 
@@ -323,7 +323,7 @@ def stub_out_db_network_api(stubs):
              fake_fixed_ip_get_by_address,
              fake_fixed_ip_get_network,
              fake_fixed_ip_update,
-             fake_instance_type_get_by_id,
+             fake_instance_type_get,
              fake_virtual_interface_create,
              fake_virtual_interface_delete_by_instance,
              fake_virtual_interface_get_by_instance,
@@ -415,7 +415,7 @@ def stub_out_db_instance_api(stubs, injected=True):
     def fake_instance_type_get_by_name(context, name):
         return INSTANCE_TYPES[name]
 
-    def fake_instance_type_get_by_id(context, id):
+    def fake_instance_type_get(context, id):
         for name, inst_type in INSTANCE_TYPES.iteritems():
             if str(inst_type['id']) == str(id):
                 return inst_type
@@ -448,7 +448,7 @@ def stub_out_db_instance_api(stubs, injected=True):
              fake_network_get_all_by_instance,
              fake_instance_type_get_all,
              fake_instance_type_get_by_name,
-             fake_instance_type_get_by_id,
+             fake_instance_type_get,
              fake_instance_get_fixed_addresses,
              fake_instance_get_fixed_addresses_v6,
              fake_network_get_all_by_instance,
diff --git a/nova/tests/fake_flags.py b/nova/tests/fake_flags.py
index 2297d2f0e..073216495 100644
--- a/nova/tests/fake_flags.py
+++ b/nova/tests/fake_flags.py
@@ -42,3 +42,4 @@ FLAGS['iscsi_num_targets'].SetDefault(8)
 FLAGS['verbose'].SetDefault(True)
 FLAGS['sqlite_db'].SetDefault("tests.sqlite")
 FLAGS['use_ipv6'].SetDefault(True)
+FLAGS['flat_network_bridge'].SetDefault('br100')
diff --git a/nova/tests/test_api.py b/nova/tests/test_api.py
index 26ac5ff24..fe7fd8402 100644
--- a/nova/tests/test_api.py
+++ b/nova/tests/test_api.py
@@ -213,7 +213,11 @@ class ApiEc2TestCase(test.TestCase):
         self.http = FakeHttplibConnection(
                 self.app, '%s:8773' % (self.host), False)
         # pylint: disable=E1103
-        self.ec2.new_http_connection(host, is_secure).AndReturn(self.http)
+        if boto.Version >= '2':
+            self.ec2.new_http_connection(host or '%s:8773' % (self.host),
+                is_secure).AndReturn(self.http)
+        else:
+            self.ec2.new_http_connection(host, is_secure).AndReturn(self.http)
         return self.http
 
     def test_return_valid_isoformat(self):
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 8cdc73a66..e419e7a50 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -121,7 +121,6 @@ class CloudTestCase(test.TestCase):
                                   public_ip=address)
         db.floating_ip_destroy(self.context, address)
 
-    @test.skip_test("Skipping this pending future merge")
     def test_allocate_address(self):
         address = "10.10.10.10"
         allocate = self.cloud.allocate_address
@@ -161,13 +160,10 @@ class CloudTestCase(test.TestCase):
         # ApiError: Floating ip is in use.  Disassociate it before releasing.
         self.assertRaises(exception.ApiError, release, self.context, address)
 
-    @test.skip_test("Skipping this pending future merge")
     def test_associate_disassociate_address(self):
         """Verifies associate runs cleanly without raising an exception"""
         address = "10.10.10.10"
-        db.floating_ip_create(self.context,
-                              {'address': address,
-                               'host': self.network.host})
+        db.floating_ip_create(self.context, {'address': address})
         self.cloud.allocate_address(self.context)
         # TODO(jkoelker) Probably need to query for instance_type_id and
         #                make sure we get a valid one
@@ -175,11 +171,14 @@ class CloudTestCase(test.TestCase):
                                                  'instance_type_id': 1})
         networks = db.network_get_all(self.context)
         for network in networks:
-            self.network.set_network_host(self.context, network['id'])
+            db.network_update(self.context, network['id'],
+                              {'host': self.network.host})
         project_id = self.context.project_id
         type_id = inst['instance_type_id']
         ips = self.network.allocate_for_instance(self.context,
                                                  instance_id=inst['id'],
+                                                 host=inst['host'],
+                                                 vpn=None,
                                                  instance_type_id=type_id,
                                                  project_id=project_id)
         # TODO(jkoelker) Make this mas bueno
@@ -269,25 +268,81 @@ class CloudTestCase(test.TestCase):
         delete = self.cloud.delete_security_group
         self.assertRaises(exception.ApiError, delete, self.context)
 
-    def test_authorize_revoke_security_group_ingress(self):
+    def test_authorize_security_group_ingress(self):
         kwargs = {'project_id': self.context.project_id, 'name': 'test'}
         sec = db.security_group_create(self.context, kwargs)
         authz = self.cloud.authorize_security_group_ingress
         kwargs = {'to_port': '999', 'from_port': '999', 'ip_protocol': 'tcp'}
-        authz(self.context, group_name=sec['name'], **kwargs)
+        self.assertTrue(authz(self.context, group_name=sec['name'], **kwargs))
+
+    def test_authorize_security_group_ingress_ip_permissions_ip_ranges(self):
+        kwargs = {'project_id': self.context.project_id, 'name': 'test'}
+        sec = db.security_group_create(self.context, kwargs)
+        authz = self.cloud.authorize_security_group_ingress
+        kwargs = {'ip_permissions': [{'to_port': 81, 'from_port': 81,
+                                      'ip_ranges':
+                                         {'1': {'cidr_ip': u'0.0.0.0/0'},
+                                          '2': {'cidr_ip': u'10.10.10.10/32'}},
+                                      'ip_protocol': u'tcp'}]}
+        self.assertTrue(authz(self.context, group_name=sec['name'], **kwargs))
+
+    def test_authorize_security_group_fail_missing_source_group(self):
+        kwargs = {'project_id': self.context.project_id, 'name': 'test'}
+        sec = db.security_group_create(self.context, kwargs)
+        authz = self.cloud.authorize_security_group_ingress
+        kwargs = {'ip_permissions': [{'to_port': 81, 'from_port': 81,
+                  'ip_ranges':{'1': {'cidr_ip': u'0.0.0.0/0'},
+                                '2': {'cidr_ip': u'10.10.10.10/32'}},
+                  'groups': {'1': {'user_id': u'someuser',
+                                   'group_name': u'somegroup1'}},
+                  'ip_protocol': u'tcp'}]}
+        self.assertRaises(exception.SecurityGroupNotFound, authz,
+                          self.context, group_name=sec['name'], **kwargs)
+
+    def test_authorize_security_group_ingress_ip_permissions_groups(self):
+        kwargs = {'project_id': self.context.project_id, 'name': 'test'}
+        sec = db.security_group_create(self.context,
+                                       {'project_id': 'someuser',
+                                        'name': 'somegroup1'})
+        sec = db.security_group_create(self.context,
+                                       {'project_id': 'someuser',
+                                        'name': 'othergroup2'})
+        sec = db.security_group_create(self.context, kwargs)
+        authz = self.cloud.authorize_security_group_ingress
+        kwargs = {'ip_permissions': [{'to_port': 81, 'from_port': 81,
+                  'groups': {'1': {'user_id': u'someuser',
+                                   'group_name': u'somegroup1'},
+                             '2': {'user_id': u'someuser',
+                                   'group_name': u'othergroup2'}},
+                  'ip_protocol': u'tcp'}]}
+        self.assertTrue(authz(self.context, group_name=sec['name'], **kwargs))
+
+    def test_revoke_security_group_ingress(self):
+        kwargs = {'project_id': self.context.project_id, 'name': 'test'}
+        sec = db.security_group_create(self.context, kwargs)
+        authz = self.cloud.authorize_security_group_ingress
+        kwargs = {'to_port': '999', 'from_port': '999', 'ip_protocol': 'tcp'}
+        authz(self.context, group_id=sec['id'], **kwargs)
         revoke = self.cloud.revoke_security_group_ingress
         self.assertTrue(revoke(self.context, group_name=sec['name'], **kwargs))
 
-    def test_authorize_revoke_security_group_ingress_by_id(self):
-        sec = db.security_group_create(self.context,
-                                       {'project_id': self.context.project_id,
-                                        'name': 'test'})
+    def test_revoke_security_group_ingress_by_id(self):
+        kwargs = {'project_id': self.context.project_id, 'name': 'test'}
+        sec = db.security_group_create(self.context, kwargs)
         authz = self.cloud.authorize_security_group_ingress
         kwargs = {'to_port': '999', 'from_port': '999', 'ip_protocol': 'tcp'}
         authz(self.context, group_id=sec['id'], **kwargs)
         revoke = self.cloud.revoke_security_group_ingress
         self.assertTrue(revoke(self.context, group_id=sec['id'], **kwargs))
 
+    def test_authorize_security_group_ingress_by_id(self):
+        sec = db.security_group_create(self.context,
+                                       {'project_id': self.context.project_id,
+                                        'name': 'test'})
+        authz = self.cloud.authorize_security_group_ingress
+        kwargs = {'to_port': '999', 'from_port': '999', 'ip_protocol': 'tcp'}
+        self.assertTrue(authz(self.context, group_id=sec['id'], **kwargs))
+
     def test_authorize_security_group_ingress_missing_protocol_params(self):
         sec = db.security_group_create(self.context,
                                        {'project_id': self.context.project_id,
@@ -366,8 +421,6 @@ class CloudTestCase(test.TestCase):
         db.service_destroy(self.context, service1['id'])
         db.service_destroy(self.context, service2['id'])
 
-    # NOTE(jkoelker): this test relies on fixed_ip being in instances
-    @test.skip_test("EC2 stuff needs fixed_ip in instance_ref")
     def test_describe_snapshots(self):
         """Makes sure describe_snapshots works and filters results."""
         vol = db.volume_create(self.context, {})
@@ -908,6 +961,21 @@ class CloudTestCase(test.TestCase):
         self._wait_for_running(ec2_instance_id)
         return ec2_instance_id
 
+    def test_rescue_unrescue_instance(self):
+        instance_id = self._run_instance(
+            image_id='ami-1',
+            instance_type=FLAGS.default_instance_type,
+            max_count=1)
+        self.cloud.rescue_instance(context=self.context,
+                                   instance_id=instance_id)
+        # NOTE(vish): This currently does no validation, it simply makes sure
+        #             that the code path doesn't throw an exception.
+        self.cloud.unrescue_instance(context=self.context,
+                                   instance_id=instance_id)
+        # TODO(soren): We need this until we can stop polling in the rpc code
+        #              for unit tests.
+        self.cloud.terminate_instances(self.context, [instance_id])
+
     def test_console_output(self):
         instance_id = self._run_instance(
             image_id='ami-1',
@@ -987,12 +1055,6 @@ class CloudTestCase(test.TestCase):
         self.cloud.delete_key_pair(self.context, 'test')
 
     def test_run_instances(self):
-        # stub out the rpc call
-        def stub_cast(*args, **kwargs):
-            pass
-
-        self.stubs.Set(rpc, 'cast', stub_cast)
-
         kwargs = {'image_id': FLAGS.default_image,
                   'instance_type': FLAGS.default_instance_type,
                   'max_count': 1}
@@ -1002,7 +1064,7 @@ class CloudTestCase(test.TestCase):
         self.assertEqual(instance['imageId'], 'ami-00000001')
         self.assertEqual(instance['displayName'], 'Server 1')
         self.assertEqual(instance['instanceId'], 'i-00000001')
-        self.assertEqual(instance['instanceState']['name'], 'scheduling')
+        self.assertEqual(instance['instanceState']['name'], 'running')
         self.assertEqual(instance['instanceType'], 'm1.small')
 
     def test_run_instances_image_state_none(self):
@@ -1074,16 +1136,15 @@ class CloudTestCase(test.TestCase):
         self.assertEqual('c00l 1m4g3', inst['display_name'])
         db.instance_destroy(self.context, inst['id'])
 
-    # NOTE(jkoelker): This test relies on mac_address in instance
-    @test.skip_test("EC2 stuff needs mac_address in instance_ref")
     def test_update_of_instance_wont_update_private_fields(self):
         inst = db.instance_create(self.context, {})
+        host = inst['host']
         ec2_id = ec2utils.id_to_ec2_id(inst['id'])
         self.cloud.update_instance(self.context, ec2_id,
                                    display_name='c00l 1m4g3',
-                                   mac_address='DE:AD:BE:EF')
+                                   host='otherhost')
         inst = db.instance_get(self.context, inst['id'])
-        self.assertEqual(None, inst['mac_address'])
+        self.assertEqual(host, inst['host'])
         db.instance_destroy(self.context, inst['id'])
 
     def test_update_of_volume_display_fields(self):
@@ -1139,7 +1200,6 @@ class CloudTestCase(test.TestCase):
         elevated = self.context.elevated(read_deleted=True)
         self._wait_for_state(elevated, instance_id, is_deleted)
 
-    @test.skip_test("skipping, test is hanging with multinic for rpc reasons")
     def test_stop_start_instance(self):
         """Makes sure stop/start instance works"""
         # enforce periodic tasks run in short time to avoid wait for 60s.
@@ -1197,7 +1257,6 @@ class CloudTestCase(test.TestCase):
         self.assertEqual(vol['status'], "available")
         self.assertEqual(vol['attach_status'], "detached")
 
-    @test.skip_test("skipping, test is hanging with multinic for rpc reasons")
     def test_stop_start_with_volume(self):
         """Make sure run instance with block device mapping works"""
 
@@ -1266,7 +1325,6 @@ class CloudTestCase(test.TestCase):
 
         self._restart_compute_service()
 
-    @test.skip_test("skipping, test is hanging with multinic for rpc reasons")
     def test_stop_with_attached_volume(self):
         """Make sure attach info is reflected to block device mapping"""
         # enforce periodic tasks run in short time to avoid wait for 60s.
@@ -1342,7 +1400,6 @@ class CloudTestCase(test.TestCase):
         greenthread.sleep(0.3)
         return result['snapshotId']
 
-    @test.skip_test("skipping, test is hanging with multinic for rpc reasons")
     def test_run_with_snapshot(self):
         """Makes sure run/stop/start instance with snapshot works."""
         vol = self._volume_create()
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index b407d77b0..65a6acd29 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -428,11 +428,12 @@ class ComputeTestCase(test.TestCase):
         self.stubs.Set(self.compute.network_api, 'get_instance_nw_info', fake)
         context = self.context.elevated()
         instance_id = self._create_instance()
-        self.compute.prep_resize(context, instance_id, 1)
+        instance_ref = db.instance_get(context, instance_id)
+        self.compute.prep_resize(context, instance_ref['uuid'], 1)
         migration_ref = db.migration_get_by_instance_and_status(context,
-                instance_id, 'pre-migrating')
+                instance_ref['uuid'], 'pre-migrating')
         try:
-            self.compute.finish_resize(context, instance_id,
+            self.compute.finish_resize(context, instance_ref['uuid'],
                     int(migration_ref['id']), {})
         except KeyError, e:
             # Only catch key errors. We want other reasons for the test to
@@ -445,14 +446,15 @@ class ComputeTestCase(test.TestCase):
         """Ensure notifications on instance migrate/resize"""
         instance_id = self._create_instance()
         context = self.context.elevated()
+        inst_ref = db.instance_get(context, instance_id)
 
         self.compute.run_instance(self.context, instance_id)
         test_notifier.NOTIFICATIONS = []
 
         db.instance_update(self.context, instance_id, {'host': 'foo'})
-        self.compute.prep_resize(context, instance_id, 1)
+        self.compute.prep_resize(context, inst_ref['uuid'], 1)
         migration_ref = db.migration_get_by_instance_and_status(context,
-                instance_id, 'pre-migrating')
+                inst_ref['uuid'], 'pre-migrating')
 
         self.assertEquals(len(test_notifier.NOTIFICATIONS), 1)
         msg = test_notifier.NOTIFICATIONS[0]
@@ -475,13 +477,15 @@ class ComputeTestCase(test.TestCase):
         """Ensure instance can be migrated/resized"""
         instance_id = self._create_instance()
         context = self.context.elevated()
+        inst_ref = db.instance_get(context, instance_id)
 
         self.compute.run_instance(self.context, instance_id)
-        db.instance_update(self.context, instance_id, {'host': 'foo'})
-        self.compute.prep_resize(context, instance_id, 1)
+        db.instance_update(self.context, inst_ref['uuid'],
+                           {'host': 'foo'})
+        self.compute.prep_resize(context, inst_ref['uuid'], 1)
         migration_ref = db.migration_get_by_instance_and_status(context,
-                instance_id, 'pre-migrating')
-        self.compute.resize_instance(context, instance_id,
+                inst_ref['uuid'], 'pre-migrating')
+        self.compute.resize_instance(context, inst_ref['uuid'],
                 migration_ref['id'])
         self.compute.terminate_instance(context, instance_id)
 
@@ -539,36 +543,36 @@ class ComputeTestCase(test.TestCase):
 
         # Confirm the instance size before the resize starts
         inst_ref = db.instance_get(context, instance_id)
-        instance_type_ref = db.instance_type_get_by_id(context,
+        instance_type_ref = db.instance_type_get(context,
                 inst_ref['instance_type_id'])
         self.assertEqual(instance_type_ref['flavorid'], 1)
 
         db.instance_update(self.context, instance_id, {'host': 'foo'})
 
-        self.compute.prep_resize(context, instance_id, 3)
+        self.compute.prep_resize(context, inst_ref['uuid'], 3)
 
         migration_ref = db.migration_get_by_instance_and_status(context,
-                instance_id, 'pre-migrating')
+                inst_ref['uuid'], 'pre-migrating')
 
-        self.compute.resize_instance(context, instance_id,
+        self.compute.resize_instance(context, inst_ref['uuid'],
                 migration_ref['id'])
-        self.compute.finish_resize(context, instance_id,
+        self.compute.finish_resize(context, inst_ref['uuid'],
                     int(migration_ref['id']), {})
 
         # Prove that the instance size is now the new size
         inst_ref = db.instance_get(context, instance_id)
-        instance_type_ref = db.instance_type_get_by_id(context,
+        instance_type_ref = db.instance_type_get(context,
                 inst_ref['instance_type_id'])
         self.assertEqual(instance_type_ref['flavorid'], 3)
 
         # Finally, revert and confirm the old flavor has been applied
-        self.compute.revert_resize(context, instance_id,
+        self.compute.revert_resize(context, inst_ref['uuid'],
                 migration_ref['id'])
-        self.compute.finish_revert_resize(context, instance_id,
+        self.compute.finish_revert_resize(context, inst_ref['uuid'],
                 migration_ref['id'])
 
         inst_ref = db.instance_get(context, instance_id)
-        instance_type_ref = db.instance_type_get_by_id(context,
+        instance_type_ref = db.instance_type_get(context,
                 inst_ref['instance_type_id'])
         self.assertEqual(instance_type_ref['flavorid'], 1)
 
@@ -583,8 +587,9 @@ class ComputeTestCase(test.TestCase):
         the same host"""
         instance_id = self._create_instance()
         self.compute.run_instance(self.context, instance_id)
+        inst_ref = db.instance_get(self.context, instance_id)
         self.assertRaises(exception.Error, self.compute.prep_resize,
-                self.context, instance_id, 1)
+                self.context, inst_ref['uuid'], 1)
         self.compute.terminate_instance(self.context, instance_id)
 
     def test_migrate(self):
@@ -624,7 +629,6 @@ class ComputeTestCase(test.TestCase):
         self._setup_other_managers()
         dbmock = self.mox.CreateMock(db)
         volmock = self.mox.CreateMock(self.volume_manager)
-        netmock = self.mox.CreateMock(self.network_manager)
         drivermock = self.mox.CreateMock(self.compute_driver)
 
         dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
@@ -632,12 +636,11 @@ class ComputeTestCase(test.TestCase):
         for i in range(len(i_ref['volumes'])):
             vid = i_ref['volumes'][i]['id']
             volmock.setup_compute_volume(c, vid).InAnyOrder('g1')
-        netmock.setup_compute_network(c, i_ref['id'])
+        drivermock.plug_vifs(i_ref, [])
         drivermock.ensure_filtering_rules_for_instance(i_ref)
 
         self.compute.db = dbmock
         self.compute.volume_manager = volmock
-        self.compute.network_manager = netmock
         self.compute.driver = drivermock
 
         self.mox.ReplayAll()
@@ -652,18 +655,16 @@ class ComputeTestCase(test.TestCase):
 
         self._setup_other_managers()
         dbmock = self.mox.CreateMock(db)
-        netmock = self.mox.CreateMock(self.network_manager)
         drivermock = self.mox.CreateMock(self.compute_driver)
 
         dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
         dbmock.instance_get_fixed_addresses(c, i_ref['id']).AndReturn('dummy')
         self.mox.StubOutWithMock(compute_manager.LOG, 'info')
         compute_manager.LOG.info(_("%s has no volume."), i_ref['hostname'])
-        netmock.setup_compute_network(c, i_ref['id'])
+        drivermock.plug_vifs(i_ref, [])
         drivermock.ensure_filtering_rules_for_instance(i_ref)
 
         self.compute.db = dbmock
-        self.compute.network_manager = netmock
         self.compute.driver = drivermock
 
         self.mox.ReplayAll()
@@ -684,18 +685,20 @@ class ComputeTestCase(test.TestCase):
         dbmock = self.mox.CreateMock(db)
         netmock = self.mox.CreateMock(self.network_manager)
         volmock = self.mox.CreateMock(self.volume_manager)
+        drivermock = self.mox.CreateMock(self.compute_driver)
 
         dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
         dbmock.instance_get_fixed_addresses(c, i_ref['id']).AndReturn('dummy')
         for i in range(len(i_ref['volumes'])):
             volmock.setup_compute_volume(c, i_ref['volumes'][i]['id'])
         for i in range(FLAGS.live_migration_retry_count):
-            netmock.setup_compute_network(c, i_ref['id']).\
+            drivermock.plug_vifs(i_ref, []).\
                 AndRaise(exception.ProcessExecutionError())
 
         self.compute.db = dbmock
         self.compute.network_manager = netmock
         self.compute.volume_manager = volmock
+        self.compute.driver = drivermock
 
         self.mox.ReplayAll()
         self.assertRaises(exception.ProcessExecutionError,
@@ -830,7 +833,7 @@ class ComputeTestCase(test.TestCase):
         for v in i_ref['volumes']:
             self.compute.volume_manager.remove_compute_volume(c, v['id'])
         self.mox.StubOutWithMock(self.compute.driver, 'unfilter_instance')
-        self.compute.driver.unfilter_instance(i_ref)
+        self.compute.driver.unfilter_instance(i_ref, [])
 
         # executing
         self.mox.ReplayAll()
diff --git a/nova/tests/test_db_api.py b/nova/tests/test_db_api.py
new file mode 100644
index 000000000..107fd03e3
--- /dev/null
+++ b/nova/tests/test_db_api.py
@@ -0,0 +1,86 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+"""Unit tests for the DB API"""
+
+from nova import test
+from nova import context
+from nova import db
+from nova import flags
+from nova.auth import manager
+
+FLAGS = flags.FLAGS
+
+
+def _setup_networking(instance_id, ip='1.2.3.4', flo_addr='1.2.1.2'):
+    ctxt = context.get_admin_context()
+    network_ref = db.project_get_networks(ctxt,
+                                           'fake',
+                                           associate=True)[0]
+    vif = {'address': '56:12:12:12:12:12',
+           'network_id': network_ref['id'],
+           'instance_id': instance_id}
+    vif_ref = db.virtual_interface_create(ctxt, vif)
+
+    fixed_ip = {'address': ip,
+                'network_id': network_ref['id'],
+                'virtual_interface_id': vif_ref['id'],
+                'allocated': True,
+                'instance_id': instance_id}
+    db.fixed_ip_create(ctxt, fixed_ip)
+    fix_ref = db.fixed_ip_get_by_address(ctxt, ip)
+    db.floating_ip_create(ctxt, {'address': flo_addr,
+                                        'fixed_ip_id': fix_ref.id})
+
+
+class DbApiTestCase(test.TestCase):
+    def setUp(self):
+        super(DbApiTestCase, self).setUp()
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('admin', 'admin', 'admin', True)
+        self.project = self.manager.create_project('proj', 'admin', 'proj')
+        self.context = context.RequestContext(user=self.user,
+                                              project=self.project)
+
+    def tearDown(self):
+        self.manager.delete_project(self.project)
+        self.manager.delete_user(self.user)
+        super(DbApiTestCase, self).tearDown()
+
+    def test_instance_get_project_vpn(self):
+        result = db.fixed_ip_get_all(self.context)
+        values = {'instance_type_id': FLAGS.default_instance_type,
+                  'image_ref': FLAGS.vpn_image_id,
+                  'project_id': self.project.id
+                 }
+        instance = db.instance_create(self.context, values)
+        result = db.instance_get_project_vpn(self.context, self.project.id)
+        self.assertEqual(instance.id, result.id)
+
+    def test_instance_get_project_vpn_joins(self):
+        result = db.fixed_ip_get_all(self.context)
+        values = {'instance_type_id': FLAGS.default_instance_type,
+                  'image_ref': FLAGS.vpn_image_id,
+                  'project_id': self.project.id
+                 }
+        instance = db.instance_create(self.context, values)
+        _setup_networking(instance.id)
+        result = db.instance_get_project_vpn(self.context, self.project.id)
+        self.assertEqual(instance.id, result.id)
+        self.assertEqual(result['fixed_ips'][0]['floating_ips'][0].address,
+                         '1.2.1.2')
diff --git a/nova/tests/test_instance_types_extra_specs.py b/nova/tests/test_instance_types_extra_specs.py
index c26cf82ff..393ed1e36 100644
--- a/nova/tests/test_instance_types_extra_specs.py
+++ b/nova/tests/test_instance_types_extra_specs.py
@@ -105,8 +105,8 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                               self.instance_type_id)
         self.assertEquals(expected_specs, actual_specs)
 
-    def test_instance_type_get_by_id_with_extra_specs(self):
-        instance_type = db.api.instance_type_get_by_id(
+    def test_instance_type_get_with_extra_specs(self):
+        instance_type = db.api.instance_type_get(
                             context.get_admin_context(),
                             self.instance_type_id)
         self.assertEquals(instance_type['extra_specs'],
@@ -115,7 +115,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                xpu_arch="fermi",
                                xpus="2",
                                xpu_model="Tesla 2050"))
-        instance_type = db.api.instance_type_get_by_id(
+        instance_type = db.api.instance_type_get(
                             context.get_admin_context(),
                             5)
         self.assertEquals(instance_type['extra_specs'], {})
@@ -136,7 +136,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                             "m1.small")
         self.assertEquals(instance_type['extra_specs'], {})
 
-    def test_instance_type_get_by_id_with_extra_specs(self):
+    def test_instance_type_get_with_extra_specs(self):
         instance_type = db.api.instance_type_get_by_flavor_id(
                             context.get_admin_context(),
                             105)
diff --git a/nova/tests/test_libvirt.py b/nova/tests/test_libvirt.py
index f99e1713d..bab4d200b 100644
--- a/nova/tests/test_libvirt.py
+++ b/nova/tests/test_libvirt.py
@@ -54,10 +54,15 @@ def _create_network_info(count=1, ipv6=None):
     fake_ip = '0.0.0.0/0'
     fake_ip_2 = '0.0.0.1/0'
     fake_ip_3 = '0.0.0.1/0'
+    fake_vlan = 100
+    fake_bridge_interface = 'eth0'
     network = {'bridge': fake,
                'cidr': fake_ip,
-               'cidr_v6': fake_ip}
+               'cidr_v6': fake_ip,
+               'vlan': fake_vlan,
+               'bridge_interface': fake_bridge_interface}
     mapping = {'mac': fake,
+               'dhcp_server': fake,
                'gateway': fake,
                'gateway6': fake,
                'ips': [{'ip': fake_ip}, {'ip': fake_ip}]}
@@ -83,7 +88,7 @@ def _setup_networking(instance_id, ip='1.2.3.4'):
                 'virtual_interface_id': vif_ref['id']}
     db.fixed_ip_create(ctxt, fixed_ip)
     db.fixed_ip_update(ctxt, ip, {'allocated': True,
-                                        'instance_id': instance_id})
+                                  'instance_id': instance_id})
 
 
 class CacheConcurrencyTestCase(test.TestCase):
@@ -172,13 +177,13 @@ class LibvirtConnTestCase(test.TestCase):
         self.context = context.get_admin_context()
         FLAGS.instances_path = ''
         self.call_libvirt_dependant_setup = False
+        self.test_ip = '10.11.12.13'
 
     def tearDown(self):
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
         super(LibvirtConnTestCase, self).tearDown()
 
-    test_ip = '10.11.12.13'
     test_instance = {'memory_kb':     '1024000',
                      'basepath':      '/some/path',
                      'bridge_name':   'br100',
@@ -218,9 +223,29 @@ class LibvirtConnTestCase(test.TestCase):
             def setattr(self, key, val):
                 self.__setattr__(key, val)
 
+        # A fake VIF driver
+        class FakeVIFDriver(object):
+
+            def __init__(self, **kwargs):
+                pass
+
+            def setattr(self, key, val):
+                self.__setattr__(key, val)
+
+            def plug(self, instance, network, mapping):
+                return {
+                    'id': 'fake',
+                    'bridge_name': 'fake',
+                    'mac_address': 'fake',
+                    'ip_address': 'fake',
+                    'dhcp_server': 'fake',
+                    'extra_params': 'fake'
+                }
+
         # Creating mocks
         fake = FakeLibvirtConnection()
         fakeip = FakeIptablesFirewallDriver
+        fakevif = FakeVIFDriver()
         # Customizing above fake if necessary
         for key, val in kwargs.items():
             fake.__setattr__(key, val)
@@ -228,6 +253,8 @@ class LibvirtConnTestCase(test.TestCase):
         # Inevitable mocks for connection.LibvirtConnection
         self.mox.StubOutWithMock(connection.utils, 'import_class')
         connection.utils.import_class(mox.IgnoreArg()).AndReturn(fakeip)
+        self.mox.StubOutWithMock(connection.utils, 'import_object')
+        connection.utils.import_object(mox.IgnoreArg()).AndReturn(fakevif)
         self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
         connection.LibvirtConnection._conn = fake
 
@@ -263,7 +290,6 @@ class LibvirtConnTestCase(test.TestCase):
 
         return db.service_create(context.get_admin_context(), service_ref)
 
-    @test.skip_test("Please review this test to ensure intent")
     def test_preparing_xml_info(self):
         conn = connection.LibvirtConnection(True)
         instance_ref = db.instance_create(self.context, self.test_instance)
@@ -279,43 +305,23 @@ class LibvirtConnTestCase(test.TestCase):
                                         _create_network_info(2))
         self.assertTrue(len(result['nics']) == 2)
 
-    def test_get_nic_for_xml_v4(self):
-        conn = connection.LibvirtConnection(True)
-        network, mapping = _create_network_info()[0]
-        self.flags(use_ipv6=False)
-        params = conn._get_nic_for_xml(network, mapping)['extra_params']
-        self.assertTrue(params.find('PROJNETV6') == -1)
-        self.assertTrue(params.find('PROJMASKV6') == -1)
-
-    def test_get_nic_for_xml_v6(self):
-        conn = connection.LibvirtConnection(True)
-        network, mapping = _create_network_info()[0]
-        self.flags(use_ipv6=True)
-        params = conn._get_nic_for_xml(network, mapping)['extra_params']
-        self.assertTrue(params.find('PROJNETV6') > -1)
-        self.assertTrue(params.find('PROJMASKV6') > -1)
-
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri_no_ramdisk_no_kernel(self):
         instance_data = dict(self.test_instance)
         self._check_xml_and_uri(instance_data,
                                 expect_kernel=False, expect_ramdisk=False)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri_no_ramdisk(self):
         instance_data = dict(self.test_instance)
         instance_data['kernel_id'] = 'aki-deadbeef'
         self._check_xml_and_uri(instance_data,
                                 expect_kernel=True, expect_ramdisk=False)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri_no_kernel(self):
         instance_data = dict(self.test_instance)
         instance_data['ramdisk_id'] = 'ari-deadbeef'
         self._check_xml_and_uri(instance_data,
                                 expect_kernel=False, expect_ramdisk=False)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri(self):
         instance_data = dict(self.test_instance)
         instance_data['ramdisk_id'] = 'ari-deadbeef'
@@ -323,7 +329,6 @@ class LibvirtConnTestCase(test.TestCase):
         self._check_xml_and_uri(instance_data,
                                 expect_kernel=True, expect_ramdisk=True)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri_rescue(self):
         instance_data = dict(self.test_instance)
         instance_data['ramdisk_id'] = 'ari-deadbeef'
@@ -331,7 +336,6 @@ class LibvirtConnTestCase(test.TestCase):
         self._check_xml_and_uri(instance_data, expect_kernel=True,
                                 expect_ramdisk=True, rescue=True)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_lxc_container_and_uri(self):
         instance_data = dict(self.test_instance)
         self._check_xml_and_container(instance_data)
@@ -411,6 +415,15 @@ class LibvirtConnTestCase(test.TestCase):
         self.assertEquals(snapshot['status'], 'active')
         self.assertEquals(snapshot['name'], snapshot_name)
 
+    def test_attach_invalid_device(self):
+        self.create_fake_libvirt_mock()
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(exception.InvalidDevicePath,
+                          conn.attach_volume,
+                          "fake", "bad/device/path", "/dev/fake")
+
     def test_multi_nic(self):
         instance_data = dict(self.test_instance)
         network_info = _create_network_info(2)
@@ -431,24 +444,7 @@ class LibvirtConnTestCase(test.TestCase):
         user_context = context.RequestContext(project=self.project,
                                               user=self.user)
         instance_ref = db.instance_create(user_context, instance)
-        # Re-get the instance so it's bound to an actual session
-        instance_ref = db.instance_get(user_context, instance_ref['id'])
-        network_ref = db.project_get_networks(context.get_admin_context(),
-                                             self.project.id)[0]
-
-        vif = {'address': '56:12:12:12:12:12',
-               'network_id': network_ref['id'],
-               'instance_id': instance_ref['id']}
-        vif_ref = db.virtual_interface_create(self.context, vif)
-        fixed_ip = {'address': self.test_ip,
-                    'network_id': network_ref['id'],
-                    'virtual_interface_id': vif_ref['id']}
-
-        ctxt = context.get_admin_context()
-        fixed_ip_ref = db.fixed_ip_create(ctxt, fixed_ip)
-        db.fixed_ip_update(ctxt, self.test_ip,
-                                 {'allocated': True,
-                                  'instance_id': instance_ref['id']})
+        _setup_networking(instance_ref['id'], self.test_ip)
 
         self.flags(libvirt_type='lxc')
         conn = connection.LibvirtConnection(True)
@@ -480,7 +476,7 @@ class LibvirtConnTestCase(test.TestCase):
         network_ref = db.project_get_networks(context.get_admin_context(),
                                              self.project.id)[0]
 
-        _setup_networking(instance_ref['id'], ip=self.test_ip)
+        _setup_networking(instance_ref['id'], self.test_ip)
 
         type_uri_map = {'qemu': ('qemu:///system',
                              [(lambda t: t.find('.').get('type'), 'qemu'),
@@ -721,6 +717,9 @@ class LibvirtConnTestCase(test.TestCase):
                 return vdmock
 
         self.create_fake_libvirt_mock(lookupByName=fake_lookup)
+        self.mox.StubOutWithMock(self.compute, "recover_live_migration")
+        self.compute.recover_live_migration(self.context, instance_ref,
+                                            dest='dest')
 
         # Start test
         self.mox.ReplayAll()
@@ -739,7 +738,6 @@ class LibvirtConnTestCase(test.TestCase):
         db.volume_destroy(self.context, volume_ref['id'])
         db.instance_destroy(self.context, instance_ref['id'])
 
-    @test.skip_test("test needs rewrite: instance no longer has mac_address")
     def test_spawn_with_network_info(self):
         # Skip if non-libvirt environment
         if not self.lazy_load_library_exists():
@@ -758,17 +756,7 @@ class LibvirtConnTestCase(test.TestCase):
         conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
         conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
 
-        network = db.project_get_networks(context.get_admin_context(),
-                                          self.project.id)[0]
-        ip_dict = {'ip': self.test_ip,
-                   'netmask': network['netmask'],
-                   'enabled': '1'}
-        mapping = {'label': network['label'],
-                   'gateway': network['gateway'],
-                   'mac': instance['mac_address'],
-                   'dns': [network['dns']],
-                   'ips': [ip_dict]}
-        network_info = [(network, mapping)]
+        network_info = _create_network_info()
 
         try:
             conn.spawn(instance, network_info)
@@ -826,6 +814,7 @@ class IptablesFirewallTestCase(test.TestCase):
                 """setup_basic_rules in nwfilter calls this."""
                 pass
         self.fake_libvirt_connection = FakeLibvirtConnection()
+        self.test_ip = '10.11.12.13'
         self.fw = firewall.IptablesFirewallDriver(
                       get_connection=lambda: self.fake_libvirt_connection)
 
@@ -891,27 +880,11 @@ class IptablesFirewallTestCase(test.TestCase):
                                    'project_id': 'fake',
                                    'instance_type_id': 1})
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_static_filters(self):
         instance_ref = self._create_instance_ref()
-        ip = '10.11.12.13'
-
-        network_ref = db.project_get_networks(self.context,
-                                               'fake',
-                                               associate=True)[0]
-        vif = {'address': '56:12:12:12:12:12',
-               'network_id': network_ref['id'],
-               'instance_id': instance_ref['id']}
-        vif_ref = db.virtual_interface_create(self.context, vif)
-
-        fixed_ip = {'address': ip,
-                    'network_id': network_ref['id'],
-                    'virtual_interface_id': vif_ref['id']}
-        admin_ctxt = context.get_admin_context()
-        db.fixed_ip_create(admin_ctxt, fixed_ip)
-        db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': instance_ref['id']})
+        _setup_networking(instance_ref['id'], self.test_ip)
 
+        admin_ctxt = context.get_admin_context()
         secgroup = db.security_group_create(admin_ctxt,
                                             {'user_id': 'fake',
                                              'project_id': 'fake',
@@ -1043,7 +1016,6 @@ class IptablesFirewallTestCase(test.TestCase):
         self.assertEquals(ipv6_network_rules,
                           ipv6_rules_per_network * networks_count)
 
-    @test.skip_test("skipping libvirt tests")
     def test_do_refresh_security_group_rules(self):
         instance_ref = self._create_instance_ref()
         self.mox.StubOutWithMock(self.fw,
@@ -1054,7 +1026,6 @@ class IptablesFirewallTestCase(test.TestCase):
         self.mox.ReplayAll()
         self.fw.do_refresh_security_group_rules("fake")
 
-    @test.skip_test("skip libvirt test project_get_network no longer exists")
     def test_unfilter_instance_undefines_nwfilter(self):
         # Skip if non-libvirt environment
         if not self.lazy_load_library_exists():
@@ -1068,38 +1039,24 @@ class IptablesFirewallTestCase(test.TestCase):
         self.fw.nwfilter._conn.nwfilterLookupByName =\
                                fakefilter.nwfilterLookupByName
         instance_ref = self._create_instance_ref()
-        inst_id = instance_ref['id']
-        instance = db.instance_get(self.context, inst_id)
 
-        ip = '10.11.12.13'
-        network_ref = db.project_get_network(self.context, 'fake')
-        fixed_ip = {'address': ip, 'network_id': network_ref['id']}
-        db.fixed_ip_create(admin_ctxt, fixed_ip)
-        db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': inst_id})
-        self.fw.setup_basic_filtering(instance)
-        self.fw.prepare_instance_filter(instance)
-        self.fw.apply_instance_filter(instance)
+        _setup_networking(instance_ref['id'], self.test_ip)
+        self.fw.setup_basic_filtering(instance_ref)
+        self.fw.prepare_instance_filter(instance_ref)
+        self.fw.apply_instance_filter(instance_ref)
         original_filter_count = len(fakefilter.filters)
-        self.fw.unfilter_instance(instance)
+        self.fw.unfilter_instance(instance_ref)
 
         # should undefine just the instance filter
         self.assertEqual(original_filter_count - len(fakefilter.filters), 1)
 
         db.instance_destroy(admin_ctxt, instance_ref['id'])
 
-    @test.skip_test("skip libvirt test project_get_network no longer exists")
     def test_provider_firewall_rules(self):
         # setup basic instance data
         instance_ref = self._create_instance_ref()
         nw_info = _create_network_info(1)
-        ip = '10.11.12.13'
-        network_ref = db.project_get_network(self.context, 'fake')
-        admin_ctxt = context.get_admin_context()
-        fixed_ip = {'address': ip, 'network_id': network_ref['id']}
-        db.fixed_ip_create(admin_ctxt, fixed_ip)
-        db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': instance_ref['id']})
+        _setup_networking(instance_ref['id'], self.test_ip)
         # FRAGILE: peeks at how the firewall names chains
         chain_name = 'inst-%s' % instance_ref['id']
 
@@ -1111,6 +1068,7 @@ class IptablesFirewallTestCase(test.TestCase):
                       if rule.chain == 'provider']
         self.assertEqual(0, len(rules))
 
+        admin_ctxt = context.get_admin_context()
         # add a rule and send the update message, check for 1 rule
         provider_fw0 = db.provider_fw_rule_create(admin_ctxt,
                                                   {'protocol': 'tcp',
@@ -1169,6 +1127,7 @@ class NWFilterTestCase(test.TestCase):
 
         self.fake_libvirt_connection = Mock()
 
+        self.test_ip = '10.11.12.13'
         self.fw = firewall.NWFilterFirewall(
                                          lambda: self.fake_libvirt_connection)
 
@@ -1255,7 +1214,6 @@ class NWFilterTestCase(test.TestCase):
         inst.update(params)
         return db.instance_type_create(context, inst)['id']
 
-    @test.skip_test('Skipping this test')
     def test_creates_base_rule_first(self):
         # These come pre-defined by libvirt
         self.defined_filters = ['no-mac-spoofing',
@@ -1287,21 +1245,11 @@ class NWFilterTestCase(test.TestCase):
         instance_ref = self._create_instance()
         inst_id = instance_ref['id']
 
-        ip = '10.11.12.13'
-
-        #network_ref = db.project_get_networks(self.context, 'fake')[0]
-        #fixed_ip = {'address': ip, 'network_id': network_ref['id']}
-
-        #admin_ctxt = context.get_admin_context()
-        #db.fixed_ip_create(admin_ctxt, fixed_ip)
-        #db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-        #                                    'instance_id': inst_id})
-
-        self._setup_networking(instance_ref['id'], ip=ip)
+        _setup_networking(instance_ref['id'], self.test_ip)
 
         def _ensure_all_called():
             instance_filter = 'nova-instance-%s-%s' % (instance_ref['name'],
-                                                       '00A0C914C829')
+                                                       '561212121212')
             secgroup_filter = 'nova-secgroup-%s' % self.security_group['id']
             for required in [secgroup_filter, 'allow-dhcp-server',
                              'no-arp-spoofing', 'no-ip-spoofing',
@@ -1322,7 +1270,7 @@ class NWFilterTestCase(test.TestCase):
         self.fw.apply_instance_filter(instance)
         _ensure_all_called()
         self.teardown_security_group()
-        db.instance_destroy(admin_ctxt, instance_ref['id'])
+        db.instance_destroy(context.get_admin_context(), instance_ref['id'])
 
     def test_create_network_filters(self):
         instance_ref = self._create_instance()
@@ -1332,7 +1280,6 @@ class NWFilterTestCase(test.TestCase):
                                                  "fake")
         self.assertEquals(len(result), 3)
 
-    @test.skip_test("skip libvirt test project_get_network no longer exists")
     def test_unfilter_instance_undefines_nwfilters(self):
         admin_ctxt = context.get_admin_context()
 
@@ -1350,12 +1297,7 @@ class NWFilterTestCase(test.TestCase):
 
         instance = db.instance_get(self.context, inst_id)
 
-        ip = '10.11.12.13'
-        network_ref = db.project_get_network(self.context, 'fake')
-        fixed_ip = {'address': ip, 'network_id': network_ref['id']}
-        db.fixed_ip_create(admin_ctxt, fixed_ip)
-        db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': inst_id})
+        _setup_networking(instance_ref['id'], self.test_ip)
         self.fw.setup_basic_filtering(instance)
         self.fw.prepare_instance_filter(instance)
         self.fw.apply_instance_filter(instance)
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index b09021e13..28f50d328 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -45,6 +45,7 @@ class FakeModel(dict):
 networks = [{'id': 0,
              'label': 'test0',
              'injected': False,
+             'multi_host': False,
              'cidr': '192.168.0.0/24',
              'cidr_v6': '2001:db8::/64',
              'gateway_v6': '2001:db8::1',
@@ -54,7 +55,8 @@ networks = [{'id': 0,
              'bridge_interface': 'fake_fa0',
              'gateway': '192.168.0.1',
              'broadcast': '192.168.0.255',
-             'dns': '192.168.0.1',
+             'dns1': '192.168.0.1',
+             'dns2': '192.168.0.2',
              'vlan': None,
              'host': None,
              'project_id': 'fake_project',
@@ -62,6 +64,7 @@ networks = [{'id': 0,
             {'id': 1,
              'label': 'test1',
              'injected': False,
+             'multi_host': False,
              'cidr': '192.168.1.0/24',
              'cidr_v6': '2001:db9::/64',
              'gateway_v6': '2001:db9::1',
@@ -71,7 +74,8 @@ networks = [{'id': 0,
              'bridge_interface': 'fake_fa1',
              'gateway': '192.168.1.1',
              'broadcast': '192.168.1.255',
-             'dns': '192.168.0.1',
+             'dns1': '192.168.0.1',
+             'dns2': '192.168.0.2',
              'vlan': None,
              'host': None,
              'project_id': 'fake_project',
@@ -122,34 +126,20 @@ class FlatNetworkTestCase(test.TestCase):
         self.network = network_manager.FlatManager(host=HOST)
         self.network.db = db
 
-    def test_set_network_hosts(self):
-        self.mox.StubOutWithMock(db, 'network_get_all')
-        self.mox.StubOutWithMock(db, 'network_set_host')
-        self.mox.StubOutWithMock(db, 'network_update')
-
-        db.network_get_all(mox.IgnoreArg()).AndReturn([networks[0]])
-        db.network_set_host(mox.IgnoreArg(),
-                            networks[0]['id'],
-                            mox.IgnoreArg()).AndReturn(HOST)
-        db.network_update(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg())
-        self.mox.ReplayAll()
-
-        self.network.set_network_hosts(None)
-
     def test_get_instance_nw_info(self):
         self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance')
         self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
-        self.mox.StubOutWithMock(db, 'instance_type_get_by_id')
+        self.mox.StubOutWithMock(db, 'instance_type_get')
 
         db.fixed_ip_get_by_instance(mox.IgnoreArg(),
                                     mox.IgnoreArg()).AndReturn(fixed_ips)
         db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                              mox.IgnoreArg()).AndReturn(vifs)
-        db.instance_type_get_by_id(mox.IgnoreArg(),
+        db.instance_type_get(mox.IgnoreArg(),
                                    mox.IgnoreArg()).AndReturn(flavor)
         self.mox.ReplayAll()
 
-        nw_info = self.network.get_instance_nw_info(None, 0, 0)
+        nw_info = self.network.get_instance_nw_info(None, 0, 0, None)
 
         self.assertTrue(nw_info)
 
@@ -159,11 +149,15 @@ class FlatNetworkTestCase(test.TestCase):
                      'cidr': '192.168.%s.0/24' % i,
                      'cidr_v6': '2001:db%s::/64' % i8,
                      'id': i,
-                     'injected': 'DONTCARE'}
+                     'multi_host': False,
+                     'injected': 'DONTCARE',
+                     'bridge_interface': 'fake_fa%s' % i,
+                     'vlan': None}
 
             self.assertDictMatch(nw[0], check)
 
             check = {'broadcast': '192.168.%s.255' % i,
+                     'dhcp_server': '192.168.%s.1' % i,
                      'dns': 'DONTCARE',
                      'gateway': '192.168.%s.1' % i,
                      'gateway6': '2001:db%s::1' % i8,
@@ -171,7 +165,9 @@ class FlatNetworkTestCase(test.TestCase):
                      'ips': 'DONTCARE',
                      'label': 'test%s' % i,
                      'mac': 'DE:AD:BE:EF:00:0%s' % i,
-                     'rxtx_cap': 'DONTCARE'}
+                     'rxtx_cap': 'DONTCARE',
+                     'should_create_vlan': False,
+                     'should_create_bridge': False}
             self.assertDictMatch(nw[1], check)
 
             check = [{'enabled': 'DONTCARE',
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 69d2deafe..a35caadf8 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -269,11 +269,10 @@ class QuotaTestCase(test.TestCase):
         for volume_id in volume_ids:
             db.volume_destroy(self.context, volume_id)
 
-    @test.skip_test
     def test_too_many_addresses(self):
         address = '192.168.0.100'
         db.floating_ip_create(context.get_admin_context(),
-                              {'address': address, 'host': FLAGS.host,
+                              {'address': address,
                                'project_id': self.project.id})
         self.assertRaises(quota.QuotaError,
                           self.network.allocate_floating_ip,
diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index cbf7801cf..7313508a6 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -19,9 +19,6 @@
 Test suite for VMWareAPI.
 """
 
-import stubout
-
-from nova import context
 from nova import db
 from nova import flags
 from nova import test
@@ -41,51 +38,66 @@ FLAGS = flags.FLAGS
 class VMWareAPIVMTestCase(test.TestCase):
     """Unit tests for Vmware API connection calls."""
 
-    # NOTE(jkoelker): This is leaking stubs into the db module.
-    #                 Commenting out until updated for multi-nic.
-    #def setUp(self):
-    #    super(VMWareAPIVMTestCase, self).setUp()
-    #    self.flags(vmwareapi_host_ip='test_url',
-    #               vmwareapi_host_username='test_username',
-    #               vmwareapi_host_password='test_pass')
-    #    self.manager = manager.AuthManager()
-    #    self.user = self.manager.create_user('fake', 'fake', 'fake',
-    #                                         admin=True)
-    #    self.project = self.manager.create_project('fake', 'fake', 'fake')
-    #    self.network = utils.import_object(FLAGS.network_manager)
-    #    self.stubs = stubout.StubOutForTesting()
-    #    vmwareapi_fake.reset()
-    #    db_fakes.stub_out_db_instance_api(self.stubs)
-    #    stubs.set_stubs(self.stubs)
-    #    glance_stubs.stubout_glance_client(self.stubs,
-    #                                       glance_stubs.FakeGlance)
-    #    self.conn = vmwareapi_conn.get_connection(False)
-
-    #def tearDown(self):
-    #    super(VMWareAPIVMTestCase, self).tearDown()
-    #    vmwareapi_fake.cleanup()
-    #    self.manager.delete_project(self.project)
-    #    self.manager.delete_user(self.user)
-    #    self.stubs.UnsetAll()
+    def setUp(self):
+        super(VMWareAPIVMTestCase, self).setUp()
+        self.flags(vmwareapi_host_ip='test_url',
+                   vmwareapi_host_username='test_username',
+                   vmwareapi_host_password='test_pass')
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('fake', 'fake', 'fake',
+                                             admin=True)
+        self.project = self.manager.create_project('fake', 'fake', 'fake')
+        self.network = utils.import_object(FLAGS.network_manager)
+        vmwareapi_fake.reset()
+        db_fakes.stub_out_db_instance_api(self.stubs)
+        stubs.set_stubs(self.stubs)
+        glance_stubs.stubout_glance_client(self.stubs)
+        self.conn = vmwareapi_conn.get_connection(False)
+        # NOTE(vish): none of the network plugging code is actually
+        #             being tested
+        self.network_info = [({'bridge': 'fa0',
+                               'id': 0,
+                               'vlan': None,
+                               'bridge_interface': None,
+                               'injected': True},
+                          {'broadcast': '192.168.0.255',
+                           'dns': ['192.168.0.1'],
+                           'gateway': '192.168.0.1',
+                           'gateway6': 'dead:beef::1',
+                           'ip6s': [{'enabled': '1',
+                                     'ip': 'dead:beef::dcad:beff:feef:0',
+                                           'netmask': '64'}],
+                           'ips': [{'enabled': '1',
+                                    'ip': '192.168.0.100',
+                                    'netmask': '255.255.255.0'}],
+                           'label': 'fake',
+                           'mac': 'DE:AD:BE:EF:00:00',
+                           'rxtx_cap': 3})]
+
+    def tearDown(self):
+        super(VMWareAPIVMTestCase, self).tearDown()
+        vmwareapi_fake.cleanup()
+        self.manager.delete_project(self.project)
+        self.manager.delete_user(self.user)
 
     def _create_instance_in_the_db(self):
         values = {'name': 1,
                   'id': 1,
                   'project_id': self.project.id,
                   'user_id': self.user.id,
-                  'image_id': "1",
+                  'image_ref': "1",
                   'kernel_id': "1",
                   'ramdisk_id': "1",
+                  'mac_address': "de:ad:be:ef:be:ef",
                   'instance_type': 'm1.large',
-                  'mac_address': 'aa:bb:cc:dd:ee:ff',
                   }
-        self.instance = db.instance_create(values)
+        self.instance = db.instance_create(None, values)
 
     def _create_vm(self):
         """Create and spawn the VM."""
         self._create_instance_in_the_db()
         self.type_data = db.instance_type_get_by_name(None, 'm1.large')
-        self.conn.spawn(self.instance)
+        self.conn.spawn(self.instance, self.network_info)
         self._check_vm_record()
 
     def _check_vm_record(self):
@@ -129,24 +141,20 @@ class VMWareAPIVMTestCase(test.TestCase):
         self.assertEquals(info["mem"], mem_kib)
         self.assertEquals(info["num_cpu"], self.type_data['vcpus'])
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_list_instances(self):
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 0)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_list_instances_1(self):
         self._create_vm()
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 1)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_spawn(self):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_snapshot(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -155,27 +163,23 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_snapshot_non_existent(self):
         self._create_instance_in_the_db()
         self.assertRaises(Exception, self.conn.snapshot, self.instance,
                           "Test-Snapshot")
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_reboot(self):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
-        self.conn.reboot(self.instance)
+        self.conn.reboot(self.instance, self.network_info)
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_reboot_non_existent(self):
         self._create_instance_in_the_db()
         self.assertRaises(Exception, self.conn.reboot, self.instance)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_reboot_not_poweredon(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -185,7 +189,6 @@ class VMWareAPIVMTestCase(test.TestCase):
         self._check_vm_info(info, power_state.PAUSED)
         self.assertRaises(Exception, self.conn.reboot, self.instance)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_suspend(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -194,13 +197,11 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.PAUSED)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_suspend_non_existent(self):
         self._create_instance_in_the_db()
         self.assertRaises(Exception, self.conn.suspend, self.instance,
                           self.dummy_callback_handler)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_resume(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -212,13 +213,11 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_resume_non_existent(self):
         self._create_instance_in_the_db()
         self.assertRaises(Exception, self.conn.resume, self.instance,
                           self.dummy_callback_handler)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_resume_not_suspended(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -226,49 +225,41 @@ class VMWareAPIVMTestCase(test.TestCase):
         self.assertRaises(Exception, self.conn.resume, self.instance,
                           self.dummy_callback_handler)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_get_info(self):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_destroy(self):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 1)
-        self.conn.destroy(self.instance)
+        self.conn.destroy(self.instance, self.network_info)
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 0)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_destroy_non_existent(self):
         self._create_instance_in_the_db()
-        self.assertEquals(self.conn.destroy(self.instance), None)
+        self.assertEquals(self.conn.destroy(self.instance, self.network_info),
+                          None)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_pause(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_unpause(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_diagnostics(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_get_console_output(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_get_ajax_console(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def dummy_callback_handler(self, ret):
         """
         Dummy callback function to be passed to suspend, resume, etc., calls.
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 4cb7447d3..8b3b5fa28 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -396,18 +396,22 @@ class XenAPIVMTestCase(test.TestCase):
     def _test_spawn(self, image_ref, kernel_id, ramdisk_id,
                     instance_type_id="3", os_type="linux",
                     architecture="x86-64", instance_id=1,
-                    check_injection=False):
+                    check_injection=False,
+                    create_record=True):
         stubs.stubout_loopingcall_start(self.stubs)
-        values = {'id': instance_id,
-                  'project_id': self.project.id,
-                  'user_id': self.user.id,
-                  'image_ref': image_ref,
-                  'kernel_id': kernel_id,
-                  'ramdisk_id': ramdisk_id,
-                  'instance_type_id': instance_type_id,
-                  'os_type': os_type,
-                  'architecture': architecture}
-        instance = db.instance_create(self.context, values)
+        if create_record:
+            values = {'id': instance_id,
+                      'project_id': self.project.id,
+                      'user_id': self.user.id,
+                      'image_ref': image_ref,
+                      'kernel_id': kernel_id,
+                      'ramdisk_id': ramdisk_id,
+                      'instance_type_id': instance_type_id,
+                      'os_type': os_type,
+                      'architecture': architecture}
+            instance = db.instance_create(self.context, values)
+        else:
+            instance = db.instance_get(self.context, instance_id)
         network_info = [({'bridge': 'fa0', 'id': 0, 'injected': True},
                           {'broadcast': '192.168.0.255',
                            'dns': ['192.168.0.1'],
@@ -599,41 +603,38 @@ class XenAPIVMTestCase(test.TestCase):
         # guest agent is detected
         self.assertFalse(self._tee_executed)
 
-    @test.skip_test("Never gets an address, not sure why")
     def test_spawn_vlanmanager(self):
         self.flags(xenapi_image_service='glance',
                    network_manager='nova.network.manager.VlanManager',
-                   network_driver='nova.network.xenapi_net',
                    vlan_interface='fake0')
 
         def dummy(*args, **kwargs):
             pass
 
-        self.stubs.Set(VMOps, 'create_vifs', dummy)
+        self.stubs.Set(vmops.VMOps, 'create_vifs', dummy)
         # Reset network table
         xenapi_fake.reset_table('network')
         # Instance id = 2 will use vlan network (see db/fakes.py)
         ctxt = self.context.elevated()
-        instance_ref = self._create_instance(2)
-        network_bk = self.network
-        # Ensure we use xenapi_net driver
-        self.network = utils.import_object(FLAGS.network_manager)
+        instance = self._create_instance(2, False)
         networks = self.network.db.network_get_all(ctxt)
         for network in networks:
-            self.network.set_network_host(ctxt, network['id'])
-
-        self.network.allocate_for_instance(ctxt, instance_id=instance_ref.id,
-                instance_type_id=1, project_id=self.project.id)
-        self.network.setup_compute_network(ctxt, instance_ref.id)
+            self.network.set_network_host(ctxt, network)
+
+        self.network.allocate_for_instance(ctxt,
+                                           instance_id=2,
+                                           host=FLAGS.host,
+                                           vpn=None,
+                                           instance_type_id=1,
+                                           project_id=self.project.id)
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
                          glance_stubs.FakeGlance.IMAGE_KERNEL,
                          glance_stubs.FakeGlance.IMAGE_RAMDISK,
-                         instance_id=instance_ref.id,
+                         instance_id=2,
                          create_record=False)
         # TODO(salvatore-orlando): a complete test here would require
         # a check for making sure the bridge for the VM's VIF is
         # consistent with bridge specified in nova db
-        self.network = network_bk
 
     def test_spawn_with_network_qos(self):
         self._create_instance()
@@ -644,10 +645,10 @@ class XenAPIVMTestCase(test.TestCase):
                               str(3 * 1024))
 
     def test_rescue(self):
-        self.flags(xenapi_inject_image=False)
+        self.flags(flat_injected=False)
         instance = self._create_instance()
         conn = xenapi_conn.get_connection(False)
-        conn.rescue(instance, None)
+        conn.rescue(instance, None, [])
 
     def test_unrescue(self):
         instance = self._create_instance()
@@ -663,7 +664,7 @@ class XenAPIVMTestCase(test.TestCase):
         self.vm = None
         self.stubs.UnsetAll()
 
-    def _create_instance(self, instance_id=1):
+    def _create_instance(self, instance_id=1, spawn=True):
         """Creates and spawns a test instance."""
         stubs.stubout_loopingcall_start(self.stubs)
         values = {
@@ -691,7 +692,8 @@ class XenAPIVMTestCase(test.TestCase):
                            'label': 'fake',
                            'mac': 'DE:AD:BE:EF:00:00',
                            'rxtx_cap': 3})]
-        self.conn.spawn(instance, network_info)
+        if spawn:
+            self.conn.spawn(instance, network_info)
         return instance
 
 
diff --git a/nova/tests/vmwareapi/db_fakes.py b/nova/tests/vmwareapi/db_fakes.py
index d4eb87daf..afd672c7a 100644
--- a/nova/tests/vmwareapi/db_fakes.py
+++ b/nova/tests/vmwareapi/db_fakes.py
@@ -70,8 +70,8 @@ def stub_out_db_instance_api(stubs):
             'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),

             'instance_type': values['instance_type'],

             'memory_mb': type_data['memory_mb'],

-            'mac_address': values['mac_address'],

             'vcpus': type_data['vcpus'],

+            'mac_addresses': [{'address': values['mac_address']}],

             'local_gb': type_data['local_gb'],

             }

         return FakeModel(base_options)

@@ -83,6 +83,8 @@ def stub_out_db_instance_api(stubs):
             'bridge': 'vmnet0',

             'netmask': '255.255.255.0',

             'gateway': '10.10.10.1',

+            'broadcast': '10.10.10.255',

+            'dns1': 'fake',

             'vlan': 100}

         return FakeModel(fields)

 

@@ -90,7 +92,7 @@ def stub_out_db_instance_api(stubs):
         """Stubs out the db.instance_action_create method."""

         pass

 

-    def fake_instance_get_fixed_address(context, instance_id):

+    def fake_instance_get_fixed_addresses(context, instance_id):

         """Stubs out the db.instance_get_fixed_address method."""

         return '10.10.10.10'

 

@@ -103,7 +105,7 @@ def stub_out_db_instance_api(stubs):
     stubs.Set(db, 'instance_create', fake_instance_create)

     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)

     stubs.Set(db, 'instance_action_create', fake_instance_action_create)

-    stubs.Set(db, 'instance_get_fixed_address',

-                fake_instance_get_fixed_address)

+    stubs.Set(db, 'instance_get_fixed_addresses',

+                fake_instance_get_fixed_addresses)

     stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)

     stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)

diff --git a/nova/tests/vmwareapi/stubs.py b/nova/tests/vmwareapi/stubs.py
index a648efb16..0ed5e9b68 100644
--- a/nova/tests/vmwareapi/stubs.py
+++ b/nova/tests/vmwareapi/stubs.py
@@ -22,6 +22,8 @@ Stubouts for the test suite
 from nova.virt import vmwareapi_conn

 from nova.virt.vmwareapi import fake

 from nova.virt.vmwareapi import vmware_images

+from nova.virt.vmwareapi import vmops

+from nova.virt.vmwareapi import network_utils

 

 

 def fake_get_vim_object(arg):

@@ -36,11 +38,16 @@ def fake_is_vim_object(arg, module):
 

 def set_stubs(stubs):

     """Set the stubs."""

+    stubs.Set(vmops.VMWareVMOps, 'plug_vifs', fake.fake_plug_vifs)

+    stubs.Set(network_utils, 'get_network_with_the_name',

+              fake.fake_get_network)

     stubs.Set(vmware_images, 'fetch_image', fake.fake_fetch_image)

     stubs.Set(vmware_images, 'get_vmdk_size_and_properties',

               fake.fake_get_vmdk_size_and_properties)

     stubs.Set(vmware_images, 'upload_image', fake.fake_upload_image)

     stubs.Set(vmwareapi_conn.VMWareAPISession, "_get_vim_object",

               fake_get_vim_object)

+    stubs.Set(vmwareapi_conn.VMWareAPISession, "_get_vim_object",

+              fake_get_vim_object)

     stubs.Set(vmwareapi_conn.VMWareAPISession, "_is_vim_object",

               fake_is_vim_object)