merged trunk

14 files changed, 1178 insertions, 220 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_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..927009e77 100644
--- a/nova/tests/api/openstack/test_faults.py
+++ b/nova/tests/api/openstack/test_faults.py
@@ -139,3 +139,8 @@ 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)
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_images.py b/nova/tests/api/openstack/test_images.py
index 534460d46..17f2fb755 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -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)
-        mocker.VerifyAll()
+        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)
+        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 875d8b06e..54d86e0bb 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -688,6 +688,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'},
@@ -702,6 +703,50 @@ 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)
+        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)
@@ -728,6 +773,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'},
@@ -747,6 +793,7 @@ class ServersTest(test.TestCase):
                     },
                     {'address': '172.19.0.2'},
                 ],
+                'fixed_ipv6': '2001:4860::12',
             },
         ]
 
@@ -769,6 +816,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'},
                 ],
             },
         }
@@ -776,6 +824,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'},
@@ -795,6 +844,7 @@ class ServersTest(test.TestCase):
                     },
                     {'address': '172.19.0.2'},
                 ],
+                'fixed_ipv6': '2001:4860::12',
             },
         ]
         _return_vifs = return_virtual_interface_by_instance(interfaces)
@@ -811,6 +861,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)
@@ -1228,6 +1279,38 @@ class ServersTest(test.TestCase):
         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()
 
@@ -2024,7 +2107,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')
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/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/test_cloud.py b/nova/tests/test_cloud.py
index a0d50b287..8cdc73a66 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -15,6 +15,7 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
+import mox
 
 from base64 import b64decode
 from M2Crypto import BIO
@@ -29,6 +30,7 @@ from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova import network
 from nova import rpc
 from nova import test
 from nova import utils
@@ -132,6 +134,33 @@ class CloudTestCase(test.TestCase):
                           allocate,
                           self.context)
 
+    def test_release_address(self):
+        address = "10.10.10.10"
+        allocate = self.cloud.allocate_address
+        db.floating_ip_create(self.context,
+                              {'address': address,
+                               'host': self.network.host})
+        result = self.cloud.release_address(self.context, address)
+        self.assertEqual(result['releaseResponse'], ['Address released.'])
+
+    def test_release_address_still_associated(self):
+        address = "10.10.10.10"
+        fixed_ip = {'instance': {'id': 1}}
+        floating_ip = {'id': 0,
+                       'address': address,
+                       'fixed_ip_id': 0,
+                       'fixed_ip': fixed_ip,
+                       'project_id': None,
+                       'auto_assigned': False}
+        network_api = network.api.API()
+        self.mox.StubOutWithMock(network_api.db, 'floating_ip_get_by_address')
+        network_api.db.floating_ip_get_by_address(mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(floating_ip)
+        self.mox.ReplayAll()
+        release = self.cloud.release_address
+        # 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"""
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 2900c594e..5d59b628a 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -424,11 +424,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
@@ -441,14 +442,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]
@@ -471,13 +473,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)
 
@@ -519,6 +523,57 @@ class ComputeTestCase(test.TestCase):
 
         self.compute.terminate_instance(context, instance_id)
 
+    def test_finish_revert_resize(self):
+        """Ensure that the flavor is reverted to the original on revert"""
+        context = self.context.elevated()
+        instance_id = self._create_instance()
+
+        def fake(*args, **kwargs):
+            pass
+
+        self.stubs.Set(self.compute.driver, 'finish_resize', fake)
+        self.stubs.Set(self.compute.driver, 'revert_resize', fake)
+        self.stubs.Set(self.compute.network_api, 'get_instance_nw_info', fake)
+
+        self.compute.run_instance(self.context, instance_id)
+
+        # Confirm the instance size before the resize starts
+        inst_ref = db.instance_get(context, instance_id)
+        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, inst_ref['uuid'], 3)
+
+        migration_ref = db.migration_get_by_instance_and_status(context,
+                inst_ref['uuid'], 'pre-migrating')
+
+        self.compute.resize_instance(context, inst_ref['uuid'],
+                migration_ref['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(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, inst_ref['uuid'],
+                migration_ref['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(context,
+                inst_ref['instance_type_id'])
+        self.assertEqual(instance_type_ref['flavorid'], 1)
+
+        self.compute.terminate_instance(context, instance_id)
+
     def test_get_by_flavor_id(self):
         type = instance_types.get_instance_type_by_flavor_id(1)
         self.assertEqual(type['name'], 'm1.tiny')
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..6e2ec7ed6 100644
--- a/nova/tests/test_libvirt.py
+++ b/nova/tests/test_libvirt.py
@@ -58,6 +58,7 @@ def _create_network_info(count=1, ipv6=None):
                'cidr': fake_ip,
                'cidr_v6': fake_ip}
     mapping = {'mac': fake,
+               'dhcp_server': fake,
                'gateway': fake,
                'gateway6': fake,
                'ips': [{'ip': fake_ip}, {'ip': fake_ip}]}
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index b09021e13..fbe7d769e 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)
 
@@ -164,6 +154,7 @@ class FlatNetworkTestCase(test.TestCase):
             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,