merging trunk r863

18 files changed, 1306 insertions, 434 deletions

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 911eeaaad..56143114d 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import copy
 import datetime
 import json
 import random
@@ -154,22 +155,23 @@ def stub_out_glance(stubs, initial_fixtures=None):
                     for f in self.fixtures]
 
         def fake_get_images_detailed(self):
-            return self.fixtures
+            return copy.deepcopy(self.fixtures)
 
         def fake_get_image_meta(self, image_id):
-            for f in self.fixtures:
-                if f['id'] == image_id:
-                    return f
+            image = self._find_image(image_id)
+            if image:
+                return copy.deepcopy(image)
             raise glance_exc.NotFound
 
         def fake_add_image(self, image_meta, data=None):
+            image_meta = copy.deepcopy(image_meta)
             id = ''.join(random.choice(string.letters) for _ in range(20))
             image_meta['id'] = id
             self.fixtures.append(image_meta)
             return image_meta
 
         def fake_update_image(self, image_id, image_meta, data=None):
-            f = self.fake_get_image_meta(image_id)
+            f = self._find_image(image_id)
             if not f:
                 raise glance_exc.NotFound
 
@@ -177,7 +179,7 @@ def stub_out_glance(stubs, initial_fixtures=None):
             return f
 
         def fake_delete_image(self, image_id):
-            f = self.fake_get_image_meta(image_id)
+            f = self._find_image(image_id)
             if not f:
                 raise glance_exc.NotFound
 
@@ -186,6 +188,12 @@ def stub_out_glance(stubs, initial_fixtures=None):
         ##def fake_delete_all(self):
         ##    self.fixtures = []
 
+        def _find_image(self, image_id):
+            for f in self.fixtures:
+                if f['id'] == image_id:
+                    return f
+            return None
+
     GlanceClient = glance_client.Client
     fake = FakeGlanceClient(initial_fixtures)
 
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index a674ccefe..feb32ed9f 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -189,13 +189,13 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
     """Test of the OpenStack API /images application controller"""
 
     # Registered images at start of each test.
