Added docstring to explain usage of reserved keyword argument

9 files changed, 987 insertions, 30 deletions

diff --git a/nova/tests/api/openstack/contrib/test_createserverext.py b/nova/tests/api/openstack/contrib/test_createserverext.py
index 089c8e59d..078b72d67 100644
--- a/nova/tests/api/openstack/contrib/test_createserverext.py
+++ b/nova/tests/api/openstack/contrib/test_createserverext.py
@@ -16,6 +16,7 @@
 #    under the License.
 
 import base64
+import datetime
 import json
 import unittest
 from xml.dom import minidom
@@ -27,15 +28,7 @@ from nova import db
 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
 
 
@@ -52,22 +45,45 @@ DUPLICATE_NETWORKS = [('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '10.0.1.12'),
 
 INVALID_NETWORKS = [('invalid', 'invalid-ip-address')]
 
+INSTANCE = {
+             "id": 1,
+             "display_name": "test_server",
+             "uuid": FAKE_UUID,
+             "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
+             "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
+             "security_groups": [{"id": 1, "name": "test"}]
+        }
+
+
+def return_server_by_id(context, id, session=None):
+    INSTANCE['id'] = id
+    return INSTANCE
+
+
+def return_security_group_non_existing(context, project_id, group_name):
+    raise exception.SecurityGroupNotFoundForProject(project_id=project_id,
+                                                 security_group_id=group_name)
+
+
+def return_security_group_get_by_name(context, project_id, group_name):
+    return {'id': 1, 'name': group_name}
+
+
+def return_security_group_get(context, security_group_id, session):
+    return {'id': security_group_id}
+
+
+def return_instance_add_security_group(context, instance_id,
+                                       security_group_id):
+    pass
+
 
 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):
@@ -96,6 +112,8 @@ class CreateserverextTest(test.TestCase):
 
                 return [{'id': '1234', 'display_name': 'fakeinstance',
                          'uuid': FAKE_UUID,
+                         'user_id': 'fake',
+                         'project_id': 'fake',
                          'created_at': "",
                          'updated_at': ""}]
 
@@ -114,6 +132,18 @@ class CreateserverextTest(test.TestCase):
             '_get_kernel_ramdisk_from_image', make_stub_method((1, 1)))
         return compute_api
 
+    def _create_security_group_request_dict(self, security_groups):
+        server = {}
+        server['name'] = 'new-server-test'
+        server['imageRef'] = 1
+        server['flavorRef'] = 1
+        if security_groups is not None:
+            sg_list = []
+            for name in security_groups:
+                sg_list.append({'name': name})
+            server['security_groups'] = sg_list
+        return {'server': server}
+
     def _create_networks_request_dict(self, networks):
         server = {}
         server['name'] = 'new-server-test'
@@ -348,3 +378,38 @@ class CreateserverextTest(test.TestCase):
                 self._create_instance_with_user_data_json(user_data_contents)
         self.assertEquals(response.status_int, 400)
         self.assertEquals(user_data, None)
