Merge sync branch.

29 files changed, 467 insertions, 165 deletions

diff --git a/nova/tests/__init__.py b/nova/tests/__init__.py
index 592d5bea9..7fba02a93 100644
--- a/nova/tests/__init__.py
+++ b/nova/tests/__init__.py
@@ -37,5 +37,30 @@ setattr(__builtin__, '_', lambda x: x)
 
 
 def setup():
+    import os
+    import shutil
+
+    from nova import context
+    from nova import flags
     from nova.db import migration
+    from nova.network import manager as network_manager
+    from nova.tests import fake_flags
+
+    FLAGS = flags.FLAGS
+
+    testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db)
+    if os.path.exists(testdb):
+        os.unlink(testdb)
     migration.db_sync()
+    ctxt = context.get_admin_context()
+    network_manager.VlanManager().create_networks(ctxt,
+                                                  FLAGS.fixed_range,
+                                                  FLAGS.num_networks,
+                                                  FLAGS.network_size,
+                                                  FLAGS.fixed_range_v6,
+                                                  FLAGS.vlan_start,
+                                                  FLAGS.vpn_start,
+                                                  )
+
+    cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db)
+    shutil.copyfile(testdb, cleandb)
diff --git a/nova/tests/api/openstack/__init__.py b/nova/tests/api/openstack/__init__.py
index 77b1dd37f..e18120285 100644
--- a/nova/tests/api/openstack/__init__.py
+++ b/nova/tests/api/openstack/__init__.py
@@ -16,7 +16,7 @@
 #    under the License.
 
 import webob.dec
-import unittest
+from nova import test
 
 from nova import context
 from nova import flags
@@ -33,7 +33,7 @@ def simple_wsgi(req):
     return ""
 
 
-class RateLimitingMiddlewareTest(unittest.TestCase):
+class RateLimitingMiddlewareTest(test.TestCase):
 
     def test_get_action_name(self):
         middleware = RateLimitingMiddleware(simple_wsgi)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index e0b7b8029..49ce8c1b5 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -188,7 +188,11 @@ def stub_out_glance(stubs, initial_fixtures=None):
 
 
 class FakeToken(object):
+    id = 0
+
     def __init__(self, **kwargs):
+        FakeToken.id += 1
+        self.id = FakeToken.id
         for k, v in kwargs.iteritems():
             setattr(self, k, v)
 
@@ -203,26 +207,28 @@ class FakeAuthDatabase(object):
     data = {}
 
     @staticmethod
-    def auth_get_token(context, token_hash):
+    def auth_token_get(context, token_hash):
         return FakeAuthDatabase.data.get(token_hash, None)
 
     @staticmethod
-    def auth_create_token(context, token):
+    def auth_token_create(context, token):
         fake_token = FakeToken(created_at=datetime.datetime.now(), **token)
         FakeAuthDatabase.data[fake_token.token_hash] = fake_token
+        FakeAuthDatabase.data['id_%i' % fake_token.id] = fake_token
         return fake_token
 
     @staticmethod
-    def auth_destroy_token(context, token):
-        if token.token_hash in FakeAuthDatabase.data:
-            del FakeAuthDatabase.data['token_hash']
+    def auth_token_destroy(context, token_id):
+        token = FakeAuthDatabase.data.get('id_%i' % token_id)
+        if token and token.token_hash in FakeAuthDatabase.data:
+            del FakeAuthDatabase.data[token.token_hash]
+            del FakeAuthDatabase.data['id_%i' % token_id]
 
 
 class FakeAuthManager(object):
     auth_data = {}
 
-    def add_user(self, user):
-        key = user.id
+    def add_user(self, key, user):
         FakeAuthManager.auth_data[key] = user
 
     def get_user(self, uid):
@@ -235,10 +241,7 @@ class FakeAuthManager(object):
         return None
 
     def get_user_from_access_key(self, key):
-        for k, v in FakeAuthManager.auth_data.iteritems():
-            if v.access == key:
-                return v
-        return None
+        return FakeAuthManager.auth_data.get(key, None)
 
 
 class FakeRateLimiter(object):
diff --git a/nova/tests/api/openstack/test_adminapi.py b/nova/tests/api/openstack/test_adminapi.py
index 73120c31d..dfce1b127 100644
--- a/nova/tests/api/openstack/test_adminapi.py
+++ b/nova/tests/api/openstack/test_adminapi.py
@@ -15,13 +15,13 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import unittest
 
 import stubout
 import webob
 from paste import urlmap
 
 from nova import flags
+from nova import test
 from nova.api import openstack
 from nova.api.openstack import ratelimiting
 from nova.api.openstack import auth
@@ -30,9 +30,10 @@ from nova.tests.api.openstack import fakes
 FLAGS = flags.FLAGS
 
 
-class AdminAPITest(unittest.TestCase):
+class AdminAPITest(test.TestCase):
 
     def setUp(self):