-
+    now = datetime.datetime.utcnow()
     IMAGE_FIXTURES = [
         {'id': '23g2ogk23k4hhkk4k42l',
          'imageId': '23g2ogk23k4hhkk4k42l',
          'name': 'public image #1',
-         'created_at': str(datetime.datetime.utcnow()),
-         'updated_at': str(datetime.datetime.utcnow()),
+         'created_at': now.isoformat(),
+         'updated_at': now.isoformat(),
          'deleted_at': None,
          'deleted': False,
          'is_public': True,
@@ -204,8 +204,8 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {'id': 'slkduhfas73kkaskgdas',
          'imageId': 'slkduhfas73kkaskgdas',
          'name': 'public image #2',
-         'created_at': str(datetime.datetime.utcnow()),
-         'updated_at': str(datetime.datetime.utcnow()),
+         'created_at': now.isoformat(),
+         'updated_at': now.isoformat(),
          'deleted_at': None,
          'deleted': False,
          'is_public': True,
@@ -247,20 +247,20 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-        def _is_equivalent_subset(x, y):
-            if set(x) <= set(y):
-                for k, v in x.iteritems():
-                    if x[k] != y[k]:
-                        if x[k] == 'active' and y[k] == 'available':
-                            continue
-                        return False
-                return True
-            return False
-
-        for image in res_dict['images']:
-            for image_fixture in self.IMAGE_FIXTURES:
-                if _is_equivalent_subset(image, image_fixture):
-                    break
-            else:
-                self.assertEquals(1, 2, "image %s not in fixtures!" %
-                                                            str(image))
+        for image in self.IMAGE_FIXTURES:
+            expected = {
+                'id': abs(hash(image['imageId'])),
+                'name': image['name'],
+                'status': 'active',
+            }
+            self.assertTrue(expected in res_dict['images'])
+
+    def test_show_image(self):
+        expected = self.IMAGE_FIXTURES[0]
+        id = abs(hash(expected['id']))
+        expected_time = self.now.strftime('%Y-%m-%dT%H:%M:%SZ')
+        req = webob.Request.blank('/v1.0/images/%s' % id)
+        res = req.get_response(fakes.wsgi_app())
+        actual = json.loads(res.body)['image']
+        self.assertEqual(expected_time, actual['created_at'])
+        self.assertEqual(expected_time, actual['updated_at'])
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 0f1c487ae..3f160df85 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -188,6 +188,7 @@ class ServersTest(test.TestCase):
             },
         ]
 
+        print res_dict['server']
         self.assertEqual(res_dict['server']['links'], expected_links)
 
     def test_get_server_by_id_with_addresses(self):
@@ -365,10 +366,19 @@ class ServersTest(test.TestCase):
 
         imageRef = 'http://localhost/v1.1/images/2'
         flavorRef = 'http://localhost/v1.1/flavors/3'
-        body = dict(server=dict(
-            name='server_test', imageRef=imageRef, flavorRef=flavorRef,
-            metadata={'hello': 'world', 'open': 'stack'},
-            personality={}))
+        body = {
+            'server': {
+                'name': 'server_test',
+                'imageRef': imageRef,
+                'flavorRef': flavorRef,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+            },
+        }
+
         req = webob.Request.blank('/v1.1/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
@@ -622,16 +632,6 @@ class ServersTest(test.TestCase):
         req.body = json.dumps(body)
         res = req.get_response(fakes.wsgi_app())
 
-    def test_server_resize(self):
-        body = dict(server=dict(
-            name='server_test', imageId=2, flavorId=2, metadata={},
-            personality={}))
-        req = webob.Request.blank('/v1.0/servers/1/action')
-        req.method = 'POST'
-        req.content_type = 'application/json'
-        req.body = json.dumps(body)
-        res = req.get_response(fakes.wsgi_app())
-
     def test_delete_server_instance(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'DELETE'
@@ -687,6 +687,18 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_resized_server_has_correct_status(self):
+        req = self.webreq('/1', 'GET', dict(resize=dict(flavorId=3)))
+
+        def fake_migration_get(*args):
+            return {}
+
+        self.stubs.Set(nova.db, 'migration_get_by_instance_and_status',
+                fake_migration_get)
+        res = req.get_response(fakes.wsgi_app())
+        body = json.loads(res.body)
+        self.assertEqual(body['server']['status'], 'resize-confirm')
+
     def test_confirm_resize_server(self):
         req = self.webreq('/1/action', 'POST', dict(confirmResize=None))
 
@@ -1041,7 +1053,7 @@ class TestServerInstanceCreation(test.TestCase):
 
     def _setup_mock_compute_api_for_personality(self):
 
-        class MockComputeAPI(object):
+        class MockComputeAPI(nova.compute.API):
 
             def __init__(self):
                 self.injected_files = None
diff --git a/nova/tests/image/__init__.py b/nova/tests/image/__init__.py
new file mode 100644
index 000000000..b94e2e54e
--- /dev/null
+++ b/nova/tests/image/__init__.py
@@ -0,0 +1,16 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Openstack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
new file mode 100644
index 000000000..f1f8504f3
--- /dev/null
+++ b/nova/tests/image/test_glance.py
@@ -0,0 +1,188 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Openstack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+import datetime
+import unittest
+
+from nova.image import glance
+
+
+class StubGlanceClient(object):
+
+    def __init__(self, images, add_response=None, update_response=None):
+        self.images = images
+        self.add_response = add_response
+        self.update_response = update_response
+
+    def get_image_meta(self, id):
+        return self.images[id]
+
+    def get_images_detailed(self):
+        return self.images.itervalues()
+
+    def get_image(self, id):
+        return self.images[id], []
+
+    def add_image(self, metadata, data):
+        return self.add_response
+
+    def update_image(self, image_id, metadata, data):
+        return self.update_response
+
+
+class NullWriter(object):
+
+    def write(self, *arg, **kwargs):
+        pass
+
+
+class TestGlanceImageServiceDatetimes(unittest.TestCase):
+
+    def setUp(self):
+        self.client = StubGlanceClient(None)
+        self.service = glance.GlanceImageService(self.client)
+
+    def test_show_passes_through_to_client(self):
+        self.client.images = {'xyz': {'foo': 'bar'}}
+        self.assertEqual(self.service.show({}, 'xyz'), {'foo': 'bar'})
+
+    def test_detail_passes_through_to_client(self):
+        self.client.images = {1: {'foo': 'bar'}}
+        self.assertEqual(list(self.service.detail({})), [{'foo': 'bar'}])
+
+    def test_show_makes_create_datetimes(self):
+        create_time = datetime.datetime.utcnow()
+        self.client.images = {'xyz': {
+            'id': "id",
+            'name': "my awesome image",
+            'created_at': create_time.isoformat(),
+        }}
+        actual = self.service.show({}, 'xyz')
+        self.assertEqual(actual['created_at'], create_time)
+
+    def test_show_makes_update_datetimes(self):
+        update_time = datetime.datetime.utcnow()
+        self.client.images = {'abc': {
+            'id': "id",
+            'name': "my okay image",
+            'updated_at': update_time.isoformat(),
+        }}
+        actual = self.service.show({}, 'abc')
+        self.assertEqual(actual['updated_at'], update_time)
+
+    def test_show_makes_delete_datetimes(self):
+        delete_time = datetime.datetime.utcnow()
+        self.client.images = {'123': {
+            'id': "123",
+            'name': "my lame image",
+            'deleted_at': delete_time.isoformat(),
+        }}
+        actual = self.service.show({}, '123')
+        self.assertEqual(actual['deleted_at'], delete_time)
+
+    def test_show_handles_deleted_at_none(self):
+        self.client.images = {'747': {
+            'id': "747",
+            'name': "not deleted",
+            'deleted_at': None,
+        }}
+        actual = self.service.show({}, '747')
+        self.assertEqual(actual['deleted_at'], None)
+
+    def test_detail_handles_timestamps(self):
+        now = datetime.datetime.utcnow()
+        image1 = {
+            'id': 1,
+            'name': 'image 1',
+            'created_at': now.isoformat(),
+            'updated_at': now.isoformat(),
+            'deleted_at': None,
+        }
+        image2 = {
+            'id': 2,
+            'name': 'image 2',
+            'deleted_at': now.isoformat(),
+        }
+        self.client.images = {1: image1, 2: image2}
+        i1, i2 = self.service.detail({})
+        self.assertEqual(i1['created_at'], now)
+        self.assertEqual(i1['updated_at'], now)
+        self.assertEqual(i1['deleted_at'], None)
+        self.assertEqual(i2['deleted_at'], now)
+
+    def test_get_handles_timestamps(self):
+        now = datetime.datetime.utcnow()
+        self.client.images = {'abcd': {
+            'id': 'abcd',
+            'name': 'nifty image',
+            'created_at': now.isoformat(),
+            'updated_at': now.isoformat(),
+            'deleted_at': now.isoformat(),
+        }}
+        actual = self.service.get({}, 'abcd', NullWriter())
+        for attr in ('created_at', 'updated_at', 'deleted_at'):
+            self.assertEqual(actual[attr], now)
+
+    def test_get_handles_deleted_at_none(self):
+        self.client.images = {'abcd': {'deleted_at': None}}
+        actual = self.service.get({}, 'abcd', NullWriter())
+        self.assertEqual(actual['deleted_at'], None)
+
+    def test_create_handles_timestamps(self):
+        now = datetime.datetime.utcnow()
+        self.client.add_response = {
+            'id': 'abcd',
+            'name': 'blah',
+            'created_at': now.isoformat(),
+            'updated_at': now.isoformat(),
+            'deleted_at': now.isoformat(),
+        }
+        actual = self.service.create({}, {})
+        for attr in ('created_at', 'updated_at', 'deleted_at'):
+            self.assertEqual(actual[attr], now)
+
+    def test_create_handles_deleted_at_none(self):
+        self.client.add_response = {
+            'id': 'abcd',
+            'name': 'blah',
+            'deleted_at': None,
+        }
+        actual = self.service.create({}, {})
+        self.assertEqual(actual['deleted_at'], None)
+
+    def test_update_handles_timestamps(self):
+        now = datetime.datetime.utcnow()
+        self.client.update_response = {
+            'id': 'abcd',
+            'name': 'blah',
+            'created_at': now.isoformat(),
+            'updated_at': now.isoformat(),
+            'deleted_at': now.isoformat(),
+        }
+        actual = self.service.update({}, 'dummy_id', {})
+        for attr in ('created_at', 'updated_at', 'deleted_at'):
+            self.assertEqual(actual[attr], now)
+
+    def test_create_handles_deleted_at_none(self):
+        self.client.update_response = {
+            'id': 'abcd',
+            'name': 'blah',
+            'deleted_at': None,
+        }
+        actual = self.service.update({}, 'dummy_id', {})
+        self.assertEqual(actual['deleted_at'], None)
diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index 245eb8c69..fc7c344e7 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -108,9 +108,7 @@ class TestOpenStackClient(object):
         http_status = response.status
         LOG.debug(_("%(auth_uri)s => code %(http_status)s") % locals())
 
-        # Until bug732866 is fixed, we can't check this properly...
-        #if http_status == 401:
-        if http_status != 204:
+        if http_status == 401:
             raise OpenStackApiAuthenticationException(response=response)
 
         auth_headers = {}
diff --git a/nova/tests/integrated/integrated_helpers.py b/nova/tests/integrated/integrated_helpers.py
new file mode 100644
index 000000000..47093636e
--- /dev/null
+++ b/nova/tests/integrated/integrated_helpers.py
@@ -0,0 +1,188 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Justin Santa Barbara
+# 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.
+
+"""
+Provides common functionality for integrated unit tests
+"""
+
+import random
+import string
+
+from nova import exception
+from nova import flags
+from nova import service
+from nova import test  # For the flags
+from nova.auth import manager
+from nova.exception import Error
+from nova.log import logging
+from nova.tests.integrated.api import client
+
+
+FLAGS = flags.FLAGS
+
+LOG = logging.getLogger('nova.tests.integrated')
+
+
+def generate_random_alphanumeric(length):
+    """Creates a random alphanumeric string of specified length"""
+    return ''.join(random.choice(string.ascii_uppercase + string.digits)
+                   for _x in range(length))
+
+
+def generate_random_numeric(length):
+    """Creates a random numeric string of specified length"""
+    return ''.join(random.choice(string.digits)
+                   for _x in range(length))
+
+
+def generate_new_element(items, prefix, numeric=False):
+    """Creates a random string with prefix, that is not in 'items' list"""
+    while True:
+        if numeric:
+            candidate = prefix + generate_random_numeric(8)
+        else:
+            candidate = prefix + generate_random_alphanumeric(8)
+        if not candidate in items:
+            return candidate
+        print "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)
+
+
+class IntegratedUnitTestContext(object):
+    __INSTANCE = None
+
+    def __init__(self):
+        self.auth_manager = manager.AuthManager()
+
+        self.wsgi_server = None
+        self.wsgi_apps = []
+        self.api_service = None
+
+        self.services = []
+        self.auth_url = None
+        self.project_name = None
+
+        self.setup()
+
+    def setup(self):
+        self._start_services()
+
+        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 _start_services(self):
+        # WSGI shutdown broken :-(
+        # bug731668
+        if not self.api_service:
+            self._start_api_service()
+
+    def cleanup(self):
+        for service in self.services:
+            service.kill()
+        self.services = []
+        # TODO(justinsb): Shutdown WSGI & anything else we startup
+        # bug731668
+        # WSGI shutdown broken :-(
+        # self.wsgi_server.terminate()
+        # self.wsgi_server = None
+        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)
+
+    def _start_api_service(self):
+        api_service = service.ApiService.create()
+        api_service.start()
+
+        if not api_service:
+            raise Exception("API Service was None")
+
+        # WSGI shutdown broken :-(
+        #self.services.append(volume_service)
+        self.api_service = api_service
+
+        self.auth_url = 'http://localhost:8774/v1.0'
+
+        return api_service
+
+    # WSGI shutdown broken :-(
+    # bug731668
+    #@staticmethod
+    #def get():
+    #    if not IntegratedUnitTestContext.__INSTANCE:
+    #        IntegratedUnitTestContext.startup()
+    #        #raise Error("Must call IntegratedUnitTestContext::startup")
+    #    return IntegratedUnitTestContext.__INSTANCE
+
+    @staticmethod
+    def startup():
+        # Because WSGI shutdown is broken at the moment, we have to recycle
+        # bug731668
+        if IntegratedUnitTestContext.__INSTANCE:
+            #raise Error("Multiple calls to IntegratedUnitTestContext.startup")
+            IntegratedUnitTestContext.__INSTANCE.setup()
+        else:
+            IntegratedUnitTestContext.__INSTANCE = IntegratedUnitTestContext()
+        return IntegratedUnitTestContext.__INSTANCE
+
+    @staticmethod
+    def shutdown():
+        if not IntegratedUnitTestContext.__INSTANCE:
+            raise Error("Must call IntegratedUnitTestContext::startup")
+        IntegratedUnitTestContext.__INSTANCE.cleanup()
+        # WSGI shutdown broken :-(
+        # bug731668
+        #IntegratedUnitTestContext.__INSTANCE = None
diff --git a/nova/tests/integrated/test_login.py b/nova/tests/integrated/test_login.py
new file mode 100644
index 000000000..501f8c919
--- /dev/null
+++ b/nova/tests/integrated/test_login.py
@@ -0,0 +1,79 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Justin Santa Barbara
+# 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 unittest
+
+from nova import flags
+from nova import test
+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')
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+class LoginTest(test.TestCase):
+    def setUp(self):
+        super(LoginTest, self).setUp()
+        context = integrated_helpers.IntegratedUnitTestContext.startup()
+        self.user = context.test_user
+        self.api = self.user.openstack_api
+
+    def tearDown(self):
+        integrated_helpers.IntegratedUnitTestContext.shutdown()
+        super(LoginTest, self).tearDown()
+
+    def test_login(self):
+        """Simple check - we list flavors - so we know we're logged in"""
+        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)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/nova/tests/network/__init__.py b/nova/tests/network/__init__.py
new file mode 100644
index 000000000..97f96b6fa
--- /dev/null
+++ b/nova/tests/network/__init__.py
@@ -0,0 +1,67 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+Utility methods
+"""
+import os
+
+from nova import context
+from nova import db
+from nova import flags
+from nova import log as logging
+from nova import utils
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+def binpath(script):
+    """Returns the absolute path to a script in bin"""
+    return os.path.abspath(os.path.join(__file__, "../../../../bin", script))
+
+
+def lease_ip(private_ip):
+    """Run add command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
+                                          private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            private_ip)
+    cmd = (binpath('nova-dhcpbridge'), 'add',
+           instance_ref['mac_address'],
+           private_ip, 'fake')
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(*cmd, addl_env=env)
+    LOG.debug("ISSUE_IP: %s, %s ", out, err)
+
+
+def release_ip(private_ip):
+    """Run del command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
+                                          private_ip)
+    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            private_ip)
+    cmd = (binpath('nova-dhcpbridge'), 'del',
+           instance_ref['mac_address'],
+           private_ip, 'fake')
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(*cmd, addl_env=env)
+    LOG.debug("RELEASE_IP: %s, %s ", out, err)
diff --git a/nova/tests/network/base.py b/nova/tests/network/base.py
new file mode 100644
index 000000000..988a1de72
--- /dev/null
+++ b/nova/tests/network/base.py
@@ -0,0 +1,154 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+Base class of Unit Tests for all network models
+"""
+import IPy
+import os
+
+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.auth import manager
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+class NetworkTestCase(test.TestCase):
+    """Test cases for network code"""
+    def setUp(self):
+        super(NetworkTestCase, self).setUp()
+        # NOTE(vish): if you change these flags, make sure to change the
+        #             flags in the corresponding section in nova-dhcpbridge
+        self.flags(connection_type='fake',
+                   fake_call=True,
+                   fake_network=True)
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
+        self.projects = []
+        self.network = utils.import_object(FLAGS.network_manager)
+        self.context = context.RequestContext(project=None, user=self.user)
+        for i in range(FLAGS.num_networks):
+            name = 'project%s' % i
+            project = self.manager.create_project(name, 'netuser', name)
+            self.projects.append(project)
+            # create the necessary network data for the project
+            user_context = context.RequestContext(project=self.projects[i],
+                                                     user=self.user)
+            host = self.network.get_network_host(user_context.elevated())
+        instance_ref = self._create_instance(0)
+        self.instance_id = instance_ref['id']
+        instance_ref = self._create_instance(1)
+        self.instance2_id = instance_ref['id']
+
+    def tearDown(self):
+        # TODO(termie): this should really be instantiating clean datastores
+        #               in between runs, one failure kills all the tests
+        db.instance_destroy(context.get_admin_context(), self.instance_id)
+        db.instance_destroy(context.get_admin_context(), self.instance2_id)
+        for project in self.projects:
+            self.manager.delete_project(project)
+        self.manager.delete_user(self.user)
+        super(NetworkTestCase, self).tearDown()
+
+    def _create_instance(self, project_num, mac=None):
+        if not mac:
+            mac = utils.generate_mac()
+        project = self.projects[project_num]
+        self.context._project = project
+        self.context.project_id = project.id
+        return db.instance_create(self.context,
+                                  {'project_id': project.id,
+                                   'mac_address': mac})
+
+    def _create_address(self, project_num, instance_id=None):
+        """Create an address in given project num"""
+        if instance_id is None:
+            instance_id = self.instance_id
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        return self.network.allocate_fixed_ip(self.context, instance_id)
+
+    def _deallocate_address(self, project_num, address):
+        self.context._project = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
+        self.network.deallocate_fixed_ip(self.context, address)
+
+    def _is_allocated_in_project(self, address, project_id):
+        """Returns true if address is in specified project"""
+        project_net = db.network_get_by_bridge(context.get_admin_context(),
+                                           FLAGS.flat_network_bridge)
+        network = db.fixed_ip_get_network(context.get_admin_context(),
+                                          address)
+        instance = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            address)
+        # instance exists until release
+        return instance is not None and network['id'] == project_net['id']
+
+    def test_private_ipv6(self):
+        """Make sure ipv6 is OK"""
+        if FLAGS.use_ipv6:
+            instance_ref = self._create_instance(0)
+            address = self._create_address(0, instance_ref['id'])
+            network_ref = db.project_get_network(
+                                                 context.get_admin_context(),
+                                                 self.context.project_id)
+            address_v6 = db.instance_get_fixed_address_v6(
+                                                 context.get_admin_context(),
+                                                 instance_ref['id'])
+            self.assertEqual(instance_ref['mac_address'],
+                             utils.to_mac(address_v6))
+            instance_ref2 = db.fixed_ip_get_instance_v6(
+                                                 context.get_admin_context(),
+                                                 address_v6)
+            self.assertEqual(instance_ref['id'], instance_ref2['id'])
+            self.assertEqual(address_v6,
+                             utils.to_global_ipv6(
+                                                 network_ref['cidr_v6'],
+                                                 instance_ref['mac_address']))
+            self._deallocate_address(0, address)
+            db.instance_destroy(context.get_admin_context(),
+                                instance_ref['id'])
+
+    def test_available_ips(self):
+        """Make sure the number of available ips for the network is correct
+
+        The number of available IP addresses depends on the test
+        environment's setup.
+
+        Network size is set in test fixture's setUp method.
+
+        There are ips reserved at the bottom and top of the range.
+        services (network, gateway, CloudPipe, broadcast)
+        """
+        network = db.project_get_network(context.get_admin_context(),
+                                         self.projects[0].id)
+        net_size = flags.FLAGS.network_size
+        admin_context = context.get_admin_context()
+        total_ips = (db.network_count_available_ips(admin_context,
+                                                    network['id']) +
+                     db.network_count_reserved_ips(admin_context,
+                                                   network['id']) +
+                     db.network_count_allocated_ips(admin_context,
+                                                    network['id']))
+        self.assertEqual(total_ips, net_size)
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 3651f4cef..d1ef68de4 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -44,6 +44,14 @@ flags.DECLARE('stub_network', 'nova.compute.manager')
 flags.DECLARE('live_migration_retry_count', 'nova.compute.manager')
 
 
