Merged from upstream.

10 files changed, 806 insertions, 179 deletions

diff --git a/nova/tests/api/openstack/contrib/test_createserverext.py b/nova/tests/api/openstack/contrib/test_createserverext.py
new file mode 100644
index 000000000..e5eed14fe
--- /dev/null
+++ b/nova/tests/api/openstack/contrib/test_createserverext.py
@@ -0,0 +1,306 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import base64
+import json
+import unittest
+from xml.dom import minidom
+
+import stubout
+import webob
+
+from nova import exception
+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.contrib import createserverext
+import nova.compute.api
+
+import nova.scheduler.api
+import nova.image.fake
+import nova.rpc
+from nova.tests.api.openstack import fakes
+
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
+
+FAKE_NETWORKS = [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '10.0.1.12'),
+                 ('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', '10.0.2.12')]
+
+DUPLICATE_NETWORKS = [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '10.0.1.12'),
+                      ('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '10.0.1.12')]
+
+INVALID_NETWORKS = [('invalid', 'invalid-ip-address')]
+
+
+class CreateserverextTest(test.TestCase):
+
+    def setUp(self):
+        super(CreateserverextTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
+        fakes.stub_out_image_service(self.stubs)
+        fakes.stub_out_key_pair_funcs(self.stubs)
+        self.allow_admin = FLAGS.allow_admin_api
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.allow_admin_api = self.allow_admin
+        super(CreateserverextTest, self).tearDown()
+
+    def _setup_mock_compute_api(self):
+
+        class MockComputeAPI(nova.compute.API):
+
+            def __init__(self):
+                self.injected_files = None
+                self.networks = None
+
+            def create(self, *args, **kwargs):
+                if 'injected_files' in kwargs:
+                    self.injected_files = kwargs['injected_files']
+                else:
+                    self.injected_files = None
+
+                if 'requested_networks' in kwargs:
+                    self.networks = kwargs['requested_networks']
+                else:
+                    self.networks = None
+                return [{'id': '1234', 'display_name': 'fakeinstance',
+                         'uuid': FAKE_UUID,
+                         'created_at': "",
+                         'updated_at': ""}]
+
+            def set_admin_password(self, *args, **kwargs):
+                pass
+
+        def make_stub_method(canned_return):
+            def stub_method(*args, **kwargs):
+                return canned_return
+            return stub_method
+
+        compute_api = MockComputeAPI()
+        self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api))
+        self.stubs.Set(
+            nova.api.openstack.create_instance_helper.CreateInstanceHelper,
+            '_get_kernel_ramdisk_from_image', make_stub_method((1, 1)))
+        return compute_api
+
+    def _create_networks_request_dict(self, networks):
+        server = {}
+        server['name'] = 'new-server-test'
+        server['imageRef'] = 1
+        server['flavorRef'] = 1
+        if networks is not None:
+            network_list = []
+            for uuid, fixed_ip in networks:
+                network_list.append({'uuid': uuid, 'fixed_ip': fixed_ip})
+            server['networks'] = network_list
+        return {'server': server}
+
+    def _get_create_request_json(self, body_dict):
+        req = webob.Request.blank('/v1.1/123/os-create-server-ext')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body_dict)
+        return req
+
+    def _run_create_instance_with_mock_compute_api(self, request):
+        compute_api = self._setup_mock_compute_api()
+        response = request.get_response(fakes.wsgi_app())
+        return compute_api, response
+
+    def _format_xml_request_body(self, body_dict):
+        server = body_dict['server']
+        body_parts = []
+        body_parts.extend([
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.1"',
+            ' name="%s" imageRef="%s" flavorRef="%s">' % (
+                    server['name'], server['imageRef'], server['flavorRef'])])
+        if 'metadata' in server:
+            metadata = server['metadata']
+            body_parts.append('<metadata>')
+            for item in metadata.iteritems():
+                body_parts.append('<meta key="%s">%s</meta>' % item)
+            body_parts.append('</metadata>')
+        if 'personality' in server:
+            personalities = server['personality']
+            body_parts.append('<personality>')
+            for file in personalities:
+                item = (file['path'], file['contents'])
+                body_parts.append('<file path="%s">%s</file>' % item)
+            body_parts.append('</personality>')
+        if 'networks' in server:
+            networks = server['networks']
+            body_parts.append('<networks>')
+            for network in networks:
+                item = (network['uuid'], network['fixed_ip'])
+                body_parts.append('<network uuid="%s" fixed_ip="%s"></network>'
+                                  % item)
+            body_parts.append('</networks>')
+        body_parts.append('</server>')
+        return ''.join(body_parts)
+
+    def _get_create_request_xml(self, body_dict):
+        req = webob.Request.blank('/v1.1/123/os-create-server-ext')
+        req.content_type = 'application/xml'
+        req.accept = 'application/xml'
+        req.method = 'POST'
+        req.body = self._format_xml_request_body(body_dict)
+        return req
+
+    def _create_instance_with_networks_json(self, networks):
+        body_dict = self._create_networks_request_dict(networks)
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        return request, response, compute_api.networks
+
+    def _create_instance_with_networks_xml(self, networks):
+        body_dict = self._create_networks_request_dict(networks)
+        request = self._get_create_request_xml(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        return request, response, compute_api.networks
+
+    def test_create_instance_with_no_networks(self):
+        request, response, networks = \
+                self._create_instance_with_networks_json(networks=None)
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_no_networks_xml(self):
+        request, response, networks = \
+                self._create_instance_with_networks_xml(networks=None)
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_one_network(self):
+        request, response, networks = \
+            self._create_instance_with_networks_json([FAKE_NETWORKS[0]])
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, [FAKE_NETWORKS[0]])
+
+    def test_create_instance_with_one_network_xml(self):
+        request, response, networks = \
+            self._create_instance_with_networks_xml([FAKE_NETWORKS[0]])
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, [FAKE_NETWORKS[0]])
+
+    def test_create_instance_with_two_networks(self):
+        request, response, networks = \
+            self._create_instance_with_networks_json(FAKE_NETWORKS)
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, FAKE_NETWORKS)
+
+    def test_create_instance_with_two_networks_xml(self):
+        request, response, networks = \
+            self._create_instance_with_networks_xml(FAKE_NETWORKS)
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(networks, FAKE_NETWORKS)
+
+    def test_create_instance_with_duplicate_networks(self):
+        request, response, networks = \
+            self._create_instance_with_networks_json(DUPLICATE_NETWORKS)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_duplicate_networks_xml(self):
+        request, response, networks = \
+            self._create_instance_with_networks_xml(DUPLICATE_NETWORKS)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_network_no_id(self):
+        body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]])
+        del body_dict['server']['networks'][0]['uuid']
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.networks, None)
+
+    def test_create_instance_with_network_no_id_xml(self):
+        body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]])
+        request = self._get_create_request_xml(body_dict)
+        uuid = ' uuid="aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"'
+        request.body = request.body.replace(uuid, '')
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.networks, None)
+
+    def test_create_instance_with_network_invalid_id(self):
+        request, response, networks = \
+            self._create_instance_with_networks_json(INVALID_NETWORKS)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_network_invalid_id_xml(self):
+        request, response, networks = \
+            self._create_instance_with_networks_xml(INVALID_NETWORKS)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_network_empty_fixed_ip(self):
+        networks = [('1', '')]
+        request, response, networks = \
+            self._create_instance_with_networks_json(networks)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_network_non_string_fixed_ip(self):
+        networks = [('1', 12345)]
+        request, response, networks = \
+            self._create_instance_with_networks_json(networks)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_network_empty_fixed_ip_xml(self):
+        networks = [('1', '')]
+        request, response, networks = \
+            self._create_instance_with_networks_xml(networks)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(networks, None)
+
+    def test_create_instance_with_network_no_fixed_ip(self):
+        body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]])
+        del body_dict['server']['networks'][0]['fixed_ip']
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(compute_api.networks,
+                          [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', None)])
+
+    def test_create_instance_with_network_no_fixed_ip_xml(self):
+        body_dict = self._create_networks_request_dict([FAKE_NETWORKS[0]])
+        request = self._get_create_request_xml(body_dict)
+        request.body = request.body.replace(' fixed_ip="10.0.1.12"', '')
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 202)
+        self.assertEquals(compute_api.networks,
+                          [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', None)])
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 4060763fc..9f923852d 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -85,6 +85,7 @@ class ExtensionControllerTest(test.TestCase):
         ext_path = os.path.join(os.path.dirname(__file__), "extensions")
         self.flags(osapi_extensions_path=ext_path)
         self.ext_list = [
+            "Createserverext",
             "FlavorExtraSpecs",
             "Floating_ips",
             "Fox In Socks",
diff --git a/nova/tests/api/openstack/test_server_actions.py b/nova/tests/api/openstack/test_server_actions.py
index 90fe2f0b3..bdd6824e7 100644
--- a/nova/tests/api/openstack/test_server_actions.py
+++ b/nova/tests/api/openstack/test_server_actions.py
@@ -1,17 +1,13 @@
 import base64
 import json
-import unittest
-from xml.dom import minidom
 
 import stubout
 import webob
 
 from nova import context
-from nova import db
 from nova import utils
 from nova import flags
 from nova.api.openstack import create_instance_helper
-from nova.compute import instance_types
 from nova.compute import power_state
 import nova.db.api
 from nova import test
@@ -103,8 +99,6 @@ class ServerActionsTest(test.TestCase):
         super(ServerActionsTest, self).setUp()
         self.flags(verbose=True)
         self.stubs = stubout.StubOutForTesting()
-        fakes.FakeAuthManager.reset_fake_data()
-        fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_auth(self.stubs)
         self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         self.stubs.Set(nova.db.api, 'instance_update', instance_update)
@@ -468,8 +462,6 @@ class ServerActionsTestV11(test.TestCase):
         self.maxDiff = None
         super(ServerActionsTestV11, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        fakes.FakeAuthManager.reset_fake_data()
-        fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_auth(self.stubs)
         self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         self.stubs.Set(nova.db.api, 'instance_update', instance_update)
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 800a2e229..aec2ad947 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -1,6 +1,7 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 # Copyright 2010-2011 OpenStack LLC.
+# Copyright 2011 Piston Cloud Computing, Inc.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -233,7 +234,6 @@ class MockSetAdminPassword(object):
 
 
 class ServersTest(test.TestCase):
-
     def setUp(self):
         self.maxDiff = None
         super(ServersTest, self).setUp()
@@ -265,6 +265,7 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.compute.API, "get_actions", fake_compute_api)
 
         self.webreq = common.webob_factory('/v1.0/servers')
+        self.config_drive = None
 
     def test_get_server_by_id(self):
         req = webob.Request.blank('/v1.0/servers/1')
@@ -379,6 +380,7 @@ class ServersTest(test.TestCase):
                 "metadata": {
                     "seq": "1",
                 },
+                "config_drive": None,
                 "links": [
                     {
                         "rel": "self",
@@ -545,6 +547,7 @@ class ServersTest(test.TestCase):
                 "metadata": {
                     "seq": "1",
                 },
+                "config_drive": None,
                 "links": [
                     {
                         "rel": "self",
@@ -638,6 +641,7 @@ class ServersTest(test.TestCase):
                 "metadata": {
                     "seq": "1",
                 },
+                "config_drive": None,
                 "links": [
                     {
                         "rel": "self",
@@ -1399,6 +1403,7 @@ class ServersTest(test.TestCase):
                     'image_ref': image_ref,
                     "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
                     "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
+                    "config_drive": self.config_drive,
                    }
 
         def server_update(context, id, params):
@@ -1424,8 +1429,7 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.db.api, 'instance_create', instance_create)
         self.stubs.Set(nova.rpc, 'cast', fake_method)
         self.stubs.Set(nova.rpc, 'call', fake_method)
-        self.stubs.Set(nova.db.api, 'instance_update',
-            server_update)
+        self.stubs.Set(nova.db.api, 'instance_update', server_update)
         self.stubs.Set(nova.db.api, 'queue_get_for', queue_get_for)
         self.stubs.Set(nova.network.manager.VlanManager, 'allocate_fixed_ip',
             fake_method)
@@ -1768,6 +1772,129 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_create_instance_with_config_drive_v1_1(self):
+        self.config_drive = True
+        self._setup_for_create_instance()
+
+        image_href = 'http://localhost/v1.1/123/images/2'
+        flavor_ref = 'http://localhost/v1.1/123/flavors/3'
+        body = {
+            'server': {
+                'name': 'config_drive_test',
+                'imageRef': image_href,
+                'flavorRef': flavor_ref,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+                'config_drive': True,
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/123/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        res = req.get_response(fakes.wsgi_app())
+        print res
+        self.assertEqual(res.status_int, 202)
+        server = json.loads(res.body)['server']
+        self.assertEqual(1, server['id'])
+        self.assertTrue(server['config_drive'])
+
+    def test_create_instance_with_config_drive_as_id_v1_1(self):
+        self.config_drive = 2
+        self._setup_for_create_instance()
+
+        image_href = 'http://localhost/v1.1/123/images/2'
+        flavor_ref = 'http://localhost/v1.1/123/flavors/3'
+        body = {
+            'server': {
+                'name': 'config_drive_test',
+                'imageRef': image_href,
+                'flavorRef': flavor_ref,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+                'config_drive': 2,
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/123/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, 202)
+        server = json.loads(res.body)['server']
+        self.assertEqual(1, server['id'])
+        self.assertTrue(server['config_drive'])
+        self.assertEqual(2, server['config_drive'])
+
+    def test_create_instance_with_bad_config_drive_v1_1(self):
+        self.config_drive = "asdf"
+        self._setup_for_create_instance()
+
+        image_href = 'http://localhost/v1.1/123/images/2'
+        flavor_ref = 'http://localhost/v1.1/123/flavors/3'
+        body = {
+            'server': {
+                'name': 'config_drive_test',
+                'imageRef': image_href,
+                'flavorRef': flavor_ref,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+                'config_drive': 'asdf',
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/123/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_without_config_drive_v1_1(self):
+        self._setup_for_create_instance()
+
+        image_href = 'http://localhost/v1.1/123/images/2'
+        flavor_ref = 'http://localhost/v1.1/123/flavors/3'
+        body = {
+            'server': {
+                'name': 'config_drive_test',
+                'imageRef': image_href,
+                'flavorRef': flavor_ref,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+                'config_drive': True,
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/123/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, 202)
+        server = json.loads(res.body)['server']
+        self.assertEqual(1, server['id'])
+        self.assertFalse(server['config_drive'])
+
     def test_create_instance_v1_1_bad_href(self):
         self._setup_for_create_instance()
 
@@ -1890,6 +2017,29 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_create_instance_whitespace_name(self):
+        self._setup_for_create_instance()
+
+        body = {
+            'server': {
+                'name': '    ',
+                'imageId': 3,
+                'flavorId': 1,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+            },
+        }
+
+        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, 400)
+
     def test_update_server_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
@@ -2829,6 +2979,164 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
         }
         self.assertEquals(request['body'], expected)
 
+    def test_request_with_empty_networks(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks/>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": []
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network uuid="1" fixed_ip="10.0.1.12"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_two_networks(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network uuid="1" fixed_ip="10.0.1.12"/>
+       <network uuid="2" fixed_ip="10.0.2.12"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"},
+                             {"uuid": "2", "fixed_ip": "10.0.2.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_second_network_node_ignored(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network uuid="1" fixed_ip="10.0.1.12"/>
+    </networks>
+    <networks>
+       <network uuid="2" fixed_ip="10.0.2.12"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network_missing_id(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network fixed_ip="10.0.1.12"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"fixed_ip": "10.0.1.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network_missing_fixed_ip(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+ name="new-server-test" imageRef="1" flavorRef="1">
+    <networks>
+       <network uuid="1"/>
+    </networks>
+</server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network_empty_id(self):
+        serial_request = """
+    <server xmlns="http://docs.openstack.org/compute/api/v1.1"
+     name="new-server-test" imageRef="1" flavorRef="1">
+        <networks>
+           <network uuid="" fixed_ip="10.0.1.12"/>
+        </networks>
+    </server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "", "fixed_ip": "10.0.1.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_one_network_empty_fixed_ip(self):
+        serial_request = """
+    <server xmlns="http://docs.openstack.org/compute/api/v1.1"
+     name="new-server-test" imageRef="1" flavorRef="1">
+        <networks>
+           <network uuid="1" fixed_ip=""/>
+        </networks>
+    </server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": ""}],
+                }}
+        self.assertEquals(request['body'], expected)
+
+    def test_request_with_networks_duplicate_ids(self):
+        serial_request = """
+    <server xmlns="http://docs.openstack.org/compute/api/v1.1"
+     name="new-server-test" imageRef="1" flavorRef="1">
+        <networks>
+           <network uuid="1" fixed_ip="10.0.1.12"/>
+           <network uuid="1" fixed_ip="10.0.2.12"/>
+        </networks>
+    </server>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "1",
+                "networks": [{"uuid": "1", "fixed_ip": "10.0.1.12"},
+                             {"uuid": "1", "fixed_ip": "10.0.2.12"}],
+                }}
+        self.assertEquals(request['body'], expected)
+
 
 class TestAddressesXMLSerialization(test.TestCase):
 
@@ -2899,12 +3207,14 @@ class TestServerInstanceCreation(test.TestCase):
 
             def __init__(self):
                 self.injected_files = None
+                self.networks = None
 
             def create(self, *args, **kwargs):
                 if 'injected_files' in kwargs:
                     self.injected_files = kwargs['injected_files']
                 else:
                     self.injected_files = None
+
                 return [{'id': '1234', 'display_name': 'fakeinstance',
                          'uuid': FAKE_UUID}]
 
@@ -3266,6 +3576,7 @@ class ServersViewBuilderV11Test(test.TestCase):
                         "href": "http://localhost/servers/1",
                     },
                 ],
+                "config_drive": None,
             }
         }
 
@@ -3278,6 +3589,7 @@ class ServersViewBuilderV11Test(test.TestCase):
                 "id": 1,
                 "uuid": self.instance['uuid'],
                 "name": "test_server",
+                "config_drive": None,
                 "links": [
                     {
                         "rel": "self",
@@ -3330,6 +3642,7 @@ class ServersViewBuilderV11Test(test.TestCase):
                 },
                 "addresses": {},
                 "metadata": {},
+                "config_drive": None,
                 "links": [
                     {
                         "rel": "self",
@@ -3383,6 +3696,7 @@ class ServersViewBuilderV11Test(test.TestCase):
                 },
                 "addresses": {},
                 "metadata": {},
+                "config_drive": None,
                 "links": [
                     {
                         "rel": "self",
@@ -3435,6 +3749,7 @@ class ServersViewBuilderV11Test(test.TestCase):
                 },
                 "addresses": {},
                 "metadata": {},
+                "config_drive": None,
                 "accessIPv4": "1.2.3.4",
                 "accessIPv6": "",
                 "links": [
@@ -3489,6 +3804,7 @@ class ServersViewBuilderV11Test(test.TestCase):
                 },
                 "addresses": {},
                 "metadata": {},
+                "config_drive": None,
                 "accessIPv4": "",
                 "accessIPv6": "fead::1234",
                 "links": [
@@ -3551,6 +3867,7 @@ class ServersViewBuilderV11Test(test.TestCase):
                     "Open": "Stack",
                     "Number": "1",
                 },
+                "config_drive": None,
                 "links": [
                     {
                         "rel": "self",
diff --git a/nova/tests/integrated/integrated_helpers.py b/nova/tests/integrated/integrated_helpers.py
index fb2f88502..343190427 100644
--- a/nova/tests/integrated/integrated_helpers.py
+++ b/nova/tests/integrated/integrated_helpers.py
@@ -22,10 +22,8 @@ Provides common functionality for integrated unit tests
 import random
 import string
 
-from nova import exception
 from nova import service
 from nova import test  # For the flags
-from nova.auth import manager
 import nova.image.glance
 from nova.log import logging
 from nova.tests.integrated.api import client
@@ -58,90 +56,6 @@ def generate_new_element(items, prefix, numeric=False):
         LOG.debug("Random collision on %s" % candidate)
 
 
-class TestUser(object):
-    def __init__(self, name, secret, auth_url):
-        self.name = name
-        self.secret = secret
-        self.auth_url = auth_url
-
-        if not auth_url:
-            raise exception.Error("auth_url is required")
-        self.openstack_api = client.TestOpenStackClient(self.name,
-                                                        self.secret,
-                                                        self.auth_url)
-
-    def get_unused_server_name(self):
-        servers = self.openstack_api.get_servers()
-        server_names = [server['name'] for server in servers]
-        return generate_new_element(server_names, 'server')
-
-    def get_invalid_image(self):
-        images = self.openstack_api.get_images()
-        image_ids = [image['id'] for image in images]
-        return generate_new_element(image_ids, '', numeric=True)
-
-    def get_valid_image(self, create=False):
-        images = self.openstack_api.get_images()
-        if create and not images:
-            # TODO(justinsb): No way currently to create an image through API
-            #created_image = self.openstack_api.post_image(image)
-            #images.append(created_image)
-            raise exception.Error("No way to create an image through API")
-
-        if images:
-            return images[0]
-        return None
-
-
-class IntegratedUnitTestContext(object):
-    def __init__(self, auth_url):
-        self.auth_manager = manager.AuthManager()
-
-        self.auth_url = auth_url
-        self.project_name = None
-
-        self.test_user = None
-
-        self.setup()
-
-    def setup(self):
-        self._create_test_user()
-
-    def _create_test_user(self):
-        self.test_user = self._create_unittest_user()
-
-        # No way to currently pass this through the OpenStack API
-        self.project_name = 'openstack'
-        self._configure_project(self.project_name, self.test_user)
-
-    def cleanup(self):
-        self.test_user = None
-
-    def _create_unittest_user(self):
-        users = self.auth_manager.get_users()
-        user_names = [user.name for user in users]
-        auth_name = generate_new_element(user_names, 'unittest_user_')
-        auth_key = generate_random_alphanumeric(16)
-
-        # Right now there's a bug where auth_name and auth_key are reversed
-        # bug732907
-        auth_key = auth_name
-
-        self.auth_manager.create_user(auth_name, auth_name, auth_key, False)
-        return TestUser(auth_name, auth_key, self.auth_url)
-
-    def _configure_project(self, project_name, user):
-        projects = self.auth_manager.get_projects()
-        project_names = [project.name for project in projects]
-        if not project_name in project_names:
-            project = self.auth_manager.create_project(project_name,
-                                                       user.name,
-                                                       description=None,
-                                                       member_users=None)
-        else:
-            self.auth_manager.add_to_project(user.name, project_name)
-
-
 class _IntegratedTestBase(test.TestCase):
     def setUp(self):
         super(_IntegratedTestBase, self).setUp()
@@ -163,10 +77,7 @@ class _IntegratedTestBase(test.TestCase):
 
         self._start_api_service()
 
-        self.context = IntegratedUnitTestContext(self.auth_url)
-
-        self.user = self.context.test_user
-        self.api = self.user.openstack_api
+        self.api = client.TestOpenStackClient('fake', 'fake', self.auth_url)
 
     def _start_api_service(self):
         osapi = service.WSGIService("osapi")
@@ -174,10 +85,6 @@ class _IntegratedTestBase(test.TestCase):
         self.auth_url = 'http://%s:%s/v1.1' % (osapi.host, osapi.port)
         LOG.warn(self.auth_url)
 
-    def tearDown(self):
-        self.context.cleanup()
-        super(_IntegratedTestBase, self).tearDown()
-
     def _get_flags(self):
         """An opportunity to setup flags, before the services are started."""
         f = {}
@@ -190,10 +97,20 @@ class _IntegratedTestBase(test.TestCase):
         f['fake_network'] = True
         return f
 
+    def get_unused_server_name(self):
+        servers = self.api.get_servers()
+        server_names = [server['name'] for server in servers]
+        return generate_new_element(server_names, 'server')
+
+    def get_invalid_image(self):
+        images = self.api.get_images()
+        image_ids = [image['id'] for image in images]
+        return generate_new_element(image_ids, '', numeric=True)
+
     def _build_minimal_create_server_request(self):
         server = {}
 
-        image = self.user.get_valid_image(create=True)
+        image = self.api.get_images()[0]
         LOG.debug("Image: %s" % image)
 
         if 'imageRef' in image:
@@ -211,7 +128,7 @@ class _IntegratedTestBase(test.TestCase):
         server['flavorRef'] = 'http://fake.server/%s' % flavor['id']
 
         # Set a valid server name
-        server_name = self.user.get_unused_server_name()
+        server_name = self.get_unused_server_name()
         server['name'] = server_name
 
         return server
diff --git a/nova/tests/integrated/test_login.py b/nova/tests/integrated/test_login.py
index 9d1925bc0..3a863d0f9 100644
--- a/nova/tests/integrated/test_login.py
+++ b/nova/tests/integrated/test_login.py
@@ -15,11 +15,9 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import unittest
 
 from nova.log import logging
 from nova.tests.integrated import integrated_helpers
-from nova.tests.integrated.api import client
 
 
 LOG = logging.getLogger('nova.tests.integrated')
@@ -31,40 +29,3 @@ class LoginTest(integrated_helpers._IntegratedTestBase):
         flavors = self.api.get_flavors()
         for flavor in flavors:
             LOG.debug(_("flavor: %s") % flavor)
-
-    def test_bad_login_password(self):
-        """Test that I get a 401 with a bad username."""
-        bad_credentials_api = client.TestOpenStackClient(self.user.name,
-                                                         "notso_password",
-                                                         self.user.auth_url)
-
-        self.assertRaises(client.OpenStackApiAuthenticationException,
-                          bad_credentials_api.get_flavors)
-
-    def test_bad_login_username(self):
-        """Test that I get a 401 with a bad password."""
-        bad_credentials_api = client.TestOpenStackClient("notso_username",
-                                                         self.user.secret,
-                                                         self.user.auth_url)
-
-        self.assertRaises(client.OpenStackApiAuthenticationException,
-                          bad_credentials_api.get_flavors)
-
-    def test_bad_login_both_bad(self):
-        """Test that I get a 401 with both bad username and bad password."""
-        bad_credentials_api = client.TestOpenStackClient("notso_username",
-                                                         "notso_password",
-                                                         self.user.auth_url)
-
-        self.assertRaises(client.OpenStackApiAuthenticationException,
-                          bad_credentials_api.get_flavors)
-
-    def test_good_login_bad_project(self):
-        """Test that I get a 401 with valid user/pass but bad project"""
-        self.api.project_id = 'openstackBAD'
-
-        self.assertRaises(client.OpenStackApiAuthorizationException,
-                          self.api.get_flavors)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/nova/tests/integrated/test_servers.py b/nova/tests/integrated/test_servers.py
index 725f6d529..c2f800689 100644
--- a/nova/tests/integrated/test_servers.py
+++ b/nova/tests/integrated/test_servers.py
@@ -51,7 +51,7 @@ class ServersTest(integrated_helpers._IntegratedTestBase):
                           self.api.post_server, post)
 
         # With an invalid imageRef, this throws 500.
-        server['imageRef'] = self.user.get_invalid_image()
+        server['imageRef'] = self.get_invalid_image()
         # TODO(justinsb): Check whatever the spec says should be thrown here
         self.assertRaises(client.OpenStackApiException,
                           self.api.post_server, post)
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 993a87f23..0523d73b6 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -2,6 +2,7 @@
 
 # Copyright 2010 United States Government as represented by the
 # Administrator of the National Aeronautics and Space Administration.
+# Copyright 2011 Piston Cloud Computing, Inc.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -159,6 +160,20 @@ class ComputeTestCase(test.TestCase):
             db.security_group_destroy(self.context, group['id'])
             db.instance_destroy(self.context, ref[0]['id'])
 
+    def test_create_instance_associates_config_drive(self):
+        """Make sure create associates a config drive."""
+
+        instance_id = self._create_instance(params={'config_drive': True, })
+
+        try:
+            self.compute.run_instance(self.context, instance_id)
+            instances = db.instance_get_all(context.get_admin_context())
+            instance = instances[0]
+
+            self.assertTrue(instance.config_drive)
+        finally:
+            db.instance_destroy(self.context, instance_id)
+
     def test_default_hostname_generator(self):
         cases = [(None, 'server_1'), ('Hello, Server!', 'hello_server'),
                  ('<}\x1fh\x10e\x08l\x02l\x05o\x12!{>', 'hello')]
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index e5c80b6f6..0b8539442 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -15,6 +15,7 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+from nova import context
 from nova import db
 from nova import exception
 from nova import log as logging
@@ -41,6 +42,7 @@ class FakeModel(dict):
 
 
 networks = [{'id': 0,
+             'uuid': "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
              'label': 'test0',
              'injected': False,
              'multi_host': False,
@@ -60,6 +62,7 @@ networks = [{'id': 0,
              'project_id': 'fake_project',
              'vpn_public_address': '192.168.0.2'},
             {'id': 1,
+             'uuid': "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
              'label': 'test1',
              'injected': False,
              'multi_host': False,
@@ -126,6 +129,8 @@ class FlatNetworkTestCase(test.TestCase):
         super(FlatNetworkTestCase, self).setUp()
         self.network = network_manager.FlatManager(host=HOST)
         self.network.db = db
+        self.context = context.RequestContext('testuser', 'testproject',
+                                              is_admin=False)
 
     def test_get_instance_nw_info(self):
         self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance')
@@ -183,12 +188,73 @@ class FlatNetworkTestCase(test.TestCase):
                       'netmask': '255.255.255.0'}]
             self.assertDictListMatch(nw[1]['ips'], check)
 
+    def test_validate_networks(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+        self.mox.StubOutWithMock(db, "fixed_ip_get_by_address")
+
+        requested_networks = [("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+                               "192.168.1.100")]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+
+        fixed_ips[1]['network'] = FakeModel(**networks[1])
+        fixed_ips[1]['instance'] = None
+        db.fixed_ip_get_by_address(mox.IgnoreArg(),
+                                    mox.IgnoreArg()).AndReturn(fixed_ips[1])
+
+        self.mox.ReplayAll()
+        self.network.validate_networks(self.context, requested_networks)
+
+    def test_validate_networks_none_requested_networks(self):
+        self.network.validate_networks(self.context, None)
+
+    def test_validate_networks_empty_requested_networks(self):
+        requested_networks = []
+        self.mox.ReplayAll()
+
+        self.network.validate_networks(self.context, requested_networks)
+
+    def test_validate_networks_invalid_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+        requested_networks = [(1, "192.168.0.100.1")]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+        self.mox.ReplayAll()
+
+        self.assertRaises(exception.FixedIpInvalid,
+                          self.network.validate_networks, None,
+                          requested_networks)
+
+    def test_validate_networks_empty_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+
+        requested_networks = [(1, "")]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+        self.mox.ReplayAll()
+
+        self.assertRaises(exception.FixedIpInvalid,
+                          self.network.validate_networks,
+                          None, requested_networks)
+
+    def test_validate_networks_none_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+
+        requested_networks = [(1, None)]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                    mox.IgnoreArg()).AndReturn(networks)
+        self.mox.ReplayAll()
+
+        self.network.validate_networks(None, requested_networks)
+
 
 class VlanNetworkTestCase(test.TestCase):
     def setUp(self):
         super(VlanNetworkTestCase, self).setUp()
         self.network = network_manager.VlanManager(host=HOST)
         self.network.db = db
+        self.context = context.RequestContext('testuser', 'testproject',
+                                              is_admin=False)
 
     def test_vpn_allocate_fixed_ip(self):
         self.mox.StubOutWithMock(db, 'fixed_ip_associate')
@@ -232,7 +298,7 @@ class VlanNetworkTestCase(test.TestCase):
 
         network = dict(networks[0])
         network['vpn_private_address'] = '192.168.0.2'
-        self.network.allocate_fixed_ip(None, 0, network)
+        self.network.allocate_fixed_ip(self.context, 0, network)
 
     def test_create_networks_too_big(self):
         self.assertRaises(ValueError, self.network.create_networks, None,
@@ -243,6 +309,68 @@ class VlanNetworkTestCase(test.TestCase):
                           num_networks=100, vlan_start=1,
                           cidr='192.168.0.1/24', network_size=100)
 
+    def test_validate_networks(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+        self.mox.StubOutWithMock(db, "fixed_ip_get_by_address")
+
+        requested_networks = [("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+                               "192.168.1.100")]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+
+        fixed_ips[1]['network'] = FakeModel(**networks[1])
+        fixed_ips[1]['instance'] = None
+        db.fixed_ip_get_by_address(mox.IgnoreArg(),
+                                    mox.IgnoreArg()).AndReturn(fixed_ips[1])
+
+        self.mox.ReplayAll()
+        self.network.validate_networks(self.context, requested_networks)
+
+    def test_validate_networks_none_requested_networks(self):
+        self.network.validate_networks(self.context, None)
+
+    def test_validate_networks_empty_requested_networks(self):
+        requested_networks = []
+        self.mox.ReplayAll()
+
+        self.network.validate_networks(self.context, requested_networks)
+
+    def test_validate_networks_invalid_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+        requested_networks = [(1, "192.168.0.100.1")]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+        self.mox.ReplayAll()
+
+        self.assertRaises(exception.FixedIpInvalid,
+                          self.network.validate_networks, self.context,
+                          requested_networks)
+
+    def test_validate_networks_empty_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+
+        requested_networks = [(1, "")]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+        self.mox.ReplayAll()
+
+        self.assertRaises(exception.FixedIpInvalid,
+                          self.network.validate_networks,
+                          self.context, requested_networks)
+
+    def test_validate_networks_none_fixed_ip(self):
+        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
+
+        requested_networks = [(1, None)]
+        db.network_get_all_by_uuids(mox.IgnoreArg(),
+                                mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(networks)
+        self.mox.ReplayAll()
+        self.network.validate_networks(self.context, requested_networks)
+
 
 class CommonNetworkTestCase(test.TestCase):
 
diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
index 9c6563f14..f5ea68a03 100644
--- a/nova/tests/test_nova_manage.py
+++ b/nova/tests/test_nova_manage.py
@@ -28,55 +28,45 @@ sys.dont_write_bytecode = True
 import imp
 nova_manage = imp.load_source('nova_manage.py', NOVA_MANAGE_PATH)
 sys.dont_write_bytecode = False
+import mox
+import stubout
 
-import netaddr
 from nova import context
 from nova import db
-from nova import flags
+from nova import exception
 from nova import test
-
-FLAGS = flags.FLAGS
+from nova.tests.db import fakes as db_fakes
 
 
 class FixedIpCommandsTestCase(test.TestCase):
     def setUp(self):
         super(FixedIpCommandsTestCase, self).setUp()
-        cidr = '10.0.0.0/24'
-        net = netaddr.IPNetwork(cidr)
-        net_info = {'bridge': 'fakebr',
-               'bridge_interface': 'fakeeth',
-               'dns': FLAGS.flat_network_dns,
-               'cidr': cidr,
-               'netmask': str(net.netmask),
-               'gateway': str(net[1]),
-               'broadcast': str(net.broadcast),
-               'dhcp_start': str(net[2])}
-        self.network = db.network_create_safe(context.get_admin_context(),
-                                              net_info)
-        num_ips = len(net)
-        for index in range(num_ips):
-            address = str(net[index])
-            reserved = (index == 1 or index == 2)
-            db.fixed_ip_create(context.get_admin_context(),
-                               {'network_id': self.network['id'],
-                                'address': address,
-                                'reserved': reserved})
+        self.stubs = stubout.StubOutForTesting()
+        db_fakes.stub_out_db_network_api(self.stubs)
         self.commands = nova_manage.FixedIpCommands()
 
     def tearDown(self):
-        db.network_delete_safe(context.get_admin_context(), self.network['id'])
         super(FixedIpCommandsTestCase, self).tearDown()
+        self.stubs.UnsetAll()
 
     def test_reserve(self):
-        self.commands.reserve('10.0.0.100')
+        self.commands.reserve('192.168.0.100')
         address = db.fixed_ip_get_by_address(context.get_admin_context(),
-                                             '10.0.0.100')
+                                             '192.168.0.100')
         self.assertEqual(address['reserved'], True)
 
+    def test_reserve_nonexistent_address(self):
+        self.assertRaises(SystemExit,
+                          self.commands.reserve,
+                          '55.55.55.55')
+
     def test_unreserve(self):
-        db.fixed_ip_update(context.get_admin_context(), '10.0.0.100',
-                           {'reserved': True})
-        self.commands.unreserve('10.0.0.100')
+        self.commands.unreserve('192.168.0.100')
         address = db.fixed_ip_get_by_address(context.get_admin_context(),
-                                             '10.0.0.100')
+                                             '192.168.0.100')
         self.assertEqual(address['reserved'], False)
+
+    def test_unreserve_nonexistent_address(self):
+        self.assertRaises(SystemExit,
+                          self.commands.unreserve,
+                          '55.55.55.55')