+
+    def test_create_instance_with_security_group_json(self):
+        security_groups = ['test', 'test1']
+        self.stubs.Set(nova.db.api, 'security_group_get_by_name',
+                       return_security_group_get_by_name)
+        self.stubs.Set(nova.db.api, 'instance_add_security_group',
+                       return_instance_add_security_group)
+        body_dict = self._create_security_group_request_dict(security_groups)
+        request = self._get_create_request_json(body_dict)
+        response = request.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 202)
+
+    def test_get_server_by_id_verify_security_groups_json(self):
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
+        req = webob.Request.blank('/v1.1/123/os-create-server-ext/1')
+        req.headers['Content-Type'] = 'application/json'
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 200)
+        res_dict = json.loads(response.body)
+        expected_security_group = [{"name": "test"}]
+        self.assertEquals(res_dict['server']['security_groups'],
+                          expected_security_group)
+
+    def test_get_server_by_id_verify_security_groups_xml(self):
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
+        req = webob.Request.blank('/v1.1/123/os-create-server-ext/1')
+        req.headers['Accept'] = 'application/xml'
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 200)
+        dom = minidom.parseString(response.body)
+        server = dom.childNodes[0]
+        sec_groups = server.getElementsByTagName('security_groups')[0]
+        sec_group = sec_groups.getElementsByTagName('security_group')[0]
+        self.assertEqual(INSTANCE['security_groups'][0]['name'],
+                         sec_group.getAttribute("name"))
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 1591ea56c..d063a60c2 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -347,6 +347,8 @@ class ServersTest(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": FAKE_UUID,
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "updated": "2010-11-11T11:00:00Z",
                 "created": "2010-10-10T12:00:00Z",
                 "progress": 0,
@@ -446,6 +448,8 @@ class ServersTest(test.TestCase):
         expected = minidom.parseString("""
         <server id="1"
                 uuid="%(expected_uuid)s"
+                userId="fake"
+                tenantId="fake"
                 xmlns="http://docs.openstack.org/compute/api/v1.1"
                 xmlns:atom="http://www.w3.org/2005/Atom"
                 name="server1"
@@ -515,6 +519,8 @@ class ServersTest(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": FAKE_UUID,
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "updated": "2010-11-11T11:00:00Z",
                 "created": "2010-10-10T12:00:00Z",
                 "progress": 100,
@@ -610,6 +616,8 @@ class ServersTest(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": FAKE_UUID,
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "updated": "2010-11-11T11:00:00Z",
                 "created": "2010-10-10T12:00:00Z",
                 "progress": 100,
@@ -1199,6 +1207,26 @@ class ServersTest(test.TestCase):
         self.assertEqual(len(servers), 1)
         self.assertEqual(servers[0]['id'], 100)
 
+    def test_tenant_id_filter_converts_to_project_id_for_admin(self):
+        def fake_get_all(context, filters=None):
+            self.assertNotEqual(filters, None)
+            self.assertEqual(filters['project_id'], 'faketenant')
+            self.assertFalse(filters.get('tenant_id'))
+            return [stub_instance(100)]
+
+        self.stubs.Set(nova.db.api, 'instance_get_all_by_filters',
+                       fake_get_all)
+        self.flags(allow_admin_api=True)
+
+        req = webob.Request.blank('/v1.1/fake/servers?tenant_id=faketenant')
+        # Use admin context
+        context = nova.context.RequestContext('testuser', 'testproject',
+                is_admin=True)
+        res = req.get_response(fakes.wsgi_app(fake_auth_context=context))
+        res_dict = json.loads(res.body)
+        # Failure in fake_get_all returns non 200 status code
+        self.assertEqual(res.status_int, 200)
+
     def test_get_servers_allows_flavor_v1_1(self):
         def fake_get_all(compute_self, context, search_opts=None):
             self.assertNotEqual(search_opts, None)
@@ -1455,6 +1483,8 @@ class ServersTest(test.TestCase):
                     'access_ip_v4': '1.2.3.4',
                     'access_ip_v6': 'fead::1234',
                     'image_ref': image_ref,
+                    'user_id': 'fake',
+                    'project_id': 'fake',
                     "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,
@@ -3103,7 +3133,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "1",
                 "flavorRef": "1",
-                "networks": []
+                "networks": [],
                 }}
         self.assertEquals(request['body'], expected)
 
@@ -3330,6 +3360,8 @@ class TestServerInstanceCreation(test.TestCase):
                     self.injected_files = None
 
                 return [{'id': '1234', 'display_name': 'fakeinstance',
+                         'user_id': 'fake',
+                         'project_id': 'fake',
                          'uuid': FAKE_UUID}]
 
             def set_admin_password(self, *args, **kwargs):
@@ -3583,10 +3615,14 @@ class TestGetKernelRamdiskFromImage(test.TestCase):
         self.assertRaises(exception.NotFound, self._get_k_r, image_meta)
 
     def test_ami_no_ramdisk(self):
-        """If an ami is missing a ramdisk it should raise NotFound"""
+        """If an ami is missing a ramdisk, return kernel ID and None for
+        ramdisk ID
+        """
         image_meta = {'id': 1, 'status': 'active', 'container_format': 'ami',
                       'properties': {'kernel_id': 1}}
-        self.assertRaises(exception.NotFound, self._get_k_r, image_meta)
+        kernel_id, ramdisk_id = self._get_k_r(image_meta)
+        self.assertEqual(kernel_id, 1)
+        self.assertEqual(ramdisk_id, None)
 
     def test_ami_kernel_ramdisk_present(self):
         """Return IDs if both kernel and ramdisk are present"""
@@ -3621,8 +3657,8 @@ class ServersViewBuilderV11Test(test.TestCase):
             "created_at": created_at,
             "updated_at": updated_at,
             "admin_pass": "",
-            "user_id": "",
-            "project_id": "",
+            "user_id": "fake",
+            "project_id": "fake",
             "image_ref": "5",
             "kernel_id": "",
             "ramdisk_id": "",
@@ -3647,7 +3683,6 @@ class ServersViewBuilderV11Test(test.TestCase):
             "terminated_at": utils.utcnow(),
             "availability_zone": "",
             "display_name": "test_server",
-            "display_description": "",
             "locked": False,
             "metadata": [],
             "accessIPv4": "1.2.3.4",
@@ -3730,6 +3765,8 @@ class ServersViewBuilderV11Test(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": self.instance['uuid'],
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "updated": "2010-11-11T11:00:00Z",
                 "created": "2010-10-10T12:00:00Z",
                 "progress": 0,
@@ -3785,6 +3822,8 @@ class ServersViewBuilderV11Test(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": self.instance['uuid'],
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "updated": "2010-11-11T11:00:00Z",
                 "created": "2010-10-10T12:00:00Z",
                 "progress": 100,
@@ -3841,6 +3880,8 @@ class ServersViewBuilderV11Test(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": self.instance['uuid'],
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "updated": "2010-11-11T11:00:00Z",
                 "created": "2010-10-10T12:00:00Z",
                 "progress": 0,
@@ -3897,6 +3938,8 @@ class ServersViewBuilderV11Test(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": self.instance['uuid'],
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "updated": "2010-11-11T11:00:00Z",
                 "created": "2010-10-10T12:00:00Z",
                 "progress": 0,
@@ -3956,6 +3999,8 @@ class ServersViewBuilderV11Test(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": self.instance['uuid'],
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "updated": "2010-11-11T11:00:00Z",
                 "created": "2010-10-10T12:00:00Z",
                 "progress": 0,
@@ -4024,6 +4069,8 @@ class ServerXMLSerializationTest(test.TestCase):
         fixture = {
             "server": {
                 "id": 1,
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "uuid": FAKE_UUID,
                 'created': self.TIMESTAMP,
                 'updated': self.TIMESTAMP,
@@ -4161,6 +4208,8 @@ class ServerXMLSerializationTest(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": FAKE_UUID,
+                "user_id": "fake",
+                "tenant_id": "fake",
                 'created': self.TIMESTAMP,
                 'updated': self.TIMESTAMP,
                 "progress": 0,
@@ -4361,6 +4410,8 @@ class ServerXMLSerializationTest(test.TestCase):
             {
                 "id": 1,
                 "uuid": FAKE_UUID,
+                "user_id": "fake",
+                "tenant_id": "fake",
                 'created': self.TIMESTAMP,
                 'updated': self.TIMESTAMP,
                 "progress": 0,
@@ -4416,6 +4467,8 @@ class ServerXMLSerializationTest(test.TestCase):
             {
                 "id": 2,
                 "uuid": FAKE_UUID,
+                "user_id": 'fake',
+                "tenant_id": 'fake',
                 'created': self.TIMESTAMP,
                 'updated': self.TIMESTAMP,
                 "progress": 100,
@@ -4535,6 +4588,8 @@ class ServerXMLSerializationTest(test.TestCase):
         fixture = {
             "server": {
                 "id": 1,
+                "user_id": "fake",
+                "tenant_id": "fake",
                 "uuid": FAKE_UUID,
                 'created': self.TIMESTAMP,
                 'updated': self.TIMESTAMP,
@@ -4671,6 +4726,8 @@ class ServerXMLSerializationTest(test.TestCase):
             "server": {
                 "id": 1,
                 "uuid": FAKE_UUID,
+                "user_id": "fake",
+                "tenant_id": "fake",
                 'created': self.TIMESTAMP,
                 'updated': self.TIMESTAMP,
                 "progress": 0,
diff --git a/nova/tests/scheduler/test_abstract_scheduler.py b/nova/tests/scheduler/test_abstract_scheduler.py
index aa97e2344..5549ea453 100644
--- a/nova/tests/scheduler/test_abstract_scheduler.py
+++ b/nova/tests/scheduler/test_abstract_scheduler.py
@@ -26,6 +26,7 @@ from nova import test
 from nova.compute import api as compute_api
 from nova.scheduler import driver
 from nova.scheduler import abstract_scheduler
+from nova.scheduler import base_scheduler
 from nova.scheduler import zone_manager
 
 
@@ -65,6 +66,11 @@ class FakeAbstractScheduler(abstract_scheduler.AbstractScheduler):
     pass
 
 
+class FakeBaseScheduler(base_scheduler.BaseScheduler):
+    # No need to stub anything at the moment
+    pass
+
+
 class FakeZoneManager(zone_manager.ZoneManager):
     def __init__(self):
         self.service_states = {
@@ -365,3 +371,52 @@ class AbstractSchedulerTestCase(test.TestCase):
 
         self.assertEqual(fixture._decrypt_blob(test_data),
                          json.dumps(test_data))
+
+    def test_empty_local_hosts(self):
+        """
+        Create a nested set of FakeZones, try to build multiple instances
+        and ensure that a select call returns the appropriate build plan.
+        """
+        sched = FakeAbstractScheduler()
+        self.stubs.Set(sched, '_call_zone_method', fake_call_zone_method)
+        self.stubs.Set(nova.db, 'zone_get_all', fake_zone_get_all)
+
+        zm = FakeZoneManager()
+        # patch this to have no local hosts
+        zm.service_states = {}
+        sched.set_zone_manager(zm)
+
+        fake_context = {}
+        build_plan = sched.select(fake_context,
+                {'instance_type': {'memory_mb': 512},
+                    'num_instances': 4})
+
+        # 0 from local zones, 12 from remotes
+        self.assertEqual(12, len(build_plan))
+
+
+class BaseSchedulerTestCase(test.TestCase):
+    """Test case for Base Scheduler."""
+
+    def test_weigh_hosts(self):
+        """
+        Try to weigh a short list of hosts and make sure enough
+        entries for a larger number instances are returned.
+        """
+
+        sched = FakeBaseScheduler()
+
+        # Fake out a list of hosts
+        zm = FakeZoneManager()
+        hostlist = [(host, services['compute'])
+                    for host, services in zm.service_states.items()
+                    if 'compute' in services]
+
+        # Call weigh_hosts()
+        num_instances = len(hostlist) * 2 + len(hostlist) / 2
+        instlist = sched.weigh_hosts('compute',
+                                     dict(num_instances=num_instances),
+                                     hostlist)
+
+        # Should be enough entries to cover all instances
+        self.assertEqual(len(instlist), num_instances)
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index a52dd041a..890348192 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -963,9 +963,14 @@ class FakeZone(object):
         self.password = password
 
 
+ZONE_API_URL1 = "http://1.example.com"
+ZONE_API_URL2 = "http://2.example.com"
+
+
 def zone_get_all(context):
     return [
-                FakeZone(1, 'http://example.com', 'bob', 'xxx'),
+                FakeZone(1, ZONE_API_URL1, 'bob', 'xxx'),
+                FakeZone(2, ZONE_API_URL2, 'bob', 'xxx'),
            ]
 
 
@@ -1065,7 +1070,9 @@ class ZoneRedirectTest(test.TestCase):
 
     def test_unmarshal_single_server(self):
         decorator = api.reroute_compute("foo")
-        self.assertEquals(decorator.unmarshall_result([]), {})
+        decorator.item_uuid = 'fake_uuid'
+        self.assertRaises(exception.InstanceNotFound,
+                decorator.unmarshall_result, [])
         self.assertEquals(decorator.unmarshall_result(
                 [FakeResource(dict(a=1, b=2)), ]),
                 dict(server=dict(a=1, b=2)))
@@ -1079,6 +1086,90 @@ class ZoneRedirectTest(test.TestCase):
                 [FakeResource(dict(_a=1, manager=2)), ]),
                 dict(server={}))
 
+    def test_one_zone_down_no_instances(self):
+
+        def _fake_issue_novaclient_command(nova, zone, *args, **kwargs):
+            return None
+
+        class FakeNovaClientWithFailure(object):
+            def __init__(self, username, password, method, api_url):
+                self.api_url = api_url
+
+            def authenticate(self):
+                if self.api_url == ZONE_API_URL2:
+                    raise novaclient_exceptions.BadRequest('foo')
+
+        self.stubs.Set(api, '_issue_novaclient_command',
+                _fake_issue_novaclient_command)
+        self.stubs.Set(api.novaclient, 'Client', FakeNovaClientWithFailure)
+
+        @api.reroute_compute("get")
+        def do_get(self, context, uuid):
+            pass
+
+        self.assertRaises(exception.ZoneRequestError,
+                do_get, None, {}, FAKE_UUID)
+
+    def test_one_zone_down_got_instance(self):
+
+        def _fake_issue_novaclient_command(nova, zone, *args, **kwargs):
+            class FakeServer(object):
+                def __init__(self):
+                    self.id = FAKE_UUID
+                    self.test = '1234'
+            return FakeServer()
+
+        class FakeNovaClientWithFailure(object):
+            def __init__(self, username, password, method, api_url):
+                self.api_url = api_url
+
+            def authenticate(self):
+                if self.api_url == ZONE_API_URL2:
+                    raise novaclient_exceptions.BadRequest('foo')
+
+        self.stubs.Set(api, '_issue_novaclient_command',
+                _fake_issue_novaclient_command)
+        self.stubs.Set(api.novaclient, 'Client', FakeNovaClientWithFailure)
+
+        @api.reroute_compute("get")
+        def do_get(self, context, uuid):
+            pass
+
+        try:
+            do_get(None, {}, FAKE_UUID)
+        except api.RedirectResult, e:
+            results = e.results
+            self.assertIn('server', results)
+            self.assertEqual(results['server']['id'], FAKE_UUID)
+            self.assertEqual(results['server']['test'], '1234')
+        except Exception, e:
+            self.fail(_("RedirectResult should have been raised"))
+        else:
+            self.fail(_("RedirectResult should have been raised"))
+
+    def test_zones_up_no_instances(self):
+
+        def _fake_issue_novaclient_command(nova, zone, *args, **kwargs):
+            return None
+
+        class FakeNovaClientNoFailure(object):
+            def __init__(self, username, password, method, api_url):
+                pass
+
+            def authenticate(self):
+                return
+
+        self.stubs.Set(api, '_issue_novaclient_command',
+                _fake_issue_novaclient_command)
+        self.stubs.Set(api.novaclient, 'Client', FakeNovaClientNoFailure)
+
+        @api.reroute_compute("get")
+        def do_get(self, context, uuid):
+            pass
+
+        self.assertRaises(exception.InstanceNotFound,
+                do_get, None, {}, FAKE_UUID)
+
 
 class FakeServerCollection(object):
     def get(self, instance_id):
@@ -1097,7 +1188,7 @@ class FakeEmptyServerCollection(object):
 
 
 class FakeNovaClient(object):
-    def __init__(self, collection):
+    def __init__(self, collection, *args, **kwargs):
         self.servers = collection
 
 
@@ -1162,8 +1253,9 @@ class CallZoneMethodTest(test.TestCase):
         context = {}
         method = 'do_something'
         results = api.call_zone_method(context, method)
-        expected = [(1, 42)]
-        self.assertEqual(expected, results)
+        self.assertEqual(len(results), 2)
+        self.assertIn((1, 42), results)
+        self.assertIn((2, 42), results)
 
     def test_call_zone_method_not_present(self):
         context = {}
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 766a7da9b..65fdffbd6 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -161,6 +161,19 @@ class ComputeTestCase(test.TestCase):
             db.security_group_destroy(self.context, group['id'])
             db.instance_destroy(self.context, ref[0]['id'])
 
+    def test_create_instance_with_invalid_security_group_raises(self):
+        instance_type = instance_types.get_default_instance_type()
+
+        pre_build_len = len(db.instance_get_all(context.get_admin_context()))
+        self.assertRaises(exception.SecurityGroupNotFoundForProject,
+                          self.compute_api.create,
+                          self.context,
+                          instance_type=instance_type,
+                          image_href=None,
+                          security_group=['this_is_a_fake_sec_group'])
+        self.assertEqual(pre_build_len,
+                         len(db.instance_get_all(context.get_admin_context())))
+
     def test_create_instance_associates_config_drive(self):
         """Make sure create associates a config drive."""
 
diff --git a/nova/tests/test_linux_net.py b/nova/tests/test_linux_net.py
new file mode 100755
index 000000000..99577b88e
--- /dev/null
+++ b/nova/tests/test_linux_net.py
@@ -0,0 +1,347 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright 2011 NTT

+# 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.

+

+from nova import context

+from nova import db

+from nova import exception

+from nova import flags

+from nova import log as logging

+from nova import test

+from nova import utils

+from nova.network import manager as network_manager

+from nova.network import linux_net

+

+import mox

+

+FLAGS = flags.FLAGS

+

+LOG = logging.getLogger('nova.tests.network')

+

+

+HOST = "testhost"

+

+instances = [{'id': 0,

+              'host': 'fake_instance00',

+              'hostname': 'fake_instance00'},

+             {'id': 1,

+              'host': 'fake_instance01',

+              'hostname': 'fake_instance01'}]

+

+

+addresses = [{"address": "10.0.0.1"},

+             {"address": "10.0.0.2"},

+             {"address": "10.0.0.3"},

+             {"address": "10.0.0.4"},

+             {"address": "10.0.0.5"},

+             {"address": "10.0.0.6"}]

+

+

+networks = [{'id': 0,

+             'uuid': "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",

+             'label': 'test0',

+             'injected': False,

+             'multi_host': False,

+             'cidr': '192.168.0.0/24',

+             'cidr_v6': '2001:db8::/64',

+             'gateway_v6': '2001:db8::1',

+             'netmask_v6': '64',

+             'netmask': '255.255.255.0',

+             'bridge': 'fa0',

+             'bridge_interface': 'fake_fa0',

+             'gateway': '192.168.0.1',

+             'broadcast': '192.168.0.255',

+             'dns1': '192.168.0.1',

+             'dns2': '192.168.0.2',

+             'dhcp_server': '0.0.0.0',

+             'dhcp_start': '192.168.100.1',

+             'vlan': None,

+             'host': None,

+             '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,

+             'cidr': '192.168.1.0/24',

+             'cidr_v6': '2001:db9::/64',

+             'gateway_v6': '2001:db9::1',

+             'netmask_v6': '64',

+             'netmask': '255.255.255.0',

+             'bridge': 'fa1',

+             'bridge_interface': 'fake_fa1',

+             'gateway': '192.168.1.1',

+             'broadcast': '192.168.1.255',

+             'dns1': '192.168.0.1',

+             'dns2': '192.168.0.2',

+             'dhcp_server': '0.0.0.0',

+             'dhcp_start': '192.168.100.1',

+             'vlan': None,

+             'host': None,

+             'project_id': 'fake_project',

+             'vpn_public_address': '192.168.1.2'}]

+

+

+fixed_ips = [{'id': 0,

+              'network_id': 0,

+              'address': '192.168.0.100',

+              'instance_id': 0,

+              'allocated': True,

+              'virtual_interface_id': 0,

+              'virtual_interface': addresses[0],

+              'instance': instances[0],

+              'floating_ips': []},

+             {'id': 1,

+              'network_id': 1,

+              'address': '192.168.1.100',

+              'instance_id': 0,

+              'allocated': True,

+              'virtual_interface_id': 1,

+              'virtual_interface': addresses[1],

+              'instance': instances[0],

+              'floating_ips': []},

+             {'id': 2,

+              'network_id': 1,

+              'address': '192.168.0.101',

+              'instance_id': 1,

+              'allocated': True,

+              'virtual_interface_id': 2,

+              'virtual_interface': addresses[2],

+              'instance': instances[1],

+              'floating_ips': []},

+             {'id': 3,

+              'network_id': 0,

+              'address': '192.168.1.101',

+              'instance_id': 1,

+              'allocated': True,

+              'virtual_interface_id': 3,

+              'virtual_interface': addresses[3],

+              'instance': instances[1],

+              'floating_ips': []},

+             {'id': 4,

+              'network_id': 0,

+              'address': '192.168.0.102',

+              'instance_id': 0,

+              'allocated': True,

+              'virtual_interface_id': 4,

+              'virtual_interface': addresses[4],

+              'instance': instances[0],

+              'floating_ips': []},

+             {'id': 5,

+              'network_id': 1,

+              'address': '192.168.1.102',

+              'instance_id': 1,

+              'allocated': True,

+              'virtual_interface_id': 5,

+              'virtual_interface': addresses[5],

+              'instance': instances[1],

+              'floating_ips': []}]

+

+

+vifs = [{'id': 0,

+         'address': 'DE:AD:BE:EF:00:00',

+         'uuid': '00000000-0000-0000-0000-0000000000000000',

+         'network_id': 0,

+         'network': networks[0],

+         'instance_id': 0},

+        {'id': 1,

+         'address': 'DE:AD:BE:EF:00:01',

+         'uuid': '00000000-0000-0000-0000-0000000000000001',

+         'network_id': 1,

+         'network': networks[1],

+         'instance_id': 0},

+        {'id': 2,

+         'address': 'DE:AD:BE:EF:00:02',

+         'uuid': '00000000-0000-0000-0000-0000000000000002',

+         'network_id': 1,

+         'network': networks[1],

+         'instance_id': 1},

+        {'id': 3,

+         'address': 'DE:AD:BE:EF:00:03',

+         'uuid': '00000000-0000-0000-0000-0000000000000003',

+         'network_id': 0,

+         'network': networks[0],

+         'instance_id': 1},

+        {'id': 4,

+         'address': 'DE:AD:BE:EF:00:04',

+         'uuid': '00000000-0000-0000-0000-0000000000000004',

+         'network_id': 0,

+         'network': networks[0],

+         'instance_id': 0},

+        {'id': 5,

+         'address': 'DE:AD:BE:EF:00:05',

+         'uuid': '00000000-0000-0000-0000-0000000000000005',

+         'network_id': 1,

+         'network': networks[1],

+         'instance_id': 1}]

+

+

+class LinuxNetworkTestCase(test.TestCase):

+

+    def setUp(self):

+        super(LinuxNetworkTestCase, self).setUp()

+        network_driver = FLAGS.network_driver

+        self.driver = utils.import_object(network_driver)

+        self.driver.db = db

+

+    def test_update_dhcp_for_nw00(self):

+        self.flags(use_single_default_gateway=True)

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[0],

+                                                        fixed_ips[3]])

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[0],

+                                                        fixed_ips[3]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[0], vifs[1]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[2], vifs[3]])

+        self.mox.ReplayAll()

+

+        self.driver.update_dhcp(None, "eth0", networks[0])

+

+    def test_update_dhcp_for_nw01(self):

+        self.flags(use_single_default_gateway=True)

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[1],

+                                                        fixed_ips[2]])

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[1],

+                                                        fixed_ips[2]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[0], vifs[1]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[2], vifs[3]])

+        self.mox.ReplayAll()

+

+        self.driver.update_dhcp(None, "eth0", networks[0])

+

+    def test_get_dhcp_hosts_for_nw00(self):

+        self.flags(use_single_default_gateway=True)

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[0],

+                                                        fixed_ips[3]])

+        self.mox.ReplayAll()

+

+        expected = \

+        "10.0.0.1,fake_instance00.novalocal,"\

+            "192.168.0.100,net:NW-i00000000-0\n"\

+        "10.0.0.4,fake_instance01.novalocal,"\

+            "192.168.1.101,net:NW-i00000001-0"

+        actual_hosts = self.driver.get_dhcp_hosts(None, networks[1])

+

+        self.assertEquals(actual_hosts, expected)

+

+    def test_get_dhcp_hosts_for_nw01(self):

+        self.flags(use_single_default_gateway=True)

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[1],

+                                                        fixed_ips[2]])

+        self.mox.ReplayAll()

+

+        expected = \

+        "10.0.0.2,fake_instance00.novalocal,"\

+            "192.168.1.100,net:NW-i00000000-1\n"\

+        "10.0.0.3,fake_instance01.novalocal,"\

+            "192.168.0.101,net:NW-i00000001-1"

+        actual_hosts = self.driver.get_dhcp_hosts(None, networks[0])

+

+        self.assertEquals(actual_hosts, expected)

+

+    def test_get_dhcp_opts_for_nw00(self):

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[0],

+                                                        fixed_ips[3],

+                                                        fixed_ips[4]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[0],

+                                                         vifs[1],

+                                                         vifs[4]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[2],

+                                                         vifs[3],

+                                                         vifs[5]])

+        self.mox.ReplayAll()

+

+        expected_opts = 'NW-i00000001-0,3'

+        actual_opts = self.driver.get_dhcp_opts(None, networks[0])

+

+        self.assertEquals(actual_opts, expected_opts)

+

+    def test_get_dhcp_opts_for_nw01(self):

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[1],

+                                                        fixed_ips[2],

+                                                        fixed_ips[5]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[0],

+                                                         vifs[1],

+                                                         vifs[4]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[2],

+                                                         vifs[3],

+                                                         vifs[5]])

+        self.mox.ReplayAll()

+

+        expected_opts = "NW-i00000000-1,3"

+        actual_opts = self.driver.get_dhcp_opts(None, networks[1])

+

+        self.assertEquals(actual_opts, expected_opts)

+

+    def test_dhcp_opts_not_default_gateway_network(self):

+        expected = "NW-i00000000-0,3"

+        actual = self.driver._host_dhcp_opts(fixed_ips[0])

+        self.assertEquals(actual, expected)

+

+    def test_host_dhcp_without_default_gateway_network(self):

+        expected = ("10.0.0.1,fake_instance00.novalocal,192.168.0.100")

+        actual = self.driver._host_dhcp(fixed_ips[0])

+        self.assertEquals(actual, expected)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 2347544de..176bfc295 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -118,9 +118,14 @@ vifs = [{'id': 0,
         {'id': 1,
          'address': 'DE:AD:BE:EF:00:01',
          'uuid': '00000000-0000-0000-0000-0000000000000001',
-         'network_id': 0,
          'network_id': 1,
          'network': FakeModel(**networks[1]),
+         'instance_id': 0},
+        {'id': 2,
+         'address': 'DE:AD:BE:EF:00:02',
+         'uuid': '00000000-0000-0000-0000-0000000000000002',
+         'network_id': 2,
+         'network': None,
          'instance_id': 0}]
 
 
diff --git a/nova/tests/test_quantum.py b/nova/tests/test_quantum.py
new file mode 100644
index 000000000..0feec9b99
--- /dev/null
+++ b/nova/tests/test_quantum.py
@@ -0,0 +1,323 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Nicira, Inc.
+# 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.
+
+from nova import context
+from nova import db
+from nova.db.sqlalchemy import models
+from nova.db.sqlalchemy.session import get_session
+from nova import exception
+from nova import ipv6
+from nova import log as logging
+from nova.network.quantum import manager as quantum_manager
+from nova import test
+from nova import utils
+
+LOG = logging.getLogger('nova.tests.quantum_network')
+
+
+# this class can be used for unit functional/testing on nova,
+# as it does not actually make remote calls to the Quantum service
+class FakeQuantumClientConnection(object):
+
+    def __init__(self):
+        self.nets = {}
+
+    def get_networks_for_tenant(self, tenant_id):
+        net_ids = []
+        for net_id, n in self.nets.items():
+            if n['tenant-id'] == tenant_id:
+                net_ids.append(net_id)
+        return net_ids
+
+    def create_network(self, tenant_id, network_name):
+
+        uuid = str(utils.gen_uuid())
+        self.nets[uuid] = {'net-name': network_name,
+                           'tenant-id': tenant_id,
+                           'ports': {}}
+        return uuid
+
+    def delete_network(self, tenant_id, net_id):
+        if self.nets[net_id]['tenant-id'] == tenant_id:
+            del self.nets[net_id]
+
+    def network_exists(self, tenant_id, net_id):
+        try:
+            return self.nets[net_id]['tenant-id'] == tenant_id
+        except KeyError:
+            return False
+
+    def _confirm_not_attached(self, interface_id):
+        for n in self.nets.values():
+            for p in n['ports'].values():
+                if p['attachment-id'] == interface_id:
+                    raise Exception(_("interface '%s' is already attached" %
+                                          interface_id))
+
+    def create_and_attach_port(self, tenant_id, net_id, interface_id):
+        if not self.network_exists(tenant_id, net_id):
+            raise Exception(
+                _("network %(net_id)s does not exist for tenant %(tenant_id)"
+                    % locals()))
+
+        self._confirm_not_attached(interface_id)
+        uuid = str(utils.gen_uuid())
+        self.nets[net_id]['ports'][uuid] = \
+                {"port-state": "ACTIVE",
+                "attachment-id": interface_id}
+
+    def detach_and_delete_port(self, tenant_id, net_id, port_id):
+        if not self.network_exists(tenant_id, net_id):
+            raise exception.NotFound(
+                    _("network %(net_id)s does not exist "
+                        "for tenant %(tenant_id)s" % locals()))
+        del self.nets[net_id]['ports'][port_id]
+
+    def get_port_by_attachment(self, tenant_id, attachment_id):
+        for net_id, n in self.nets.items():
+            if n['tenant-id'] == tenant_id:
+                for port_id, p in n['ports'].items():
+                    if p['attachment-id'] == attachment_id:
+                        return (net_id, port_id)
+
+        return (None, None)
+
+networks = [{'label': 'project1-net1',
+             'injected': False,
+             'multi_host': False,
+             'cidr': '192.168.0.0/24',
+             'cidr_v6': '2001:1db8::/64',
+             'gateway_v6': '2001:1db8::1',
+             'netmask_v6': '64',
+             'netmask': '255.255.255.0',
+             'bridge': None,
+             'bridge_interface': None,
+             'gateway': '192.168.0.1',
+             'broadcast': '192.168.0.255',
+             'dns1': '192.168.0.1',
+             'dns2': '192.168.0.2',
+             'vlan': None,
+             'host': None,
+             'vpn_public_address': None,
+             'project_id': 'fake_project1',
+             'priority': 1},
+            {'label': 'project2-net1',
+             'injected': False,
+             'multi_host': False,
+             'cidr': '192.168.1.0/24',
+             'cidr_v6': '2001:1db9::/64',
+             'gateway_v6': '2001:1db9::1',
+             'netmask_v6': '64',
+             'netmask': '255.255.255.0',
+             'bridge': None,
+             'bridge_interface': None,
+             'gateway': '192.168.1.1',
+             'broadcast': '192.168.1.255',
+             'dns1': '192.168.0.1',
+             'dns2': '192.168.0.2',
+             'vlan': None,
+             'host': None,
+             'project_id': 'fake_project2',
+             'priority': 1},
+             {'label': "public",
+             'injected': False,
+             'multi_host': False,
+             'cidr': '10.0.0.0/24',
+             'cidr_v6': '2001:1dba::/64',
+             'gateway_v6': '2001:1dba::1',
+             'netmask_v6': '64',
+             'netmask': '255.255.255.0',
+             'bridge': None,
+             'bridge_interface': None,
+             'gateway': '10.0.0.1',
+             'broadcast': '10.0.0.255',
+             'dns1': '10.0.0.1',
+             'dns2': '10.0.0.2',
+             'vlan': None,
+             'host': None,
+             'project_id': None,
+             'priority': 0},
+             {'label': "project2-net2",
+             'injected': False,
+             'multi_host': False,
+             'cidr': '9.0.0.0/24',
+             'cidr_v6': '2001:1dbb::/64',
+             'gateway_v6': '2001:1dbb::1',
+             'netmask_v6': '64',
+             'netmask': '255.255.255.0',
+             'bridge': None,
+             'bridge_interface': None,
+             'gateway': '9.0.0.1',
+             'broadcast': '9.0.0.255',
+             'dns1': '9.0.0.1',
+             'dns2': '9.0.0.2',
+             'vlan': None,
+             'host': None,
+             'project_id': "fake_project2",
+             'priority': 2}]
+
+
+# this is a base class to be used by all other Quantum Test classes
+class QuantumTestCaseBase(object):
+
+    def test_create_and_delete_nets(self):
+        self._create_nets()
+        self._delete_nets()
+
+    def _create_nets(self):
+        for n in networks:
+            ctx = context.RequestContext('user1', n['project_id'])
+            self.net_man.create_networks(ctx,
+                    label=n['label'], cidr=n['cidr'],
+                    multi_host=n['multi_host'],
+                    num_networks=1, network_size=256, cidr_v6=n['cidr_v6'],
+                    gateway_v6=n['gateway_v6'], bridge=None,
+                    bridge_interface=None, dns1=n['dns1'],
+                    dns2=n['dns2'], project_id=n['project_id'],
+                    priority=n['priority'])
+
+    def _delete_nets(self):
+        for n in networks:
+            ctx = context.RequestContext('user1', n['project_id'])
+            self.net_man.delete_network(ctx, n['cidr'])
+
+    def test_allocate_and_deallocate_instance_static(self):
+        self._create_nets()
+
+        project_id = "fake_project1"
+        ctx = context.RequestContext('user1', project_id)
+
+        instance_ref = db.api.instance_create(ctx,
+                                    {"project_id": project_id})
+        nw_info = self.net_man.allocate_for_instance(ctx,
+                        instance_id=instance_ref['id'], host="",
+                        instance_type_id=instance_ref['instance_type_id'],
+                        project_id=project_id)
+
+        self.assertEquals(len(nw_info), 2)
+
+        # we don't know which order the NICs will be in until we
+        # introduce the notion of priority
+        # v4 cidr
+        self.assertTrue(nw_info[0][0]['cidr'].startswith("10."))
+        self.assertTrue(nw_info[1][0]['cidr'].startswith("192."))
+
+        # v4 address
+        self.assertTrue(nw_info[0][1]['ips'][0]['ip'].startswith("10."))
+        self.assertTrue(nw_info[1][1]['ips'][0]['ip'].startswith("192."))
+
+        # v6 cidr
+        self.assertTrue(nw_info[0][0]['cidr_v6'].startswith("2001:1dba:"))
+        self.assertTrue(nw_info[1][0]['cidr_v6'].startswith("2001:1db8:"))
+
+        # v6 address
+        self.assertTrue(
+            nw_info[0][1]['ip6s'][0]['ip'].startswith("2001:1dba:"))
+        self.assertTrue(
+            nw_info[1][1]['ip6s'][0]['ip'].startswith("2001:1db8:"))
+
+        self.net_man.deallocate_for_instance(ctx,
+                    instance_id=instance_ref['id'],
+                    project_id=project_id)
+
+        self._delete_nets()
+
+    def test_allocate_and_deallocate_instance_dynamic(self):
+        self._create_nets()
+        project_id = "fake_project2"
+        ctx = context.RequestContext('user1', project_id)
+
+        net_ids = self.net_man.q_conn.get_networks_for_tenant(project_id)
+        requested_networks = [(net_id, None) for net_id in net_ids]
+
+        self.net_man.validate_networks(ctx, requested_networks)
+
+        instance_ref = db.api.instance_create(ctx,
+                                    {"project_id": project_id})
+        nw_info = self.net_man.allocate_for_instance(ctx,
+                        instance_id=instance_ref['id'], host="",
+                        instance_type_id=instance_ref['instance_type_id'],
+                        project_id=project_id,
+                        requested_networks=requested_networks)
+
+        self.assertEquals(len(nw_info), 2)
+
+        # we don't know which order the NICs will be in until we
+        # introduce the notion of priority
+        # v4 cidr
+        self.assertTrue(nw_info[0][0]['cidr'].startswith("9.") or
+                        nw_info[1][0]['cidr'].startswith("9."))
+        self.assertTrue(nw_info[0][0]['cidr'].startswith("192.") or
+                        nw_info[1][0]['cidr'].startswith("192."))
+
+        # v4 address
+        self.assertTrue(nw_info[0][1]['ips'][0]['ip'].startswith("9.") or
+                        nw_info[1][1]['ips'][0]['ip'].startswith("9."))
+        self.assertTrue(nw_info[0][1]['ips'][0]['ip'].startswith("192.") or
+                        nw_info[1][1]['ips'][0]['ip'].startswith("192."))
+
+        # v6 cidr
+        self.assertTrue(nw_info[0][0]['cidr_v6'].startswith("2001:1dbb:") or
+                        nw_info[1][0]['cidr_v6'].startswith("2001:1dbb:"))
+        self.assertTrue(nw_info[0][0]['cidr_v6'].startswith("2001:1db9:") or
+                        nw_info[1][0]['cidr_v6'].startswith("2001:1db9:"))
+
+        # v6 address
+        self.assertTrue(
+            nw_info[0][1]['ip6s'][0]['ip'].startswith("2001:1dbb:") or
+            nw_info[1][1]['ip6s'][0]['ip'].startswith("2001:1dbb:"))
+        self.assertTrue(
+            nw_info[0][1]['ip6s'][0]['ip'].startswith("2001:1db9:") or
+            nw_info[1][1]['ip6s'][0]['ip'].startswith("2001:1db9:"))
+
+        self.net_man.deallocate_for_instance(ctx,
+                    instance_id=instance_ref['id'],
+                    project_id=project_id)
+
+        self._delete_nets()
+
+    def test_validate_bad_network(self):
+        ctx = context.RequestContext('user1', 'fake_project1')
+        self.assertRaises(exception.NetworkNotFound,
+                        self.net_man.validate_networks, ctx, [("", None)])
+
+
+class QuantumNovaIPAMTestCase(QuantumTestCaseBase, test.TestCase):
+
+    def setUp(self):
+        super(QuantumNovaIPAMTestCase, self).setUp()
+
+        self.net_man = quantum_manager.QuantumManager(
+                ipam_lib="nova.network.quantum.nova_ipam_lib",
+                q_conn=FakeQuantumClientConnection())
+
+        # Tests seem to create some networks by default, which
+        # we don't want.  So we delete them.
+
+        ctx = context.RequestContext('user1', 'fake_project1').elevated()
+        for n in db.network_get_all(ctx):
+            db.network_delete_safe(ctx, n['id'])
+
+        # Other unit tests (e.g., test_compute.py) have a nasty
+        # habit of of creating fixed IPs and not cleaning up, which
+        # can confuse these tests, so we remove all existing fixed
+        # ips before starting.
+        session = get_session()
+        result = session.query(models.FixedIp).all()
+        with session.begin():
+            for fip_ref in result:
+                session.delete(fip_ref)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 45dad3516..91b4161b0 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -494,6 +494,7 @@ class XenAPIVMTestCase(test.TestCase):
         self.check_vm_params_for_linux_with_external_kernel()
 
     def test_spawn_netinject_file(self):
+        self.flags(flat_injected=True)
         db_fakes.stub_out_db_instance_api(self.stubs, injected=True)
 
         self._tee_executed = False
@@ -611,7 +612,6 @@ class XenAPIVMTestCase(test.TestCase):
                               str(3 * 1024))
 
     def test_rescue(self):
-        self.flags(flat_injected=False)
         instance = self._create_instance()
         conn = xenapi_conn.get_connection(False)
         conn.rescue(self.context, instance, None, [])