+class FakeTime(object):
+    def __init__(self):
+        self.counter = 0
+
+    def sleep(self, t):
+        self.counter += t
+
+
 class ComputeTestCase(test.TestCase):
     """Test case for compute"""
     def setUp(self):
@@ -82,6 +90,21 @@ class ComputeTestCase(test.TestCase):
         inst.update(params)
         return db.instance_create(self.context, inst)['id']
 
+    def _create_instance_type(self, params={}):
+        """Create a test instance"""
+        context = self.context.elevated()
+        inst = {}
+        inst['name'] = 'm1.small'
+        inst['memory_mb'] = '1024'
+        inst['vcpus'] = '1'
+        inst['local_gb'] = '20'
+        inst['flavorid'] = '1'
+        inst['swap'] = '2048'
+        inst['rxtx_quota'] = 100
+        inst['rxtx_cap'] = 200
+        inst.update(params)
+        return db.instance_type_create(context, inst)['id']
+
     def _create_group(self):
         values = {'name': 'testgroup',
                   'description': 'testgroup',
@@ -299,15 +322,53 @@ class ComputeTestCase(test.TestCase):
         """Ensure instance can be migrated/resized"""
         instance_id = self._create_instance()
         context = self.context.elevated()
+
         self.compute.run_instance(self.context, instance_id)
         db.instance_update(self.context, instance_id, {'host': 'foo'})
-        self.compute.prep_resize(context, instance_id)
+        self.compute.prep_resize(context, instance_id, 1)
         migration_ref = db.migration_get_by_instance_and_status(context,
                 instance_id, 'pre-migrating')
         self.compute.resize_instance(context, instance_id,
                 migration_ref['id'])
         self.compute.terminate_instance(context, instance_id)
 
+    def test_resize_invalid_flavor_fails(self):
+        """Ensure invalid flavors raise"""
+        instance_id = self._create_instance()
+        context = self.context.elevated()
+        self.compute.run_instance(self.context, instance_id)
+
+        self.assertRaises(exception.NotFound, self.compute_api.resize,
+                context, instance_id, 200)
+
+        self.compute.terminate_instance(context, instance_id)
+
+    def test_resize_down_fails(self):
+        """Ensure resizing down raises and fails"""
+        context = self.context.elevated()
+        instance_id = self._create_instance()
+
+        self.compute.run_instance(self.context, instance_id)
+        db.instance_update(self.context, instance_id,
+                {'instance_type': 'm1.xlarge'})
+
+        self.assertRaises(exception.ApiError, self.compute_api.resize,
+                context, instance_id, 1)
+
+        self.compute.terminate_instance(context, instance_id)
+
+    def test_resize_same_size_fails(self):
+        """Ensure invalid flavors raise"""
+        context = self.context.elevated()
+        instance_id = self._create_instance()
+
+        self.compute.run_instance(self.context, instance_id)
+
+        self.assertRaises(exception.ApiError, self.compute_api.resize,
+                context, instance_id, 1)
+
+        self.compute.terminate_instance(context, instance_id)
+
     def test_get_by_flavor_id(self):
         type = instance_types.get_by_flavor_id(1)
         self.assertEqual(type, 'm1.tiny')
@@ -318,10 +379,8 @@ class ComputeTestCase(test.TestCase):
         instance_id = self._create_instance()
         self.compute.run_instance(self.context, instance_id)
         self.assertRaises(exception.Error, self.compute.prep_resize,
-                self.context, instance_id)
+                self.context, instance_id, 1)
         self.compute.terminate_instance(self.context, instance_id)