+        super(AdminAPITest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         fakes.FakeAuthManager.auth_data = {}
         fakes.FakeAuthDatabase.data = {}
@@ -44,6 +45,7 @@ class AdminAPITest(unittest.TestCase):
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
+        super(AdminAPITest, self).tearDown()
 
     def test_admin_enabled(self):
         FLAGS.allow_admin_api = True
@@ -58,8 +60,5 @@ class AdminAPITest(unittest.TestCase):
         # We should still be able to access public operations.
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
         # TODO: Confirm admin operations are unavailable.
-
-if __name__ == '__main__':
-    unittest.main()
+        self.assertEqual(res.status_int, 200)
diff --git a/nova/tests/api/openstack/test_api.py b/nova/tests/api/openstack/test_api.py
index db0fe1060..5112c486f 100644
--- a/nova/tests/api/openstack/test_api.py
+++ b/nova/tests/api/openstack/test_api.py
@@ -15,17 +15,17 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import unittest
 import webob.exc
 import webob.dec
 
 from webob import Request
 
+from nova import test
 from nova.api import openstack
 from nova.api.openstack import faults
 
 
-class APITest(unittest.TestCase):
+class APITest(test.TestCase):
 
     def _wsgi_app(self, inner_app):
         # simpler version of the app than fakes.wsgi_app
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index eab78b50c..ff8d42a14 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -16,7 +16,6 @@
 #    under the License.
 
 import datetime
-import unittest
 
 import stubout
 import webob
@@ -27,12 +26,15 @@ import nova.api.openstack.auth
 import nova.auth.manager
 from nova import auth
 from nova import context
+from nova import db
+from nova import test
 from nova.tests.api.openstack import fakes
 
 
-class Test(unittest.TestCase):
+class Test(test.TestCase):
 
     def setUp(self):
+        super(Test, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         self.stubs.Set(nova.api.openstack.auth.AuthMiddleware,
             '__init__', fakes.fake_auth_init)
@@ -45,10 +47,11 @@ class Test(unittest.TestCase):
     def tearDown(self):
         self.stubs.UnsetAll()
         fakes.fake_data_store = {}
+        super(Test, self).tearDown()
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        f.add_user(nova.auth.manager.User(1, 'herp', 'herp', 'derp', None))
+        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'herp'
@@ -62,7 +65,7 @@ class Test(unittest.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        f.add_user(nova.auth.manager.User(1, 'herp', 'herp', 'derp', None))
+        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
 
         req = webob.Request.blank('/v1.0/', {'HTTP_HOST': 'foo'})
         req.headers['X-Auth-User'] = 'herp'
@@ -97,10 +100,10 @@ class Test(unittest.TestCase):
                     token_hash=token_hash,
                     created_at=datetime.datetime(1990, 1, 1))
 
-        self.stubs.Set(fakes.FakeAuthDatabase, 'auth_destroy_token',
+        self.stubs.Set(fakes.FakeAuthDatabase, 'auth_token_destroy',
             destroy_token_mock)
 
-        self.stubs.Set(fakes.FakeAuthDatabase, 'auth_get_token',
+        self.stubs.Set(fakes.FakeAuthDatabase, 'auth_token_get',
             bad_token)
 
         req = webob.Request.blank('/v1.0/')
@@ -128,8 +131,36 @@ class Test(unittest.TestCase):
         self.assertEqual(result.status, '401 Unauthorized')
 
 
-class TestLimiter(unittest.TestCase):
+class TestFunctional(test.TestCase):
+    def test_token_expiry(self):
+        ctx = context.get_admin_context()
+        tok = db.auth_token_create(ctx, dict(
+                token_hash='bacon',
+                cdn_management_url='',
+                server_management_url='',
+                storage_url='',
+                user_id='ham',
+                ))
+
+        db.auth_token_update(ctx, tok.token_hash, dict(
+                created_at=datetime.datetime(2000, 1, 1, 12, 0, 0),
+                ))
+
+        req = webob.Request.blank('/v1.0/')
+        req.headers['X-Auth-Token'] = 'bacon'
+        result = req.get_response(fakes.wsgi_app())
+        self.assertEqual(result.status, '401 Unauthorized')
+
+    def test_token_doesnotexist(self):
+        req = webob.Request.blank('/v1.0/')
+        req.headers['X-Auth-Token'] = 'ham'
+        result = req.get_response(fakes.wsgi_app())
+        self.assertEqual(result.status, '401 Unauthorized')
+
+
+class TestLimiter(test.TestCase):
     def setUp(self):
+        super(TestLimiter, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         self.stubs.Set(nova.api.openstack.auth.AuthMiddleware,
             '__init__', fakes.fake_auth_init)
@@ -141,10 +172,11 @@ class TestLimiter(unittest.TestCase):
     def tearDown(self):
         self.stubs.UnsetAll()
         fakes.fake_data_store = {}
+        super(TestLimiter, self).tearDown()
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        f.add_user(nova.auth.manager.User(1, 'herp', 'herp', 'derp', None))
+        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'herp'
@@ -161,7 +193,3 @@ class TestLimiter(unittest.TestCase):
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '200 OK')
         self.assertEqual(result.headers['X-Test-Success'], 'True')
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/nova/tests/api/openstack/test_common.py b/nova/tests/api/openstack/test_common.py
index 9d9837cc9..59d850157 100644
--- a/nova/tests/api/openstack/test_common.py
+++ b/nova/tests/api/openstack/test_common.py
@@ -19,14 +19,14 @@
 Test suites for 'common' code used throughout the OpenStack HTTP API.
 """
 
-import unittest
 
 from webob import Request
 
+from nova import test
 from nova.api.openstack.common import limited
 
 
-class LimiterTest(unittest.TestCase):
+class LimiterTest(test.TestCase):
     """
     Unit tests for the `nova.api.openstack.common.limited` method which takes
     in a list of items and, depending on the 'offset' and 'limit' GET params,
@@ -37,6 +37,7 @@ class LimiterTest(unittest.TestCase):
         """
         Run before each test.
         """
+        super(LimiterTest, self).setUp()
         self.tiny = range(1)
         self.small = range(10)
         self.medium = range(1000)
diff --git a/nova/tests/api/openstack/test_faults.py b/nova/tests/api/openstack/test_faults.py
index fda2b5ede..7667753f4 100644
--- a/nova/tests/api/openstack/test_faults.py
+++ b/nova/tests/api/openstack/test_faults.py
@@ -15,15 +15,15 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import unittest
 import webob
 import webob.dec
 import webob.exc
 
+from nova import test
 from nova.api.openstack import faults
 
 
-class TestFaults(unittest.TestCase):
+class TestFaults(test.TestCase):
 
     def test_fault_parts(self):
         req = webob.Request.blank('/.xml')
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 1bdaea161..761265965 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -15,18 +15,18 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import unittest
-
 import stubout
 import webob
 
+from nova import test
 import nova.api
 from nova.api.openstack import flavors
 from nova.tests.api.openstack import fakes
 
 
-class FlavorsTest(unittest.TestCase):
+class FlavorsTest(test.TestCase):
     def setUp(self):
+        super(FlavorsTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         fakes.FakeAuthManager.auth_data = {}
         fakes.FakeAuthDatabase.data = {}
@@ -36,6 +36,7 @@ class FlavorsTest(unittest.TestCase):
 
     def tearDown(self):
         self.stubs.UnsetAll()
+        super(FlavorsTest, self).tearDown()
 
     def test_get_flavor_list(self):
         req = webob.Request.blank('/v1.0/flavors')
@@ -43,6 +44,3 @@ class FlavorsTest(unittest.TestCase):
 
     def test_get_flavor_by_id(self):
         pass
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 8ab4d7569..e232bc3d5 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -22,7 +22,6 @@ and as a WSGI layer
 
 import json
 import datetime
-import unittest
 
 import stubout
 import webob
@@ -30,6 +29,7 @@ import webob
 from nova import context
 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 images
@@ -130,12 +130,13 @@ class BaseImageServiceTests(object):
         self.assertEquals(1, num_images)
 
 
-class LocalImageServiceTest(unittest.TestCase,
+class LocalImageServiceTest(test.TestCase,
                             BaseImageServiceTests):
 
     """Tests the local image service"""
 
     def setUp(self):
+        super(LocalImageServiceTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         service_class = 'nova.image.local.LocalImageService'
         self.service = utils.import_object(service_class)
@@ -145,14 +146,16 @@ class LocalImageServiceTest(unittest.TestCase,
         self.service.delete_all()
         self.service.delete_imagedir()
         self.stubs.UnsetAll()
+        super(LocalImageServiceTest, self).tearDown()
 
 
-class GlanceImageServiceTest(unittest.TestCase,
+class GlanceImageServiceTest(test.TestCase,
                              BaseImageServiceTests):
 
     """Tests the local image service"""
 
     def setUp(self):
+        super(GlanceImageServiceTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         fakes.stub_out_glance(self.stubs)
         fakes.stub_out_compute_api_snapshot(self.stubs)
@@ -163,9 +166,10 @@ class GlanceImageServiceTest(unittest.TestCase,
 
     def tearDown(self):
         self.stubs.UnsetAll()
+        super(GlanceImageServiceTest, self).tearDown()
 
 
-class ImageControllerWithGlanceServiceTest(unittest.TestCase):
+class ImageControllerWithGlanceServiceTest(test.TestCase):
 
     """Test of the OpenStack API /images application controller"""
 
@@ -194,6 +198,7 @@ class ImageControllerWithGlanceServiceTest(unittest.TestCase):
          'image_type': 'ramdisk'}]
 
     def setUp(self):
+        super(ImageControllerWithGlanceServiceTest, self).setUp()
         self.orig_image_service = FLAGS.image_service
         FLAGS.image_service = 'nova.image.glance.GlanceImageService'
         self.stubs = stubout.StubOutForTesting()
@@ -208,6 +213,7 @@ class ImageControllerWithGlanceServiceTest(unittest.TestCase):
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.image_service = self.orig_image_service
+        super(ImageControllerWithGlanceServiceTest, self).tearDown()
 
     def test_get_image_index(self):
         req = webob.Request.blank('/v1.0/images')
diff --git a/nova/tests/api/openstack/test_ratelimiting.py b/nova/tests/api/openstack/test_ratelimiting.py
index 4c9d6bc23..9ae90ee20 100644
--- a/nova/tests/api/openstack/test_ratelimiting.py
+++ b/nova/tests/api/openstack/test_ratelimiting.py
@@ -1,15 +1,16 @@
 import httplib
 import StringIO
 import time
-import unittest
 import webob
 
+from nova import test
 import nova.api.openstack.ratelimiting as ratelimiting
 
 
-class LimiterTest(unittest.TestCase):
+class LimiterTest(test.TestCase):
 
     def setUp(self):
+        super(LimiterTest, self).setUp()
         self.limits = {
                 'a': (5, ratelimiting.PER_SECOND),
                 'b': (5, ratelimiting.PER_MINUTE),
@@ -83,9 +84,10 @@ class FakeLimiter(object):
         return self._delay
 
 
-class WSGIAppTest(unittest.TestCase):
+class WSGIAppTest(test.TestCase):
 
     def setUp(self):
+        super(WSGIAppTest, self).setUp()
         self.limiter = FakeLimiter(self)
         self.app = ratelimiting.WSGIApp(self.limiter)
 
@@ -206,7 +208,7 @@ def wire_HTTPConnection_to_WSGI(host, app):
     httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
 
 
-class WSGIAppProxyTest(unittest.TestCase):
+class WSGIAppProxyTest(test.TestCase):
 
     def setUp(self):
         """Our WSGIAppProxy is going to call across an HTTPConnection to a
@@ -218,6 +220,7 @@ class WSGIAppProxyTest(unittest.TestCase):
         at the WSGIApp.  And the limiter isn't real -- it's a fake that
         behaves the way we tell it to.
         """
+        super(WSGIAppProxyTest, self).setUp()
         self.limiter = FakeLimiter(self)
         app = ratelimiting.WSGIApp(self.limiter)
         wire_HTTPConnection_to_WSGI('100.100.100.100:80', app)
@@ -238,7 +241,3 @@ class WSGIAppProxyTest(unittest.TestCase):
             self.limiter.mock('murder', 'brutus', None)
             self.proxy.perform('stab', 'brutus')
         self.assertRaises(AssertionError, shouldRaise)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index a7be0796e..7a25abe9d 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -17,17 +17,18 @@
 
 import datetime
 import json
-import unittest
 
 import stubout
 import webob
 
 from nova import db
 from nova import flags
+from nova import test
 import nova.api.openstack
 from nova.api.openstack import servers
 import nova.db.api
 from nova.db.sqlalchemy.models import Instance
+from nova.db.sqlalchemy.models import InstanceMetadata
 import nova.rpc
 from nova.tests.api.openstack import fakes
 
@@ -64,6 +65,9 @@ def instance_address(context, instance_id):
 
 
 def stub_instance(id, user_id=1, private_address=None, public_addresses=None):
+    metadata = []
+    metadata.append(InstanceMetadata(key='seq', value=id))
+
     if public_addresses == None:
         public_addresses = list()
 
@@ -84,7 +88,7 @@ def stub_instance(id, user_id=1, private_address=None, public_addresses=None):
         "vcpus": 0,
         "local_gb": 0,
         "hostname": "",
-        "host": "",
+        "host": None,
         "instance_type": "",
         "user_data": "",
         "reservation_id": "",
@@ -95,7 +99,8 @@ def stub_instance(id, user_id=1, private_address=None, public_addresses=None):
         "availability_zone": "",
         "display_name": "server%s" % id,
         "display_description": "",
-        "locked": False}
+        "locked": False,
+        "metadata": metadata}
 
     instance["fixed_ip"] = {
         "address": private_address,
@@ -108,9 +113,10 @@ def fake_compute_api(cls, req, id):
     return True
 
 
-class ServersTest(unittest.TestCase):
+class ServersTest(test.TestCase):
 
     def setUp(self):
+        super(ServersTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         fakes.FakeAuthManager.auth_data = {}
         fakes.FakeAuthDatabase.data = {}
@@ -141,6 +147,7 @@ class ServersTest(unittest.TestCase):
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
+        super(ServersTest, self).tearDown()
 
     def test_get_server_by_id(self):
         req = webob.Request.blank('/v1.0/servers/1')
@@ -214,7 +221,8 @@ class ServersTest(unittest.TestCase):
             "get_image_id_from_image_hash", image_id_from_hash)
 
         body = dict(server=dict(
-            name='server_test', imageId=2, flavorId=2, metadata={},
+            name='server_test', imageId=2, flavorId=2,
+            metadata={'hello': 'world', 'open': 'stack'},
             personality={}))
         req = webob.Request.blank('/v1.0/servers')
         req.method = 'POST'
@@ -291,6 +299,7 @@ class ServersTest(unittest.TestCase):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['name'], 'server%d' % i)
             self.assertEqual(s['imageId'], 10)
+            self.assertEqual(s['metadata']['seq'], i)
             i += 1
 
     def test_server_pause(self):
@@ -353,6 +362,18 @@ class ServersTest(unittest.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 202)
 
+    def test_server_inject_network_info(self):
+        FLAGS.allow_admin_api = True
+        body = dict(server=dict(
+            name='server_test', imageId=2, flavorId=2, metadata={},
+            personality={}))
+        req = webob.Request.blank('/v1.0/servers/1/inject_network_info')
+        req.method = 'POST'
+        req.content_type = 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+
     def test_server_diagnostics(self):
         req = webob.Request.blank("/v1.0/servers/1/diagnostics")
         req.method = "GET"
@@ -410,7 +431,3 @@ class ServersTest(unittest.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status, '202 Accepted')
         self.assertEqual(self.server_delete_called, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/nova/tests/api/openstack/test_shared_ip_groups.py b/nova/tests/api/openstack/test_shared_ip_groups.py
index c2fc3a203..b4de2ef41 100644
--- a/nova/tests/api/openstack/test_shared_ip_groups.py
+++ b/nova/tests/api/openstack/test_shared_ip_groups.py
@@ -15,19 +15,20 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import unittest
-
 import stubout
 
+from nova import test
 from nova.api.openstack import shared_ip_groups
 
 
-class SharedIpGroupsTest(unittest.TestCase):
+class SharedIpGroupsTest(test.TestCase):
     def setUp(self):
+        super(SharedIpGroupsTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
 
     def tearDown(self):
         self.stubs.UnsetAll()
+        super(SharedIpGroupsTest, self).tearDown()
 
     def test_get_shared_ip_groups(self):
         pass
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index df497ef1b..555b206b9 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -13,7 +13,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import unittest
 
 import stubout
 import webob
@@ -22,6 +21,7 @@ import json
 import nova.db
 from nova import context
 from nova import flags
+from nova import test
 from nova.api.openstack import zones
 from nova.tests.api.openstack import fakes
 
@@ -60,8 +60,9 @@ def zone_get_all(context):
                  password='qwerty')]
 
 
-class ZonesTest(unittest.TestCase):
+class ZonesTest(test.TestCase):
     def setUp(self):
+        super(ZonesTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         fakes.FakeAuthManager.auth_data = {}
         fakes.FakeAuthDatabase.data = {}
@@ -81,6 +82,7 @@ class ZonesTest(unittest.TestCase):
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
+        super(ZonesTest, self).tearDown()
 
     def test_get_zone_list(self):
         req = webob.Request.blank('/v1.0/zones')
@@ -134,7 +136,3 @@ class ZonesTest(unittest.TestCase):
         self.assertEqual(res_dict['zone']['id'], 1)
         self.assertEqual(res_dict['zone']['api_url'], 'http://foo.com')
         self.assertFalse('username' in res_dict['zone'])
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/nova/tests/api/test_wsgi.py b/nova/tests/api/test_wsgi.py
index 44e2d615c..2c7852214 100644
--- a/nova/tests/api/test_wsgi.py
+++ b/nova/tests/api/test_wsgi.py
@@ -21,7 +21,7 @@
 Test WSGI basics and provide some helper functions for other WSGI tests.
 """
 
-import unittest
+from nova import test
 
 import routes
 import webob
@@ -29,7 +29,7 @@ import webob
 from nova import wsgi
 
 
-class Test(unittest.TestCase):
+class Test(test.TestCase):
 
     def test_debug(self):
 
@@ -92,7 +92,7 @@ class Test(unittest.TestCase):
         self.assertNotEqual(result.body, "123")
 
 
-class SerializerTest(unittest.TestCase):
+class SerializerTest(test.TestCase):
 
     def match(self, url, accept, expect):
         input_dict = dict(servers=dict(a=(2, 3)))
diff --git a/nova/tests/fake_flags.py b/nova/tests/fake_flags.py
index cfa65c137..cbd949477 100644
--- a/nova/tests/fake_flags.py
+++ b/nova/tests/fake_flags.py
@@ -29,8 +29,8 @@ FLAGS.auth_driver = 'nova.auth.dbdriver.DbDriver'
 flags.DECLARE('network_size', 'nova.network.manager')
 flags.DECLARE('num_networks', 'nova.network.manager')
 flags.DECLARE('fake_network', 'nova.network.manager')
-FLAGS.network_size = 16
-FLAGS.num_networks = 5
+FLAGS.network_size = 8
+FLAGS.num_networks = 2
 FLAGS.fake_network = True
 flags.DECLARE('num_shelves', 'nova.volume.driver')
 flags.DECLARE('blades_per_shelf', 'nova.volume.driver')
@@ -39,6 +39,5 @@ FLAGS.num_shelves = 2
 FLAGS.blades_per_shelf = 4
 FLAGS.iscsi_num_targets = 8
 FLAGS.verbose = True
-FLAGS.sql_connection = 'sqlite:///nova.sqlite'
+FLAGS.sqlite_db = "tests.sqlite"
 FLAGS.use_ipv6 = True
-FLAGS.logfile = 'tests.log'
diff --git a/nova/tests/objectstore_unittest.py b/nova/tests/objectstore_unittest.py
index da86e6e11..5a1be08eb 100644
--- a/nova/tests/objectstore_unittest.py
+++ b/nova/tests/objectstore_unittest.py
@@ -311,4 +311,5 @@ class S3APITestCase(test.TestCase):
         self.auth_manager.delete_user('admin')
         self.auth_manager.delete_project('admin')
         stop_listening = defer.maybeDeferred(self.listening_port.stopListening)
+        super(S3APITestCase, self).tearDown()
         return defer.DeferredList([stop_listening])
diff --git a/nova/tests/test_api.py b/nova/tests/test_api.py
index fa27825cd..d5c54a1c3 100644
--- a/nova/tests/test_api.py
+++ b/nova/tests/test_api.py
@@ -20,6 +20,7 @@
 
 import boto
 from boto.ec2 import regioninfo
+import datetime
 import httplib
 import random
 import StringIO
@@ -127,6 +128,28 @@ class ApiEc2TestCase(test.TestCase):
         self.ec2.new_http_connection(host, is_secure).AndReturn(self.http)
         return self.http
 
+    def test_return_valid_isoformat(self):
+        """
+            Ensure that the ec2 api returns datetime in xs:dateTime
+            (which apparently isn't datetime.isoformat())
+            NOTE(ken-pepple): https://bugs.launchpad.net/nova/+bug/721297
+        """
+        conv = apirequest._database_to_isoformat
+        # sqlite database representation with microseconds
+        time_to_convert = datetime.datetime.strptime(
+                            "2011-02-21 20:14:10.634276",
+                            "%Y-%m-%d %H:%M:%S.%f")
+        self.assertEqual(
+                        conv(time_to_convert),
+                        '2011-02-21T20:14:10Z')
+        # mysqlite database representation
+        time_to_convert = datetime.datetime.strptime(
+                            "2011-02-21 19:56:18",
+                            "%Y-%m-%d %H:%M:%S")
+        self.assertEqual(
+                        conv(time_to_convert),
+                        '2011-02-21T19:56:18Z')
+
     def test_xmlns_version_matches_request_version(self):
         self.expect_http(api_version='2010-10-30')
         self.mox.ReplayAll()
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 1824d24bc..061910013 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -66,6 +66,7 @@ class CloudTestCase(test.TestCase):
 
         # set up services
         self.compute = self.start_service('compute')
+        self.scheduter = self.start_service('scheduler')
         self.network = self.start_service('network')
 
         self.manager = manager.AuthManager()
@@ -73,8 +74,12 @@ class CloudTestCase(test.TestCase):
         self.project = self.manager.create_project('proj', 'admin', 'proj')
         self.context = context.RequestContext(user=self.user,
                                               project=self.project)
+        host = self.network.get_network_host(self.context.elevated())
 
     def tearDown(self):
+        network_ref = db.project_get_network(self.context,
+                                             self.project.id)
+        db.network_disassociate(self.context, network_ref['id'])
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
         self.compute.kill()
@@ -131,6 +136,22 @@ class CloudTestCase(test.TestCase):
         db.instance_destroy(self.context, inst['id'])
         db.floating_ip_destroy(self.context, address)
 
+    def test_describe_security_groups(self):
+        """Makes sure describe_security_groups works and filters results."""
+        sec = db.security_group_create(self.context,
+                                       {'project_id': self.context.project_id,
+                                        'name': 'test'})
+        result = self.cloud.describe_security_groups(self.context)
+        # NOTE(vish): should have the default group as well
+        self.assertEqual(len(result['securityGroupInfo']), 2)
+        result = self.cloud.describe_security_groups(self.context,
+                      group_name=[sec['name']])
+        self.assertEqual(len(result['securityGroupInfo']), 1)
+        self.assertEqual(
+                result['securityGroupInfo'][0]['groupName'],
+                sec['name'])
+        db.security_group_destroy(self.context, sec['id'])
+
     def test_describe_volumes(self):
         """Makes sure describe_volumes works and filters results."""
         vol1 = db.volume_create(self.context, {})
@@ -201,27 +222,32 @@ class CloudTestCase(test.TestCase):
                   'instance_type': instance_type,
                   'max_count': max_count}
         rv = self.cloud.run_instances(self.context, **kwargs)
+        greenthread.sleep(0.3)
         instance_id = rv['instancesSet'][0]['instanceId']
         output = self.cloud.get_console_output(context=self.context,
-                                                     instance_id=[instance_id])
+                                               instance_id=[instance_id])
         self.assertEquals(b64decode(output['output']), 'FAKE CONSOLE OUTPUT')
         # TODO(soren): We need this until we can stop polling in the rpc code
         #              for unit tests.
         greenthread.sleep(0.3)
         rv = self.cloud.terminate_instances(self.context, [instance_id])
+        greenthread.sleep(0.3)
 
     def test_ajax_console(self):
+        image_id = FLAGS.default_image
         kwargs = {'image_id': image_id}
-        rv = yield self.cloud.run_instances(self.context, **kwargs)
+        rv = self.cloud.run_instances(self.context, **kwargs)
         instance_id = rv['instancesSet'][0]['instanceId']
-        output = yield self.cloud.get_console_output(context=self.context,
-                                                     instance_id=[instance_id])
-        self.assertEquals(b64decode(output['output']),
-                          'http://fakeajaxconsole.com/?token=FAKETOKEN')
+        greenthread.sleep(0.3)
+        output = self.cloud.get_ajax_console(context=self.context,
+                                             instance_id=[instance_id])
+        self.assertEquals(output['url'],
+                          '%s/?token=FAKETOKEN' % FLAGS.ajax_console_proxy_url)
         # TODO(soren): We need this until we can stop polling in the rpc code
         #              for unit tests.
         greenthread.sleep(0.3)
-        rv = yield self.cloud.terminate_instances(self.context, [instance_id])
+        rv = self.cloud.terminate_instances(self.context, [instance_id])
+        greenthread.sleep(0.3)
 
     def test_key_generation(self):
         result = self._create_key('test')
@@ -284,70 +310,6 @@ class CloudTestCase(test.TestCase):
                 LOG.debug(_("Terminating instance %s"), instance_id)
                 rv = self.compute.terminate_instance(instance_id)
 
-    def test_describe_instances(self):
-        """Makes sure describe_instances works."""
-        instance1 = db.instance_create(self.context, {'host': 'host2'})
-        comp1 = db.service_create(self.context, {'host': 'host2',
-                                                 'availability_zone': 'zone1',
-                                                 'topic': "compute"})
-        result = self.cloud.describe_instances(self.context)
-        self.assertEqual(result['reservationSet'][0]
-                         ['instancesSet'][0]
-                         ['placement']['availabilityZone'], 'zone1')
-        db.instance_destroy(self.context, instance1['id'])
-        db.service_destroy(self.context, comp1['id'])
-
-    def test_instance_update_state(self):
-        # TODO(termie): what is this code even testing?
-        def instance(num):
-            return {
-                'reservation_id': 'r-1',
-                'instance_id': 'i-%s' % num,
-                'image_id': 'ami-%s' % num,
-                'private_dns_name': '10.0.0.%s' % num,
-                'dns_name': '10.0.0%s' % num,
-                'ami_launch_index': str(num),
-                'instance_type': 'fake',
-                'availability_zone': 'fake',
-                'key_name': None,
-                'kernel_id': 'fake',
-                'ramdisk_id': 'fake',
-                'groups': ['default'],
-                'product_codes': None,
-                'state': 0x01,
-                'user_data': ''}
-        rv = self.cloud._format_describe_instances(self.context)
-        logging.error(str(rv))
-        self.assertEqual(len(rv['reservationSet']), 0)
-
-        # simulate launch of 5 instances
-        # self.cloud.instances['pending'] = {}
-        #for i in xrange(5):
-        #    inst = instance(i)
-        #    self.cloud.instances['pending'][inst['instance_id']] = inst
-
-        #rv = self.cloud._format_instances(self.admin)
-        #self.assert_(len(rv['reservationSet']) == 1)
-        #self.assert_(len(rv['reservationSet'][0]['instances_set']) == 5)
-        # report 4 nodes each having 1 of the instances
-        #for i in xrange(4):
-        #    self.cloud.update_state('instances',
-        #                            {('node-%s' % i): {('i-%s' % i):
-        #                                               instance(i)}})
-
-        # one instance should be pending still
-        #self.assert_(len(self.cloud.instances['pending'].keys()) == 1)
-
-        # check that the reservations collapse
-        #rv = self.cloud._format_instances(self.admin)
-        #self.assert_(len(rv['reservationSet']) == 1)
-        #self.assert_(len(rv['reservationSet'][0]['instances_set']) == 5)
-
-        # check that we can get metadata for each instance
-        #for i in xrange(4):
-        #    data = self.cloud.get_metadata(instance(i)['private_dns_name'])
-        #    self.assert_(data['meta-data']['ami-id'] == 'ami-%s' % i)
-
     @staticmethod
     def _fake_set_image_description(ctxt, image_id, description):
         from nova.objectstore import handler
diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index 7656f5396..b6bfab534 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -52,6 +52,7 @@ class DirectTestCase(test.TestCase):
 
     def tearDown(self):
         direct.ROUTES = {}
+        super(DirectTestCase, self).tearDown()
 
     def test_delegated_auth(self):
         req = webob.Request.blank('/fake/context')
diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index e6da6112a..154b6fae6 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -14,10 +14,14 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from datetime import datetime
+import errno
 import os
+import select
+import time
 
 from nova import test
-from nova.utils import parse_mailmap, str_dict_replace
+from nova.utils import parse_mailmap, str_dict_replace, synchronized
 
 
 class ProjectTestCase(test.TestCase):
@@ -55,3 +59,34 @@ class ProjectTestCase(test.TestCase):
                                 '%r not listed in Authors' % missing)
             finally:
                 tree.unlock()
+
+
+class LockTestCase(test.TestCase):
+    def test_synchronized(self):
+        rpipe, wpipe = os.pipe()
+        pid = os.fork()
+        if pid > 0:
+            os.close(wpipe)
+
+            @synchronized('testlock')
+            def f():
+                rfds, _, __ = select.select([rpipe], [], [], 1)
+                self.assertEquals(len(rfds), 0, "The other process, which was"
+                                                " supposed to be locked, "
+                                                "wrote on its end of the "
+                                                "pipe")
+                os.close(rpipe)
+
+            f()
+        else:
+            os.close(rpipe)
+
+            @synchronized('testlock')
+            def g():
+                try:
+                    os.write(wpipe, "foo")
+                except OSError, e:
+                    self.assertEquals(e.errno, errno.EPIPE)
+                    return
+            g()
+            os._exit(0)
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index d3a23abf4..70080db38 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -184,15 +184,13 @@ class NetworkTestCase(test.TestCase):
         #             flags in the corresponding section in nova-dhcpbridge
         self.flags(connection_type='fake',
                    fake_call=True,
-                   fake_network=True,
-                   network_size=16,
-                   num_networks=5)
+                   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(5):
+        for i in range(FLAGS.num_networks):
             name = 'project%s' % i
             project = self.manager.create_project(name, 'netuser', name)
             self.projects.append(project)
@@ -259,6 +257,9 @@ class NetworkTestCase(test.TestCase):
                              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"""
@@ -334,7 +335,7 @@ class NetworkTestCase(test.TestCase):
         first = self._create_address(0)
         lease_ip(first)
         instance_ids = []
-        for i in range(1, 5):
+        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'])
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 9548a8c13..1e42fddf3 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -16,6 +16,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from nova import compute
 from nova import context
 from nova import db
 from nova import flags
@@ -87,6 +88,18 @@ class QuotaTestCase(test.TestCase):
         num_instances = quota.allowed_instances(self.context, 100,
             instance_types.INSTANCE_TYPES['m1.small'])
         self.assertEqual(num_instances, 10)
+
+        # metadata_items
+        too_many_items = FLAGS.quota_metadata_items + 1000
+        num_metadata_items = quota.allowed_metadata_items(self.context,
+                                                          too_many_items)
+        self.assertEqual(num_metadata_items, FLAGS.quota_metadata_items)
+        db.quota_update(self.context, self.project.id, {'metadata_items': 5})
+        num_metadata_items = quota.allowed_metadata_items(self.context,
+                                                          too_many_items)
+        self.assertEqual(num_metadata_items, 5)
+
+        # Cleanup
         db.quota_destroy(self.context, self.project.id)
 
     def test_too_many_instances(self):
@@ -151,3 +164,15 @@ class QuotaTestCase(test.TestCase):
         self.assertRaises(quota.QuotaError, self.cloud.allocate_address,
                           self.context)
         db.floating_ip_destroy(context.get_admin_context(), address)
+
+    def test_too_many_metadata_items(self):
+        metadata = {}
+        for i in range(FLAGS.quota_metadata_items + 1):
+            metadata['key%s' % i] = 'value%s' % i
+        self.assertRaises(quota.QuotaError, compute.API().create,
+                                            self.context,
+                                            min_count=1,
+                                            max_count=1,
+                                            instance_type='m1.small',
+                                            image_id='fake',
+                                            metadata=metadata)
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index 250170072..b6888c4d2 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -150,6 +150,7 @@ class SimpleDriverTestCase(test.TestCase):
     def tearDown(self):
         self.manager.delete_user(self.user)
         self.manager.delete_project(self.project)
+        super(SimpleDriverTestCase, self).tearDown()
 
     def _create_instance(self, **kwargs):
         """Create a test instance"""
@@ -270,6 +271,7 @@ class SimpleDriverTestCase(test.TestCase):
                           self.scheduler.driver.schedule_run_instance,
                           self.context,
                           instance_id)
+        db.instance_destroy(self.context, instance_id)
         for instance_id in instance_ids1:
             compute1.terminate_instance(self.context, instance_id)
         for instance_id in instance_ids2:
diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index a67c8d1e8..45d9afa6c 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -50,13 +50,6 @@ class ExtendedService(service.Service):
 class ServiceManagerTestCase(test.TestCase):
     """Test cases for Services"""
 
-    def test_attribute_error_for_no_manager(self):
-        serv = service.Service('test',
-                               'test',
-                               'test',
-                               'nova.tests.test_service.FakeManager')
-        self.assertRaises(AttributeError, getattr, serv, 'test_method')
-
     def test_message_gets_to_manager(self):
         serv = service.Service('test',
                                'test',
diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py
new file mode 100644
index 000000000..34a407f1a
--- /dev/null
+++ b/nova/tests/test_utils.py
@@ -0,0 +1,174 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright 2011 Justin Santa Barbara
+#
+#    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 test
+from nova import utils
+from nova import exception
+
+
+class GetFromPathTestCase(test.TestCase):
+    def test_tolerates_nones(self):
+        f = utils.get_from_path
+
+        input = []
+        self.assertEquals([], f(input, "a"))
+        self.assertEquals([], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [None]
+        self.assertEquals([], f(input, "a"))
+        self.assertEquals([], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': None}]
+        self.assertEquals([], f(input, "a"))
+        self.assertEquals([], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': {'b': None}}]
+        self.assertEquals([{'b': None}], f(input, "a"))
+        self.assertEquals([], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': {'b': {'c': None}}}]
+        self.assertEquals([{'b': {'c': None}}], f(input, "a"))
+        self.assertEquals([{'c': None}], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': {'b': {'c': None}}}, {'a': None}]
+        self.assertEquals([{'b': {'c': None}}], f(input, "a"))
+        self.assertEquals([{'c': None}], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': {'b': {'c': None}}}, {'a': {'b': None}}]
+        self.assertEquals([{'b': {'c': None}}, {'b': None}], f(input, "a"))
+        self.assertEquals([{'c': None}], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+    def test_does_select(self):
+        f = utils.get_from_path
+
+        input = [{'a': 'a_1'}]
+        self.assertEquals(['a_1'], f(input, "a"))
+        self.assertEquals([], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': {'b': 'b_1'}}]
+        self.assertEquals([{'b': 'b_1'}], f(input, "a"))
+        self.assertEquals(['b_1'], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': {'b': {'c': 'c_1'}}}]
+        self.assertEquals([{'b': {'c': 'c_1'}}], f(input, "a"))
+        self.assertEquals([{'c': 'c_1'}], f(input, "a/b"))
+        self.assertEquals(['c_1'], f(input, "a/b/c"))
+
+        input = [{'a': {'b': {'c': 'c_1'}}}, {'a': None}]
+        self.assertEquals([{'b': {'c': 'c_1'}}], f(input, "a"))
+        self.assertEquals([{'c': 'c_1'}], f(input, "a/b"))
+        self.assertEquals(['c_1'], f(input, "a/b/c"))
+
+        input = [{'a': {'b': {'c': 'c_1'}}},
+                 {'a': {'b': None}}]
+        self.assertEquals([{'b': {'c': 'c_1'}}, {'b': None}], f(input, "a"))
+        self.assertEquals([{'c': 'c_1'}], f(input, "a/b"))
+        self.assertEquals(['c_1'], f(input, "a/b/c"))
+
+        input = [{'a': {'b': {'c': 'c_1'}}},
+                 {'a': {'b': {'c': 'c_2'}}}]
+        self.assertEquals([{'b': {'c': 'c_1'}}, {'b': {'c': 'c_2'}}],
+                          f(input, "a"))
+        self.assertEquals([{'c': 'c_1'}, {'c': 'c_2'}], f(input, "a/b"))
+        self.assertEquals(['c_1', 'c_2'], f(input, "a/b/c"))
+
+        self.assertEquals([], f(input, "a/b/c/d"))
+        self.assertEquals([], f(input, "c/a/b/d"))
+        self.assertEquals([], f(input, "i/r/t"))
+
+    def test_flattens_lists(self):
+        f = utils.get_from_path
+
+        input = [{'a': [1, 2, 3]}]
+        self.assertEquals([1, 2, 3], f(input, "a"))
+        self.assertEquals([], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': {'b': [1, 2, 3]}}]
+        self.assertEquals([{'b': [1, 2, 3]}], f(input, "a"))
+        self.assertEquals([1, 2, 3], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': {'b': [1, 2, 3]}}, {'a': {'b': [4, 5, 6]}}]
+        self.assertEquals([1, 2, 3, 4, 5, 6], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': [{'b': [1, 2, 3]}, {'b': [4, 5, 6]}]}]
+        self.assertEquals([1, 2, 3, 4, 5, 6], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = [{'a': [1, 2, {'b': 'b_1'}]}]
+        self.assertEquals([1, 2, {'b': 'b_1'}], f(input, "a"))
+        self.assertEquals(['b_1'], f(input, "a/b"))
+
+    def test_bad_xpath(self):
+        f = utils.get_from_path
+
+        self.assertRaises(exception.Error, f, [], None)
+        self.assertRaises(exception.Error, f, [], "")
+        self.assertRaises(exception.Error, f, [], "/")
+        self.assertRaises(exception.Error, f, [], "/a")
+        self.assertRaises(exception.Error, f, [], "/a/")
+        self.assertRaises(exception.Error, f, [], "//")
+        self.assertRaises(exception.Error, f, [], "//a")
+        self.assertRaises(exception.Error, f, [], "a//a")
+        self.assertRaises(exception.Error, f, [], "a//a/")
+        self.assertRaises(exception.Error, f, [], "a/a/")
+
+    def test_real_failure1(self):
+        # Real world failure case...
+        #  We weren't coping when the input was a Dictionary instead of a List
+        # This led to test_accepts_dictionaries
+        f = utils.get_from_path
+
+        inst = {'fixed_ip': {'floating_ips': [{'address': '1.2.3.4'}],
+                             'address': '192.168.0.3'},
+                'hostname': ''}
+
+        private_ips = f(inst, 'fixed_ip/address')
+        public_ips = f(inst, 'fixed_ip/floating_ips/address')
+        self.assertEquals(['192.168.0.3'], private_ips)
+        self.assertEquals(['1.2.3.4'], public_ips)
+
+    def test_accepts_dictionaries(self):
+        f = utils.get_from_path
+
+        input = {'a': [1, 2, 3]}
+        self.assertEquals([1, 2, 3], f(input, "a"))
+        self.assertEquals([], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = {'a': {'b': [1, 2, 3]}}
+        self.assertEquals([{'b': [1, 2, 3]}], f(input, "a"))
+        self.assertEquals([1, 2, 3], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = {'a': [{'b': [1, 2, 3]}, {'b': [4, 5, 6]}]}
+        self.assertEquals([1, 2, 3, 4, 5, 6], f(input, "a/b"))
+        self.assertEquals([], f(input, "a/b/c"))
+
+        input = {'a': [1, 2, {'b': 'b_1'}]}
+        self.assertEquals([1, 2, {'b': 'b_1'}], f(input, "a"))
+        self.assertEquals(['b_1'], f(input, "a/b"))
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index c2c7c8337..b2a937a4e 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -205,11 +205,12 @@ class LibvirtConnTestCase(test.TestCase):
             conn = libvirt_conn.LibvirtConnection(True)
             uri = conn.get_uri()
             self.assertEquals(uri, testuri)
+        db.instance_destroy(user_context, instance_ref['id'])
 
     def tearDown(self):
-        super(LibvirtConnTestCase, self).tearDown()
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
+        super(LibvirtConnTestCase, self).tearDown()
 
 
 class IptablesFirewallTestCase(test.TestCase):
@@ -382,6 +383,7 @@ class IptablesFirewallTestCase(test.TestCase):
                            '--dports 80:81 -j ACCEPT')
         self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
                         "TCP port 80/81 acceptance rule wasn't added")
+        db.instance_destroy(admin_ctxt, instance_ref['id'])
 
 
 class NWFilterTestCase(test.TestCase):
@@ -405,6 +407,7 @@ class NWFilterTestCase(test.TestCase):
     def tearDown(self):
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
+        super(NWFilterTestCase, self).tearDown()
 
     def test_cidr_rule_nwfilter_xml(self):
         cloud_controller = cloud.CloudController()
@@ -531,3 +534,4 @@ class NWFilterTestCase(test.TestCase):
         self.fw.apply_instance_filter(instance)
         _ensure_all_called()
         self.teardown_security_group()
+        db.instance_destroy(admin_ctxt, instance_ref['id'])
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 6b8efc9d8..2cbe58aab 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -167,6 +167,7 @@ class XenAPIVMTestCase(test.TestCase):
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
         stubs.stubout_get_this_vm_uuid(self.stubs)
         stubs.stubout_stream_disk(self.stubs)
+        stubs.stubout_is_vdi_pv(self.stubs)
         self.stubs.Set(VMOps, 'reset_network', reset_network)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 624995ada..4fec2bd75 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -130,6 +130,12 @@ def stubout_stream_disk(stubs):
     stubs.Set(vm_utils, '_stream_disk', f)
 
 
+def stubout_is_vdi_pv(stubs):
+    def f(_1):
+        return False
+    stubs.Set(vm_utils, '_is_vdi_pv', f)
+
+
 class FakeSessionForVMTests(fake.SessionBase):
     """ Stubs out a XenAPISession for VM tests """
     def __init__(self, uri):