-        type = instance_types.get_by_flavor_id("1")
-        self.assertEqual(type, 'm1.tiny')
 
     def _setup_other_managers(self):
         self.volume_manager = utils.import_object(FLAGS.volume_manager)
@@ -342,7 +401,7 @@ class ComputeTestCase(test.TestCase):
         self.mox.ReplayAll()
         self.assertRaises(exception.NotFound,
                           self.compute.pre_live_migration,
-                          c, instance_ref['id'])
+                          c, instance_ref['id'], time=FakeTime())
 
     def test_pre_live_migration_instance_has_volume(self):
         """Confirm setup_compute_volume is called when volume is mounted."""
@@ -395,7 +454,7 @@ class ComputeTestCase(test.TestCase):
         self.compute.driver = drivermock
 
         self.mox.ReplayAll()
-        ret = self.compute.pre_live_migration(c, i_ref['id'])
+        ret = self.compute.pre_live_migration(c, i_ref['id'], time=FakeTime())
         self.assertEqual(ret, None)
 
     def test_pre_live_migration_setup_compute_node_fail(self):
@@ -428,7 +487,7 @@ class ComputeTestCase(test.TestCase):
         self.mox.ReplayAll()
         self.assertRaises(exception.ProcessExecutionError,
                           self.compute.pre_live_migration,
-                          c, i_ref['id'])
+                          c, i_ref['id'], time=FakeTime())
 
     def test_live_migration_works_correctly_with_volume(self):
         """Confirm check_for_export to confirm volume health check."""
@@ -575,3 +634,24 @@ class ComputeTestCase(test.TestCase):
         db.instance_destroy(c, instance_id)
         db.volume_destroy(c, v_ref['id'])
         db.floating_ip_destroy(c, flo_addr)
+
+    def test_run_kill_vm(self):
+        """Detect when a vm is terminated behind the scenes"""
+        instance_id = self._create_instance()
+
+        self.compute.run_instance(self.context, instance_id)
+
+        instances = db.instance_get_all(context.get_admin_context())
+        LOG.info(_("Running instances: %s"), instances)
+        self.assertEqual(len(instances), 1)
+
+        instance_name = instances[0].name
+        self.compute.driver.test_remove_vm(instance_name)
+
+        # Force the compute manager to do its periodic poll
+        error_list = self.compute.periodic_tasks(context.get_admin_context())
+        self.assertFalse(error_list)
+
+        instances = db.instance_get_all(context.get_admin_context())
+        LOG.info(_("After force-killing instances: %s"), instances)
+        self.assertEqual(len(instances), 0)
diff --git a/nova/tests/test_flat_network.py b/nova/tests/test_flat_network.py
new file mode 100644
index 000000000..dcc617e25
--- /dev/null
+++ b/nova/tests/test_flat_network.py
@@ -0,0 +1,161 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+Unit Tests for flat network code
+"""
+import IPy
+import os
+import unittest
+
+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.auth import manager
+from nova.tests.network import base
+
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+class FlatNetworkTestCase(base.NetworkTestCase):
+    """Test cases for network code"""
+    def test_public_network_association(self):
+        """Makes sure that we can allocate a public ip"""
+        # TODO(vish): better way of adding floating ips
+
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
+        pubnet = IPy.IP(flags.FLAGS.floating_range)
+        address = str(pubnet[0])
+        try:
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
+        except exception.NotFound:
+            db.floating_ip_create(context.get_admin_context(),
+                                  {'address': address,
+                                   'host': FLAGS.host})
+
+        self.assertRaises(NotImplementedError,
+                          self.network.allocate_floating_ip,
+                          self.context, self.projects[0].id)
+
+        fix_addr = self._create_address(0)
+        float_addr = address
+        self.assertRaises(NotImplementedError,
+                          self.network.associate_floating_ip,
+                          self.context, float_addr, fix_addr)
+
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, None)
+
+        self.assertRaises(NotImplementedError,
+                          self.network.disassociate_floating_ip,
+                          self.context, float_addr)
+
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, None)
+
+        self.assertRaises(NotImplementedError,
+                          self.network.deallocate_floating_ip,
+                          self.context, float_addr)
+
+        self.network.deallocate_fixed_ip(self.context, fix_addr)
+        db.floating_ip_destroy(context.get_admin_context(), float_addr)
+
+    def test_allocate_deallocate_fixed_ip(self):
+        """Makes sure that we can allocate and deallocate a fixed ip"""
+        address = self._create_address(0)
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+        self._deallocate_address(0, address)
+
+        # check if the fixed ip address is really deallocated
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
+
+    def test_side_effects(self):
+        """Ensures allocating and releasing has no side effects"""
+        address = self._create_address(0)
+        address2 = self._create_address(1, self.instance2_id)
+
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[1].id))
+
+        self._deallocate_address(0, address)
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
+
+        # First address release shouldn't affect the second
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[0].id))
+
+        self._deallocate_address(1, address2)
+        self.assertFalse(self._is_allocated_in_project(address2,
+                                                 self.projects[1].id))
+
+    def test_ips_are_reused(self):
+        """Makes sure that ip addresses that are deallocated get reused"""
+        address = self._create_address(0)
+        self.network.deallocate_fixed_ip(self.context, address)
+
+        address2 = self._create_address(0)
+        self.assertEqual(address, address2)
+
+        self.network.deallocate_fixed_ip(self.context, address2)
+
+    def test_too_many_addresses(self):
+        """Test for a NoMoreAddresses exception when all fixed ips are used.
+        """
+        admin_context = context.get_admin_context()
+        network = db.project_get_network(admin_context, self.projects[0].id)
+        num_available_ips = db.network_count_available_ips(admin_context,
+                                                           network['id'])
+        addresses = []
+        instance_ids = []
+        for i in range(num_available_ips):
+            instance_ref = self._create_instance(0)
+            instance_ids.append(instance_ref['id'])
+            address = self._create_address(0, instance_ref['id'])
+            addresses.append(address)
+
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, 0)
+        self.assertRaises(db.NoMoreAddresses,
+                          self.network.allocate_fixed_ip,
+                          self.context,
+                          'foo')
+
+        for i in range(num_available_ips):
+            self.network.deallocate_fixed_ip(self.context, addresses[i])
+            db.instance_destroy(context.get_admin_context(), instance_ids[i])
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, num_available_ips)
+
+    def run(self, result=None):
+        if(FLAGS.network_manager == 'nova.network.manager.FlatManager'):
+            super(FlatNetworkTestCase, self).run(result)
diff --git a/nova/tests/test_localization.py b/nova/tests/test_localization.py
index 393d71038..a25809a79 100644
--- a/nova/tests/test_localization.py
+++ b/nova/tests/test_localization.py
@@ -21,9 +21,10 @@ import sys
 import unittest
 
 import nova
+from nova import test
 
 
-class LocalizationTestCase(unittest.TestCase):
+class LocalizationTestCase(test.TestCase):
     def test_multiple_positional_format_placeholders(self):
         pat = re.compile("\W_\(")
         single_pat = re.compile("\W%\W")
diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index 1fbaf304f..4e17e1ce0 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -18,8 +18,12 @@ import errno
 import os
 import select
 
+from eventlet import greenpool
+from eventlet import greenthread
+
 from nova import test
-from nova.utils import parse_mailmap, str_dict_replace, synchronized
+from nova import utils
+from nova.utils import parse_mailmap, str_dict_replace
 
 
 class ProjectTestCase(test.TestCase):
@@ -63,7 +67,7 @@ class ProjectTestCase(test.TestCase):
 
 class LockTestCase(test.TestCase):
     def test_synchronized_wrapped_function_metadata(self):
-        @synchronized('whatever')
+        @utils.synchronized('whatever')
         def foo():
             """Bar"""
             pass
@@ -72,11 +76,42 @@ class LockTestCase(test.TestCase):
         self.assertEquals(foo.__name__, 'foo', "Wrapped function's name "
                                                "got mangled")
 
-    def test_synchronized(self):
+    def test_synchronized_internally(self):
+        """We can lock across multiple green threads"""
+        saved_sem_num = len(utils._semaphores)
+        seen_threads = list()
+
+        @utils.synchronized('testlock2', external=False)
+        def f(id):
+            for x in range(10):
+                seen_threads.append(id)
+                greenthread.sleep(0)
+
+        threads = []
+        pool = greenpool.GreenPool(10)
+        for i in range(10):
+            threads.append(pool.spawn(f, i))
+
+        for thread in threads:
+            thread.wait()
+
+        self.assertEquals(len(seen_threads), 100)
+        # Looking at the seen threads, split it into chunks of 10, and verify
+        # that the last 9 match the first in each chunk.
+        for i in range(10):
+            for j in range(9):
+                self.assertEquals(seen_threads[i * 10],
+                                  seen_threads[i * 10 + 1 + j])
+
+        self.assertEqual(saved_sem_num, len(utils._semaphores),
+                         "Semaphore leak detected")
+
+    def test_synchronized_externally(self):
+        """We can lock across multiple processes"""
         rpipe1, wpipe1 = os.pipe()
         rpipe2, wpipe2 = os.pipe()
 
-        @synchronized('testlock')
+        @utils.synchronized('testlock1', external=True)
         def f(rpipe, wpipe):
             try:
                 os.write(wpipe, "foo")
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 1e634b388..77f6aaff3 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -20,21 +20,10 @@ Unit Tests for network code
 """
 import IPy
 import os
-import time
 
-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.auth import manager
 from nova.network import linux_net
 
-FLAGS = flags.FLAGS
-LOG = logging.getLogger('nova.tests.network')
-
 
 class IptablesManagerTestCase(test.TestCase):
     sample_filter = ['#Generated by iptables-save on Fri Feb 18 15:17:05 2011',
@@ -175,363 +164,3 @@ class IptablesManagerTestCase(test.TestCase):
             self.assertTrue('-A %s -j run_tests.py-%s' \
                             % (chain, chain) in new_lines,
                             "Built-in chain %s not wrapped" % (chain,))
-
-
-class NetworkTestCase(test.TestCase):
-    """Test cases for network code"""
-    def setUp(self):
-        super(NetworkTestCase, self).setUp()
-        # NOTE(vish): if you change these flags, make sure to change the
-        #             flags in the corresponding section in nova-dhcpbridge
-        self.flags(connection_type='fake',
-                   fake_call=True,
-                   fake_network=True)
-        self.manager = manager.AuthManager()
-        self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
-        self.projects = []
-        self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.RequestContext(project=None, user=self.user)
-        for i in range(FLAGS.num_networks):
-            name = 'project%s' % i
-            project = self.manager.create_project(name, 'netuser', name)
-            self.projects.append(project)
-            # create the necessary network data for the project
-            user_context = context.RequestContext(project=self.projects[i],
-                                                     user=self.user)
-            host = self.network.get_network_host(user_context.elevated())
-        instance_ref = self._create_instance(0)
-        self.instance_id = instance_ref['id']
-        instance_ref = self._create_instance(1)
-        self.instance2_id = instance_ref['id']
-
-    def tearDown(self):
-        # TODO(termie): this should really be instantiating clean datastores
-        #               in between runs, one failure kills all the tests
-        db.instance_destroy(context.get_admin_context(), self.instance_id)
-        db.instance_destroy(context.get_admin_context(), self.instance2_id)
-        for project in self.projects:
-            self.manager.delete_project(project)
-        self.manager.delete_user(self.user)
-        super(NetworkTestCase, self).tearDown()
-
-    def _create_instance(self, project_num, mac=None):
-        if not mac:
-            mac = utils.generate_mac()
-        project = self.projects[project_num]
-        self.context._project = project
-        self.context.project_id = project.id
-        return db.instance_create(self.context,
-                                  {'project_id': project.id,
-                                   'mac_address': mac})
-
-    def _create_address(self, project_num, instance_id=None):
-        """Create an address in given project num"""
-        if instance_id is None:
-            instance_id = self.instance_id
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        return self.network.allocate_fixed_ip(self.context, instance_id)
-
-    def _deallocate_address(self, project_num, address):
-        self.context._project = self.projects[project_num]
-        self.context.project_id = self.projects[project_num].id
-        self.network.deallocate_fixed_ip(self.context, address)
-
-    def test_private_ipv6(self):
-        """Make sure ipv6 is OK"""
-        if FLAGS.use_ipv6:
-            instance_ref = self._create_instance(0)
-            address = self._create_address(0, instance_ref['id'])
-            network_ref = db.project_get_network(
-                                                 context.get_admin_context(),
-                                                 self.context.project_id)
-            address_v6 = db.instance_get_fixed_address_v6(
-                                                 context.get_admin_context(),
-                                                 instance_ref['id'])
-            self.assertEqual(instance_ref['mac_address'],
-                             utils.to_mac(address_v6))
-            instance_ref2 = db.fixed_ip_get_instance_v6(
-                                                 context.get_admin_context(),
-                                                 address_v6)
-            self.assertEqual(instance_ref['id'], instance_ref2['id'])
-            self.assertEqual(address_v6,
-                             utils.to_global_ipv6(
-                                                 network_ref['cidr_v6'],
-                                                 instance_ref['mac_address']))
-            self._deallocate_address(0, address)
-            db.instance_destroy(context.get_admin_context(),
-                                instance_ref['id'])
-
-    def test_public_network_association(self):
-        """Makes sure that we can allocaate a public ip"""
-        # TODO(vish): better way of adding floating ips
-        self.context._project = self.projects[0]
-        self.context.project_id = self.projects[0].id
-        pubnet = IPy.IP(flags.FLAGS.floating_range)
-        address = str(pubnet[0])
-        try:
-            db.floating_ip_get_by_address(context.get_admin_context(), address)
-        except exception.NotFound:
-            db.floating_ip_create(context.get_admin_context(),
-                                  {'address': address,
-                                   'host': FLAGS.host})
-        float_addr = self.network.allocate_floating_ip(self.context,
-                                                       self.projects[0].id)
-        fix_addr = self._create_address(0)
-        lease_ip(fix_addr)
-        self.assertEqual(float_addr, str(pubnet[0]))
-        self.network.associate_floating_ip(self.context, float_addr, fix_addr)
-        address = db.instance_get_floating_address(context.get_admin_context(),
-                                                   self.instance_id)
-        self.assertEqual(address, float_addr)
-        self.network.disassociate_floating_ip(self.context, float_addr)
-        address = db.instance_get_floating_address(context.get_admin_context(),
-                                                   self.instance_id)
-        self.assertEqual(address, None)
-        self.network.deallocate_floating_ip(self.context, float_addr)
-        self.network.deallocate_fixed_ip(self.context, fix_addr)
-        release_ip(fix_addr)
-        db.floating_ip_destroy(context.get_admin_context(), float_addr)
-
-    def test_allocate_deallocate_fixed_ip(self):
-        """Makes sure that we can allocate and deallocate a fixed ip"""
-        address = self._create_address(0)
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-        lease_ip(address)
-        self._deallocate_address(0, address)
-
-        # Doesn't go away until it's dhcp released
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-
-        release_ip(address)
-        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
-
-    def test_side_effects(self):
-        """Ensures allocating and releasing has no side effects"""
-        address = self._create_address(0)
-        address2 = self._create_address(1, self.instance2_id)
-
-        self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
-        self.assertFalse(is_allocated_in_project(address, self.projects[1].id))
-
-        # Addresses are allocated before they're issued
-        lease_ip(address)
-        lease_ip(address2)
-
-        self._deallocate_address(0, address)
-        release_ip(address)
-        self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
-
-        # First address release shouldn't affect the second
-        self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
-
-        self._deallocate_address(1, address2)
-        release_ip(address2)
-        self.assertFalse(is_allocated_in_project(address2,
-                                                 self.projects[1].id))
-
-    def test_subnet_edge(self):
-        """Makes sure that private ips don't overlap"""
-        first = self._create_address(0)
-        lease_ip(first)
-        instance_ids = []
-        for i in range(1, FLAGS.num_networks):
-            instance_ref = self._create_instance(i, mac=utils.generate_mac())
-            instance_ids.append(instance_ref['id'])
-            address = self._create_address(i, instance_ref['id'])
-            instance_ref = self._create_instance(i, mac=utils.generate_mac())
-            instance_ids.append(instance_ref['id'])
-            address2 = self._create_address(i, instance_ref['id'])
-            instance_ref = self._create_instance(i, mac=utils.generate_mac())
-            instance_ids.append(instance_ref['id'])
-            address3 = self._create_address(i, instance_ref['id'])
-            lease_ip(address)
-            lease_ip(address2)
-            lease_ip(address3)
-            self.context._project = self.projects[i]
-            self.context.project_id = self.projects[i].id
-            self.assertFalse(is_allocated_in_project(address,
-                                                     self.projects[0].id))
-            self.assertFalse(is_allocated_in_project(address2,
-                                                     self.projects[0].id))
-            self.assertFalse(is_allocated_in_project(address3,
-                                                     self.projects[0].id))
-            self.network.deallocate_fixed_ip(self.context, address)
-            self.network.deallocate_fixed_ip(self.context, address2)
-            self.network.deallocate_fixed_ip(self.context, address3)
-            release_ip(address)
-            release_ip(address2)
-            release_ip(address3)
-        for instance_id in instance_ids:
-            db.instance_destroy(context.get_admin_context(), instance_id)
-        self.context._project = self.projects[0]
-        self.context.project_id = self.projects[0].id
-        self.network.deallocate_fixed_ip(self.context, first)
-        self._deallocate_address(0, first)
-        release_ip(first)
-
-    def test_vpn_ip_and_port_looks_valid(self):
-        """Ensure the vpn ip and port are reasonable"""
-        self.assert_(self.projects[0].vpn_ip)
-        self.assert_(self.projects[0].vpn_port >= FLAGS.vpn_start)
-        self.assert_(self.projects[0].vpn_port <= FLAGS.vpn_start +
-                                                  FLAGS.num_networks)
-
-    def test_too_many_networks(self):
-        """Ensure error is raised if we run out of networks"""
-        projects = []
-        networks_left = (FLAGS.num_networks -
-                         db.network_count(context.get_admin_context()))
-        for i in range(networks_left):
-            project = self.manager.create_project('many%s' % i, self.user)
-            projects.append(project)
-            db.project_get_network(context.get_admin_context(), project.id)
-        project = self.manager.create_project('last', self.user)
-        projects.append(project)
-        self.assertRaises(db.NoMoreNetworks,
-                          db.project_get_network,
-                          context.get_admin_context(),
-                          project.id)
-        for project in projects:
-            self.manager.delete_project(project)
-
-    def test_ips_are_reused(self):
-        """Makes sure that ip addresses that are deallocated get reused"""
-        address = self._create_address(0)
-        lease_ip(address)
-        self.network.deallocate_fixed_ip(self.context, address)
-        release_ip(address)
-
-        address2 = self._create_address(0)
-        self.assertEqual(address, address2)
-        lease_ip(address)
-        self.network.deallocate_fixed_ip(self.context, address2)
-        release_ip(address)
-
-    def test_available_ips(self):
-        """Make sure the number of available ips for the network is correct
-
-        The number of available IP addresses depends on the test
-        environment's setup.
-
-        Network size is set in test fixture's setUp method.
-
-        There are ips reserved at the bottom and top of the range.
-        services (network, gateway, CloudPipe, broadcast)
-        """
-        network = db.project_get_network(context.get_admin_context(),
-                                         self.projects[0].id)
-        net_size = flags.FLAGS.network_size
-        admin_context = context.get_admin_context()
-        total_ips = (db.network_count_available_ips(admin_context,
-                                                    network['id']) +
-                     db.network_count_reserved_ips(admin_context,
-                                                   network['id']) +
-                     db.network_count_allocated_ips(admin_context,
-                                                    network['id']))
-        self.assertEqual(total_ips, net_size)
-
-    def test_too_many_addresses(self):
-        """Test for a NoMoreAddresses exception when all fixed ips are used.
-        """
-        admin_context = context.get_admin_context()
-        network = db.project_get_network(admin_context, self.projects[0].id)
-        num_available_ips = db.network_count_available_ips(admin_context,
-                                                           network['id'])
-        addresses = []
-        instance_ids = []
-        for i in range(num_available_ips):
-            instance_ref = self._create_instance(0)
-            instance_ids.append(instance_ref['id'])
-            address = self._create_address(0, instance_ref['id'])
-            addresses.append(address)
-            lease_ip(address)
-
-        ip_count = db.network_count_available_ips(context.get_admin_context(),
-                                                  network['id'])
-        self.assertEqual(ip_count, 0)
-        self.assertRaises(db.NoMoreAddresses,
-                          self.network.allocate_fixed_ip,
-                          self.context,
-                          'foo')
-
-        for i in range(num_available_ips):
-            self.network.deallocate_fixed_ip(self.context, addresses[i])
-            release_ip(addresses[i])
-            db.instance_destroy(context.get_admin_context(), instance_ids[i])
-        ip_count = db.network_count_available_ips(context.get_admin_context(),
-                                                  network['id'])
-        self.assertEqual(ip_count, num_available_ips)
-
-    def test_dhcp_lease_output(self):
-        admin_ctxt = context.get_admin_context()
-        address = self._create_address(0, self.instance_id)
-        lease_ip(address)
-        network_ref = db.network_get_by_instance(admin_ctxt, self.instance_id)
-        leases = linux_net.get_dhcp_leases(context.get_admin_context(),
-                                           network_ref['id'])
-        for line in leases.split('\n'):
-            seconds, mac, ip, hostname, client_id = line.split(' ')
-            self.assertTrue(int(seconds) > time.time(), 'Lease expires in '
-                                                        'the past')
-            octets = mac.split(':')
-            self.assertEqual(len(octets), 6, "Wrong number of octets "
-                                             "in %s" % (max,))
-            for octet in octets:
-                self.assertEqual(len(octet), 2, "Oddly sized octet: %s"
-                                                                    % (octet,))
-                # This will throw an exception if the octet is invalid
-                int(octet, 16)
-
-            # And this will raise an exception in case of an invalid IP
-            IPy.IP(ip)
-
-        release_ip(address)
-
-
-def is_allocated_in_project(address, project_id):
-    """Returns true if address is in specified project"""
-    project_net = db.project_get_network(context.get_admin_context(),
-                                         project_id)
-    network = db.fixed_ip_get_network(context.get_admin_context(), address)
-    instance = db.fixed_ip_get_instance(context.get_admin_context(), address)
-    # instance exists until release
-    return instance is not None and network['id'] == project_net['id']
-
-
-def binpath(script):
-    """Returns the absolute path to a script in bin"""
-    return os.path.abspath(os.path.join(__file__, "../../../bin", script))
-
-
-def lease_ip(private_ip):
-    """Run add command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
-                                          private_ip)
-    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            private_ip)
-    cmd = (binpath('nova-dhcpbridge'), 'add',
-           instance_ref['mac_address'],
-           private_ip, 'fake')
-    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
-           'TESTING': '1',
-           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(*cmd, addl_env=env)
-    LOG.debug("ISSUE_IP: %s, %s ", out, err)
-
-
-def release_ip(private_ip):
-    """Run del command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(context.get_admin_context(),
-                                          private_ip)
-    instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
-                                            private_ip)
-    cmd = (binpath('nova-dhcpbridge'), 'del',
-           instance_ref['mac_address'],
-           private_ip, 'fake')
-    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
-           'TESTING': '1',
-           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(*cmd, addl_env=env)
-    LOG.debug("RELEASE_IP: %s, %s ", out, err)
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index b214f5ce7..fb0ba53b1 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -77,13 +77,11 @@ class CacheConcurrencyTestCase(test.TestCase):
         eventlet.sleep(0)
         try:
             self.assertFalse(done2.ready())
-            self.assertTrue('fname' in conn._image_sems)
         finally:
             wait1.send()
         done1.wait()
         eventlet.sleep(0)
         self.assertTrue(done2.ready())
-        self.assertFalse('fname' in conn._image_sems)
 
     def test_different_fname_concurrency(self):
         """Ensures that two different fname caches are concurrent"""
@@ -429,6 +427,15 @@ class LibvirtConnTestCase(test.TestCase):
         def fake_raise(self):
             raise libvirt.libvirtError('ERR')
 
+        class FakeTime(object):
+            def __init__(self):
+                self.counter = 0
+
+            def sleep(self, t):
+                self.counter += t
+
+        fake_timer = FakeTime()
+
         self.create_fake_libvirt_mock(nwfilterLookupByName=fake_raise)
         instance_ref = db.instance_create(self.context, self.test_instance)
 
@@ -438,11 +445,15 @@ class LibvirtConnTestCase(test.TestCase):
             conn = libvirt_conn.LibvirtConnection(False)
             conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
             conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
-            conn.ensure_filtering_rules_for_instance(instance_ref)
+            conn.ensure_filtering_rules_for_instance(instance_ref,
+                                                     time=fake_timer)
         except exception.Error, e:
             c1 = (0 <= e.message.find('Timeout migrating for'))
         self.assertTrue(c1)
 
+        self.assertEqual(29, fake_timer.counter, "Didn't wait the expected "
+                                                 "amount of time")
+
         db.instance_destroy(self.context, instance_ref['id'])
 
     def test_live_migration_raises_exception(self):
diff --git a/nova/tests/test_vlan_network.py b/nova/tests/test_vlan_network.py
new file mode 100644
index 000000000..063b81832
--- /dev/null
+++ b/nova/tests/test_vlan_network.py
@@ -0,0 +1,242 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+Unit Tests for vlan network code
+"""
+import IPy
+import os
+
+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.auth import manager
+from nova.tests.network import base
+from nova.tests.network import binpath,\
+    lease_ip, release_ip
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.network')
+
+
+class VlanNetworkTestCase(base.NetworkTestCase):
+    """Test cases for network code"""
+    def test_public_network_association(self):
+        """Makes sure that we can allocaate a public ip"""
+        # TODO(vish): better way of adding floating ips
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
+        pubnet = IPy.IP(flags.FLAGS.floating_range)
+        address = str(pubnet[0])
+        try:
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
+        except exception.NotFound:
+            db.floating_ip_create(context.get_admin_context(),
+                                  {'address': address,
+                                   'host': FLAGS.host})
+        float_addr = self.network.allocate_floating_ip(self.context,
+                                                       self.projects[0].id)
+        fix_addr = self._create_address(0)
+        lease_ip(fix_addr)
+        self.assertEqual(float_addr, str(pubnet[0]))
+        self.network.associate_floating_ip(self.context, float_addr, fix_addr)
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, float_addr)
+        self.network.disassociate_floating_ip(self.context, float_addr)
+        address = db.instance_get_floating_address(context.get_admin_context(),
+                                                   self.instance_id)
+        self.assertEqual(address, None)
+        self.network.deallocate_floating_ip(self.context, float_addr)
+        self.network.deallocate_fixed_ip(self.context, fix_addr)
+        release_ip(fix_addr)
+        db.floating_ip_destroy(context.get_admin_context(), float_addr)
+
+    def test_allocate_deallocate_fixed_ip(self):
+        """Makes sure that we can allocate and deallocate a fixed ip"""
+        address = self._create_address(0)
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+        lease_ip(address)
+        self._deallocate_address(0, address)
+
+        # Doesn't go away until it's dhcp released
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+
+        release_ip(address)
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
+
+    def test_side_effects(self):
+        """Ensures allocating and releasing has no side effects"""
+        address = self._create_address(0)
+        address2 = self._create_address(1, self.instance2_id)
+
+        self.assertTrue(self._is_allocated_in_project(address,
+                                                      self.projects[0].id))
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[1].id))
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[1].id))
+
+        # Addresses are allocated before they're issued
+        lease_ip(address)
+        lease_ip(address2)
+
+        self._deallocate_address(0, address)
+        release_ip(address)
+        self.assertFalse(self._is_allocated_in_project(address,
+                                                       self.projects[0].id))
+
+        # First address release shouldn't affect the second
+        self.assertTrue(self._is_allocated_in_project(address2,
+                                                      self.projects[1].id))
+
+        self._deallocate_address(1, address2)
+        release_ip(address2)
+        self.assertFalse(self._is_allocated_in_project(address2,
+                                                 self.projects[1].id))
+
+    def test_subnet_edge(self):
+        """Makes sure that private ips don't overlap"""
+        first = self._create_address(0)
+        lease_ip(first)
+        instance_ids = []
+        for i in range(1, FLAGS.num_networks):
+            instance_ref = self._create_instance(i, mac=utils.generate_mac())
+            instance_ids.append(instance_ref['id'])
+            address = self._create_address(i, instance_ref['id'])
+            instance_ref = self._create_instance(i, mac=utils.generate_mac())
+            instance_ids.append(instance_ref['id'])
+            address2 = self._create_address(i, instance_ref['id'])
+            instance_ref = self._create_instance(i, mac=utils.generate_mac())
+            instance_ids.append(instance_ref['id'])
+            address3 = self._create_address(i, instance_ref['id'])
+            lease_ip(address)
+            lease_ip(address2)
+            lease_ip(address3)
+            self.context._project = self.projects[i]
+            self.context.project_id = self.projects[i].id
+            self.assertFalse(self._is_allocated_in_project(address,
+                                                     self.projects[0].id))
+            self.assertFalse(self._is_allocated_in_project(address2,
+                                                     self.projects[0].id))
+            self.assertFalse(self._is_allocated_in_project(address3,
+                                                     self.projects[0].id))
+            self.network.deallocate_fixed_ip(self.context, address)
+            self.network.deallocate_fixed_ip(self.context, address2)
+            self.network.deallocate_fixed_ip(self.context, address3)
+            release_ip(address)
+            release_ip(address2)
+            release_ip(address3)
+        for instance_id in instance_ids:
+            db.instance_destroy(context.get_admin_context(), instance_id)
+        self.context._project = self.projects[0]
+        self.context.project_id = self.projects[0].id
+        self.network.deallocate_fixed_ip(self.context, first)
+        self._deallocate_address(0, first)
+        release_ip(first)
+
+    def test_vpn_ip_and_port_looks_valid(self):
+        """Ensure the vpn ip and port are reasonable"""
+        self.assert_(self.projects[0].vpn_ip)
+        self.assert_(self.projects[0].vpn_port >= FLAGS.vpn_start)
+        self.assert_(self.projects[0].vpn_port <= FLAGS.vpn_start +
+                                                  FLAGS.num_networks)
+
+    def test_too_many_networks(self):
+        """Ensure error is raised if we run out of networks"""
+        projects = []
+        networks_left = (FLAGS.num_networks -
+                         db.network_count(context.get_admin_context()))
+        for i in range(networks_left):
+            project = self.manager.create_project('many%s' % i, self.user)
+            projects.append(project)
+            db.project_get_network(context.get_admin_context(), project.id)
+        project = self.manager.create_project('last', self.user)
+        projects.append(project)
+        self.assertRaises(db.NoMoreNetworks,
+                          db.project_get_network,
+                          context.get_admin_context(),
+                          project.id)
+        for project in projects:
+            self.manager.delete_project(project)
+
+    def test_ips_are_reused(self):
+        """Makes sure that ip addresses that are deallocated get reused"""
+        address = self._create_address(0)
+        lease_ip(address)
+        self.network.deallocate_fixed_ip(self.context, address)
+        release_ip(address)
+
+        address2 = self._create_address(0)
+        self.assertEqual(address, address2)
+        lease_ip(address)
+        self.network.deallocate_fixed_ip(self.context, address2)
+        release_ip(address)
+
+    def test_too_many_addresses(self):
+        """Test for a NoMoreAddresses exception when all fixed ips are used.
+        """
+        admin_context = context.get_admin_context()
+        network = db.project_get_network(admin_context, self.projects[0].id)
+        num_available_ips = db.network_count_available_ips(admin_context,
+                                                           network['id'])
+        addresses = []
+        instance_ids = []
+        for i in range(num_available_ips):
+            instance_ref = self._create_instance(0)
+            instance_ids.append(instance_ref['id'])
+            address = self._create_address(0, instance_ref['id'])
+            addresses.append(address)
+            lease_ip(address)
+
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, 0)
+        self.assertRaises(db.NoMoreAddresses,
+                          self.network.allocate_fixed_ip,
+                          self.context,
+                          'foo')
+
+        for i in range(num_available_ips):
+            self.network.deallocate_fixed_ip(self.context, addresses[i])
+            release_ip(addresses[i])
+            db.instance_destroy(context.get_admin_context(), instance_ids[i])
+        ip_count = db.network_count_available_ips(context.get_admin_context(),
+                                                  network['id'])
+        self.assertEqual(ip_count, num_available_ips)
+
+    def _is_allocated_in_project(self, address, project_id):
+        """Returns true if address is in specified project"""
+        project_net = db.project_get_network(context.get_admin_context(),
+                                             project_id)
+        network = db.fixed_ip_get_network(context.get_admin_context(),
+                                          address)
+        instance = db.fixed_ip_get_instance(context.get_admin_context(),
+                                            address)
+        # instance exists until release
+        return instance is not None and network['id'] == project_net['id']
+
+    def run(self, result=None):
+        if(FLAGS.network_manager == 'nova.network.manager.VlanManager'):
+            super(VlanNetworkTestCase, self).run(result)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 70d46a1fb..7f9706a3d 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -228,6 +228,9 @@ class FakeSessionForMigrationTests(fake.SessionBase):
     def VDI_get_by_uuid(*args):
         return 'hurr'
 
+    def VDI_resize_online(*args):
+        pass
+
     def VM_start(self, _1, ref, _2, _3):
         vm = fake.get_record('VM', ref)
         if vm['power_state'] != 'Halted':
@@ -240,7 +243,7 @@ class FakeSessionForMigrationTests(fake.SessionBase):
 
 def stub_out_migration_methods(stubs):
     def fake_get_snapshot(self, instance):
-        return 'foo', 'bar'
+        return 'vm_ref', dict(image='foo', snap='bar')
 
     @classmethod
     def fake_get_vdi(cls, session, vm_ref):
@@ -249,7 +252,7 @@ def stub_out_migration_methods(stubs):
         vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref)
         return vdi_ref, {'uuid': vdi_rec['uuid'], }
 
-    def fake_shutdown(self, inst, vm, method='clean'):
+    def fake_shutdown(self, inst, vm, hard=True):
         pass
 
     @classmethod