merged from trunk

70 files changed, 9863 insertions, 1478 deletions

diff --git a/nova/tests/api/openstack/__init__.py b/nova/tests/api/openstack/__init__.py
index e18120285..bac7181f7 100644
--- a/nova/tests/api/openstack/__init__.py
+++ b/nova/tests/api/openstack/__init__.py
@@ -20,7 +20,7 @@ from nova import test
 
 from nova import context
 from nova import flags
-from nova.api.openstack.ratelimiting import RateLimitingMiddleware
+from nova.api.openstack.limits import RateLimitingMiddleware
 from nova.api.openstack.common import limited
 from nova.tests.api.openstack import fakes
 from webob import Request
diff --git a/nova/tests/api/openstack/extensions/__init__.py b/nova/tests/api/openstack/extensions/__init__.py
new file mode 100644
index 000000000..848908a95
--- /dev/null
+++ b/nova/tests/api/openstack/extensions/__init__.py
@@ -0,0 +1,15 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC
+#
+#    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/api/openstack/extensions/foxinsocks.py b/nova/tests/api/openstack/extensions/foxinsocks.py
new file mode 100644
index 000000000..0860b51ac
--- /dev/null
+++ b/nova/tests/api/openstack/extensions/foxinsocks.py
@@ -0,0 +1,98 @@
+# 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 json
+
+from nova import wsgi
+
+from nova.api.openstack import extensions
+
+
+class FoxInSocksController(wsgi.Controller):
+
+    def index(self, req):
+        return "Try to say this Mr. Knox, sir..."
+
+
+class Foxinsocks(object):
+
+    def __init__(self):
+        pass
+
+    def get_name(self):
+        return "Fox In Socks"
+
+    def get_alias(self):
+        return "FOXNSOX"
+
+    def get_description(self):
+        return "The Fox In Socks Extension"
+
+    def get_namespace(self):
+        return "http://www.fox.in.socks/api/ext/pie/v1.0"
+
+    def get_updated(self):
+        return "2011-01-22T13:25:27-06:00"
+
+    def get_resources(self):
+        resources = []
+        resource = extensions.ResourceExtension('foxnsocks',
+                                               FoxInSocksController())
+        resources.append(resource)
+        return resources
+
+    def get_actions(self):
+        actions = []
+        actions.append(extensions.ActionExtension('servers', 'add_tweedle',
+                                                    self._add_tweedle))
+        actions.append(extensions.ActionExtension('servers', 'delete_tweedle',
+                                                    self._delete_tweedle))
+        return actions
+
+    def get_response_extensions(self):
+        response_exts = []
+
+        def _goose_handler(res):
+            #NOTE: This only handles JSON responses.
+            # You can use content type header to test for XML.
+            data = json.loads(res.body)
+            data['flavor']['googoose'] = "Gooey goo for chewy chewing!"
+            return data
+
+        resp_ext = extensions.ResponseExtension('GET', '/v1.1/flavors/:(id)',
+                                                _goose_handler)
+        response_exts.append(resp_ext)
+
+        def _bands_handler(res):
+            #NOTE: This only handles JSON responses.
+            # You can use content type header to test for XML.
+            data = json.loads(res.body)
+            data['big_bands'] = 'Pig Bands!'
+            return data
+
+        resp_ext2 = extensions.ResponseExtension('GET', '/v1.1/flavors/:(id)',
+                                                _bands_handler)
+        response_exts.append(resp_ext2)
+        return response_exts
+
+    def _add_tweedle(self, input_dict, req, id):
+
+        return "Tweedle Beetle Added."
+
+    def _delete_tweedle(self, input_dict, req, id):
+
+        return "Tweedle Beetle Deleted."
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index e50d11a3d..8b0729c35 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
@@ -34,7 +35,8 @@ from nova import utils
 import nova.api.openstack.auth
 from nova.api import openstack
 from nova.api.openstack import auth
-from nova.api.openstack import ratelimiting
+from nova.api.openstack import versions
+from nova.api.openstack import limits
 from nova.auth.manager import User, Project
 from nova.image import glance
 from nova.image import local
@@ -69,26 +71,36 @@ def fake_auth_init(self, application):
 @webob.dec.wsgify
 def fake_wsgi(self, req):
     req.environ['nova.context'] = context.RequestContext(1, 1)
-    if req.body:
-        req.environ['inst_dict'] = json.loads(req.body)
     return self.application
 
 
-def wsgi_app(inner_application=None):
-    if not inner_application:
-        inner_application = openstack.APIRouter()
+def wsgi_app(inner_app10=None, inner_app11=None):
+    if not inner_app10:
+        inner_app10 = openstack.APIRouterV10()
+    if not inner_app11:
+        inner_app11 = openstack.APIRouterV11()
     mapper = urlmap.URLMap()
-    api = openstack.FaultWrapper(auth.AuthMiddleware(
-              ratelimiting.RateLimitingMiddleware(inner_application)))
-    mapper['/v1.0'] = api
-    mapper['/'] = openstack.FaultWrapper(openstack.Versions())
+    api10 = openstack.FaultWrapper(auth.AuthMiddleware(
+              limits.RateLimitingMiddleware(inner_app10)))
+    api11 = openstack.FaultWrapper(auth.AuthMiddleware(
+              limits.RateLimitingMiddleware(inner_app11)))
+    mapper['/v1.0'] = api10
+    mapper['/v1.1'] = api11
+    mapper['/'] = openstack.FaultWrapper(versions.Versions())
     return mapper
 
 
-def stub_out_key_pair_funcs(stubs):
+def stub_out_key_pair_funcs(stubs, have_key_pair=True):
     def key_pair(context, user_id):
         return [dict(name='key', public_key='public_key')]
-    stubs.Set(nova.db, 'key_pair_get_all_by_user', key_pair)
+
+    def no_key_pair(context, user_id):
+        return []
+
+    if have_key_pair:
+        stubs.Set(nova.db, 'key_pair_get_all_by_user', key_pair)
+    else:
+        stubs.Set(nova.db, 'key_pair_get_all_by_user', no_key_pair)
 
 
 def stub_out_image_service(stubs):
@@ -110,13 +122,13 @@ def stub_out_auth(stubs):
 
 def stub_out_rate_limiting(stubs):
     def fake_rate_init(self, app):
-        super(ratelimiting.RateLimitingMiddleware, self).__init__(app)
+        super(limits.RateLimitingMiddleware, self).__init__(app)
         self.application = app
 
-    stubs.Set(nova.api.openstack.ratelimiting.RateLimitingMiddleware,
+    stubs.Set(nova.api.openstack.limits.RateLimitingMiddleware,
         '__init__', fake_rate_init)
 
-    stubs.Set(nova.api.openstack.ratelimiting.RateLimitingMiddleware,
+    stubs.Set(nova.api.openstack.limits.RateLimitingMiddleware,
         '__call__', fake_wsgi)
 
 
@@ -132,6 +144,21 @@ def stub_out_compute_api_snapshot(stubs):
     stubs.Set(nova.compute.API, 'snapshot', snapshot)
 
 
+def stub_out_glance_add_image(stubs, sent_to_glance):
+    """
+    We return the metadata sent to glance by modifying the sent_to_glance dict
+    in place.
+    """
+    orig_add_image = glance_client.Client.add_image
+
+    def fake_add_image(context, metadata, data=None):
+        sent_to_glance['metadata'] = metadata
+        sent_to_glance['data'] = data
+        return orig_add_image(metadata, data)
+
+    stubs.Set(glance_client.Client, 'add_image', fake_add_image)
+
+
 def stub_out_glance(stubs, initial_fixtures=None):
 
     class FakeGlanceClient:
@@ -144,37 +171,46 @@ 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):
-            id = ''.join(random.choice(string.letters) for _ in range(20))
-            image_meta['id'] = id
+            image_meta = copy.deepcopy(image_meta)
+            image_id = ''.join(random.choice(string.letters)
+                               for _ in range(20))
+            image_meta['id'] = image_id
             self.fixtures.append(image_meta)
-            return image_meta
+            return copy.deepcopy(image_meta)
 
         def fake_update_image(self, image_id, image_meta, data=None):
-            f = self.fake_get_image_meta(image_id)
+            for attr in ('created_at', 'updated_at', 'deleted_at', 'deleted'):
+                if attr in image_meta:
+                    del image_meta[attr]
+
+            f = self._find_image(image_id)
             if not f:
                 raise glance_exc.NotFound
 
             f.update(image_meta)
-            return f
+            return copy.deepcopy(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
 
             self.fixtures.remove(f)
 
-        ##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)
@@ -186,10 +222,10 @@ def stub_out_glance(stubs, initial_fixtures=None):
     stubs.Set(GlanceClient, 'add_image', fake.fake_add_image)
     stubs.Set(GlanceClient, 'update_image', fake.fake_update_image)
     stubs.Set(GlanceClient, 'delete_image', fake.fake_delete_image)
-    #stubs.Set(GlanceClient, 'delete_all', fake.fake_delete_all)
 
 
 class FakeToken(object):
+    # FIXME(sirp): let's not use id here
     id = 0
 
     def __init__(self, **kwargs):
@@ -228,52 +264,57 @@ class FakeAuthDatabase(object):
 
 
 class FakeAuthManager(object):
-    auth_data = {}
+    #NOTE(justinsb): Accessing static variables through instances is FUBAR
+    #NOTE(justinsb): This should also be private!
+    auth_data = []
     projects = {}
 
     @classmethod
     def clear_fakes(cls):
-        cls.auth_data = {}
+        cls.auth_data = []
         cls.projects = {}
 
     @classmethod
     def reset_fake_data(cls):
-        cls.auth_data = dict(acc1=User('guy1', 'guy1', 'acc1',
-                                       'fortytwo!', False))
+        u1 = User('id1', 'guy1', 'acc1', 'secret1', False)
+        cls.auth_data = [u1]
         cls.projects = dict(testacct=Project('testacct',
                                              'testacct',
-                                             'guy1',
+                                             'id1',
                                              'test',
                                               []))
 
-    def add_user(self, key, user):
-        FakeAuthManager.auth_data[key] = user
+    def add_user(self, user):
+        FakeAuthManager.auth_data.append(user)
 
     def get_users(self):
-        return FakeAuthManager.auth_data.values()
+        return FakeAuthManager.auth_data
 
     def get_user(self, uid):
-        for k, v in FakeAuthManager.auth_data.iteritems():
-            if v.id == uid:
-                return v
+        for user in FakeAuthManager.auth_data:
+            if user.id == uid:
+                return user
+        return None
+
+    def get_user_from_access_key(self, key):
+        for user in FakeAuthManager.auth_data:
+            if user.access == key:
+                return user
         return None
 
     def delete_user(self, uid):
-        for k, v in FakeAuthManager.auth_data.items():
-            if v.id == uid:
-                del FakeAuthManager.auth_data[k]
+        for user in FakeAuthManager.auth_data:
+            if user.id == uid:
+                FakeAuthManager.auth_data.remove(user)
         return None
 
     def create_user(self, name, access=None, secret=None, admin=False):
         u = User(name, name, access, secret, admin)
-        FakeAuthManager.auth_data[access] = u
+        FakeAuthManager.auth_data.append(u)
         return u
 
     def modify_user(self, user_id, access=None, secret=None, admin=None):
-        user = None
-        for k, v in FakeAuthManager.auth_data.iteritems():
-            if v.id == user_id:
-                user = v
+        user = self.get_user(user_id)
         if user:
             user.access = access
             user.secret = secret
@@ -320,9 +361,6 @@ class FakeAuthManager(object):
                     if (user.id in p.member_ids) or
                        (user.id == p.project_manager_id)]
 
-    def get_user_from_access_key(self, key):
-        return FakeAuthManager.auth_data.get(key, None)
-
 
 class FakeRateLimiter(object):
     def __init__(self, application):
diff --git a/nova/tests/api/openstack/test_accounts.py b/nova/tests/api/openstack/test_accounts.py
index 60edce769..64abcf48c 100644
--- a/nova/tests/api/openstack/test_accounts.py
+++ b/nova/tests/api/openstack/test_accounts.py
@@ -19,11 +19,9 @@ import json
 import stubout
 import webob
 
-import nova.api
-import nova.api.openstack.auth
-from nova import context
 from nova import flags
 from nova import test
+from nova.api.openstack import accounts
 from nova.auth.manager import User
 from nova.tests.api.openstack import fakes
 
@@ -44,9 +42,9 @@ class AccountsTest(test.TestCase):
     def setUp(self):
         super(AccountsTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(nova.api.openstack.accounts.Controller, '__init__',
+        self.stubs.Set(accounts.Controller, '__init__',
                        fake_init)
-        self.stubs.Set(nova.api.openstack.accounts.Controller, '_check_admin',
+        self.stubs.Set(accounts.Controller, '_check_admin',
                        fake_admin_check)
         fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthDatabase.data = {}
@@ -57,10 +55,10 @@ class AccountsTest(test.TestCase):
         self.allow_admin = FLAGS.allow_admin_api
         FLAGS.allow_admin_api = True
         fakemgr = fakes.FakeAuthManager()
-        joeuser = User('guy1', 'guy1', 'acc1', 'fortytwo!', False)
-        superuser = User('guy2', 'guy2', 'acc2', 'swordfish', True)
-        fakemgr.add_user(joeuser.access, joeuser)
-        fakemgr.add_user(superuser.access, superuser)
+        joeuser = User('id1', 'guy1', 'acc1', 'secret1', False)
+        superuser = User('id2', 'guy2', 'acc2', 'secret2', True)
+        fakemgr.add_user(joeuser)
+        fakemgr.add_user(superuser)
         fakemgr.create_project('test1', joeuser)
         fakemgr.create_project('test2', superuser)
 
@@ -76,7 +74,7 @@ class AccountsTest(test.TestCase):
 
         self.assertEqual(res_dict['account']['id'], 'test1')
         self.assertEqual(res_dict['account']['name'], 'test1')
-        self.assertEqual(res_dict['account']['manager'], 'guy1')
+        self.assertEqual(res_dict['account']['manager'], 'id1')
         self.assertEqual(res.status_int, 200)
 
     def test_account_delete(self):
@@ -88,7 +86,7 @@ class AccountsTest(test.TestCase):
 
     def test_account_create(self):
         body = dict(account=dict(description='test account',
-                              manager='guy1'))
+                                 manager='id1'))
         req = webob.Request.blank('/v1.0/accounts/newacct')
         req.headers["Content-Type"] = "application/json"
         req.method = 'PUT'
@@ -101,14 +99,14 @@ class AccountsTest(test.TestCase):
         self.assertEqual(res_dict['account']['id'], 'newacct')
         self.assertEqual(res_dict['account']['name'], 'newacct')
         self.assertEqual(res_dict['account']['description'], 'test account')
-        self.assertEqual(res_dict['account']['manager'], 'guy1')
+        self.assertEqual(res_dict['account']['manager'], 'id1')
         self.assertTrue('newacct' in
                         fakes.FakeAuthManager.projects)
         self.assertEqual(len(fakes.FakeAuthManager.projects.values()), 3)
 
     def test_account_update(self):
         body = dict(account=dict(description='test account',
-                              manager='guy2'))
+                                 manager='id2'))
         req = webob.Request.blank('/v1.0/accounts/test1')
         req.headers["Content-Type"] = "application/json"
         req.method = 'PUT'
@@ -121,5 +119,5 @@ class AccountsTest(test.TestCase):
         self.assertEqual(res_dict['account']['id'], 'test1')
         self.assertEqual(res_dict['account']['name'], 'test1')
         self.assertEqual(res_dict['account']['description'], 'test account')
-        self.assertEqual(res_dict['account']['manager'], 'guy2')
+        self.assertEqual(res_dict['account']['manager'], 'id2')
         self.assertEqual(len(fakes.FakeAuthManager.projects.values()), 2)
diff --git a/nova/tests/api/openstack/test_adminapi.py b/nova/tests/api/openstack/test_adminapi.py
index 4568cb9f5..e87255b18 100644
--- a/nova/tests/api/openstack/test_adminapi.py
+++ b/nova/tests/api/openstack/test_adminapi.py
@@ -23,7 +23,6 @@ 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
 from nova.tests.api.openstack import fakes
 
diff --git a/nova/tests/api/openstack/test_api.py b/nova/tests/api/openstack/test_api.py
index 5112c486f..c63431a45 100644
--- a/nova/tests/api/openstack/test_api.py
+++ b/nova/tests/api/openstack/test_api.py
@@ -53,13 +53,13 @@ class APITest(test.TestCase):
         #api.application = succeed
         api = self._wsgi_app(succeed)
         resp = Request.blank('/').get_response(api)
-        self.assertFalse('computeFault' in resp.body, resp.body)
+        self.assertFalse('cloudServersFault' in resp.body, resp.body)
         self.assertEqual(resp.status_int, 200, resp.body)
 
         #api.application = raise_webob_exc
         api = self._wsgi_app(raise_webob_exc)
         resp = Request.blank('/').get_response(api)
-        self.assertFalse('computeFault' in resp.body, resp.body)
+        self.assertFalse('cloudServersFault' in resp.body, resp.body)
         self.assertEqual(resp.status_int, 404, resp.body)
 
         #api.application = raise_api_fault
@@ -71,11 +71,11 @@ class APITest(test.TestCase):
         #api.application = fail
         api = self._wsgi_app(fail)
         resp = Request.blank('/').get_response(api)
-        self.assertTrue('{"computeFault' in resp.body, resp.body)
+        self.assertTrue('{"cloudServersFault' in resp.body, resp.body)
         self.assertEqual(resp.status_int, 500, resp.body)
 
         #api.application = fail
         api = self._wsgi_app(fail)
         resp = Request.blank('/.xml').get_response(api)
-        self.assertTrue('<computeFault' in resp.body, resp.body)
+        self.assertTrue('<cloudServersFault' in resp.body, resp.body)
         self.assertEqual(resp.status_int, 500, resp.body)
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index aaaa4e415..8f189c744 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -39,7 +39,7 @@ class Test(test.TestCase):
         self.stubs.Set(nova.api.openstack.auth.AuthMiddleware,
             '__init__', fakes.fake_auth_init)
         self.stubs.Set(context, 'RequestContext', fakes.FakeRequestContext)
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_networking(self.stubs)
@@ -51,11 +51,12 @@ class Test(test.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
+        user = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
+        f.add_user(user)
 
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-User'] = 'herp'
-        req.headers['X-Auth-Key'] = 'derp'
+        req.headers['X-Auth-User'] = 'user1'
+        req.headers['X-Auth-Key'] = 'user1_key'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '204 No Content')
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
@@ -65,13 +66,13 @@ class Test(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
-        f.create_project('test', u)
+        user = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
+        f.add_user(user)
+        f.create_project('user1_project', user)
 
         req = webob.Request.blank('/v1.0/', {'HTTP_HOST': 'foo'})
-        req.headers['X-Auth-User'] = 'herp'
-        req.headers['X-Auth-Key'] = 'derp'
+        req.headers['X-Auth-User'] = 'user1'
+        req.headers['X-Auth-Key'] = 'user1_key'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '204 No Content')
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
@@ -82,8 +83,7 @@ class Test(test.TestCase):
         self.assertEqual(result.headers['X-Storage-Url'], "")
 
         token = result.headers['X-Auth-Token']
-        self.stubs.Set(nova.api.openstack, 'APIRouter',
-            fakes.FakeRouter)
+        self.stubs.Set(nova.api.openstack, 'APIRouterV10', fakes.FakeRouter)
         req = webob.Request.blank('/v1.0/fake')
         req.headers['X-Auth-Token'] = token
         result = req.get_response(fakes.wsgi_app())
@@ -92,7 +92,7 @@ class Test(test.TestCase):
 
     def test_token_expiry(self):
         self.destroy_called = False
-        token_hash = 'bacon'
+        token_hash = 'token_hash'
 
         def destroy_token_mock(meh, context, token):
             self.destroy_called = True
@@ -109,15 +109,26 @@ class Test(test.TestCase):
             bad_token)
 
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-Token'] = 'bacon'
+        req.headers['X-Auth-Token'] = 'token_hash'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
         self.assertEqual(self.destroy_called, True)
 
-    def test_bad_user(self):
+    def test_bad_user_bad_key(self):
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-User'] = 'herp'
-        req.headers['X-Auth-Key'] = 'derp'
+        req.headers['X-Auth-User'] = 'unknown_user'
+        req.headers['X-Auth-Key'] = 'unknown_user_key'
+        result = req.get_response(fakes.wsgi_app())
+        self.assertEqual(result.status, '401 Unauthorized')
+
+    def test_bad_user_good_key(self):
+        f = fakes.FakeAuthManager()
+        user = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
+        f.add_user(user)
+
+        req = webob.Request.blank('/v1.0/')
+        req.headers['X-Auth-User'] = 'unknown_user'
+        req.headers['X-Auth-Key'] = 'user1_key'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
 
@@ -128,7 +139,7 @@ class Test(test.TestCase):
 
     def test_bad_token(self):
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-Token'] = 'baconbaconbacon'
+        req.headers['X-Auth-Token'] = 'unknown_token'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
 
@@ -137,11 +148,11 @@ class TestFunctional(test.TestCase):
     def test_token_expiry(self):
         ctx = context.get_admin_context()
         tok = db.auth_token_create(ctx, dict(
-                token_hash='bacon',
+                token_hash='test_token_hash',
                 cdn_management_url='',
                 server_management_url='',
                 storage_url='',
-                user_id='ham',
+                user_id='user1',
                 ))
 
         db.auth_token_update(ctx, tok.token_hash, dict(
@@ -149,13 +160,13 @@ class TestFunctional(test.TestCase):
                 ))
 
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-Token'] = 'bacon'
+        req.headers['X-Auth-Token'] = 'test_token_hash'
         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'
+        req.headers['X-Auth-Token'] = 'nonexistant_token_hash'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(result.status, '401 Unauthorized')
 
@@ -167,7 +178,7 @@ class TestLimiter(test.TestCase):
         self.stubs.Set(nova.api.openstack.auth.AuthMiddleware,
             '__init__', fakes.fake_auth_init)
         self.stubs.Set(context, 'RequestContext', fakes.FakeRequestContext)
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_networking(self.stubs)
 
@@ -178,19 +189,18 @@ class TestLimiter(test.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        u = nova.auth.manager.User(1, 'herp', None, None, None)
-        f.add_user('derp', u)
-        f.create_project('test', u)
+        user = nova.auth.manager.User('id1', 'user1', 'user1_key', None, None)
+        f.add_user(user)
+        f.create_project('test', user)
 
         req = webob.Request.blank('/v1.0/')
-        req.headers['X-Auth-User'] = 'herp'
-        req.headers['X-Auth-Key'] = 'derp'
+        req.headers['X-Auth-User'] = 'user1'
+        req.headers['X-Auth-Key'] = 'user1_key'
         result = req.get_response(fakes.wsgi_app())
         self.assertEqual(len(result.headers['X-Auth-Token']), 40)
 
         token = result.headers['X-Auth-Token']
-        self.stubs.Set(nova.api.openstack, 'APIRouter',
-            fakes.FakeRouter)
+        self.stubs.Set(nova.api.openstack, 'APIRouterV10', fakes.FakeRouter)
         req = webob.Request.blank('/v1.0/fake')
         req.method = 'POST'
         req.headers['X-Auth-Token'] = token
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
new file mode 100644
index 000000000..481d34ed1
--- /dev/null
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -0,0 +1,236 @@
+# 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 json
+import stubout
+import unittest
+import webob
+import os.path
+
+from nova import context
+from nova import flags
+from nova.api import openstack
+from nova.api.openstack import extensions
+from nova.api.openstack import flavors
+from nova.tests.api.openstack import fakes
+import nova.wsgi
+
+FLAGS = flags.FLAGS
+
+response_body = "Try to say this Mr. Knox, sir..."
+
+
+class StubController(nova.wsgi.Controller):
+
+    def __init__(self, body):
+        self.body = body
+
+    def index(self, req):
+        return self.body
+
+
+class StubExtensionManager(object):
+
+    def __init__(self, resource_ext=None, action_ext=None, response_ext=None):
+        self.resource_ext = resource_ext
+        self.action_ext = action_ext
+        self.response_ext = response_ext
+
+    def get_name(self):
+        return "Tweedle Beetle Extension"
+
+    def get_alias(self):
+        return "TWDLBETL"
+
+    def get_description(self):
+        return "Provides access to Tweedle Beetles"
+
+    def get_resources(self):
+        resource_exts = []
+        if self.resource_ext:
+            resource_exts.append(self.resource_ext)
+        return resource_exts
+
+    def get_actions(self):
+        action_exts = []
+        if self.action_ext:
+            action_exts.append(self.action_ext)
+        return action_exts
+
+    def get_response_extensions(self):
+        response_exts = []
+        if self.response_ext:
+            response_exts.append(self.response_ext)
+        return response_exts
+
+
+class ExtensionControllerTest(unittest.TestCase):
+
+    def test_index(self):
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/extensions")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+
+    def test_get_by_alias(self):
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/extensions/FOXNSOX")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+
+
+class ResourceExtensionTest(unittest.TestCase):
+
+    def test_no_extension_present(self):
+        manager = StubExtensionManager(None)
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app, manager)
+        request = webob.Request.blank("/blah")
+        response = request.get_response(ext_midware)
+        self.assertEqual(404, response.status_int)
+
+    def test_get_resources(self):
+        res_ext = extensions.ResourceExtension('tweedles',
+                                               StubController(response_body))
+        manager = StubExtensionManager(res_ext)
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app, manager)
+        request = webob.Request.blank("/tweedles")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual(response_body, response.body)
+
+    def test_get_resources_with_controller(self):
+        res_ext = extensions.ResourceExtension('tweedles',
+                                               StubController(response_body))
+        manager = StubExtensionManager(res_ext)
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app, manager)
+        request = webob.Request.blank("/tweedles")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual(response_body, response.body)
+
+
+class ExtensionManagerTest(unittest.TestCase):
+
+    response_body = "Try to say this Mr. Knox, sir..."
+
+    def setUp(self):
+        FLAGS.osapi_extensions_path = os.path.join(os.path.dirname(__file__),
+                                                    "extensions")
+
+    def test_get_resources(self):
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/foxnsocks")
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual(response_body, response.body)
+
+
+class ActionExtensionTest(unittest.TestCase):
+
+    def setUp(self):
+        FLAGS.osapi_extensions_path = os.path.join(os.path.dirname(__file__),
+                                                    "extensions")
+
+    def _send_server_action_request(self, url, body):
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank(url)
+        request.method = 'POST'
+        request.content_type = 'application/json'
+        request.body = json.dumps(body)
+        response = request.get_response(ext_midware)
+        return response
+
+    def test_extended_action(self):
+        body = dict(add_tweedle=dict(name="test"))
+        response = self._send_server_action_request("/servers/1/action", body)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual("Tweedle Beetle Added.", response.body)
+
+        body = dict(delete_tweedle=dict(name="test"))
+        response = self._send_server_action_request("/servers/1/action", body)
+        self.assertEqual(200, response.status_int)
+        self.assertEqual("Tweedle Beetle Deleted.", response.body)
+
+    def test_invalid_action_body(self):
+        body = dict(blah=dict(name="test"))  # Doesn't exist
+        response = self._send_server_action_request("/servers/1/action", body)
+        self.assertEqual(501, response.status_int)
+
+    def test_invalid_action(self):
+        body = dict(blah=dict(name="test"))
+        response = self._send_server_action_request("/asdf/1/action", body)
+        self.assertEqual(404, response.status_int)
+
+
+class ResponseExtensionTest(unittest.TestCase):
+
+    def setUp(self):
+        super(ResponseExtensionTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.reset_fake_data()
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
+        self.context = context.get_admin_context()
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        super(ResponseExtensionTest, self).tearDown()
+
+    def test_get_resources_with_stub_mgr(self):
+
+        test_resp = "Gooey goo for chewy chewing!"
+
+        def _resp_handler(res):
+            # only handle JSON responses
+            data = json.loads(res.body)
+            data['flavor']['googoose'] = test_resp
+            return data
+
+        resp_ext = extensions.ResponseExtension('GET',
+                                                '/v1.1/flavors/:(id)',
+                                                _resp_handler)
+
+        manager = StubExtensionManager(None, None, resp_ext)
+        app = fakes.wsgi_app()
+        ext_midware = extensions.ExtensionMiddleware(app, manager)
+        request = webob.Request.blank("/v1.1/flavors/1")
+        request.environ['api.version'] = '1.1'
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        response_data = json.loads(response.body)
+        self.assertEqual(test_resp, response_data['flavor']['googoose'])
+
+    def test_get_resources_with_mgr(self):
+
+        test_resp = "Gooey goo for chewy chewing!"
+
+        app = fakes.wsgi_app()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        request = webob.Request.blank("/v1.1/flavors/1")
+        request.environ['api.version'] = '1.1'
+        response = request.get_response(ext_midware)
+        self.assertEqual(200, response.status_int)
+        response_data = json.loads(response.body)
+        self.assertEqual(test_resp, response_data['flavor']['googoose'])
+        self.assertEqual("Pig Bands!", response_data['big_bands'])
diff --git a/nova/tests/api/openstack/test_faults.py b/nova/tests/api/openstack/test_faults.py
index 7667753f4..4d86ffb26 100644
--- a/nova/tests/api/openstack/test_faults.py
+++ b/nova/tests/api/openstack/test_faults.py
@@ -15,44 +15,127 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import json
+
 import webob
 import webob.dec
 import webob.exc
 
 from nova import test
+from nova.api.openstack import common
 from nova.api.openstack import faults
 
 
 class TestFaults(test.TestCase):
+    """Tests covering `nova.api.openstack.faults:Fault` class."""
 
-    def test_fault_parts(self):
-        req = webob.Request.blank('/.xml')
-        f = faults.Fault(webob.exc.HTTPBadRequest(explanation='scram'))
-        resp = req.get_response(f)
+    def _prepare_xml(self, xml_string):
+        """Remove characters from string which hinder XML equality testing."""
+        xml_string = xml_string.replace("  ", "")
+        xml_string = xml_string.replace("\n", "")
+        xml_string = xml_string.replace("\t", "")
+        return xml_string
 
-        first_two_words = resp.body.strip().split()[:2]
-        self.assertEqual(first_two_words, ['<badRequest', 'code="400">'])
-        body_without_spaces = ''.join(resp.body.split())
-        self.assertTrue('<message>scram</message>' in body_without_spaces)
+    def test_400_fault_xml(self):
+        """Test fault serialized to XML via file-extension and/or header."""
+        requests = [
+            webob.Request.blank('/.xml'),
+            webob.Request.blank('/', headers={"Accept": "application/xml"}),
+        ]
 
-    def test_retry_header(self):
-        req = webob.Request.blank('/.xml')
-        exc = webob.exc.HTTPRequestEntityTooLarge(explanation='sorry',
-                                                  headers={'Retry-After': 4})
-        f = faults.Fault(exc)
-        resp = req.get_response(f)
-        first_two_words = resp.body.strip().split()[:2]
-        self.assertEqual(first_two_words, ['<overLimit', 'code="413">'])
-        body_sans_spaces = ''.join(resp.body.split())
-        self.assertTrue('<message>sorry</message>' in body_sans_spaces)
-        self.assertTrue('<retryAfter>4</retryAfter>' in body_sans_spaces)
-        self.assertEqual(resp.headers['Retry-After'], 4)
+        for request in requests:
+            fault = faults.Fault(webob.exc.HTTPBadRequest(explanation='scram'))
+            response = request.get_response(fault)
+
+            expected = self._prepare_xml("""
+                <badRequest code="400" xmlns="%s">
+                    <message>scram</message>
+                </badRequest>
+            """ % common.XML_NS_V10)
+            actual = self._prepare_xml(response.body)
+
+            self.assertEqual(response.content_type, "application/xml")
+            self.assertEqual(expected, actual)
+
+    def test_400_fault_json(self):
+        """Test fault serialized to JSON via file-extension and/or header."""
+        requests = [
+            webob.Request.blank('/.json'),
+            webob.Request.blank('/', headers={"Accept": "application/json"}),
+        ]
+
+        for request in requests:
+            fault = faults.Fault(webob.exc.HTTPBadRequest(explanation='scram'))
+            response = request.get_response(fault)
+
+            expected = {
+                "badRequest": {
+                    "message": "scram",
+                    "code": 400,
+                },
+            }
+            actual = json.loads(response.body)
+
+            self.assertEqual(response.content_type, "application/json")
+            self.assertEqual(expected, actual)
+
+    def test_413_fault_xml(self):
+        requests = [
+            webob.Request.blank('/.xml'),
+            webob.Request.blank('/', headers={"Accept": "application/xml"}),
+        ]
+
+        for request in requests:
+            exc = webob.exc.HTTPRequestEntityTooLarge
+            fault = faults.Fault(exc(explanation='sorry',
+                        headers={'Retry-After': 4}))
+            response = request.get_response(fault)
+
+            expected = self._prepare_xml("""
+                <overLimit code="413" xmlns="%s">
+                    <message>sorry</message>
+                    <retryAfter>4</retryAfter>
+                </overLimit>
+            """ % common.XML_NS_V10)
+            actual = self._prepare_xml(response.body)
+
+            self.assertEqual(expected, actual)
+            self.assertEqual(response.content_type, "application/xml")
+            self.assertEqual(response.headers['Retry-After'], 4)
+
+    def test_413_fault_json(self):
+        """Test fault serialized to JSON via file-extension and/or header."""
+        requests = [
+            webob.Request.blank('/.json'),
+            webob.Request.blank('/', headers={"Accept": "application/json"}),
+        ]
+
+        for request in requests:
+            exc = webob.exc.HTTPRequestEntityTooLarge
+            fault = faults.Fault(exc(explanation='sorry',
+                        headers={'Retry-After': 4}))
+            response = request.get_response(fault)
+
+            expected = {
+                "overLimit": {
+                    "message": "sorry",
+                    "code": 413,
+                    "retryAfter": 4,
+                },
+            }
+            actual = json.loads(response.body)
+
+            self.assertEqual(response.content_type, "application/json")
+            self.assertEqual(expected, actual)
 
     def test_raise(self):
+        """Ensure the ability to raise `Fault`s in WSGI-ified methods."""
         @webob.dec.wsgify
         def raiser(req):
             raise faults.Fault(webob.exc.HTTPNotFound(explanation='whut?'))
+
         req = webob.Request.blank('/.xml')
         resp = req.get_response(raiser)
+        self.assertEqual(resp.content_type, "application/xml")
         self.assertEqual(resp.status_int, 404)
         self.assertTrue('whut?' in resp.body)
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 8280a505f..d1c62e454 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -15,17 +15,42 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import json
 import stubout
 import webob
 
-from nova import test
-import nova.api
+import nova.db.api
 from nova import context
-from nova import db
-from nova.api.openstack import flavors
+from nova import exception
+from nova import test
 from nova.tests.api.openstack import fakes
 
 
+def stub_flavor(flavorid, name, memory_mb="256", local_gb="10"):
+    return {
+        "flavorid": str(flavorid),
+        "name": name,
+        "memory_mb": memory_mb,
+        "local_gb": local_gb,
+    }
+
+
+def return_instance_type_by_flavor_id(context, flavorid):
+    return stub_flavor(flavorid, "flavor %s" % (flavorid,))
+
+
+def return_instance_types(context, num=2):
+    instance_types = {}
+    for i in xrange(1, num + 1):
+        name = "flavor %s" % (i,)
+        instance_types[name] = stub_flavor(i, name)
+    return instance_types
+
+
+def return_instance_type_not_found(context, flavor_id):
+    raise exception.InstanceTypeNotFound(flavor_id=flavor_id)
+
+
 class FlavorsTest(test.TestCase):
     def setUp(self):
         super(FlavorsTest, self).setUp()
@@ -35,18 +60,204 @@ class FlavorsTest(test.TestCase):
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_auth(self.stubs)
+        self.stubs.Set(nova.db.api, "instance_type_get_all",
+                       return_instance_types)
+        self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
+                       return_instance_type_by_flavor_id)
         self.context = context.get_admin_context()
 
     def tearDown(self):
         self.stubs.UnsetAll()
         super(FlavorsTest, self).tearDown()
 
-    def test_get_flavor_list(self):
+    def test_get_flavor_list_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
+        flavors = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+            },
+        ]
+        self.assertEqual(flavors, expected)
+
+    def test_get_flavor_list_detail_v1_0(self):
+        req = webob.Request.blank('/v1.0/flavors/detail')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavors = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "ram": "256",
+                "disk": "10",
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "ram": "256",
+                "disk": "10",
+            },
+        ]
+        self.assertEqual(flavors, expected)
+
+    def test_get_flavor_by_id_v1_0(self):
+        req = webob.Request.blank('/v1.0/flavors/12')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavor"]
+        expected = {
+            "id": "12",
+            "name": "flavor 12",
+            "ram": "256",
+            "disk": "10",
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_by_invalid_id(self):
+        self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
+                       return_instance_type_not_found)
+        req = webob.Request.blank('/v1.0/flavors/asdf')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
+
+    def test_get_flavor_by_id_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors/12')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavor"]
+        expected = {
+            "id": "12",
+            "name": "flavor 12",
+            "ram": "256",
+            "disk": "10",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/json",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/xml",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                ],
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                ],
+            },
+        ]
+        self.assertEqual(flavor, expected)
 
-    def test_get_flavor_by_id(self):
-        req = webob.Request.blank('/v1.0/flavors/1')
+    def test_get_flavor_list_detail_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors/detail')
+        req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "ram": "256",
+                "disk": "10",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                ],
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "ram": "256",
+                "disk": "10",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                ],
+            },
+        ]
+        self.assertEqual(flavor, expected)
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
new file mode 100644
index 000000000..56be0f1cc
--- /dev/null
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -0,0 +1,201 @@
+# 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 json
+import stubout
+import unittest
+import webob
+
+
+from nova import flags
+from nova.api import openstack
+from nova.tests.api.openstack import fakes
+import nova.wsgi
+
+
+FLAGS = flags.FLAGS
+
+
+class ImageMetaDataTest(unittest.TestCase):
+
+    IMAGE_FIXTURES = [
+        {'status': 'active',
+        'name': 'image1',
+        'deleted': False,
+        'container_format': None,
+        'created_at': '2011-03-22T17:40:15',
+        'disk_format': None,
+        'updated_at': '2011-03-22T17:40:15',
+        'id': '1',
+        'location': 'file:///var/lib/glance/images/1',
+        'is_public': True,
+        'deleted_at': None,
+        'properties': {
+            'key1': 'value1',
+            'key2': 'value2'},
+        'size': 5882349},
+        {'status': 'active',
+        'name': 'image2',
+        'deleted': False,
+        'container_format': None,
+        'created_at': '2011-03-22T17:40:15',
+        'disk_format': None,
+        'updated_at': '2011-03-22T17:40:15',
+        'id': '2',
+        'location': 'file:///var/lib/glance/images/2',
+        'is_public': True,
+        'deleted_at': None,
+        'properties': {
+            'key1': 'value1',
+            'key2': 'value2'},
+        'size': 5882349},
+        {'status': 'active',
+        'name': 'image3',
+        'deleted': False,
+        'container_format': None,
+        'created_at': '2011-03-22T17:40:15',
+        'disk_format': None,
+        'updated_at': '2011-03-22T17:40:15',
+        'id': '3',
+        'location': 'file:///var/lib/glance/images/2',
+        'is_public': True,
+        'deleted_at': None,
+        'properties': {},
+        'size': 5882349},
+        ]
+
+    def setUp(self):
+        super(ImageMetaDataTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        self.orig_image_service = FLAGS.image_service
+        FLAGS.image_service = 'nova.image.glance.GlanceImageService'
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
+        # NOTE(dprince) max out properties/metadata in image 3 for testing
+        img3 = self.IMAGE_FIXTURES[2]
+        for num in range(FLAGS.quota_metadata_items):
+            img3['properties']['key%i' % num] = "blah"
+        fakes.stub_out_glance(self.stubs, self.IMAGE_FIXTURES)
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.image_service = self.orig_image_service
+        super(ImageMetaDataTest, self).tearDown()
+
+    def test_index(self):
+        req = webob.Request.blank('/v1.1/images/1/meta')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+
+    def test_show(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['key1'])
+
+    def test_show_not_found(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key9')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(404, res.status_int)
+
+    def test_create(self):
+        req = webob.Request.blank('/v1.1/images/2/meta')
+        req.environ['api.version'] = '1.1'
+        req.method = 'POST'
+        req.body = '{"metadata": {"key9": "value9"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value9', res_dict['metadata']['key9'])
+        # other items should not be modified
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+        self.assertEqual('value2', res_dict['metadata']['key2'])
+        self.assertEqual(1, len(res_dict))
+
+    def test_update_item(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "zz"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('zz', res_dict['key1'])
+
+    def test_update_item_too_many_keys(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1", "key2": "value2"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_update_item_body_uri_mismatch(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/bad')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_delete(self):
+        req = webob.Request.blank('/v1.1/images/2/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+
+    def test_delete_not_found(self):
+        req = webob.Request.blank('/v1.1/images/2/meta/blah')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
+    def test_too_many_metadata_items_on_create(self):
+        data = {"metadata": {}}
+        for num in range(FLAGS.quota_metadata_items + 1):
+            data['metadata']['key%i' % num] = "blah"
+        json_string = str(data).replace("\'", "\"")
+        req = webob.Request.blank('/v1.1/images/2/meta')
+        req.environ['api.version'] = '1.1'
+        req.method = 'POST'
+        req.body = json_string
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_too_many_metadata_items_on_put(self):
+        req = webob.Request.blank('/v1.1/images/3/meta/blah')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"blah": "blah"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 76f758929..2c329f920 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -20,14 +20,18 @@ Tests of the new image services, both as a service layer,
 and as a WSGI layer
 """
 
+import copy
 import json
 import datetime
+import os
 import shutil
 import tempfile
+import xml.dom.minidom as minidom
 
 import stubout
 import webob
 
+from glance import client as glance_client
 from nova import context
 from nova import exception
 from nova import flags
@@ -41,79 +45,62 @@ from nova.tests.api.openstack import fakes
 FLAGS = flags.FLAGS
 
 
-class BaseImageServiceTests(object):
-
+class _BaseImageServiceTests(test.TestCase):
     """Tasks to test for all image services"""
 
-    def test_create(self):
-
-        fixture = {'name': 'test image',
-                   'updated': None,
-                   'created': None,
-                   'status': None,
-                   'instance_id': None,
-                   'progress': None}
+    def __init__(self, *args, **kwargs):
+        super(_BaseImageServiceTests, self).__init__(*args, **kwargs)
+        self.service = None
+        self.context = None
 
+    def test_create(self):
+        fixture = self._make_fixture('test image')
         num_images = len(self.service.index(self.context))
 
-        id = self.service.create(self.context, fixture)['id']
+        image_id = self.service.create(self.context, fixture)['id']
 
-        self.assertNotEquals(None, id)
+        self.assertNotEquals(None, image_id)
         self.assertEquals(num_images + 1,
                           len(self.service.index(self.context)))
 
     def test_create_and_show_non_existing_image(self):
-
-        fixture = {'name': 'test image',
-                   'updated': None,
-                   'created': None,
-                   'status': None,
-                   'instance_id': None,
-                   'progress': None}
-
+        fixture = self._make_fixture('test image')
         num_images = len(self.service.index(self.context))
 
-        id = self.service.create(self.context, fixture)['id']
-
-        self.assertNotEquals(None, id)
+        image_id = self.service.create(self.context, fixture)['id']
 
+        self.assertNotEquals(None, image_id)
         self.assertRaises(exception.NotFound,
                           self.service.show,
                           self.context,
                           'bad image id')
 
-    def test_update(self):
+    def test_create_and_show_non_existing_image_by_name(self):
+        fixture = self._make_fixture('test image')
+        num_images = len(self.service.index(self.context))
 
-        fixture = {'name': 'test image',
-                   'updated': None,
-                   'created': None,
-                   'status': None,
-                   'instance_id': None,
-                   'progress': None}
+        image_id = self.service.create(self.context, fixture)['id']
 
-        id = self.service.create(self.context, fixture)['id']
+        self.assertNotEquals(None, image_id)
+        self.assertRaises(exception.ImageNotFound,
+                          self.service.show_by_name,
+                          self.context,
+                          'bad image id')
 
+    def test_update(self):
+        fixture = self._make_fixture('test image')
+        image_id = self.service.create(self.context, fixture)['id']
         fixture['status'] = 'in progress'
 
-        self.service.update(self.context, id, fixture)
-        new_image_data = self.service.show(self.context, id)
+        self.service.update(self.context, image_id, fixture)
+
+        new_image_data = self.service.show(self.context, image_id)
         self.assertEquals('in progress', new_image_data['status'])
 
     def test_delete(self):
-
-        fixtures = [
-                    {'name': 'test image 1',
-                     'updated': None,
-                     'created': None,
-                     'status': None,
-                     'instance_id': None,
-                     'progress': None},
-                    {'name': 'test image 2',
-                     'updated': None,
-                     'created': None,
-                     'status': None,
-                     'instance_id': None,
-                     'progress': None}]
+        fixture1 = self._make_fixture('test image 1')
+        fixture2 = self._make_fixture('test image 2')
+        fixtures = [fixture1, fixture2]
 
         num_images = len(self.service.index(self.context))
         self.assertEquals(0, num_images, str(self.service.index(self.context)))
@@ -131,9 +118,24 @@ class BaseImageServiceTests(object):
         num_images = len(self.service.index(self.context))
         self.assertEquals(1, num_images)
 
+    def test_index(self):
+        fixture = self._make_fixture('test image')
+        image_id = self.service.create(self.context, fixture)['id']
+        image_metas = self.service.index(self.context)
+        expected = [{'id': 'DONTCARE', 'name': 'test image'}]
+        self.assertDictListMatch(image_metas, expected)
 
-class LocalImageServiceTest(test.TestCase,
-                            BaseImageServiceTests):
+    @staticmethod
+    def _make_fixture(name):
+        fixture = {'name': 'test image',
+                   'updated': None,
+                   'created': None,
+                   'status': None,
+                   'is_public': True}
+        return fixture
+
+
+class LocalImageServiceTest(_BaseImageServiceTests):
 
     """Tests the local image service"""
 
@@ -151,12 +153,31 @@ class LocalImageServiceTest(test.TestCase,
         self.stubs.UnsetAll()
         super(LocalImageServiceTest, self).tearDown()
 
+    def test_get_all_ids_with_incorrect_directory_formats(self):
+        # create some old-style image directories (starting with 'ami-')
+        for x in [1, 2, 3]:
+            tempfile.mkstemp(prefix='ami-', dir=self.tempdir)
+        # create some valid image directories names
+        for x in ["1485baed", "1a60f0ee", "3123a73d"]:
+            os.makedirs(os.path.join(self.tempdir, x))
+        found_image_ids = self.service._ids()
+        self.assertEqual(True, isinstance(found_image_ids, list))
+        self.assertEqual(3, len(found_image_ids), len(found_image_ids))
 
-class GlanceImageServiceTest(test.TestCase,
-                             BaseImageServiceTests):
 
-    """Tests the local image service"""
+class GlanceImageServiceTest(_BaseImageServiceTests):
 
+    """Tests the Glance image service, in particular that metadata translation
+    works properly.
+
+    At a high level, the translations involved are:
+
+        1. Glance -> ImageService - This is needed so we can support
+           multple ImageServices (Glance, Local, etc)
+
+        2. ImageService -> API - This is needed so we can support multple
+           APIs (OpenStack, EC2)
+    """
     def setUp(self):
         super(GlanceImageServiceTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
@@ -164,43 +185,57 @@ class GlanceImageServiceTest(test.TestCase,
         fakes.stub_out_compute_api_snapshot(self.stubs)
         service_class = 'nova.image.glance.GlanceImageService'
         self.service = utils.import_object(service_class)
-        self.context = context.RequestContext(None, None)
+        self.context = context.RequestContext(1, None)
         self.service.delete_all()
+        self.sent_to_glance = {}
+        fakes.stub_out_glance_add_image(self.stubs, self.sent_to_glance)
 
     def tearDown(self):
         self.stubs.UnsetAll()
         super(GlanceImageServiceTest, self).tearDown()
 
+    def test_create_with_instance_id(self):
+        """Ensure instance_id is persisted as an image-property"""
+        fixture = {'name': 'test image',
+                   'is_public': False,
+                   'properties': {'instance_id': '42', 'user_id': '1'}}
 
-class ImageControllerWithGlanceServiceTest(test.TestCase):
+        image_id = self.service.create(self.context, fixture)['id']
+        expected = fixture
+        self.assertDictMatch(self.sent_to_glance['metadata'], expected)
 
-    """Test of the OpenStack API /images application controller"""
-
-    # Registered images at start of each test.
-
-    IMAGE_FIXTURES = [
-        {'id': '23g2ogk23k4hhkk4k42l',
-         'imageId': '23g2ogk23k4hhkk4k42l',
-         'name': 'public image #1',
-         'created_at': str(datetime.datetime.utcnow()),
-         'updated_at': str(datetime.datetime.utcnow()),
-         'deleted_at': None,
-         'deleted': False,
-         'is_public': True,
-         'status': 'available',
-         'image_type': 'kernel'},
-        {'id': 'slkduhfas73kkaskgdas',
-         'imageId': 'slkduhfas73kkaskgdas',
-         'name': 'public image #2',
-         'created_at': str(datetime.datetime.utcnow()),
-         'updated_at': str(datetime.datetime.utcnow()),
-         'deleted_at': None,
-         'deleted': False,
-         'is_public': True,
-         'status': 'available',
-         'image_type': 'ramdisk'}]
+        image_meta = self.service.show(self.context, image_id)
+        expected = {'id': image_id,
+                    'name': 'test image',
+                    'is_public': False,
+                    'properties': {'instance_id': '42', 'user_id': '1'}}
+        self.assertDictMatch(image_meta, expected)
+
+        image_metas = self.service.detail(self.context)
+        self.assertDictMatch(image_metas[0], expected)
+
+    def test_create_without_instance_id(self):
+        """
+        Ensure we can create an image without having to specify an
+        instance_id. Public images are an example of an image not tied to an
+        instance.
+        """
+        fixture = {'name': 'test image'}
+        image_id = self.service.create(self.context, fixture)['id']
+
+        expected = {'name': 'test image', 'properties': {}}
+        self.assertDictMatch(self.sent_to_glance['metadata'], expected)
+
+
+class ImageControllerWithGlanceServiceTest(test.TestCase):
+    """
+    Test of the OpenStack API /images application controller w/Glance.
+    """
+    NOW_GLANCE_FORMAT = "2010-10-11T10:30:22"
+    NOW_API_FORMAT = "2010-10-11T10:30:22Z"
 
     def setUp(self):
+        """Run before each test."""
         super(ImageControllerWithGlanceServiceTest, self).setUp()
         self.orig_image_service = FLAGS.image_service
         FLAGS.image_service = 'nova.image.glance.GlanceImageService'
@@ -211,44 +246,526 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_auth(self.stubs)
         fakes.stub_out_key_pair_funcs(self.stubs)
-        fakes.stub_out_glance(self.stubs, initial_fixtures=self.IMAGE_FIXTURES)
+        self.fixtures = self._make_image_fixtures()
+        fakes.stub_out_glance(self.stubs, initial_fixtures=self.fixtures)
 
     def tearDown(self):
+        """Run after each test."""
         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')
-        res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
-
-        fixture_index = [dict(id=f['id'], name=f['name']) for f
-                         in self.IMAGE_FIXTURES]
+    def _applicable_fixture(self, fixture, user_id):
+        """Determine if this fixture is applicable for given user id."""
+        is_public = fixture["is_public"]
+        try:
+            uid = int(fixture["properties"]["user_id"])
+        except KeyError:
+            uid = None
+        return uid == user_id or is_public
 
-        for image in res_dict['images']:
-            self.assertEquals(1, fixture_index.count(image),
-                              "image %s not in fixture index!" % str(image))
+    def test_get_image_index(self):
+        request = webob.Request.blank('/v1.0/images')
+        response = request.get_response(fakes.wsgi_app())
+
+        response_dict = json.loads(response.body)
+        response_list = response_dict["images"]
+
+        expected = [{'id': 123, 'name': 'public image'},
+                    {'id': 124, 'name': 'queued backup'},
+                    {'id': 125, 'name': 'saving backup'},
+                    {'id': 126, 'name': 'active backup'},
+                    {'id': 127, 'name': 'killed backup'},
+                    {'id': 129, 'name': None}]
+
+        self.assertDictListMatch(response_list, expected)
+
+    def test_get_image(self):
+        request = webob.Request.blank('/v1.0/images/123')
+        response = request.get_response(fakes.wsgi_app())
+
+        self.assertEqual(200, response.status_int)
+
+        actual_image = json.loads(response.body)
+
+        expected_image = {
+            "image": {
+                "id": 123,
+                "name": "public image",
+                "updated": self.NOW_API_FORMAT,
+                "created": self.NOW_API_FORMAT,
+                "status": "ACTIVE",
+            },
+        }
+
+        self.assertEqual(expected_image, actual_image)
+
+    def test_get_image_v1_1(self):
+        request = webob.Request.blank('/v1.1/images/123')
+        response = request.get_response(fakes.wsgi_app())
+
+        actual_image = json.loads(response.body)
+
+        href = "http://localhost/v1.1/images/123"
+
+        expected_image = {
+            "image": {
+                "id": 123,
+                "name": "public image",
+                "updated": self.NOW_API_FORMAT,
+                "created": self.NOW_API_FORMAT,
+                "status": "ACTIVE",
+                "links": [{
+                    "rel": "self",
+                    "href": href,
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/json",
+                    "href": href,
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/xml",
+                    "href": href,
+                }],
+            },
+        }
+
+        self.assertEqual(expected_image, actual_image)
+
+    def test_get_image_xml(self):
+        request = webob.Request.blank('/v1.0/images/123')
+        request.accept = "application/xml"
+        response = request.get_response(fakes.wsgi_app())
+
+        actual_image = minidom.parseString(response.body.replace("  ", ""))
+
+        expected_now = self.NOW_API_FORMAT
+        expected_image = minidom.parseString("""
+            <image id="123"
+                    name="public image"
+                    updated="%(expected_now)s"
+                    created="%(expected_now)s"
+                    status="ACTIVE"
+                    xmlns="http://docs.rackspacecloud.com/servers/api/v1.0" />
+        """ % (locals()))
+
+        self.assertEqual(expected_image.toxml(), actual_image.toxml())
+
+    def test_get_image_xml_no_name(self):
+        request = webob.Request.blank('/v1.0/images/129')
+        request.accept = "application/xml"
+        response = request.get_response(fakes.wsgi_app())
+
+        actual_image = minidom.parseString(response.body.replace("  ", ""))
+
+        expected_now = self.NOW_API_FORMAT
+        expected_image = minidom.parseString("""
+            <image id="129"
+                    name="None"
+                    updated="%(expected_now)s"
+                    created="%(expected_now)s"
+                    status="ACTIVE"
+                    xmlns="http://docs.rackspacecloud.com/servers/api/v1.0" />
+        """ % (locals()))
+
+        self.assertEqual(expected_image.toxml(), actual_image.toxml())
+
+    def test_get_image_v1_1_xml(self):
+        request = webob.Request.blank('/v1.1/images/123')
+        request.accept = "application/xml"
+        response = request.get_response(fakes.wsgi_app())
+
+        actual_image = minidom.parseString(response.body.replace("  ", ""))
+
+        expected_href = "http://localhost/v1.1/images/123"
+        expected_now = self.NOW_API_FORMAT
+        expected_image = minidom.parseString("""
+        <image id="123"
+                name="public image"
+                updated="%(expected_now)s"
+                created="%(expected_now)s"
+                status="ACTIVE"
+                xmlns="http://docs.openstack.org/compute/api/v1.1">
+            <links>
+                <link href="%(expected_href)s" rel="self"/>
+                <link href="%(expected_href)s" rel="bookmark"
+                    type="application/json" />
+                <link href="%(expected_href)s" rel="bookmark"
+                    type="application/xml" />
+            </links>
+        </image>
+        """.replace("  ", "") % (locals()))
+
+        self.assertEqual(expected_image.toxml(), actual_image.toxml())
+
+    def test_get_image_404_json(self):
+        request = webob.Request.blank('/v1.0/images/NonExistantImage')
+        response = request.get_response(fakes.wsgi_app())
+        self.assertEqual(404, response.status_int)
+
+        expected = {
+            "itemNotFound": {
+                "message": "Image not found.",
+                "code": 404,
+            },
+        }
+
+        actual = json.loads(response.body)
+
+        self.assertEqual(expected, actual)
+
+    def test_get_image_404_xml(self):
+        request = webob.Request.blank('/v1.0/images/NonExistantImage')
+        request.accept = "application/xml"
+        response = request.get_response(fakes.wsgi_app())
+        self.assertEqual(404, response.status_int)
+
+        expected = minidom.parseString("""
+            <itemNotFound code="404"
+                    xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
+                <message>
+                    Image not found.
+                </message>
+            </itemNotFound>
+        """.replace("  ", ""))
+
+        actual = minidom.parseString(response.body.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_get_image_404_v1_1_json(self):
+        request = webob.Request.blank('/v1.1/images/NonExistantImage')
+        response = request.get_response(fakes.wsgi_app())
+        self.assertEqual(404, response.status_int)
+
+        expected = {
+            "itemNotFound": {
+                "message": "Image not found.",
+                "code": 404,
+            },
+        }
+
+        actual = json.loads(response.body)
+
+        self.assertEqual(expected, actual)
+
+    def test_get_image_404_v1_1_xml(self):
+        request = webob.Request.blank('/v1.1/images/NonExistantImage')
+        request.accept = "application/xml"
+        response = request.get_response(fakes.wsgi_app())
+        self.assertEqual(404, response.status_int)
+
+        # NOTE(justinsb): I believe this should still use the v1.0 XSD,
+        # because the element hasn't changed definition
+        expected = minidom.parseString("""
+            <itemNotFound code="404"
+                    xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
+                <message>
+                    Image not found.
+                </message>
+            </itemNotFound>
+        """.replace("  ", ""))
+
+        actual = minidom.parseString(response.body.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_get_image_index_v1_1(self):
+        request = webob.Request.blank('/v1.1/images')
+        response = request.get_response(fakes.wsgi_app())
+
+        response_dict = json.loads(response.body)
+        response_list = response_dict["images"]
+
+        fixtures = copy.copy(self.fixtures)
+
+        for image in fixtures:
+            if not self._applicable_fixture(image, 1):
+                fixtures.remove(image)
+                continue
+
+            href = "http://localhost/v1.1/images/%s" % image["id"]
+            test_image = {
+                "id": image["id"],
+                "name": image["name"],
+                "links": [{
+                    "rel": "self",
+                    "href": "http://localhost/v1.1/images/%s" % image["id"],
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/json",
+                    "href": href,
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/xml",
+                    "href": href,
+                }],
+            }
+            self.assertTrue(test_image in response_list)
+
+        self.assertEqual(len(response_list), len(fixtures))
 
     def test_get_image_details(self):
-        req = webob.Request.blank('/v1.0/images/detail')
+        request = webob.Request.blank('/v1.0/images/detail')
+        response = request.get_response(fakes.wsgi_app())
+
+        response_dict = json.loads(response.body)
+        response_list = response_dict["images"]
+
+        expected = [{
+            'id': 123,
+            'name': 'public image',
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'ACTIVE',
+        },
+        {
+            'id': 124,
+            'name': 'queued backup',
+            'serverId': 42,
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'QUEUED',
+        },
+        {
+            'id': 125,
+            'name': 'saving backup',
+            'serverId': 42,
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'SAVING',
+            'progress': 0,
+        },
+        {
+            'id': 126,
+            'name': 'active backup',
+            'serverId': 42,
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'ACTIVE'
+        },
+        {
+            'id': 127,
+            'name': 'killed backup',
+            'serverId': 42,
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'FAILED',
+        },
+        {
+            'id': 129,
+            'name': None,
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'ACTIVE',
+        }]
+
+        self.assertDictListMatch(expected, response_list)
+
+    def test_get_image_details_v1_1(self):
+        request = webob.Request.blank('/v1.1/images/detail')
+        response = request.get_response(fakes.wsgi_app())
+
+        response_dict = json.loads(response.body)
+        response_list = response_dict["images"]
+
+        expected = [{
+            'id': 123,
+            'name': 'public image',
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'ACTIVE',
+            "links": [{
+                "rel": "self",
+                "href": "http://localhost/v1.1/images/123",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/images/123",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/images/123",
+            }],
+        },
+        {
+            'id': 124,
+            'name': 'queued backup',
+            'serverRef': "http://localhost/v1.1/servers/42",
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'QUEUED',
+            "links": [{
+                "rel": "self",
+                "href": "http://localhost/v1.1/images/124",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/images/124",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/images/124",
+            }],
+        },
+        {
+            'id': 125,
+            'name': 'saving backup',
+            'serverRef': "http://localhost/v1.1/servers/42",
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'SAVING',
+            'progress': 0,
+            "links": [{
+                "rel": "self",
+                "href": "http://localhost/v1.1/images/125",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/images/125",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/images/125",
+            }],
+        },
+        {
+            'id': 126,
+            'name': 'active backup',
+            'serverRef': "http://localhost/v1.1/servers/42",
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'ACTIVE',
+            "links": [{
+                "rel": "self",
+                "href": "http://localhost/v1.1/images/126",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/images/126",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/images/126",
+            }],
+        },
+        {
+            'id': 127,
+            'name': 'killed backup',
+            'serverRef': "http://localhost/v1.1/servers/42",
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'FAILED',
+            "links": [{
+                "rel": "self",
+                "href": "http://localhost/v1.1/images/127",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/images/127",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/images/127",
+            }],
+        },
+        {
+            'id': 129,
+            'name': None,
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'ACTIVE',
+            "links": [{
+                "rel": "self",
+                "href": "http://localhost/v1.1/images/129",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/images/129",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/images/129",
+            }],
+        },
+        ]
+
+        self.assertDictListMatch(expected, response_list)
+
+    def test_get_image_found(self):
+        req = webob.Request.blank('/v1.0/images/123')
+        res = req.get_response(fakes.wsgi_app())
+        image_meta = json.loads(res.body)['image']
+        expected = {'id': 123, 'name': 'public image',
+                    'updated': self.NOW_API_FORMAT,
+                    'created': self.NOW_API_FORMAT, 'status': 'ACTIVE'}
+        self.assertDictMatch(image_meta, expected)
+
+    def test_get_image_non_existent(self):
+        req = webob.Request.blank('/v1.0/images/4242')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
+
+    def test_get_image_not_owned(self):
+        """We should return a 404 if we request an image that doesn't belong
+        to us
+        """
+        req = webob.Request.blank('/v1.0/images/128')
         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))
+        self.assertEqual(res.status_int, 404)
+
+    @classmethod
+    def _make_image_fixtures(cls):
+        image_id = 123
+        base_attrs = {'created_at': cls.NOW_GLANCE_FORMAT,
+                      'updated_at': cls.NOW_GLANCE_FORMAT,
+                      'deleted_at': None,
+                      'deleted': False}
+
+        fixtures = []
+
+        def add_fixture(**kwargs):
+            kwargs.update(base_attrs)
+            fixtures.append(kwargs)
+
+        # Public image
+        add_fixture(id=image_id, name='public image', is_public=True,
+                    status='active', properties={})
+        image_id += 1
+
+        # Backup for User 1
+        backup_properties = {'instance_id': '42', 'user_id': '1'}
+        for status in ('queued', 'saving', 'active', 'killed'):
+            add_fixture(id=image_id, name='%s backup' % status,
+                        is_public=False, status=status,
+                        properties=backup_properties)
+            image_id += 1
+
+        # Backup for User 2
+        other_backup_properties = {'instance_id': '43', 'user_id': '2'}
+        add_fixture(id=image_id, name='someone elses backup', is_public=False,
+                    status='active', properties=other_backup_properties)
+        image_id += 1
+
+        # Image without a name
+        add_fixture(id=image_id, is_public=True, status='active',
+                    properties={})
+        image_id += 1
+
+        return fixtures
diff --git a/nova/tests/api/openstack/test_limits.py b/nova/tests/api/openstack/test_limits.py
new file mode 100644
index 000000000..45bd4d501
--- /dev/null
+++ b/nova/tests/api/openstack/test_limits.py
@@ -0,0 +1,685 @@
+# 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.
+
+"""
+Tests dealing with HTTP rate-limiting.
+"""
+
+import httplib
+import json
+import StringIO
+import stubout
+import time
+import unittest
+import webob
+
+from xml.dom.minidom import parseString
+
+from nova.api.openstack import limits
+
+
+TEST_LIMITS = [
+    limits.Limit("GET", "/delayed", "^/delayed", 1, limits.PER_MINUTE),
+    limits.Limit("POST", "*", ".*", 7, limits.PER_MINUTE),
+    limits.Limit("POST", "/servers", "^/servers", 3, limits.PER_MINUTE),
+    limits.Limit("PUT", "*", "", 10, limits.PER_MINUTE),
+    limits.Limit("PUT", "/servers", "^/servers", 5, limits.PER_MINUTE),
+]
+
+
+class BaseLimitTestSuite(unittest.TestCase):
+    """Base test suite which provides relevant stubs and time abstraction."""
+
+    def setUp(self):
+        """Run before each test."""
+        self.time = 0.0
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(limits.Limit, "_get_time", self._get_time)
+
+    def tearDown(self):
+        """Run after each test."""
+        self.stubs.UnsetAll()
+
+    def _get_time(self):
+        """Return the "time" according to this test suite."""
+        return self.time
+
+
+class LimitsControllerV10Test(BaseLimitTestSuite):
+    """
+    Tests for `limits.LimitsControllerV10` class.
+    """
+
+    def setUp(self):
+        """Run before each test."""
+        BaseLimitTestSuite.setUp(self)
+        self.controller = limits.LimitsControllerV10()
+
+    def _get_index_request(self, accept_header="application/json"):
+        """Helper to set routing arguments."""
+        request = webob.Request.blank("/")
+        request.accept = accept_header
+        request.environ["wsgiorg.routing_args"] = (None, {
+            "action": "index",
+            "controller": "",
+        })
+        return request
+
+    def _populate_limits(self, request):
+        """Put limit info into a request."""
+        _limits = [
+            limits.Limit("GET", "*", ".*", 10, 60).display(),
+            limits.Limit("POST", "*", ".*", 5, 60 * 60).display(),
+        ]
+        request.environ["nova.limits"] = _limits
+        return request
+
+    def test_empty_index_json(self):
+        """Test getting empty limit details in JSON."""
+        request = self._get_index_request()
+        response = request.get_response(self.controller)
+        expected = {
+            "limits": {
+                "rate": [],
+                "absolute": {},
+            },
+        }
+        body = json.loads(response.body)
+        self.assertEqual(expected, body)
+
+    def test_index_json(self):
+        """Test getting limit details in JSON."""
+        request = self._get_index_request()
+        request = self._populate_limits(request)
+        response = request.get_response(self.controller)
+        expected = {
+            "limits": {
+                "rate": [{
+                    "regex": ".*",
+                    "resetTime": 0,
+                    "URI": "*",
+                    "value": 10,
+                    "verb": "GET",
+                    "remaining": 10,
+                    "unit": "MINUTE",
+                },
+                {
+                    "regex": ".*",
+                    "resetTime": 0,
+                    "URI": "*",
+                    "value": 5,
+                    "verb": "POST",
+                    "remaining": 5,
+                    "unit": "HOUR",
+                }],
+                "absolute": {},
+            },
+        }
+        body = json.loads(response.body)
+        self.assertEqual(expected, body)
+
+    def test_empty_index_xml(self):
+        """Test getting limit details in XML."""
+        request = self._get_index_request("application/xml")
+        response = request.get_response(self.controller)
+
+        expected = parseString("""
+            <limits
+                xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
+                <rate/>
+                <absolute/>
+            </limits>
+        """.replace("  ", ""))
+
+        body = parseString(response.body.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), body.toxml())
+
+    def test_index_xml(self):
+        """Test getting limit details in XML."""
+        request = self._get_index_request("application/xml")
+        request = self._populate_limits(request)
+        response = request.get_response(self.controller)
+
+        expected = parseString("""
+            <limits
+                xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
+                <rate>
+                    <limit URI="*" regex=".*" remaining="10" resetTime="0"
+                        unit="MINUTE" value="10" verb="GET"/>
+                    <limit URI="*" regex=".*" remaining="5" resetTime="0"
+                        unit="HOUR" value="5" verb="POST"/>
+                </rate>
+                <absolute/>
+            </limits>
+        """.replace("  ", ""))
+        body = parseString(response.body.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), body.toxml())
+
+
+class LimitsControllerV11Test(BaseLimitTestSuite):
+    """
+    Tests for `limits.LimitsControllerV11` class.
+    """
+
+    def setUp(self):
+        """Run before each test."""
+        BaseLimitTestSuite.setUp(self)
+        self.controller = limits.LimitsControllerV11()
+
+    def _get_index_request(self, accept_header="application/json"):
+        """Helper to set routing arguments."""
+        request = webob.Request.blank("/")
+        request.accept = accept_header
+        request.environ["wsgiorg.routing_args"] = (None, {
+            "action": "index",
+            "controller": "",
+        })
+        return request
+
+    def _populate_limits(self, request):
+        """Put limit info into a request."""
+        _limits = [
+            limits.Limit("GET", "*", ".*", 10, 60).display(),
+            limits.Limit("POST", "*", ".*", 5, 60 * 60).display(),
+            limits.Limit("GET", "changes-since*", "changes-since",
+                         5, 60).display(),
+        ]
+        request.environ["nova.limits"] = _limits
+        return request
+
+    def test_empty_index_json(self):
+        """Test getting empty limit details in JSON."""
+        request = self._get_index_request()
+        response = request.get_response(self.controller)
+        expected = {
+            "limits": {
+                "rate": [],
+                "absolute": {},
+            },
+        }
+        body = json.loads(response.body)
+        self.assertEqual(expected, body)
+
+    def test_index_json(self):
+        """Test getting limit details in JSON."""
+        request = self._get_index_request()
+        request = self._populate_limits(request)
+        response = request.get_response(self.controller)
+        expected = {
+            "limits": {
+                "rate": [
+                    {
+                        "regex": ".*",
+                        "uri": "*",
+                        "limit": [
+                            {
+                                "verb": "GET",
+                                "next-available": 0,
+                                "unit": "MINUTE",
+                                "value": 10,
+                                "remaining": 10,
+                            },
+                            {
+                                "verb": "POST",
+                                "next-available": 0,
+                                "unit": "HOUR",
+                                "value": 5,
+                                "remaining": 5,
+                            },
+                        ],
+                    },
+                    {
+                        "regex": "changes-since",
+                        "uri": "changes-since*",
+                        "limit": [
+                            {
+                                "verb": "GET",
+                                "next-available": 0,
+                                "unit": "MINUTE",
+                                "value": 5,
+                                "remaining": 5,
+                            },
+                        ],
+                    },
+
+                ],
+                "absolute": {},
+            },
+        }
+        body = json.loads(response.body)
+        self.assertEqual(expected, body)
+
+
+class LimitMiddlewareTest(BaseLimitTestSuite):
+    """
+    Tests for the `limits.RateLimitingMiddleware` class.
+    """
+
+    @webob.dec.wsgify
+    def _empty_app(self, request):
+        """Do-nothing WSGI app."""
+        pass
+
+    def setUp(self):
+        """Prepare middleware for use through fake WSGI app."""
+        BaseLimitTestSuite.setUp(self)
+        _limits = [
+            limits.Limit("GET", "*", ".*", 1, 60),
+        ]
+        self.app = limits.RateLimitingMiddleware(self._empty_app, _limits)
+
+    def test_good_request(self):
+        """Test successful GET request through middleware."""
+        request = webob.Request.blank("/")
+        response = request.get_response(self.app)
+        self.assertEqual(200, response.status_int)
+
+    def test_limited_request_json(self):
+        """Test a rate-limited (403) GET request through middleware."""
+        request = webob.Request.blank("/")
+        response = request.get_response(self.app)
+        self.assertEqual(200, response.status_int)
+
+        request = webob.Request.blank("/")
+        response = request.get_response(self.app)
+        self.assertEqual(response.status_int, 403)
+
+        body = json.loads(response.body)
+        expected = "Only 1 GET request(s) can be made to * every minute."
+        value = body["overLimitFault"]["details"].strip()
+        self.assertEqual(value, expected)
+
+    def test_limited_request_xml(self):
+        """Test a rate-limited (403) response as XML"""
+        request = webob.Request.blank("/")
+        response = request.get_response(self.app)
+        self.assertEqual(200, response.status_int)
+
+        request = webob.Request.blank("/")
+        request.accept = "application/xml"
+        response = request.get_response(self.app)
+        self.assertEqual(response.status_int, 403)
+
+        root = parseString(response.body).childNodes[0]
+        expected = "Only 1 GET request(s) can be made to * every minute."
+
+        details = root.getElementsByTagName("details")
+        self.assertEqual(details.length, 1)
+
+        value = details.item(0).firstChild.data.strip()
+        self.assertEqual(value, expected)
+
+
+class LimitTest(BaseLimitTestSuite):
+    """
+    Tests for the `limits.Limit` class.
+    """
+
+    def test_GET_no_delay(self):
+        """Test a limit handles 1 GET per second."""
+        limit = limits.Limit("GET", "*", ".*", 1, 1)
+        delay = limit("GET", "/anything")
+        self.assertEqual(None, delay)
+        self.assertEqual(0, limit.next_request)
+        self.assertEqual(0, limit.last_request)
+
+    def test_GET_delay(self):
+        """Test two calls to 1 GET per second limit."""
+        limit = limits.Limit("GET", "*", ".*", 1, 1)
+        delay = limit("GET", "/anything")
+        self.assertEqual(None, delay)
+
+        delay = limit("GET", "/anything")
+        self.assertEqual(1, delay)
+        self.assertEqual(1, limit.next_request)
+        self.assertEqual(0, limit.last_request)
+
+        self.time += 4
+
+        delay = limit("GET", "/anything")
+        self.assertEqual(None, delay)
+        self.assertEqual(4, limit.next_request)
+        self.assertEqual(4, limit.last_request)
+
+
+class LimiterTest(BaseLimitTestSuite):
+    """
+    Tests for the in-memory `limits.Limiter` class.
+    """
+
+    def setUp(self):
+        """Run before each test."""
+        BaseLimitTestSuite.setUp(self)
+        self.limiter = limits.Limiter(TEST_LIMITS)
+
+    def _check(self, num, verb, url, username=None):
+        """Check and yield results from checks."""
+        for x in xrange(num):
+            yield self.limiter.check_for_delay(verb, url, username)[0]
+
+    def _check_sum(self, num, verb, url, username=None):
+        """Check and sum results from checks."""
+        results = self._check(num, verb, url, username)
+        return sum(item for item in results if item)
+
+    def test_no_delay_GET(self):
+        """
+        Simple test to ensure no delay on a single call for a limit verb we
+        didn"t set.
+        """
+        delay = self.limiter.check_for_delay("GET", "/anything")
+        self.assertEqual(delay, (None, None))
+
+    def test_no_delay_PUT(self):
+        """
+        Simple test to ensure no delay on a single call for a known limit.
+        """
+        delay = self.limiter.check_for_delay("PUT", "/anything")
+        self.assertEqual(delay, (None, None))
+
+    def test_delay_PUT(self):
+        """
+        Ensure the 11th PUT will result in a delay of 6.0 seconds until
+        the next request will be granced.
+        """
+        expected = [None] * 10 + [6.0]
+        results = list(self._check(11, "PUT", "/anything"))
+
+        self.assertEqual(expected, results)
+
+    def test_delay_POST(self):
+        """
+        Ensure the 8th POST will result in a delay of 6.0 seconds until
+        the next request will be granced.
+        """
+        expected = [None] * 7
+        results = list(self._check(7, "POST", "/anything"))
+        self.assertEqual(expected, results)
+
+        expected = 60.0 / 7.0
+        results = self._check_sum(1, "POST", "/anything")
+        self.failUnlessAlmostEqual(expected, results, 8)
+
+    def test_delay_GET(self):
+        """
+        Ensure the 11th GET will result in NO delay.
+        """
+        expected = [None] * 11
+        results = list(self._check(11, "GET", "/anything"))
+
+        self.assertEqual(expected, results)
+
+    def test_delay_PUT_servers(self):
+        """
+        Ensure PUT on /servers limits at 5 requests, and PUT elsewhere is still
+        OK after 5 requests...but then after 11 total requests, PUT limiting
+        kicks in.
+        """
+        # First 6 requests on PUT /servers
+        expected = [None] * 5 + [12.0]
+        results = list(self._check(6, "PUT", "/servers"))
+        self.assertEqual(expected, results)
+
+        # Next 5 request on PUT /anything
+        expected = [None] * 4 + [6.0]
+        results = list(self._check(5, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_delay_PUT_wait(self):
+        """
+        Ensure after hitting the limit and then waiting for the correct
+        amount of time, the limit will be lifted.
+        """
+        expected = [None] * 10 + [6.0]
+        results = list(self._check(11, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+        # Advance time
+        self.time += 6.0
+
+        expected = [None, 6.0]
+        results = list(self._check(2, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_multiple_delays(self):
+        """
+        Ensure multiple requests still get a delay.
+        """
+        expected = [None] * 10 + [6.0] * 10
+        results = list(self._check(20, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        expected = [5.0] * 10
+        results = list(self._check(10, "PUT", "/anything"))
+        self.assertEqual(expected, results)
+
+    def test_multiple_users(self):
+        """
+        Tests involving multiple users.
+        """
+        # User1
+        expected = [None] * 10 + [6.0] * 10
+        results = list(self._check(20, "PUT", "/anything", "user1"))
+        self.assertEqual(expected, results)
+
+        # User2
+        expected = [None] * 10 + [6.0] * 5
+        results = list(self._check(15, "PUT", "/anything", "user2"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        # User1 again
+        expected = [5.0] * 10
+        results = list(self._check(10, "PUT", "/anything", "user1"))
+        self.assertEqual(expected, results)
+
+        self.time += 1.0
+
+        # User1 again
+        expected = [4.0] * 5
+        results = list(self._check(5, "PUT", "/anything", "user2"))
+        self.assertEqual(expected, results)
+
+
+class WsgiLimiterTest(BaseLimitTestSuite):
+    """
+    Tests for `limits.WsgiLimiter` class.
+    """
+
+    def setUp(self):
+        """Run before each test."""
+        BaseLimitTestSuite.setUp(self)
+        self.app = limits.WsgiLimiter(TEST_LIMITS)
+
+    def _request_data(self, verb, path):
+        """Get data decribing a limit request verb/path."""
+        return json.dumps({"verb": verb, "path": path})
+
+    def _request(self, verb, url, username=None):
+        """Make sure that POSTing to the given url causes the given username
+        to perform the given action.  Make the internal rate limiter return
+        delay and make sure that the WSGI app returns the correct response.
+        """
+        if username:
+            request = webob.Request.blank("/%s" % username)
+        else:
+            request = webob.Request.blank("/")
+
+        request.method = "POST"
+        request.body = self._request_data(verb, url)
+        response = request.get_response(self.app)
+
+        if "X-Wait-Seconds" in response.headers:
+            self.assertEqual(response.status_int, 403)
+            return response.headers["X-Wait-Seconds"]
+
+        self.assertEqual(response.status_int, 204)
+
+    def test_invalid_methods(self):
+        """Only POSTs should work."""
+        requests = []
+        for method in ["GET", "PUT", "DELETE", "HEAD", "OPTIONS"]:
+            request = webob.Request.blank("/")
+            request.body = self._request_data("GET", "/something")
+            response = request.get_response(self.app)
+            self.assertEqual(response.status_int, 405)
+
+    def test_good_url(self):
+        delay = self._request("GET", "/something")
+        self.assertEqual(delay, None)
+
+    def test_escaping(self):
+        delay = self._request("GET", "/something/jump%20up")
+        self.assertEqual(delay, None)
+
+    def test_response_to_delays(self):
+        delay = self._request("GET", "/delayed")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed")
+        self.assertEqual(delay, '60.00')
+
+    def test_response_to_delays_usernames(self):
+        delay = self._request("GET", "/delayed", "user1")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed", "user2")
+        self.assertEqual(delay, None)
+
+        delay = self._request("GET", "/delayed", "user1")
+        self.assertEqual(delay, '60.00')
+
+        delay = self._request("GET", "/delayed", "user2")
+        self.assertEqual(delay, '60.00')
+
+
+class FakeHttplibSocket(object):
+    """
+    Fake `httplib.HTTPResponse` replacement.
+    """
+
+    def __init__(self, response_string):
+        """Initialize new `FakeHttplibSocket`."""
+        self._buffer = StringIO.StringIO(response_string)
+
+    def makefile(self, _mode, _other):
+        """Returns the socket's internal buffer."""
+        return self._buffer
+
+
+class FakeHttplibConnection(object):
+    """
+    Fake `httplib.HTTPConnection`.
+    """
+
+    def __init__(self, app, host):
+        """
+        Initialize `FakeHttplibConnection`.
+        """
+        self.app = app
+        self.host = host
+
+    def request(self, method, path, body="", headers={}):
+        """
+        Requests made via this connection actually get translated and routed
+        into our WSGI app, we then wait for the response and turn it back into
+        an `httplib.HTTPResponse`.
+        """
+        req = webob.Request.blank(path)
+        req.method = method
+        req.headers = headers
+        req.host = self.host
+        req.body = body
+
+        resp = str(req.get_response(self.app))
+        resp = "HTTP/1.0 %s" % resp
+        sock = FakeHttplibSocket(resp)
+        self.http_response = httplib.HTTPResponse(sock)
+        self.http_response.begin()
+
+    def getresponse(self):
+        """Return our generated response from the request."""
+        return self.http_response
+
+
+def wire_HTTPConnection_to_WSGI(host, app):
+    """Monkeypatches HTTPConnection so that if you try to connect to host, you
+    are instead routed straight to the given WSGI app.
+
+    After calling this method, when any code calls
+
+    httplib.HTTPConnection(host)
+
+    the connection object will be a fake.  Its requests will be sent directly
+    to the given WSGI app rather than through a socket.
+
+    Code connecting to hosts other than host will not be affected.
+
+    This method may be called multiple times to map different hosts to
+    different apps.
+    """
+    class HTTPConnectionDecorator(object):
+        """Wraps the real HTTPConnection class so that when you instantiate
+        the class you might instead get a fake instance."""
+
+        def __init__(self, wrapped):
+            self.wrapped = wrapped
+
+        def __call__(self, connection_host, *args, **kwargs):
+            if connection_host == host:
+                return FakeHttplibConnection(app, host)
+            else:
+                return self.wrapped(connection_host, *args, **kwargs)
+
+    httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
+
+
+class WsgiLimiterProxyTest(BaseLimitTestSuite):
+    """
+    Tests for the `limits.WsgiLimiterProxy` class.
+    """
+
+    def setUp(self):
+        """
+        Do some nifty HTTP/WSGI magic which allows for WSGI to be called
+        directly by something like the `httplib` library.
+        """
+        BaseLimitTestSuite.setUp(self)
+        self.app = limits.WsgiLimiter(TEST_LIMITS)
+        wire_HTTPConnection_to_WSGI("169.254.0.1:80", self.app)
+        self.proxy = limits.WsgiLimiterProxy("169.254.0.1:80")
+
+    def test_200(self):
+        """Successful request test."""
+        delay = self.proxy.check_for_delay("GET", "/anything")
+        self.assertEqual(delay, (None, None))
+
+    def test_403(self):
+        """Forbidden request test."""
+        delay = self.proxy.check_for_delay("GET", "/delayed")
+        self.assertEqual(delay, (None, None))
+
+        delay, error = self.proxy.check_for_delay("GET", "/delayed")
+        error = error.strip()
+
+        expected = ("60.00", "403 Forbidden\n\nOnly 1 GET request(s) can be "\
+            "made to /delayed every minute.")
+
+        self.assertEqual((delay, error), expected)
diff --git a/nova/tests/api/openstack/test_ratelimiting.py b/nova/tests/api/openstack/test_ratelimiting.py
deleted file mode 100644
index 9ae90ee20..000000000
--- a/nova/tests/api/openstack/test_ratelimiting.py
+++ /dev/null
@@ -1,243 +0,0 @@
-import httplib
-import StringIO
-import time
-import webob
-
-from nova import test
-import nova.api.openstack.ratelimiting as ratelimiting
-
-
-class LimiterTest(test.TestCase):
-
-    def setUp(self):
-        super(LimiterTest, self).setUp()
-        self.limits = {
-                'a': (5, ratelimiting.PER_SECOND),
-                'b': (5, ratelimiting.PER_MINUTE),
-                'c': (5, ratelimiting.PER_HOUR),
-                'd': (1, ratelimiting.PER_SECOND),
-                'e': (100, ratelimiting.PER_SECOND)}
-        self.rl = ratelimiting.Limiter(self.limits)
-
-    def exhaust(self, action, times_until_exhausted, **kwargs):
-        for i in range(times_until_exhausted):
-            when = self.rl.perform(action, **kwargs)
-            self.assertEqual(when, None)
-        num, period = self.limits[action]
-        delay = period * 1.0 / num
-        # Verify that we are now thoroughly delayed
-        for i in range(10):
-            when = self.rl.perform(action, **kwargs)
-            self.assertAlmostEqual(when, delay, 2)
-
-    def test_second(self):
-        self.exhaust('a', 5)
-        time.sleep(0.2)
-        self.exhaust('a', 1)
-        time.sleep(1)
-        self.exhaust('a', 5)
-
-    def test_minute(self):
-        self.exhaust('b', 5)
-
-    def test_one_per_period(self):
-        def allow_once_and_deny_once():
-            when = self.rl.perform('d')
-            self.assertEqual(when, None)
-            when = self.rl.perform('d')
-            self.assertAlmostEqual(when, 1, 2)
-            return when
-        time.sleep(allow_once_and_deny_once())
-        time.sleep(allow_once_and_deny_once())
-        allow_once_and_deny_once()
-
-    def test_we_can_go_indefinitely_if_we_spread_out_requests(self):
-        for i in range(200):
-            when = self.rl.perform('e')
-            self.assertEqual(when, None)
-            time.sleep(0.01)
-
-    def test_users_get_separate_buckets(self):
-        self.exhaust('c', 5, username='alice')
-        self.exhaust('c', 5, username='bob')
-        self.exhaust('c', 5, username='chuck')
-        self.exhaust('c', 0, username='chuck')
-        self.exhaust('c', 0, username='bob')
-        self.exhaust('c', 0, username='alice')
-
-
-class FakeLimiter(object):
-    """Fake Limiter class that you can tell how to behave."""
-
-    def __init__(self, test):
-        self._action = self._username = self._delay = None
-        self.test = test
-
-    def mock(self, action, username, delay):
-        self._action = action
-        self._username = username
-        self._delay = delay
-
-    def perform(self, action, username):
-        self.test.assertEqual(action, self._action)
-        self.test.assertEqual(username, self._username)
-        return self._delay
-
-
-class WSGIAppTest(test.TestCase):
-
-    def setUp(self):
-        super(WSGIAppTest, self).setUp()
-        self.limiter = FakeLimiter(self)
-        self.app = ratelimiting.WSGIApp(self.limiter)
-
-    def test_invalid_methods(self):
-        requests = []
-        for method in ['GET', 'PUT', 'DELETE']:
-            req = webob.Request.blank('/limits/michael/breakdance',
-                                      dict(REQUEST_METHOD=method))
-            requests.append(req)
-        for req in requests:
-            self.assertEqual(req.get_response(self.app).status_int, 405)
-
-    def test_invalid_urls(self):
-        requests = []
-        for prefix in ['limit', '', 'limiter2', 'limiter/limits', 'limiter/1']:
-            req = webob.Request.blank('/%s/michael/breakdance' % prefix,
-                                      dict(REQUEST_METHOD='POST'))
-        requests.append(req)
-        for req in requests:
-            self.assertEqual(req.get_response(self.app).status_int, 404)
-
-    def verify(self, url, username, action, delay=None):
-        """Make sure that POSTing to the given url causes the given username
-        to perform the given action.  Make the internal rate limiter return
-        delay and make sure that the WSGI app returns the correct response.
-        """
-        req = webob.Request.blank(url, dict(REQUEST_METHOD='POST'))
-        self.limiter.mock(action, username, delay)
-        resp = req.get_response(self.app)
-        if not delay:
-            self.assertEqual(resp.status_int, 200)
-        else:
-            self.assertEqual(resp.status_int, 403)
-            self.assertEqual(resp.headers['X-Wait-Seconds'], "%.2f" % delay)
-
-    def test_good_urls(self):
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot')
-
-    def test_escaping(self):
-        self.verify('/limiter/michael/jump%20up', 'michael', 'jump up')
-
-    def test_response_to_delays(self):
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1)
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1.56)
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1000)
-
-
-class FakeHttplibSocket(object):
-    """a fake socket implementation for httplib.HTTPResponse, trivial"""
-
-    def __init__(self, response_string):
-        self._buffer = StringIO.StringIO(response_string)
-
-    def makefile(self, _mode, _other):
-        """Returns the socket's internal buffer"""
-        return self._buffer
-
-
-class FakeHttplibConnection(object):
-    """A fake httplib.HTTPConnection
-
-    Requests made via this connection actually get translated and routed into
-    our WSGI app, we then wait for the response and turn it back into
-    an httplib.HTTPResponse.
-    """
-    def __init__(self, app, host, is_secure=False):
-        self.app = app
-        self.host = host
-
-    def request(self, method, path, data='', headers={}):
-        req = webob.Request.blank(path)
-        req.method = method
-        req.body = data
-        req.headers = headers
-        req.host = self.host
-        # Call the WSGI app, get the HTTP response
-        resp = str(req.get_response(self.app))
-        # For some reason, the response doesn't have "HTTP/1.0 " prepended; I
-        # guess that's a function the web server usually provides.
-        resp = "HTTP/1.0 %s" % resp
-        sock = FakeHttplibSocket(resp)
-        self.http_response = httplib.HTTPResponse(sock)
-        self.http_response.begin()
-
-    def getresponse(self):
-        return self.http_response
-
-
-def wire_HTTPConnection_to_WSGI(host, app):
-    """Monkeypatches HTTPConnection so that if you try to connect to host, you
-    are instead routed straight to the given WSGI app.
-
-    After calling this method, when any code calls
-
-    httplib.HTTPConnection(host)
-
-    the connection object will be a fake.  Its requests will be sent directly
-    to the given WSGI app rather than through a socket.
-
-    Code connecting to hosts other than host will not be affected.
-
-    This method may be called multiple times to map different hosts to
-    different apps.
-    """
-    class HTTPConnectionDecorator(object):
-        """Wraps the real HTTPConnection class so that when you instantiate
-        the class you might instead get a fake instance."""
-
-        def __init__(self, wrapped):
-            self.wrapped = wrapped
-
-        def __call__(self, connection_host, *args, **kwargs):
-            if connection_host == host:
-                return FakeHttplibConnection(app, host)
-            else:
-                return self.wrapped(connection_host, *args, **kwargs)
-
-    httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
-
-
-class WSGIAppProxyTest(test.TestCase):
-
-    def setUp(self):
-        """Our WSGIAppProxy is going to call across an HTTPConnection to a
-        WSGIApp running a limiter.  The proxy will send input, and the proxy
-        should receive that same input, pass it to the limiter who gives a
-        result, and send the expected result back.
-
-        The HTTPConnection isn't real -- it's monkeypatched to point straight
-        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)
-        self.proxy = ratelimiting.WSGIAppProxy('100.100.100.100:80')
-
-    def test_200(self):
-        self.limiter.mock('conquer', 'caesar', None)
-        when = self.proxy.perform('conquer', 'caesar')
-        self.assertEqual(when, None)
-
-    def test_403(self):
-        self.limiter.mock('grumble', 'proletariat', 1.5)
-        when = self.proxy.perform('grumble', 'proletariat')
-        self.assertEqual(when, 1.5)
-
-    def test_failure(self):
-        def shouldRaise():
-            self.limiter.mock('murder', 'brutus', None)
-            self.proxy.perform('stab', 'brutus')
-        self.assertRaises(AssertionError, shouldRaise)
diff --git a/nova/tests/api/openstack/test_server_metadata.py b/nova/tests/api/openstack/test_server_metadata.py
new file mode 100644
index 000000000..c4d1d4fd8
--- /dev/null
+++ b/nova/tests/api/openstack/test_server_metadata.py
@@ -0,0 +1,204 @@
+# 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 json
+import stubout
+import unittest
+import webob
+
+
+from nova import flags
+from nova.api import openstack
+from nova.tests.api.openstack import fakes
+import nova.wsgi
+
+
+FLAGS = flags.FLAGS
+
+
+def return_create_instance_metadata_max(context, server_id, metadata):
+    return stub_max_server_metadata()
+
+
+def return_create_instance_metadata(context, server_id, metadata):
+    return stub_server_metadata()
+
+
+def return_server_metadata(context, server_id):
+    return stub_server_metadata()
+
+
+def return_empty_server_metadata(context, server_id):
+    return {}
+
+
+def delete_server_metadata(context, server_id, key):
+    pass
+
+
+def stub_server_metadata():
+    metadata = {
+            "key1": "value1",
+            "key2": "value2",
+            "key3": "value3",
+            "key4": "value4",
+            "key5": "value5"}
+    return metadata
+
+
+def stub_max_server_metadata():
+    metadata = {"metadata": {}}
+    for num in range(FLAGS.quota_metadata_items):
+        metadata['metadata']['key%i' % num] = "blah"
+    return metadata
+
+
+class ServerMetaDataTest(unittest.TestCase):
+
+    def setUp(self):
+        super(ServerMetaDataTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
+        fakes.stub_out_key_pair_funcs(self.stubs)
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        super(ServerMetaDataTest, self).tearDown()
+
+    def test_index(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_get',
+                       return_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+
+    def test_index_no_data(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_get',
+                       return_empty_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual(0, len(res_dict['metadata']))
+
+    def test_show(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_get',
+                       return_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value5', res_dict['key5'])
+
+    def test_show_meta_not_found(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_get',
+                       return_empty_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key6')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(404, res.status_int)
+
+    def test_delete(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_delete',
+                       delete_server_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+
+    def test_create(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
+                       return_create_instance_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta')
+        req.environ['api.version'] = '1.1'
+        req.method = 'POST'
+        req.body = '{"metadata": {"key1": "value1"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+
+    def test_update_item(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
+                       return_create_instance_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('value1', res_dict['key1'])
+
+    def test_update_item_too_many_keys(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
+                       return_create_instance_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1", "key2": "value2"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_update_item_body_uri_mismatch(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
+                       return_create_instance_metadata)
+        req = webob.Request.blank('/v1.1/servers/1/meta/bad')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_too_many_metadata_items_on_create(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
+                       return_create_instance_metadata)
+        data = {"metadata": {}}
+        for num in range(FLAGS.quota_metadata_items + 1):
+            data['metadata']['key%i' % num] = "blah"
+        json_string = str(data).replace("\'", "\"")
+        req = webob.Request.blank('/v1.1/servers/1/meta')
+        req.environ['api.version'] = '1.1'
+        req.method = 'POST'
+        req.body = json_string
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_to_many_metadata_items_on_update_item(self):
+        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
+                       return_create_instance_metadata_max)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"a new key": "a new value"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 5d7a208e9..89edece42 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -15,18 +15,25 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import base64
 import datetime
 import json
+import unittest
+from xml.dom import minidom
 
 import stubout
 import webob
 
+from nova import context
 from nova import db
+from nova import exception
 from nova import flags
 from nova import test
 import nova.api.openstack
 from nova.api.openstack import servers
 import nova.compute.api
+from nova.compute import instance_types
+from nova.compute import power_state
 import nova.db.api
 from nova.db.sqlalchemy.models import Instance
 from nova.db.sqlalchemy.models import InstanceMetadata
@@ -50,6 +57,12 @@ def return_server_with_addresses(private, public):
     return _return_server
 
 
+def return_server_with_power_state(power_state):
+    def _return_server(context, id):
+        return stub_instance(id, power_state=power_state)
+    return _return_server
+
+
 def return_servers(context, user_id=1):
     return [stub_instance(i, user_id) for i in xrange(5)]
 
@@ -66,32 +79,38 @@ def instance_address(context, instance_id):
     return None
 
 
-def stub_instance(id, user_id=1, private_address=None, public_addresses=None):
+def stub_instance(id, user_id=1, private_address=None, public_addresses=None,
+                  host=None, power_state=0):
     metadata = []
     metadata.append(InstanceMetadata(key='seq', value=id))
 
-    if public_addresses == None:
+    inst_type = instance_types.get_instance_type_by_flavor_id(1)
+
+    if public_addresses is None:
         public_addresses = list()
 
+    if host is not None:
+        host = str(host)
+
     instance = {
         "id": id,
         "admin_pass": "",
         "user_id": user_id,
         "project_id": "",
-        "image_id": 10,
+        "image_id": "10",
         "kernel_id": "",
         "ramdisk_id": "",
         "launch_index": 0,
         "key_name": "",
         "key_data": "",
-        "state": 0,
+        "state": power_state,
         "state_description": "",
         "memory_mb": 0,
         "vcpus": 0,
         "local_gb": 0,
         "hostname": "",
-        "host": None,
-        "instance_type": "",
+        "host": host,
+        "instance_type": dict(inst_type),
         "user_data": "",
         "reservation_id": "",
         "mac_address": "",
@@ -115,6 +134,10 @@ def fake_compute_api(cls, req, id):
     return True
 
 
+def find_host(self, context, instance_id):
+    return "nova"
+
+
 class ServersTest(test.TestCase):
 
     def setUp(self):
@@ -157,9 +180,56 @@ class ServersTest(test.TestCase):
         req = webob.Request.blank('/v1.0/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
-        self.assertEqual(res_dict['server']['id'], '1')
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['name'], 'server1')
+
+    def test_get_server_by_id_v11(self):
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
 
+        expected_links = [
+            {
+                "rel": "self",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+        ]
+
+        print res_dict['server']
+        self.assertEqual(res_dict['server']['links'], expected_links)
+
+    def test_get_server_by_id_with_addresses_xml(self):
+        private = "192.168.0.3"
+        public = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.0/servers/1')
+        req.headers['Accept'] = 'application/xml'
+        res = req.get_response(fakes.wsgi_app())
+        dom = minidom.parseString(res.body)
+        server = dom.childNodes[0]
+        self.assertEquals(server.nodeName, 'server')
+        self.assertEquals(server.getAttribute('id'), '1')
+        self.assertEquals(server.getAttribute('name'), 'server1')
+        (public,) = server.getElementsByTagName('public')
+        (ip,) = public.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), '1.2.3.4')
+        (private,) = server.getElementsByTagName('private')
+        (ip,) = private.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'),  '192.168.0.3')
+
     def test_get_server_by_id_with_addresses(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
@@ -168,7 +238,7 @@ class ServersTest(test.TestCase):
         req = webob.Request.blank('/v1.0/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
-        self.assertEqual(res_dict['server']['id'], '1')
+        self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
         addresses = res_dict['server']['addresses']
         self.assertEqual(len(addresses["public"]), len(public))
@@ -176,6 +246,102 @@ class ServersTest(test.TestCase):
         self.assertEqual(len(addresses["private"]), 1)
         self.assertEqual(addresses["private"][0], private)
 
+    def test_get_server_addresses_V10(self):
+        private = '192.168.0.3'
+        public = ['1.2.3.4']
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.0/servers/1/ips')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict, {
+            'addresses': {'public': public, 'private': [private]}})
+
+    def test_get_server_addresses_xml_V10(self):
+        private_expected = "192.168.0.3"
+        public_expected = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private_expected,
+                                                         public_expected)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.0/servers/1/ips')
+        req.headers['Accept'] = 'application/xml'
+        res = req.get_response(fakes.wsgi_app())
+        dom = minidom.parseString(res.body)
+        (addresses,) = dom.childNodes
+        self.assertEquals(addresses.nodeName, 'addresses')
+        (public,) = addresses.getElementsByTagName('public')
+        (ip,) = public.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), public_expected[0])
+        (private,) = addresses.getElementsByTagName('private')
+        (ip,) = private.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), private_expected)
+
+    def test_get_server_addresses_public_V10(self):
+        private = "192.168.0.3"
+        public = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.0/servers/1/ips/public')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict, {'public': public})
+
+    def test_get_server_addresses_private_V10(self):
+        private = "192.168.0.3"
+        public = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.0/servers/1/ips/private')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict, {'private': [private]})
+
+    def test_get_server_addresses_public_xml_V10(self):
+        private = "192.168.0.3"
+        public = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.0/servers/1/ips/public')
+        req.headers['Accept'] = 'application/xml'
+        res = req.get_response(fakes.wsgi_app())
+        dom = minidom.parseString(res.body)
+        (public_node,) = dom.childNodes
+        self.assertEquals(public_node.nodeName, 'public')
+        (ip,) = public_node.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), public[0])
+
+    def test_get_server_addresses_private_xml_V10(self):
+        private = "192.168.0.3"
+        public = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.0/servers/1/ips/private')
+        req.headers['Accept'] = 'application/xml'
+        res = req.get_response(fakes.wsgi_app())
+        dom = minidom.parseString(res.body)
+        (private_node,) = dom.childNodes
+        self.assertEquals(private_node.nodeName, 'private')
+        (ip,) = private_node.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), private)
+
+    def test_get_server_by_id_with_addresses_v11(self):
+        private = "192.168.0.3"
+        public = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['name'], 'server1')
+        addresses = res_dict['server']['addresses']
+        self.assertEqual(len(addresses["public"]), len(public))
+        self.assertEqual(addresses["public"][0],
+            {"version": 4, "addr": public[0]})
+        self.assertEqual(len(addresses["private"]), 1)
+        self.assertEqual(addresses["private"][0],
+            {"version": 4, "addr": private})
+
     def test_get_server_list(self):
         req = webob.Request.blank('/v1.0/servers')
         res = req.get_response(fakes.wsgi_app())
@@ -188,6 +354,35 @@ class ServersTest(test.TestCase):
             self.assertEqual(s.get('imageId', None), None)
             i += 1
 
+    def test_get_server_list_v11(self):
+        req = webob.Request.blank('/v1.1/servers')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        for i, s in enumerate(res_dict['servers']):
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['name'], 'server%d' % i)
+            self.assertEqual(s.get('imageId', None), None)
+
+            expected_links = [
+            {
+                "rel": "self",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+        ]
+
+        self.assertEqual(s['links'], expected_links)
+
     def test_get_servers_with_limit(self):
         req = webob.Request.blank('/v1.0/servers?limit=3')
         res = req.get_response(fakes.wsgi_app())
@@ -216,7 +411,38 @@ class ServersTest(test.TestCase):
         servers = json.loads(res.body)['servers']
         self.assertEqual([s['id'] for s in servers], [1, 2])
 
-    def test_create_instance(self):
+    def test_get_servers_with_bad_limit(self):
+        req = webob.Request.blank('/v1.0/servers?limit=asdf&offset=1')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+        self.assertTrue(res.body.find('limit param') > -1)
+
+    def test_get_servers_with_bad_offset(self):
+        req = webob.Request.blank('/v1.0/servers?limit=2&offset=asdf')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+        self.assertTrue(res.body.find('offset param') > -1)
+
+    def test_get_servers_with_marker(self):
+        req = webob.Request.blank('/v1.1/servers?marker=2')
+        res = req.get_response(fakes.wsgi_app())
+        servers = json.loads(res.body)['servers']
+        self.assertEqual([s['id'] for s in servers], [3, 4])
+
+    def test_get_servers_with_limit_and_marker(self):
+        req = webob.Request.blank('/v1.1/servers?limit=2&marker=1')
+        res = req.get_response(fakes.wsgi_app())
+        servers = json.loads(res.body)['servers']
+        self.assertEqual([s['id'] for s in servers], [2, 3])
+
+    def test_get_servers_with_bad_marker(self):
+        req = webob.Request.blank('/v1.1/servers?limit=2&marker=asdf')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+        self.assertTrue(res.body.find('marker param') > -1)
+
+    def _setup_for_create_instance(self):
+        """Shared implementation for tests below that create instance"""
         def instance_create(context, inst):
             return {'id': '1', 'display_name': 'server_test'}
 
@@ -251,96 +477,399 @@ class ServersTest(test.TestCase):
             "_get_kernel_ramdisk_from_image", kernel_ramdisk_mapping)
         self.stubs.Set(nova.api.openstack.common,
             "get_image_id_from_image_hash", image_id_from_hash)
+        self.stubs.Set(nova.compute.api.API, "_find_host", find_host)
+
+    def _test_create_instance_helper(self):
+        self._setup_for_create_instance()
 
         body = dict(server=dict(
-            name='server_test', imageId=2, flavorId=2,
+            name='server_test', imageId=3, flavorId=2,
             metadata={'hello': 'world', 'open': 'stack'},
             personality={}))
         req = webob.Request.blank('/v1.0/servers')
         req.method = 'POST'
         req.body = json.dumps(body)
-        req.headers["Content-Type"] = "application/json"
+        req.headers["content-type"] = "application/json"
+
+        res = req.get_response(fakes.wsgi_app())
+
+        server = json.loads(res.body)['server']
+        self.assertEqual(16, len(server['adminPass']))
+        self.assertEqual('server_test', server['name'])
+        self.assertEqual(1, server['id'])
+        self.assertEqual(2, server['flavorId'])
+        self.assertEqual(3, server['imageId'])
+        self.assertEqual(res.status_int, 200)
+
+    def test_create_instance(self):
+        self._test_create_instance_helper()
+
+    def test_create_instance_no_key_pair(self):
+        fakes.stub_out_key_pair_funcs(self.stubs, have_key_pair=False)
+        self._test_create_instance_helper()
+
+    def test_create_instance_no_name(self):
+        self._setup_for_create_instance()
+
+        body = {
+            'server': {
+                'imageId': 3,
+                'flavorId': 1,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_create_instance_nonstring_name(self):
+        self._setup_for_create_instance()
+
+        body = {
+            'server': {
+                'name': 12,
+                'imageId': 3,
+                'flavorId': 1,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_create_instance_whitespace_name(self):
+        self._setup_for_create_instance()
+
+        body = {
+            'server': {
+                'name': '    ',
+                'imageId': 3,
+                'flavorId': 1,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': {},
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_create_instance_v11(self):
+        self._setup_for_create_instance()
+
+        imageRef = 'http://localhost/v1.1/images/2'
+        flavorRef = 'http://localhost/v1.1/flavors/3'
+        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)
+        req.headers["content-type"] = "application/json"
 
         res = req.get_response(fakes.wsgi_app())
 
         server = json.loads(res.body)['server']
-        self.assertEqual('serv', server['adminPass'][:4])
         self.assertEqual(16, len(server['adminPass']))
         self.assertEqual('server_test', server['name'])
-        self.assertEqual('1', server['id'])
+        self.assertEqual(1, server['id'])
+        self.assertEqual(flavorRef, server['flavorRef'])
+        self.assertEqual(imageRef, server['imageRef'])
+        self.assertEqual(res.status_int, 200)
+
+    def test_create_instance_v11_bad_href(self):
+        self._setup_for_create_instance()
+
+        imageRef = 'http://localhost/v1.1/images/asdf'
+        flavorRef = 'http://localhost/v1.1/flavors/3'
+        body = dict(server=dict(
+            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)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_create_instance_v11_local_href(self):
+        self._setup_for_create_instance()
+
+        imageRef = 'http://localhost/v1.1/images/2'
+        imageRefLocal = '2'
+        flavorRef = 'http://localhost/v1.1/flavors/3'
+        body = {
+            'server': {
+                'name': 'server_test',
+                'imageRef': imageRefLocal,
+                'flavorRef': flavorRef,
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        res = req.get_response(fakes.wsgi_app())
 
+        server = json.loads(res.body)['server']
+        self.assertEqual(1, server['id'])
+        self.assertEqual(flavorRef, server['flavorRef'])
+        self.assertEqual(imageRef, server['imageRef'])
         self.assertEqual(res.status_int, 200)
 
+    def test_create_instance_with_admin_pass_v10(self):
+        self._setup_for_create_instance()
+
+        body = {
+            'server': {
+                'name': 'test-server-create',
+                'imageId': 3,
+                'flavorId': 1,
+                'adminPass': 'testpass',
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers['content-type'] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        res = json.loads(res.body)
+        self.assertNotEqual(res['server']['adminPass'],
+                            body['server']['adminPass'])
+
+    def test_create_instance_with_admin_pass_v11(self):
+        self._setup_for_create_instance()
+
+        imageRef = 'http://localhost/v1.1/images/2'
+        flavorRef = 'http://localhost/v1.1/flavors/3'
+        body = {
+            'server': {
+                'name': 'server_test',
+                'imageRef': imageRef,
+                'flavorRef': flavorRef,
+                'adminPass': 'testpass',
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers['content-type'] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        server = json.loads(res.body)['server']
+        self.assertEqual(server['adminPass'], body['server']['adminPass'])
+
+    def test_create_instance_with_empty_admin_pass_v11(self):
+        self._setup_for_create_instance()
+
+        imageRef = 'http://localhost/v1.1/images/2'
+        flavorRef = 'http://localhost/v1.1/flavors/3'
+        body = {
+            'server': {
+                'name': 'server_test',
+                'imageRef': imageRef,
+                'flavorRef': flavorRef,
+                'adminPass': '',
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers['content-type'] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
     def test_update_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 422)
 
-    def test_update_bad_params(self):
+    def test_update_nonstring_name(self):
         """ Confirm that update is filtering params """
-        inst_dict = dict(cat='leopard', name='server_test', adminPass='bacon')
+        inst_dict = dict(name=12, adminPass='bacon')
+        self.body = json.dumps(dict(server=inst_dict))
+
+        req = webob.Request.blank('/v1.0/servers/1')
+        req.method = 'PUT'
+        req.content_type = "application/json"
+        req.body = self.body
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_update_whitespace_name(self):
+        """ Confirm that update is filtering params """
+        inst_dict = dict(name='   ', adminPass='bacon')
+        self.body = json.dumps(dict(server=inst_dict))
+
+        req = webob.Request.blank('/v1.0/servers/1')
+        req.method = 'PUT'
+        req.content_type = "application/json"
+        req.body = self.body
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_update_null_name(self):
+        """ Confirm that update is filtering params """
+        inst_dict = dict(name='', adminPass='bacon')
+        self.body = json.dumps(dict(server=inst_dict))
+
+        req = webob.Request.blank('/v1.0/servers/1')
+        req.method = 'PUT'
+        req.content_type = "application/json"
+        req.body = self.body
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_update_server_v10(self):
+        inst_dict = dict(name='server_test', adminPass='bacon')
         self.body = json.dumps(dict(server=inst_dict))
 
         def server_update(context, id, params):
-            self.update_called = True
-            filtered_dict = dict(name='server_test', admin_pass='bacon')
+            filtered_dict = dict(
+                display_name='server_test',
+                admin_pass='bacon',
+            )
             self.assertEqual(params, filtered_dict)
+            return filtered_dict
 
         self.stubs.Set(nova.db.api, 'instance_update',
             server_update)
+        self.stubs.Set(nova.compute.api.API, "_find_host", find_host)
 
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
+        req.content_type = "application/json"
         req.body = self.body
-        req.get_response(fakes.wsgi_app())
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 204)
 
-    def test_update_server(self):
+    def test_update_server_adminPass_ignored_v11(self):
         inst_dict = dict(name='server_test', adminPass='bacon')
         self.body = json.dumps(dict(server=inst_dict))
 
         def server_update(context, id, params):
-            filtered_dict = dict(name='server_test', admin_pass='bacon')
+            filtered_dict = dict(display_name='server_test')
             self.assertEqual(params, filtered_dict)
+            return filtered_dict
 
         self.stubs.Set(nova.db.api, 'instance_update',
             server_update)
 
-        req = webob.Request.blank('/v1.0/servers/1')
+        req = webob.Request.blank('/v1.1/servers/1')
         req.method = 'PUT'
+        req.content_type = "application/json"
         req.body = self.body
-        req.get_response(fakes.wsgi_app())
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 204)
 
     def test_create_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedule')
         req.method = 'POST'
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status, '404 Not Found')
+        self.assertEqual(res.status_int, 501)
 
     def test_delete_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedule/1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status, '404 Not Found')
+        self.assertEqual(res.status_int, 501)
 
     def test_get_server_backup_schedules(self):
-        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedule')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 501)
+
+    def test_get_server_backup_schedule(self):
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedule/1')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 501)
+
+    def test_server_backup_schedule_deprecated_v11(self):
+        req = webob.Request.blank('/v1.1/servers/1/backup_schedule')
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status, '404 Not Found')
+        self.assertEqual(res.status_int, 404)
 
-    def test_get_all_server_details(self):
+    def test_get_all_server_details_xml_v1_0(self):
+        req = webob.Request.blank('/v1.0/servers/detail')
+        req.headers['Accept'] = 'application/xml'
+        res = req.get_response(fakes.wsgi_app())
+        print res.body
+        dom = minidom.parseString(res.body)
+        for i, server in enumerate(dom.getElementsByTagName('server')):
+            self.assertEqual(server.getAttribute('id'), str(i))
+            self.assertEqual(server.getAttribute('hostId'), '')
+            self.assertEqual(server.getAttribute('name'), 'server%d' % i)
+            self.assertEqual(server.getAttribute('imageId'), '10')
+            self.assertEqual(server.getAttribute('status'), 'BUILD')
+            (meta,) = server.getElementsByTagName('meta')
+            self.assertEqual(meta.getAttribute('key'), 'seq')
+            self.assertEqual(meta.firstChild.data.strip(), str(i))
+
+    def test_get_all_server_details_v1_0(self):
         req = webob.Request.blank('/v1.0/servers/detail')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-        i = 0
-        for s in res_dict['servers']:
+        for i, s in enumerate(res_dict['servers']):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['hostId'], '')
             self.assertEqual(s['name'], 'server%d' % i)
-            self.assertEqual(s['imageId'], 10)
-            self.assertEqual(s['metadata']['seq'], i)
-            i += 1
+            self.assertEqual(s['imageId'], '10')
+            self.assertEqual(s['flavorId'], 1)
+            self.assertEqual(s['status'], 'BUILD')
+            self.assertEqual(s['metadata']['seq'], str(i))
+
+    def test_get_all_server_details_v1_1(self):
+        req = webob.Request.blank('/v1.1/servers/detail')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        for i, s in enumerate(res_dict['servers']):
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['hostId'], '')
+            self.assertEqual(s['name'], 'server%d' % i)
+            self.assertEqual(s['imageRef'], 'http://localhost/v1.1/images/10')
+            self.assertEqual(s['flavorRef'], 'http://localhost/v1.1/flavors/1')
+            self.assertEqual(s['status'], 'BUILD')
+            self.assertEqual(s['metadata']['seq'], str(i))
 
     def test_get_all_server_details_with_host(self):
         '''
@@ -350,12 +879,8 @@ class ServersTest(test.TestCase):
         instances - 2 on one host and 3 on another.
         '''
 
-        def stub_instance(id, user_id=1):
-            return Instance(id=id, state=0, image_id=10, user_id=user_id,
-                display_name='server%s' % id, host='host%s' % (id % 2))
-
         def return_servers_with_host(context, user_id=1):
-            return [stub_instance(i) for i in xrange(5)]
+            return [stub_instance(i, 1, None, None, i % 2) for i in xrange(5)]
 
         self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
             return_servers_with_host)
@@ -373,7 +898,8 @@ class ServersTest(test.TestCase):
             self.assertEqual(s['id'], i)
             self.assertEqual(s['hostId'], host_ids[i % 2])
             self.assertEqual(s['name'], 'server%d' % i)
-            self.assertEqual(s['imageId'], 10)
+            self.assertEqual(s['imageId'], '10')
+            self.assertEqual(s['flavorId'], 1)
 
     def test_server_pause(self):
         FLAGS.allow_admin_api = True
@@ -460,6 +986,74 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
 
+    def test_server_change_password(self):
+        body = {'changePassword': {'adminPass': '1234pass'}}
+        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())
+        self.assertEqual(res.status_int, 501)
+
+    def test_server_change_password_v1_1(self):
+
+        class MockSetAdminPassword(object):
+            def __init__(self):
+                self.instance_id = None
+                self.password = None
+
+            def __call__(self, context, instance_id, password):
+                self.instance_id = instance_id
+                self.password = password
+
+        mock_method = MockSetAdminPassword()
+        self.stubs.Set(nova.compute.api.API, 'set_admin_password', mock_method)
+        body = {'changePassword': {'adminPass': '1234pass'}}
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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)
+        self.assertEqual(mock_method.instance_id, '1')
+        self.assertEqual(mock_method.password, '1234pass')
+
+    def test_server_change_password_bad_request_v1_1(self):
+        body = {'changePassword': {'pass': '12345'}}
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
+    def test_server_change_password_empty_string_v1_1(self):
+        body = {'changePassword': {'adminPass': ''}}
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
+    def test_server_change_password_none_v1_1(self):
+        body = {'changePassword': {'adminPass': None}}
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
+    def test_server_change_password_not_a_string_v1_1(self):
+        body = {'changePassword': {'adminPass': 1234}}
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
     def test_server_reboot(self):
         body = dict(server=dict(
             name='server_test', imageId=2, flavorId=2, metadata={},
@@ -470,25 +1064,175 @@ class ServersTest(test.TestCase):
         req.body = json.dumps(body)
         res = req.get_response(fakes.wsgi_app())
 
-    def test_server_rebuild(self):
-        body = dict(server=dict(
-            name='server_test', imageId=2, flavorId=2, metadata={},
-            personality={}))
+    def test_server_rebuild_accepted(self):
+        body = {
+            "rebuild": {
+                "imageId": 2,
+            },
+        }
+
         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())
+        self.assertEqual(res.status_int, 202)
+        self.assertEqual(res.body, "")
+
+    def test_server_rebuild_rejected_when_building(self):
+        body = {
+            "rebuild": {
+                "imageId": 2,
+            },
+        }
+
+        state = power_state.BUILDING
+        new_return_server = return_server_with_power_state(state)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+
+        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())
+        self.assertEqual(res.status_int, 409)
+
+    def test_server_rebuild_bad_entity(self):
+        body = {
+            "rebuild": {
+            },
+        }
 
-    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())
+        self.assertEqual(res.status_int, 400)
+
+    def test_server_rebuild_accepted_minimum_v11(self):
+        body = {
+            "rebuild": {
+                "imageRef": "http://localhost/images/2",
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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_rebuild_rejected_when_building_v11(self):
+        body = {
+            "rebuild": {
+                "imageRef": "http://localhost/images/2",
+            },
+        }
+
+        state = power_state.BUILDING
+        new_return_server = return_server_with_power_state(state)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 409)
+
+    def test_server_rebuild_accepted_with_metadata_v11(self):
+        body = {
+            "rebuild": {
+                "imageRef": "http://localhost/images/2",
+                "metadata": {
+                    "new": "metadata",
+                },
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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_rebuild_accepted_with_bad_metadata_v11(self):
+        body = {
+            "rebuild": {
+                "imageRef": "http://localhost/images/2",
+                "metadata": "stack",
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
+    def test_server_rebuild_bad_entity_v11(self):
+        body = {
+            "rebuild": {
+                "imageId": 2,
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
+    def test_server_rebuild_bad_personality_v11(self):
+        body = {
+            "rebuild": {
+                "imageRef": "http://localhost/images/2",
+                "personality": [{
+                    "path": "/path/to/file",
+                    "contents": "INVALID b64",
+                }]
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
+    def test_server_rebuild_personality_v11(self):
+        body = {
+            "rebuild": {
+                "imageRef": "http://localhost/images/2",
+                "personality": [{
+                    "path": "/path/to/file",
+                    "contents": base64.b64encode("Test String"),
+                }]
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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_delete_server_instance(self):
         req = webob.Request.blank('/v1.0/servers/1')
@@ -545,6 +1289,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))
 
@@ -599,5 +1355,604 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-if __name__ == "__main__":
-    unittest.main()
+    def test_shutdown_status(self):
+        new_server = return_server_with_power_state(power_state.SHUTDOWN)
+        self.stubs.Set(nova.db.api, 'instance_get', new_server)
+        req = webob.Request.blank('/v1.0/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['status'], 'SHUTDOWN')
+
+    def test_shutoff_status(self):
+        new_server = return_server_with_power_state(power_state.SHUTOFF)
+        self.stubs.Set(nova.db.api, 'instance_get', new_server)
+        req = webob.Request.blank('/v1.0/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['status'], 'SHUTOFF')
+
+
+class TestServerCreateRequestXMLDeserializer(unittest.TestCase):
+
+    def setUp(self):
+        self.deserializer = servers.ServerCreateRequestXMLDeserializer()
+
+    def test_minimal_request(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1"/>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_empty_metadata(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata/>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                "metadata": {},
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_empty_personality(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <personality/>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                "personality": [],
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_empty_metadata_and_personality(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata/>
+    <personality/>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                "metadata": {},
+                "personality": [],
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_empty_metadata_and_personality_reversed(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <personality/>
+    <metadata/>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"server": {
+                "name": "new-server-test",
+                "imageId": "1",
+                "flavorId": "1",
+                "metadata": {},
+                "personality": [],
+                }}
+        self.assertEquals(request, expected)
+
+    def test_request_with_one_personality(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <personality>
+        <file path="/etc/conf">aabbccdd</file>
+    </personality>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": "aabbccdd"}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_two_personalities(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+<personality><file path="/etc/conf">aabbccdd</file>
+<file path="/etc/sudoers">abcd</file></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": "aabbccdd"},
+                    {"path": "/etc/sudoers", "contents": "abcd"}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_second_personality_node_ignored(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <personality>
+        <file path="/etc/conf">aabbccdd</file>
+    </personality>
+    <personality>
+        <file path="/etc/ignoreme">anything</file>
+    </personality>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": "aabbccdd"}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_one_personality_missing_path(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+<personality><file>aabbccdd</file></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"contents": "aabbccdd"}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_one_personality_empty_contents(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+<personality><file path="/etc/conf"></file></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": ""}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_one_personality_empty_contents_variation(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+<personality><file path="/etc/conf"/></personality></server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = [{"path": "/etc/conf", "contents": ""}]
+        self.assertEquals(request["server"]["personality"], expected)
+
+    def test_request_with_one_metadata(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="alpha">beta</meta>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"alpha": "beta"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_two_metadata(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="alpha">beta</meta>
+        <meta key="foo">bar</meta>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"alpha": "beta", "foo": "bar"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_metadata_missing_value(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="alpha"></meta>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"alpha": ""}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_two_metadata_missing_value(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="alpha"/>
+        <meta key="delta"/>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"alpha": "", "delta": ""}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_metadata_missing_key(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta>beta</meta>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"": "beta"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_two_metadata_missing_key(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta>beta</meta>
+        <meta>gamma</meta>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"": "gamma"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_request_with_metadata_duplicate_key(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="foo">bar</meta>
+        <meta key="foo">baz</meta>
+    </metadata>
+</server>"""
+        request = self.deserializer.deserialize(serial_request)
+        expected = {"foo": "baz"}
+        self.assertEquals(request["server"]["metadata"], expected)
+
+    def test_canonical_request_from_docs(self):
+        serial_request = """
+<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"
+ name="new-server-test" imageId="1" flavorId="1">
+    <metadata>
+        <meta key="My Server Name">Apache1</meta>
+    </metadata>
+    <personality>
+        <file path="/etc/banner.txt">\
+ICAgICAgDQoiQSBjbG91ZCBkb2VzIG5vdCBrbm93IHdoeSBp\
+dCBtb3ZlcyBpbiBqdXN0IHN1Y2ggYSBkaXJlY3Rpb24gYW5k\
+IGF0IHN1Y2ggYSBzcGVlZC4uLkl0IGZlZWxzIGFuIGltcHVs\
+c2lvbi4uLnRoaXMgaXMgdGhlIHBsYWNlIHRvIGdvIG5vdy4g\
+QnV0IHRoZSBza3kga25vd3MgdGhlIHJlYXNvbnMgYW5kIHRo\
+ZSBwYXR0ZXJucyBiZWhpbmQgYWxsIGNsb3VkcywgYW5kIHlv\
+dSB3aWxsIGtub3csIHRvbywgd2hlbiB5b3UgbGlmdCB5b3Vy\
+c2VsZiBoaWdoIGVub3VnaCB0byBzZWUgYmV5b25kIGhvcml6\
+b25zLiINCg0KLVJpY2hhcmQgQmFjaA==</file>
+    </personality>
+</server>"""
+        expected = {"server": {
+            "name": "new-server-test",
+            "imageId": "1",
+            "flavorId": "1",
+            "metadata": {
+                "My Server Name": "Apache1",
+            },
+            "personality": [
+                {
+                    "path": "/etc/banner.txt",
+                    "contents": """\
+ICAgICAgDQoiQSBjbG91ZCBkb2VzIG5vdCBrbm93IHdoeSBp\
+dCBtb3ZlcyBpbiBqdXN0IHN1Y2ggYSBkaXJlY3Rpb24gYW5k\
+IGF0IHN1Y2ggYSBzcGVlZC4uLkl0IGZlZWxzIGFuIGltcHVs\
+c2lvbi4uLnRoaXMgaXMgdGhlIHBsYWNlIHRvIGdvIG5vdy4g\
+QnV0IHRoZSBza3kga25vd3MgdGhlIHJlYXNvbnMgYW5kIHRo\
+ZSBwYXR0ZXJucyBiZWhpbmQgYWxsIGNsb3VkcywgYW5kIHlv\
+dSB3aWxsIGtub3csIHRvbywgd2hlbiB5b3UgbGlmdCB5b3Vy\
+c2VsZiBoaWdoIGVub3VnaCB0byBzZWUgYmV5b25kIGhvcml6\
+b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""",
+                },
+            ],
+        }}
+        request = self.deserializer.deserialize(serial_request)
+        self.assertEqual(request, expected)
+
+
+class TestServerInstanceCreation(test.TestCase):
+
+    def setUp(self):
+        super(TestServerInstanceCreation, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
+        fakes.stub_out_key_pair_funcs(self.stubs)
+        self.allow_admin = FLAGS.allow_admin_api
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.allow_admin_api = self.allow_admin
+        super(TestServerInstanceCreation, self).tearDown()
+
+    def _setup_mock_compute_api_for_personality(self):
+
+        class MockComputeAPI(nova.compute.API):
+
+            def __init__(self):
+                self.injected_files = None
+
+            def create(self, *args, **kwargs):
+                if 'injected_files' in kwargs:
+                    self.injected_files = kwargs['injected_files']
+                else:
+                    self.injected_files = None
+                return [{'id': '1234', 'display_name': 'fakeinstance'}]
+
+            def set_admin_password(self, *args, **kwargs):
+                pass
+
+        def make_stub_method(canned_return):
+            def stub_method(*args, **kwargs):
+                return canned_return
+            return stub_method
+
+        compute_api = MockComputeAPI()
+        self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api))
+        self.stubs.Set(nova.api.openstack.servers.Controller,
+            '_get_kernel_ramdisk_from_image', make_stub_method((1, 1)))
+        self.stubs.Set(nova.api.openstack.common,
+            'get_image_id_from_image_hash', make_stub_method(2))
+        return compute_api
+
+    def _create_personality_request_dict(self, personality_files):
+        server = {}
+        server['name'] = 'new-server-test'
+        server['imageId'] = 1
+        server['flavorId'] = 1
+        if personality_files is not None:
+            personalities = []
+            for path, contents in personality_files:
+                personalities.append({'path': path, 'contents': contents})
+            server['personality'] = personalities
+        return {'server': server}
+
+    def _get_create_request_json(self, body_dict):
+        req = webob.Request.blank('/v1.0/servers')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body_dict)
+        return req
+
+    def _run_create_instance_with_mock_compute_api(self, request):
+        compute_api = self._setup_mock_compute_api_for_personality()
+        response = request.get_response(fakes.wsgi_app())
+        return compute_api, response
+
+    def _format_xml_request_body(self, body_dict):
+        server = body_dict['server']
+        body_parts = []
+        body_parts.extend([
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<server xmlns="http://docs.rackspacecloud.com/servers/api/v1.0"',
+            ' name="%s" imageId="%s" flavorId="%s">' % (
+                    server['name'], server['imageId'], server['flavorId'])])
+        if 'metadata' in server:
+            metadata = server['metadata']
+            body_parts.append('<metadata>')
+            for item in metadata.iteritems():
+                body_parts.append('<meta key="%s">%s</meta>' % item)
+            body_parts.append('</metadata>')
+        if 'personality' in server:
+            personalities = server['personality']
+            body_parts.append('<personality>')
+            for file in personalities:
+                item = (file['path'], file['contents'])
+                body_parts.append('<file path="%s">%s</file>' % item)
+            body_parts.append('</personality>')
+        body_parts.append('</server>')
+        return ''.join(body_parts)
+
+    def _get_create_request_xml(self, body_dict):
+        req = webob.Request.blank('/v1.0/servers')
+        req.content_type = 'application/xml'
+        req.accept = 'application/xml'
+        req.method = 'POST'
+        req.body = self._format_xml_request_body(body_dict)
+        return req
+
+    def _create_instance_with_personality_json(self, personality):
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        return request, response, compute_api.injected_files
+
+    def _create_instance_with_personality_xml(self, personality):
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_xml(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        return request, response, compute_api.injected_files
+
+    def test_create_instance_with_no_personality(self):
+        request, response, injected_files = \
+                self._create_instance_with_personality_json(personality=None)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(injected_files, [])
+
+    def test_create_instance_with_no_personality_xml(self):
+        request, response, injected_files = \
+                self._create_instance_with_personality_xml(personality=None)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(injected_files, [])
+
+    def test_create_instance_with_personality(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Hello, World!"\n'
+        b64contents = base64.b64encode(contents)
+        personality = [(path, b64contents)]
+        request, response, injected_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(injected_files, [(path, contents)])
+
+    def test_create_instance_with_personality_xml(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Hello, World!"\n'
+        b64contents = base64.b64encode(contents)
+        personality = [(path, b64contents)]
+        request, response, injected_files = \
+            self._create_instance_with_personality_xml(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(injected_files, [(path, contents)])
+
+    def test_create_instance_with_personality_no_path(self):
+        personality = [('/remove/this/path',
+            base64.b64encode('my\n\file\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        del body_dict['server']['personality'][0]['path']
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.injected_files, None)
+
+    def _test_create_instance_with_personality_no_path_xml(self):
+        personality = [('/remove/this/path',
+            base64.b64encode('my\n\file\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        request = self._get_create_request_xml(body_dict)
+        request.body = request.body.replace(' path="/remove/this/path"', '')
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.injected_files, None)
+
+    def test_create_instance_with_personality_no_contents(self):
+        personality = [('/test/path',
+            base64.b64encode('remove\nthese\ncontents'))]
+        body_dict = self._create_personality_request_dict(personality)
+        del body_dict['server']['personality'][0]['contents']
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.injected_files, None)
+
+    def test_create_instance_with_personality_not_a_list(self):
+        personality = [('/test/path', base64.b64encode('test\ncontents\n'))]
+        body_dict = self._create_personality_request_dict(personality)
+        body_dict['server']['personality'] = \
+            body_dict['server']['personality'][0]
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(compute_api.injected_files, None)
+
+    def test_create_instance_with_personality_with_non_b64_content(self):
+        path = '/my/file/path'
+        contents = '#!/bin/bash\necho "Oh no!"\n'
+        personality = [(path, contents)]
+        request, response, injected_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 400)
+        self.assertEquals(injected_files, None)
+
+    def test_create_instance_with_null_personality(self):
+        personality = None
+        body_dict = self._create_personality_request_dict(personality)
+        body_dict['server']['personality'] = None
+        request = self._get_create_request_json(body_dict)
+        compute_api, response = \
+            self._run_create_instance_with_mock_compute_api(request)
+        self.assertEquals(response.status_int, 200)
+
+    def test_create_instance_with_three_personalities(self):
+        files = [
+            ('/etc/sudoers', 'ALL ALL=NOPASSWD: ALL\n'),
+            ('/etc/motd', 'Enjoy your root access!\n'),
+            ('/etc/dovecot.conf', 'dovecot\nconfig\nstuff\n'),
+            ]
+        personality = []
+        for path, content in files:
+            personality.append((path, base64.b64encode(content)))
+        request, response, injected_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(injected_files, files)
+
+    def test_create_instance_personality_empty_content(self):
+        path = '/my/file/path'
+        contents = ''
+        personality = [(path, contents)]
+        request, response, injected_files = \
+            self._create_instance_with_personality_json(personality)
+        self.assertEquals(response.status_int, 200)
+        self.assertEquals(injected_files, [(path, contents)])
+
+    def test_create_instance_admin_pass_json(self):
+        request, response, dummy = \
+            self._create_instance_with_personality_json(None)
+        self.assertEquals(response.status_int, 200)
+        response = json.loads(response.body)
+        self.assertTrue('adminPass' in response['server'])
+        self.assertEqual(16, len(response['server']['adminPass']))
+
+    def test_create_instance_admin_pass_xml(self):
+        request, response, dummy = \
+            self._create_instance_with_personality_xml(None)
+        self.assertEquals(response.status_int, 200)
+        dom = minidom.parseString(response.body)
+        server = dom.childNodes[0]
+        self.assertEquals(server.nodeName, 'server')
+        self.assertEqual(16, len(server.getAttribute('adminPass')))
+
+
+class TestGetKernelRamdiskFromImage(test.TestCase):
+    """
+    If we're building from an AMI-style image, we need to be able to fetch the
+    kernel and ramdisk associated with the machine image. This information is
+    stored with the image metadata and return via the ImageService.
+
+    These tests ensure that we parse the metadata return the ImageService
+    correctly and that we handle failure modes appropriately.
+    """
+
+    def test_status_not_active(self):
+        """We should only allow fetching of kernel and ramdisk information if
+        we have a 'fully-formed' image, aka 'active'
+        """
+        image_meta = {'id': 1, 'status': 'queued'}
+        self.assertRaises(exception.Invalid, self._get_k_r, image_meta)
+
+    def test_not_ami(self):
+        """Anything other than ami should return no kernel and no ramdisk"""
+        image_meta = {'id': 1, 'status': 'active', 'container_format': 'vhd'}
+        kernel_id, ramdisk_id = self._get_k_r(image_meta)
+        self.assertEqual(kernel_id, None)
+        self.assertEqual(ramdisk_id, None)
+
+    def test_ami_no_kernel(self):
+        """If an ami is missing a kernel it should raise NotFound"""
+        image_meta = {'id': 1, 'status': 'active', 'container_format': 'ami',
+                      'properties': {'ramdisk_id': 1}}
+        self.assertRaises(exception.NotFound, self._get_k_r, image_meta)
+
+    def test_ami_no_ramdisk(self):
+        """If an ami is missing a ramdisk it should raise NotFound"""
+        image_meta = {'id': 1, 'status': 'active', 'container_format': 'ami',
+                      'properties': {'kernel_id': 1}}
+        self.assertRaises(exception.NotFound, self._get_k_r, image_meta)
+
+    def test_ami_kernel_ramdisk_present(self):
+        """Return IDs if both kernel and ramdisk are present"""
+        image_meta = {'id': 1, 'status': 'active', 'container_format': 'ami',
+                      'properties': {'kernel_id': 1, 'ramdisk_id': 2}}
+        kernel_id, ramdisk_id = self._get_k_r(image_meta)
+        self.assertEqual(kernel_id, 1)
+        self.assertEqual(ramdisk_id, 2)
+
+    @staticmethod
+    def _get_k_r(image_meta):
+        """Rebinding function to a shorter name for convenience"""
+        kernel_id, ramdisk_id = \
+            servers.Controller._do_get_kernel_ramdisk_from_image(image_meta)
+        return kernel_id, ramdisk_id
diff --git a/nova/tests/api/openstack/test_shared_ip_groups.py b/nova/tests/api/openstack/test_shared_ip_groups.py
index b4de2ef41..c2bd7e45a 100644
--- a/nova/tests/api/openstack/test_shared_ip_groups.py
+++ b/nova/tests/api/openstack/test_shared_ip_groups.py
@@ -16,25 +16,49 @@
 #    under the License.
 
 import stubout
+import webob
 
 from nova import test
 from nova.api.openstack import shared_ip_groups
+from nova.tests.api.openstack import fakes
 
 
 class SharedIpGroupsTest(test.TestCase):
     def setUp(self):
         super(SharedIpGroupsTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.reset_fake_data()
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
 
     def tearDown(self):
         self.stubs.UnsetAll()
         super(SharedIpGroupsTest, self).tearDown()
 
     def test_get_shared_ip_groups(self):
-        pass
+        req = webob.Request.blank('/v1.0/shared_ip_groups')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 501)
 
     def test_create_shared_ip_group(self):
-        pass
+        req = webob.Request.blank('/v1.0/shared_ip_groups')
+        req.method = 'POST'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 501)
+
+    def test_update_shared_ip_group(self):
+        req = webob.Request.blank('/v1.0/shared_ip_groups/12')
+        req.method = 'PUT'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 501)
 
     def test_delete_shared_ip_group(self):
-        pass
+        req = webob.Request.blank('/v1.0/shared_ip_groups/12')
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 501)
+
+    def test_deprecated_v11(self):
+        req = webob.Request.blank('/v1.1/shared_ip_groups')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
diff --git a/nova/tests/api/openstack/test_users.py b/nova/tests/api/openstack/test_users.py
index 2dda4319b..effb2f592 100644
--- a/nova/tests/api/openstack/test_users.py
+++ b/nova/tests/api/openstack/test_users.py
@@ -18,11 +18,10 @@ import json
 import stubout
 import webob
 
-import nova.api
-import nova.api.openstack.auth
-from nova import context
 from nova import flags
 from nova import test
+from nova import utils
+from nova.api.openstack import users
 from nova.auth.manager import User, Project
 from nova.tests.api.openstack import fakes
 
@@ -43,14 +42,14 @@ class UsersTest(test.TestCase):
     def setUp(self):
         super(UsersTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(nova.api.openstack.users.Controller, '__init__',
+        self.stubs.Set(users.Controller, '__init__',
                        fake_init)
-        self.stubs.Set(nova.api.openstack.users.Controller, '_check_admin',
+        self.stubs.Set(users.Controller, '_check_admin',
                        fake_admin_check)
-        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthManager.clear_fakes()
         fakes.FakeAuthManager.projects = dict(testacct=Project('testacct',
                                                                'testacct',
-                                                               'guy1',
+                                                               'id1',
                                                                'test',
                                                                []))
         fakes.FakeAuthDatabase.data = {}
@@ -61,10 +60,8 @@ class UsersTest(test.TestCase):
         self.allow_admin = FLAGS.allow_admin_api
         FLAGS.allow_admin_api = True
         fakemgr = fakes.FakeAuthManager()
-        fakemgr.add_user('acc1', User('guy1', 'guy1', 'acc1',
-                                      'fortytwo!', False))
-        fakemgr.add_user('acc2', User('guy2', 'guy2', 'acc2',
-                                      'swordfish', True))
+        fakemgr.add_user(User('id1', 'guy1', 'acc1', 'secret1', False))
+        fakemgr.add_user(User('id2', 'guy2', 'acc2', 'secret2', True))
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -80,28 +77,44 @@ class UsersTest(test.TestCase):
         self.assertEqual(len(res_dict['users']), 2)
 
     def test_get_user_by_id(self):
-        req = webob.Request.blank('/v1.0/users/guy2')
+        req = webob.Request.blank('/v1.0/users/id2')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
-        self.assertEqual(res_dict['user']['id'], 'guy2')
+        self.assertEqual(res_dict['user']['id'], 'id2')
         self.assertEqual(res_dict['user']['name'], 'guy2')
-        self.assertEqual(res_dict['user']['secret'], 'swordfish')
+        self.assertEqual(res_dict['user']['secret'], 'secret2')
         self.assertEqual(res_dict['user']['admin'], True)
         self.assertEqual(res.status_int, 200)
 
     def test_user_delete(self):
-        req = webob.Request.blank('/v1.0/users/guy1')
+        # Check the user exists
+        req = webob.Request.blank('/v1.0/users/id1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res_dict['user']['id'], 'id1')
+        self.assertEqual(res.status_int, 200)
+
+        # Delete the user
+        req = webob.Request.blank('/v1.0/users/id1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
-        self.assertTrue('guy1' not in [u.id for u in
-                        fakes.FakeAuthManager.auth_data.values()])
+        self.assertTrue('id1' not in [u.id for u in
+                        fakes.FakeAuthManager.auth_data])
         self.assertEqual(res.status_int, 200)
 
+        # Check the user is not returned (and returns 404)
+        req = webob.Request.blank('/v1.0/users/id1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res.status_int, 404)
+
     def test_user_create(self):
+        secret = utils.generate_password()
         body = dict(user=dict(name='test_guy',
                               access='acc3',
-                              secret='invasionIsInNormandy',
+                              secret=secret,
                               admin=True))
         req = webob.Request.blank('/v1.0/users')
         req.headers["Content-Type"] = "application/json"
@@ -112,20 +125,25 @@ class UsersTest(test.TestCase):
         res_dict = json.loads(res.body)
 
         self.assertEqual(res.status_int, 200)
+
+        # NOTE(justinsb): This is a questionable assertion in general
+        # fake sets id=name, but others might not...
         self.assertEqual(res_dict['user']['id'], 'test_guy')
+
         self.assertEqual(res_dict['user']['name'], 'test_guy')
         self.assertEqual(res_dict['user']['access'], 'acc3')
-        self.assertEqual(res_dict['user']['secret'], 'invasionIsInNormandy')
+        self.assertEqual(res_dict['user']['secret'], secret)
         self.assertEqual(res_dict['user']['admin'], True)
         self.assertTrue('test_guy' in [u.id for u in
-                        fakes.FakeAuthManager.auth_data.values()])
-        self.assertEqual(len(fakes.FakeAuthManager.auth_data.values()), 3)
+                        fakes.FakeAuthManager.auth_data])
+        self.assertEqual(len(fakes.FakeAuthManager.auth_data), 3)
 
     def test_user_update(self):
+        new_secret = utils.generate_password()
         body = dict(user=dict(name='guy2',
                               access='acc2',
-                              secret='invasionIsInNormandy'))
-        req = webob.Request.blank('/v1.0/users/guy2')
+                              secret=new_secret))
+        req = webob.Request.blank('/v1.0/users/id2')
         req.headers["Content-Type"] = "application/json"
         req.method = 'PUT'
         req.body = json.dumps(body)
@@ -134,8 +152,8 @@ class UsersTest(test.TestCase):
         res_dict = json.loads(res.body)
 
         self.assertEqual(res.status_int, 200)
-        self.assertEqual(res_dict['user']['id'], 'guy2')
+        self.assertEqual(res_dict['user']['id'], 'id2')
         self.assertEqual(res_dict['user']['name'], 'guy2')
         self.assertEqual(res_dict['user']['access'], 'acc2')
-        self.assertEqual(res_dict['user']['secret'], 'invasionIsInNormandy')
+        self.assertEqual(res_dict['user']['secret'], new_secret)
         self.assertEqual(res_dict['user']['admin'], True)
diff --git a/nova/tests/api/openstack/test_versions.py b/nova/tests/api/openstack/test_versions.py
new file mode 100644
index 000000000..fd8d50904
--- /dev/null
+++ b/nova/tests/api/openstack/test_versions.py
@@ -0,0 +1,121 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import json
+import webob
+
+from nova import context
+from nova import test
+from nova.tests.api.openstack import fakes
+from nova.api.openstack import views
+
+
+class VersionsTest(test.TestCase):
+    def setUp(self):
+        super(VersionsTest, self).setUp()
+        self.context = context.get_admin_context()
+
+    def tearDown(self):
+        super(VersionsTest, self).tearDown()
+
+    def test_get_version_list(self):
+        req = webob.Request.blank('/')
+        req.accept = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, "application/json")
+        versions = json.loads(res.body)["versions"]
+        expected = [
+            {
+                "id": "v1.1",
+                "status": "CURRENT",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1",
+                    }],
+            },
+            {
+                "id": "v1.0",
+                "status": "DEPRECATED",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.0",
+                    }],
+            },
+        ]
+        self.assertEqual(versions, expected)
+
+    def test_get_version_list_xml(self):
+        req = webob.Request.blank('/')
+        req.accept = "application/xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, "application/xml")
+
+        expected = """<versions>
+            <version id="v1.1" status="CURRENT">
+                <links>
+                    <link href="http://localhost/v1.1" rel="self"/>
+                </links>
+            </version>
+            <version id="v1.0" status="DEPRECATED">
+                <links>
+                    <link href="http://localhost/v1.0" rel="self"/>
+                </links>
+            </version>
+        </versions>""".replace("  ", "").replace("\n", "")
+
+        actual = res.body.replace("  ", "").replace("\n", "")
+
+        self.assertEqual(expected, actual)
+
+    def test_view_builder(self):
+        base_url = "http://example.org/"
+
+        version_data = {
+            "id": "3.2.1",
+            "status": "CURRENT",
+        }
+
+        expected = {
+            "id": "3.2.1",
+            "status": "CURRENT",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://example.org/3.2.1",
+                },
+            ],
+        }
+
+        builder = views.versions.ViewBuilder(base_url)
+        output = builder.build(version_data)
+
+        self.assertEqual(output, expected)
+
+    def test_generate_href(self):
+        base_url = "http://example.org/app/"
+        version_number = "v1.4.6"
+
+        expected = "http://example.org/app/v1.4.6"
+
+        builder = views.versions.ViewBuilder(base_url)
+        actual = builder.generate_href(version_number)
+
+        self.assertEqual(actual, expected)
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 38399bb3f..5d5799b59 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -75,6 +75,10 @@ def zone_get_all_db(context):
     ]
 
 
+def zone_capabilities(method, context):
+    return dict()
+
+
 class ZonesTest(test.TestCase):
     def setUp(self):
         super(ZonesTest, self).setUp()
@@ -93,13 +97,18 @@ class ZonesTest(test.TestCase):
         self.stubs.Set(nova.db, 'zone_create', zone_create)
         self.stubs.Set(nova.db, 'zone_delete', zone_delete)
 
+        self.old_zone_name = FLAGS.zone_name
+        self.old_zone_capabilities = FLAGS.zone_capabilities
+
     def tearDown(self):
         self.stubs.UnsetAll()
         FLAGS.allow_admin_api = self.allow_admin
+        FLAGS.zone_name = self.old_zone_name
+        FLAGS.zone_capabilities = self.old_zone_capabilities
         super(ZonesTest, self).tearDown()
 
     def test_get_zone_list_scheduler(self):
-        self.stubs.Set(api.API, '_call_scheduler', zone_get_all_scheduler)
+        self.stubs.Set(api, '_call_scheduler', zone_get_all_scheduler)
         req = webob.Request.blank('/v1.0/zones')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -108,8 +117,7 @@ class ZonesTest(test.TestCase):
         self.assertEqual(len(res_dict['zones']), 2)
 
     def test_get_zone_list_db(self):
-        self.stubs.Set(api.API, '_call_scheduler',
-                                zone_get_all_scheduler_empty)
+        self.stubs.Set(api, '_call_scheduler', zone_get_all_scheduler_empty)
         self.stubs.Set(nova.db, 'zone_get_all', zone_get_all_db)
         req = webob.Request.blank('/v1.0/zones')
         req.headers["Content-Type"] = "application/json"
@@ -167,3 +175,18 @@ class ZonesTest(test.TestCase):
         self.assertEqual(res_dict['zone']['id'], 1)
         self.assertEqual(res_dict['zone']['api_url'], 'http://example.com')
         self.assertFalse('username' in res_dict['zone'])
+
+    def test_zone_info(self):
+        FLAGS.zone_name = 'darksecret'
+        FLAGS.zone_capabilities = ['cap1=a;b', 'cap2=c;d']
+        self.stubs.Set(api, '_call_scheduler', zone_capabilities)
+
+        body = dict(zone=dict(username='zeb', password='sneaky'))
+        req = webob.Request.blank('/v1.0/zones/info')
+
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res_dict['zone']['name'], 'darksecret')
+        self.assertEqual(res_dict['zone']['cap1'], 'a;b')
+        self.assertEqual(res_dict['zone']['cap2'], 'c;d')
diff --git a/nova/tests/api/test_wsgi.py b/nova/tests/api/test_wsgi.py
index b1a849cf9..5820ecdc2 100644
--- a/nova/tests/api/test_wsgi.py
+++ b/nova/tests/api/test_wsgi.py
@@ -80,7 +80,7 @@ class ControllerTest(test.TestCase):
                     "attributes": {
                         "test": ["id"]}}}
 
-            def show(self, req, id):  # pylint: disable-msg=W0622,C0103
+            def show(self, req, id):  # pylint: disable=W0622,C0103
                 return {"test": {"id": id}}
 
         def __init__(self):
@@ -136,6 +136,12 @@ class RequestTest(test.TestCase):
         request.body = "asdf<br />"
         self.assertRaises(webob.exc.HTTPBadRequest, request.get_content_type)
 
+    def test_request_content_type_with_charset(self):
+        request = wsgi.Request.blank('/tests/123')
+        request.headers["Content-Type"] = "application/json; charset=UTF-8"
+        result = request.get_content_type()
+        self.assertEqual(result, "application/json")
+
     def test_content_type_from_accept_xml(self):
         request = wsgi.Request.blank('/tests/123')
         request.headers["Accept"] = "application/xml"
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 142f6b1c6..58d251b1e 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -24,20 +24,76 @@ from nova import test
 from nova import utils
 
 
-def stub_out_db_instance_api(stubs):
-    """ Stubs out the db API for creating Instances """
+def stub_out_db_instance_api(stubs, injected=True):
+    """Stubs out the db API for creating Instances."""
 
     INSTANCE_TYPES = {
-        'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
-        'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+        'm1.tiny': dict(id=2,
+                        memory_mb=512,
+                        vcpus=1,
+                        local_gb=0,
+                        flavorid=1,
+                        rxtx_cap=1),
+        'm1.small': dict(id=5,
+                         memory_mb=2048,
+                         vcpus=1,
+                         local_gb=20,
+                         flavorid=2,
+                         rxtx_cap=2),
         'm1.medium':
-            dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
-        'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+            dict(id=1,
+                 memory_mb=4096,
+                 vcpus=2,
+                 local_gb=40,
+                 flavorid=3,
+                 rxtx_cap=3),
+        'm1.large': dict(id=3,
+                         memory_mb=8192,
+                         vcpus=4,
+                         local_gb=80,
+                         flavorid=4,
+                         rxtx_cap=4),
         'm1.xlarge':
-            dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+            dict(id=4,
+                 memory_mb=16384,
+                 vcpus=8,
+                 local_gb=160,
+                 flavorid=5,
+                 rxtx_cap=5)}
+
+    flat_network_fields = {'id': 'fake_flat',
+                           'bridge': 'xenbr0',
+                           'label': 'fake_flat_network',
+                           'netmask': '255.255.255.0',
+                           'cidr_v6': 'fe80::a00:0/120',
+                           'netmask_v6': '120',
+                           'gateway': '10.0.0.1',
+                           'gateway_v6': 'fe80::a00:1',
+                           'broadcast': '10.0.0.255',
+                           'dns': '10.0.0.2',
+                           'ra_server': None,
+                           'injected': injected}
+
+    vlan_network_fields = {'id': 'fake_vlan',
+                           'bridge': 'br111',
+                           'label': 'fake_vlan_network',
+                           'netmask': '255.255.255.0',
+                           'cidr_v6': 'fe80::a00:0/120',
+                           'netmask_v6': '120',
+                           'gateway': '10.0.0.1',
+                           'gateway_v6': 'fe80::a00:1',
+                           'broadcast': '10.0.0.255',
+                           'dns': '10.0.0.2',
+                           'ra_server': None,
+                           'vlan': 111,
+                           'injected': False}
+
+    fixed_ip_fields = {'address': '10.0.0.3',
+                       'address_v6': 'fe80::a00:3',
+                       'network_id': 'fake_flat'}
 
     class FakeModel(object):
-        """ Stubs out for model """
+        """Stubs out for model."""
         def __init__(self, values):
             self.values = values
 
@@ -56,38 +112,47 @@ def stub_out_db_instance_api(stubs):
     def fake_instance_type_get_by_name(context, name):
         return INSTANCE_TYPES[name]
 
-    def fake_instance_create(values):
-        """ Stubs out the db.instance_create method """
-
-        type_data = INSTANCE_TYPES[values['instance_type']]
-
-        base_options = {
-            'name': values['name'],
-            'id': values['id'],
-            'reservation_id': utils.generate_uid('r'),
-            'image_id': values['image_id'],
-            'kernel_id': values['kernel_id'],
-            'ramdisk_id': values['ramdisk_id'],
-            'state_description': 'scheduling',
-            'user_id': values['user_id'],
-            'project_id': values['project_id'],
-            'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
-            'instance_type': values['instance_type'],
-            'memory_mb': type_data['memory_mb'],
-            'mac_address': values['mac_address'],
-            'vcpus': type_data['vcpus'],
-            'local_gb': type_data['local_gb'],
-            'os_type': values['os_type']
-            }
-        return FakeModel(base_options)
+    def fake_instance_type_get_by_id(context, id):
+        for name, inst_type in INSTANCE_TYPES.iteritems():
+            if str(inst_type['id']) == str(id):
+                return inst_type
+        return None
 
     def fake_network_get_by_instance(context, instance_id):
-        fields = {
-            'bridge': 'xenbr0',
-            }
-        return FakeModel(fields)
+        # Even instance numbers are on vlan networks
+        if instance_id % 2 == 0:
+            return FakeModel(vlan_network_fields)
+        else:
+            return FakeModel(flat_network_fields)
+        return FakeModel(network_fields)
+
+    def fake_network_get_all_by_instance(context, instance_id):
+        # Even instance numbers are on vlan networks
+        if instance_id % 2 == 0:
+            return [FakeModel(vlan_network_fields)]
+        else:
+            return [FakeModel(flat_network_fields)]
+
+    def fake_instance_get_fixed_address(context, instance_id):
+        return FakeModel(fixed_ip_fields).address
+
+    def fake_instance_get_fixed_address_v6(context, instance_id):
+        return FakeModel(fixed_ip_fields).address
+
+    def fake_fixed_ip_get_all_by_instance(context, instance_id):
+        return [FakeModel(fixed_ip_fields)]
 
-    stubs.Set(db, 'instance_create', fake_instance_create)
     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
+    stubs.Set(db, 'network_get_all_by_instance',
+              fake_network_get_all_by_instance)
     stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)
     stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)
+    stubs.Set(db, 'instance_type_get_by_id', fake_instance_type_get_by_id)
+    stubs.Set(db, 'instance_get_fixed_address',
+        fake_instance_get_fixed_address)
+    stubs.Set(db, 'instance_get_fixed_address_v6',
+        fake_instance_get_fixed_address_v6)
+    stubs.Set(db, 'network_get_all_by_instance',
+        fake_network_get_all_by_instance)
+    stubs.Set(db, 'fixed_ip_get_all_by_instance',
+        fake_fixed_ip_get_all_by_instance)
diff --git a/nova/tests/fake_utils.py b/nova/tests/fake_utils.py
new file mode 100644
index 000000000..be59970c9
--- /dev/null
+++ b/nova/tests/fake_utils.py
@@ -0,0 +1,109 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Citrix Systems, Inc.
+#
+#    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.
+
+"""This modules stubs out functions in nova.utils."""
+
+import re
+import types
+
+from eventlet import greenthread
+
+from nova import exception
+from nova import log as logging
+from nova import utils
+
+LOG = logging.getLogger('nova.tests.fake_utils')
+
+_fake_execute_repliers = []
+_fake_execute_log = []
+
+
+def fake_execute_get_log():
+    return _fake_execute_log
+
+
+def fake_execute_clear_log():
+    global _fake_execute_log
+    _fake_execute_log = []
+
+
+def fake_execute_set_repliers(repliers):
+    """Allows the client to configure replies to commands."""
+    global _fake_execute_repliers
+    _fake_execute_repliers = repliers
+
+
+def fake_execute_default_reply_handler(*ignore_args, **ignore_kwargs):
+    """A reply handler for commands that haven't been added to the reply list.
+
+    Returns empty strings for stdout and stderr.
+
+    """
+    return '', ''
+
+
+def fake_execute(*cmd_parts, **kwargs):
+    """This function stubs out execute.
+
+    It optionally executes a preconfigued function to return expected data.
+
+    """
+    global _fake_execute_repliers
+
+    process_input = kwargs.get('process_input', None)
+    addl_env = kwargs.get('addl_env', None)
+    check_exit_code = kwargs.get('check_exit_code', 0)
+    cmd_str = ' '.join(str(part) for part in cmd_parts)
+
+    LOG.debug(_("Faking execution of cmd (subprocess): %s"), cmd_str)
+    _fake_execute_log.append(cmd_str)
+
+    reply_handler = fake_execute_default_reply_handler
+
+    for fake_replier in _fake_execute_repliers:
+        if re.match(fake_replier[0], cmd_str):
+            reply_handler = fake_replier[1]
+            LOG.debug(_('Faked command matched %s') % fake_replier[0])
+            break
+
+    if isinstance(reply_handler, basestring):
+        # If the reply handler is a string, return it as stdout
+        reply = reply_handler, ''
+    else:
+        try:
+            # Alternative is a function, so call it
+            reply = reply_handler(cmd_parts,
+                                  process_input=process_input,
+                                  addl_env=addl_env,
+                                  check_exit_code=check_exit_code)
+        except exception.ProcessExecutionError as e:
+            LOG.debug(_('Faked command raised an exception %s' % str(e)))
+            raise
+
+    stdout = reply[0]
+    stderr = reply[1]
+    LOG.debug(_("Reply to faked command is stdout='%(stdout)s' "
+                "stderr='%(stderr)s'") % locals())
+
+    # Replicate the sleep call in the real function
+    greenthread.sleep(0)
+    return reply
+
+
+def stub_out_utils_execute(stubs):
+    fake_execute_set_repliers([])
+    fake_execute_clear_log()
+    stubs.Set(utils, 'execute', fake_execute)
diff --git a/nova/tests/hyperv_unittest.py b/nova/tests/hyperv_unittest.py
index 3980ae3cb..042819b9c 100644
--- a/nova/tests/hyperv_unittest.py
+++ b/nova/tests/hyperv_unittest.py
@@ -51,7 +51,7 @@ class HyperVTestCase(test.TestCase):
         instance_ref = db.instance_create(self.context, instance)
 
         conn = hyperv.get_connection(False)
-        conn._create_vm(instance_ref)  # pylint: disable-msg=W0212
+        conn._create_vm(instance_ref)  # pylint: disable=W0212
         found = [n  for n in conn.list_instances()
                       if n == instance_ref['name']]
         self.assertTrue(len(found) == 1)
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..109905ded
--- /dev/null
+++ b/nova/tests/image/test_glance.py
@@ -0,0 +1,236 @@
+# 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 import context
+from nova import test
+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, image_id):
+        return self.images[image_id]
+
+    def get_images_detailed(self):
+        return self.images.itervalues()
+
+    def get_image(self, image_id):
+        return self.images[image_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):
+    """Used to test ImageService.get which takes a writer object"""
+
+    def write(self, *arg, **kwargs):
+        pass
+
+
+class BaseGlanceTest(unittest.TestCase):
+    NOW_GLANCE_OLD_FORMAT = "2010-10-11T10:30:22"
+    NOW_GLANCE_FORMAT = "2010-10-11T10:30:22.000000"
+    NOW_DATETIME = datetime.datetime(2010, 10, 11, 10, 30, 22)
+
+    def setUp(self):
+        # FIXME(sirp): we can probably use stubs library here rather than
+        # dependency injection
+        self.client = StubGlanceClient(None)
+        self.service = glance.GlanceImageService(self.client)
+        self.context = context.RequestContext(None, None)
+
+    def assertDateTimesFilled(self, image_meta):
+        self.assertEqual(image_meta['created_at'], self.NOW_DATETIME)
+        self.assertEqual(image_meta['updated_at'], self.NOW_DATETIME)
+        self.assertEqual(image_meta['deleted_at'], self.NOW_DATETIME)
+
+    def assertDateTimesEmpty(self, image_meta):
+        self.assertEqual(image_meta['updated_at'], None)
+        self.assertEqual(image_meta['deleted_at'], None)
+
+    def assertDateTimesBlank(self, image_meta):
+        self.assertEqual(image_meta['updated_at'], '')
+        self.assertEqual(image_meta['deleted_at'], '')
+
+
+class TestGlanceImageServiceProperties(BaseGlanceTest):
+    def test_show_passes_through_to_client(self):
+        """Ensure attributes which aren't BASE_IMAGE_ATTRS are stored in the
+        properties dict
+        """
+        fixtures = {'image1': {'name': 'image1', 'is_public': True,
+                               'foo': 'bar',
+                               'properties': {'prop1': 'propvalue1'}}}
+        self.client.images = fixtures
+        image_meta = self.service.show(self.context, 'image1')
+
+        expected = {'name': 'image1', 'is_public': True,
+                    'properties': {'prop1': 'propvalue1', 'foo': 'bar'}}
+        self.assertEqual(image_meta, expected)
+
+    def test_detail_passes_through_to_client(self):
+        fixtures = {'image1': {'name': 'image1', 'is_public': True,
+                               'foo': 'bar',
+                               'properties': {'prop1': 'propvalue1'}}}
+        self.client.images = fixtures
+        image_meta = self.service.detail(self.context)
+        expected = [{'name': 'image1', 'is_public': True,
+                    'properties': {'prop1': 'propvalue1', 'foo': 'bar'}}]
+        self.assertEqual(image_meta, expected)
+
+
+class TestGetterDateTimeNoneTests(BaseGlanceTest):
+
+    def test_show_handles_none_datetimes(self):
+        self.client.images = self._make_none_datetime_fixtures()
+        image_meta = self.service.show(self.context, 'image1')
+        self.assertDateTimesEmpty(image_meta)
+
+    def test_show_handles_blank_datetimes(self):
+        self.client.images = self._make_blank_datetime_fixtures()
+        image_meta = self.service.show(self.context, 'image1')
+        self.assertDateTimesBlank(image_meta)
+
+    def test_detail_handles_none_datetimes(self):
+        self.client.images = self._make_none_datetime_fixtures()
+        image_meta = self.service.detail(self.context)[0]
+        self.assertDateTimesEmpty(image_meta)
+
+    def test_detail_handles_blank_datetimes(self):
+        self.client.images = self._make_blank_datetime_fixtures()
+        image_meta = self.service.detail(self.context)[0]
+        self.assertDateTimesBlank(image_meta)
+
+    def test_get_handles_none_datetimes(self):
+        self.client.images = self._make_none_datetime_fixtures()
+        writer = NullWriter()
+        image_meta = self.service.get(self.context, 'image1', writer)
+        self.assertDateTimesEmpty(image_meta)
+
+    def test_get_handles_blank_datetimes(self):
+        self.client.images = self._make_blank_datetime_fixtures()
+        writer = NullWriter()
+        image_meta = self.service.get(self.context, 'image1', writer)
+        self.assertDateTimesBlank(image_meta)
+
+    def test_show_makes_datetimes(self):
+        self.client.images = self._make_datetime_fixtures()
+        image_meta = self.service.show(self.context, 'image1')
+        self.assertDateTimesFilled(image_meta)
+        image_meta = self.service.show(self.context, 'image2')
+        self.assertDateTimesFilled(image_meta)
+
+    def test_detail_makes_datetimes(self):
+        self.client.images = self._make_datetime_fixtures()
+        image_meta = self.service.detail(self.context)[0]
+        self.assertDateTimesFilled(image_meta)
+        image_meta = self.service.detail(self.context)[1]
+        self.assertDateTimesFilled(image_meta)
+
+    def test_get_makes_datetimes(self):
+        self.client.images = self._make_datetime_fixtures()
+        writer = NullWriter()
+        image_meta = self.service.get(self.context, 'image1', writer)
+        self.assertDateTimesFilled(image_meta)
+        image_meta = self.service.get(self.context, 'image2', writer)
+        self.assertDateTimesFilled(image_meta)
+
+    def _make_datetime_fixtures(self):
+        fixtures = {
+            'image1': {
+                'name': 'image1',
+                'is_public': True,
+                'created_at': self.NOW_GLANCE_FORMAT,
+                'updated_at': self.NOW_GLANCE_FORMAT,
+                'deleted_at': self.NOW_GLANCE_FORMAT,
+            },
+            'image2': {
+                'name': 'image2',
+                'is_public': True,
+                'created_at': self.NOW_GLANCE_OLD_FORMAT,
+                'updated_at': self.NOW_GLANCE_OLD_FORMAT,
+                'deleted_at': self.NOW_GLANCE_OLD_FORMAT,
+            },
+        }
+        return fixtures
+
+    def _make_none_datetime_fixtures(self):
+        fixtures = {'image1': {'name': 'image1', 'is_public': True,
+                               'updated_at': None,
+                               'deleted_at': None}}
+        return fixtures
+
+    def _make_blank_datetime_fixtures(self):
+        fixtures = {'image1': {'name': 'image1', 'is_public': True,
+                               'updated_at': '',
+                               'deleted_at': ''}}
+        return fixtures
+
+
+class TestMutatorDateTimeTests(BaseGlanceTest):
+    """Tests create(), update()"""
+
+    def test_create_handles_datetimes(self):
+        self.client.add_response = self._make_datetime_fixture()
+        image_meta = self.service.create(self.context, {})
+        self.assertDateTimesFilled(image_meta)
+
+    def test_create_handles_none_datetimes(self):
+        self.client.add_response = self._make_none_datetime_fixture()
+        dummy_meta = {}
+        image_meta = self.service.create(self.context, dummy_meta)
+        self.assertDateTimesEmpty(image_meta)
+
+    def test_update_handles_datetimes(self):
+        self.client.images = {'image1': self._make_datetime_fixture()}
+        self.client.update_response = self._make_datetime_fixture()
+        dummy_meta = {}
+        image_meta = self.service.update(self.context, 'image1', dummy_meta)
+        self.assertDateTimesFilled(image_meta)
+
+    def test_update_handles_none_datetimes(self):
+        self.client.images = {'image1': self._make_datetime_fixture()}
+        self.client.update_response = self._make_none_datetime_fixture()
+        dummy_meta = {}
+        image_meta = self.service.update(self.context, 'image1', dummy_meta)
+        self.assertDateTimesEmpty(image_meta)
+
+    def _make_datetime_fixture(self):
+        fixture = {'id': 'image1', 'name': 'image1', 'is_public': True,
+                   'created_at': self.NOW_GLANCE_FORMAT,
+                   'updated_at': self.NOW_GLANCE_FORMAT,
+                   'deleted_at': self.NOW_GLANCE_FORMAT}
+        return fixture
+
+    def _make_none_datetime_fixture(self):
+        fixture = {'id': 'image1', 'name': 'image1', 'is_public': True,
+                   'updated_at': None,
+                   'deleted_at': None}
+        return fixture
diff --git a/nova/tests/integrated/__init__.py b/nova/tests/integrated/__init__.py
new file mode 100644
index 000000000..10e0a91d7
--- /dev/null
+++ b/nova/tests/integrated/__init__.py
@@ -0,0 +1,20 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright (c) 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.
+
+"""
+:mod:`integrated` -- Tests whole systems, using mock services where needed
+=================================
+"""
diff --git a/nova/tests/integrated/api/__init__.py b/nova/tests/integrated/api/__init__.py
new file mode 100644
index 000000000..5798ab3d1
--- /dev/null
+++ b/nova/tests/integrated/api/__init__.py
@@ -0,0 +1,20 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright (c) 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.
+
+"""
+:mod:`api` -- OpenStack API client, for testing rather than production
+=================================
+"""
diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
new file mode 100644
index 000000000..7e20c9b00
--- /dev/null
+++ b/nova/tests/integrated/api/client.py
@@ -0,0 +1,244 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright (c) 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.
+
+import json
+import httplib
+import urlparse
+
+from nova import log as logging
+
+
+LOG = logging.getLogger('nova.tests.api')
+
+
+class OpenStackApiException(Exception):
+    def __init__(self, message=None, response=None):
+        self.response = response
+        if not message:
+            message = 'Unspecified error'
+
+        if response:
+            _status = response.status
+            _body = response.read()
+
+            message = _('%(message)s\nStatus Code: %(_status)s\n'
+                        'Body: %(_body)s') % locals()
+
+        super(OpenStackApiException, self).__init__(message)
+
+
+class OpenStackApiAuthenticationException(OpenStackApiException):
+    def __init__(self, response=None, message=None):
+        if not message:
+            message = _("Authentication error")
+        super(OpenStackApiAuthenticationException, self).__init__(message,
+                                                                  response)
+
+
+class OpenStackApiNotFoundException(OpenStackApiException):
+    def __init__(self, response=None, message=None):
+        if not message:
+            message = _("Item not found")
+        super(OpenStackApiNotFoundException, self).__init__(message, response)
+
+
+class TestOpenStackClient(object):
+    """Simple OpenStack API Client.
+
+    This is a really basic OpenStack API client that is under our control,
+    so we can make changes / insert hooks for testing
+
+    """
+
+    def __init__(self, auth_user, auth_key, auth_uri):
+        super(TestOpenStackClient, self).__init__()
+        self.auth_result = None
+        self.auth_user = auth_user
+        self.auth_key = auth_key
+        self.auth_uri = auth_uri
+
+    def request(self, url, method='GET', body=None, headers=None):
+        if headers is None:
+            headers = {}
+
+        parsed_url = urlparse.urlparse(url)
+        port = parsed_url.port
+        hostname = parsed_url.hostname
+        scheme = parsed_url.scheme
+
+        if scheme == 'http':
+            conn = httplib.HTTPConnection(hostname,
+                                          port=port)
+        elif scheme == 'https':
+            conn = httplib.HTTPSConnection(hostname,
+                                           port=port)
+        else:
+            raise OpenStackApiException("Unknown scheme: %s" % url)
+
+        relative_url = parsed_url.path
+        if parsed_url.query:
+            relative_url = relative_url + parsed_url.query
+        LOG.info(_("Doing %(method)s on %(relative_url)s") % locals())
+        if body:
+            LOG.info(_("Body: %s") % body)
+            headers.setdefault('Content-Type', 'application/json')
+
+        conn.request(method, relative_url, body, headers)
+        response = conn.getresponse()
+        return response
+
+    def _authenticate(self):
+        if self.auth_result:
+            return self.auth_result
+
+        auth_uri = self.auth_uri
+        headers = {'X-Auth-User': self.auth_user,
+                   'X-Auth-Key': self.auth_key}
+        response = self.request(auth_uri,
+                                headers=headers)
+
+        http_status = response.status
+        LOG.debug(_("%(auth_uri)s => code %(http_status)s") % locals())
+
+        if http_status == 401:
+            raise OpenStackApiAuthenticationException(response=response)
+
+        auth_headers = {}
+        for k, v in response.getheaders():
+            auth_headers[k] = v
+
+        self.auth_result = auth_headers
+        return self.auth_result
+
+    def api_request(self, relative_uri, check_response_status=None, **kwargs):
+        auth_result = self._authenticate()
+
+        # NOTE(justinsb): httplib 'helpfully' converts headers to lower case
+        base_uri = auth_result['x-server-management-url']
+        full_uri = base_uri + relative_uri
+
+        headers = kwargs.setdefault('headers', {})
+        headers['X-Auth-Token'] = auth_result['x-auth-token']
+
+        response = self.request(full_uri, **kwargs)
+
+        http_status = response.status
+        LOG.debug(_("%(relative_uri)s => code %(http_status)s") % locals())
+
+        if check_response_status:
+            if not http_status in check_response_status:
+                if http_status == 404:
+                    raise OpenStackApiNotFoundException(response=response)
+                else:
+                    raise OpenStackApiException(
+                                        message=_("Unexpected status code"),
+                                        response=response)
+
+        return response
+
+    def _decode_json(self, response):
+        body = response.read()
+        LOG.debug(_("Decoding JSON: %s") % (body))
+        return json.loads(body)
+
+    def api_get(self, relative_uri, **kwargs):
+        kwargs.setdefault('check_response_status', [200])
+        response = self.api_request(relative_uri, **kwargs)
+        return self._decode_json(response)
+
+    def api_post(self, relative_uri, body, **kwargs):
+        kwargs['method'] = 'POST'
+        if body:
+            headers = kwargs.setdefault('headers', {})
+            headers['Content-Type'] = 'application/json'
+            kwargs['body'] = json.dumps(body)
+
+        kwargs.setdefault('check_response_status', [200])
+        response = self.api_request(relative_uri, **kwargs)
+        return self._decode_json(response)
+
+    def api_delete(self, relative_uri, **kwargs):
+        kwargs['method'] = 'DELETE'
+        kwargs.setdefault('check_response_status', [200, 202])
+        return self.api_request(relative_uri, **kwargs)
+
+    def get_server(self, server_id):
+        return self.api_get('/servers/%s' % server_id)['server']
+
+    def get_servers(self, detail=True):
+        rel_url = '/servers/detail' if detail else '/servers'
+        return self.api_get(rel_url)['servers']
+
+    def post_server(self, server):
+        return self.api_post('/servers', server)['server']
+
+    def delete_server(self, server_id):
+        return self.api_delete('/servers/%s' % server_id)
+
+    def get_image(self, image_id):
+        return self.api_get('/images/%s' % image_id)['image']
+
+    def get_images(self, detail=True):
+        rel_url = '/images/detail' if detail else '/images'
+        return self.api_get(rel_url)['images']
+
+    def post_image(self, image):
+        return self.api_post('/images', image)['image']
+
+    def delete_image(self, image_id):
+        return self.api_delete('/images/%s' % image_id)
+
+    def get_flavor(self, flavor_id):
+        return self.api_get('/flavors/%s' % flavor_id)['flavor']
+
+    def get_flavors(self, detail=True):
+        rel_url = '/flavors/detail' if detail else '/flavors'
+        return self.api_get(rel_url)['flavors']
+
+    def post_flavor(self, flavor):
+        return self.api_post('/flavors', flavor)['flavor']
+
+    def delete_flavor(self, flavor_id):
+        return self.api_delete('/flavors/%s' % flavor_id)
+
+    def get_volume(self, volume_id):
+        return self.api_get('/volumes/%s' % volume_id)['volume']
+
+    def get_volumes(self, detail=True):
+        rel_url = '/volumes/detail' if detail else '/volumes'
+        return self.api_get(rel_url)['volumes']
+
+    def post_volume(self, volume):
+        return self.api_post('/volumes', volume)['volume']
+
+    def delete_volume(self, volume_id):
+        return self.api_delete('/volumes/%s' % volume_id)
+
+    def get_server_volume(self, server_id, attachment_id):
+        return self.api_get('/servers/%s/volume_attachments/%s' %
+                            (server_id, attachment_id))['volumeAttachment']
+
+    def get_server_volumes(self, server_id):
+        return self.api_get('/servers/%s/volume_attachments' %
+                            (server_id))['volumeAttachments']
+
+    def post_server_volume(self, server_id, volume_attachment):
+        return self.api_post('/servers/%s/volume_attachments' %
+                        (server_id), volume_attachment)['volumeAttachment']
+
+    def delete_server_volume(self, server_id, attachment_id):
+        return self.api_delete('/servers/%s/volume_attachments/%s' %
+                            (server_id, attachment_id))
diff --git a/nova/tests/integrated/integrated_helpers.py b/nova/tests/integrated/integrated_helpers.py
new file mode 100644
index 000000000..2e5d67017
--- /dev/null
+++ b/nova/tests/integrated/integrated_helpers.py
@@ -0,0 +1,221 @@
+# 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.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
+        LOG.debug("Random collision on %s" % candidate)
+
+
+class TestUser(object):
+    def __init__(self, name, secret, auth_url):
+        self.name = name
+        self.secret = secret
+        self.auth_url = auth_url
+
+        if not auth_url:
+            raise exception.Error("auth_url is required")
+        self.openstack_api = client.TestOpenStackClient(self.name,
+                                                        self.secret,
+                                                        self.auth_url)
+
+    def get_unused_server_name(self):
+        servers = self.openstack_api.get_servers()
+        server_names = [server['name'] for server in servers]
+        return generate_new_element(server_names, 'server')
+
+    def get_invalid_image(self):
+        images = self.openstack_api.get_images()
+        image_ids = [image['id'] for image in images]
+        return generate_new_element(image_ids, '', numeric=True)
+
+    def get_valid_image(self, create=False):
+        images = self.openstack_api.get_images()
+        if create and not images:
+            # TODO(justinsb): No way currently to create an image through API
+            #created_image = self.openstack_api.post_image(image)
+            #images.append(created_image)
+            raise exception.Error("No way to create an image through API")
+
+        if images:
+            return images[0]
+        return None
+
+
+class IntegratedUnitTestContext(object):
+    def __init__(self, auth_url):
+        self.auth_manager = manager.AuthManager()
+
+        self.auth_url = auth_url
+        self.project_name = None
+
+        self.test_user = None
+
+        self.setup()
+
+    def setup(self):
+        self._create_test_user()
+
+    def _create_test_user(self):
+        self.test_user = self._create_unittest_user()
+
+        # No way to currently pass this through the OpenStack API
+        self.project_name = 'openstack'
+        self._configure_project(self.project_name, self.test_user)
+
+    def cleanup(self):
+        self.test_user = None
+
+    def _create_unittest_user(self):
+        users = self.auth_manager.get_users()
+        user_names = [user.name for user in users]
+        auth_name = generate_new_element(user_names, 'unittest_user_')
+        auth_key = generate_random_alphanumeric(16)
+
+        # Right now there's a bug where auth_name and auth_key are reversed
+        # bug732907
+        auth_key = auth_name
+
+        self.auth_manager.create_user(auth_name, auth_name, auth_key, False)
+        return TestUser(auth_name, auth_key, self.auth_url)
+
+    def _configure_project(self, project_name, user):
+        projects = self.auth_manager.get_projects()
+        project_names = [project.name for project in projects]
+        if not project_name in project_names:
+            project = self.auth_manager.create_project(project_name,
+                                                       user.name,
+                                                       description=None,
+                                                       member_users=None)
+        else:
+            self.auth_manager.add_to_project(user.name, project_name)
+
+
+class _IntegratedTestBase(test.TestCase):
+    def setUp(self):
+        super(_IntegratedTestBase, self).setUp()
+
+        f = self._get_flags()
+        self.flags(**f)
+
+        # set up services
+        self.start_service('compute')
+        self.start_service('volume')
+        # NOTE(justinsb): There's a bug here which is eluding me...
+        # If we start the network_service, all is good, but then subsequent
+        # tests fail: CloudTestCase.test_ajax_console in particular.
+        #self.start_service('network')
+        self.start_service('scheduler')
+
+        self.auth_url = self._start_api_service()
+
+        self.context = IntegratedUnitTestContext(self.auth_url)
+
+        self.user = self.context.test_user
+        self.api = self.user.openstack_api
+
+    def _start_api_service(self):
+        api_service = service.ApiService.create()
+        api_service.start()
+
+        if not api_service:
+            raise Exception("API Service was None")
+
+        auth_url = 'http://localhost:8774/v1.1'
+        return auth_url
+
+    def tearDown(self):
+        self.context.cleanup()
+        super(_IntegratedTestBase, self).tearDown()
+
+    def _get_flags(self):
+        """An opportunity to setup flags, before the services are started."""
+        f = {}
+        f['image_service'] = 'nova.image.fake.FakeImageService'
+        f['fake_network'] = True
+        return f
+
+    def _build_minimal_create_server_request(self):
+        server = {}
+
+        image = self.user.get_valid_image(create=True)
+        LOG.debug("Image: %s" % image)
+
+        if 'imageRef' in image:
+            image_ref = image['imageRef']
+        else:
+            # NOTE(justinsb): The imageRef code hasn't yet landed
+            LOG.warning("imageRef not yet in images output")
+            image_ref = image['id']
+
+            # TODO(justinsb): This is FUBAR
+            image_ref = abs(hash(image_ref))
+
+            image_ref = 'http://fake.server/%s' % image_ref
+
+        # We now have a valid imageId
+        server['imageRef'] = image_ref
+
+        # Set a valid flavorId
+        flavor = self.api.get_flavors()[0]
+        LOG.debug("Using flavor: %s" % flavor)
+        server['flavorRef'] = 'http://fake.server/%s' % flavor['id']
+
+        # Set a valid server name
+        server_name = self.user.get_unused_server_name()
+        server['name'] = server_name
+
+        return server
diff --git a/nova/tests/integrated/test_extensions.py b/nova/tests/integrated/test_extensions.py
new file mode 100644
index 000000000..0d4ee8cab
--- /dev/null
+++ b/nova/tests/integrated/test_extensions.py
@@ -0,0 +1,44 @@
+# 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 os
+
+from nova import flags
+from nova.log import logging
+from nova.tests.integrated import integrated_helpers
+
+
+LOG = logging.getLogger('nova.tests.integrated')
+
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+class ExtensionsTest(integrated_helpers._IntegratedTestBase):
+    def _get_flags(self):
+        f = super(ExtensionsTest, self)._get_flags()
+        f['osapi_extensions_path'] = os.path.join(os.path.dirname(__file__),
+                                                "../api/openstack/extensions")
+        return f
+
+    def test_get_foxnsocks(self):
+        """Simple check that fox-n-socks works."""
+        response = self.api.api_request('/foxnsocks')
+        foxnsocks = response.read()
+        LOG.debug("foxnsocks: %s" % foxnsocks)
+        self.assertEqual('Try to say this Mr. Knox, sir...', foxnsocks)
diff --git a/nova/tests/integrated/test_login.py b/nova/tests/integrated/test_login.py
new file mode 100644
index 000000000..a5180b6bc
--- /dev/null
+++ b/nova/tests/integrated/test_login.py
@@ -0,0 +1,68 @@
+# 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.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(integrated_helpers._IntegratedTestBase):
+    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/integrated/test_servers.py b/nova/tests/integrated/test_servers.py
new file mode 100644
index 000000000..e89d0100a
--- /dev/null
+++ b/nova/tests/integrated/test_servers.py
@@ -0,0 +1,184 @@
+# 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 time
+import unittest
+
+from nova import flags
+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 ServersTest(integrated_helpers._IntegratedTestBase):
+    def test_get_servers(self):
+        """Simple check that listing servers works."""
+        servers = self.api.get_servers()
+        for server in servers:
+            LOG.debug("server: %s" % server)
+
+    def test_create_and_delete_server(self):
+        """Creates and deletes a server."""
+
+        # Create server
+
+        # Build the server data gradually, checking errors along the way
+        server = {}
+        good_server = self._build_minimal_create_server_request()
+
+        post = {'server': server}
+
+        # Without an imageRef, this throws 500.
+        # TODO(justinsb): Check whatever the spec says should be thrown here
+        self.assertRaises(client.OpenStackApiException,
+                          self.api.post_server, post)
+
+        # With an invalid imageRef, this throws 500.
+        server['imageRef'] = self.user.get_invalid_image()
+        # TODO(justinsb): Check whatever the spec says should be thrown here
+        self.assertRaises(client.OpenStackApiException,
+                          self.api.post_server, post)
+
+        # Add a valid imageId/imageRef
+        server['imageId'] = good_server.get('imageId')
+        server['imageRef'] = good_server.get('imageRef')
+
+        # Without flavorId, this throws 500
+        # TODO(justinsb): Check whatever the spec says should be thrown here
+        self.assertRaises(client.OpenStackApiException,
+                          self.api.post_server, post)
+
+        # Set a valid flavorId/flavorRef
+        server['flavorRef'] = good_server.get('flavorRef')
+        server['flavorId'] = good_server.get('flavorId')
+
+        # Without a name, this throws 500
+        # TODO(justinsb): Check whatever the spec says should be thrown here
+        self.assertRaises(client.OpenStackApiException,
+                          self.api.post_server, post)
+
+        # Set a valid server name
+        server['name'] = good_server['name']
+
+        created_server = self.api.post_server(post)
+        LOG.debug("created_server: %s" % created_server)
+        self.assertTrue(created_server['id'])
+        created_server_id = created_server['id']
+
+        # Check it's there
+        found_server = self.api.get_server(created_server_id)
+        self.assertEqual(created_server_id, found_server['id'])
+
+        # It should also be in the all-servers list
+        servers = self.api.get_servers()
+        server_ids = [server['id'] for server in servers]
+        self.assertTrue(created_server_id in server_ids)
+
+        # Wait (briefly) for creation
+        retries = 0
+        while found_server['status'] == 'build':
+            LOG.debug("found server: %s" % found_server)
+            time.sleep(1)
+            found_server = self.api.get_server(created_server_id)
+            retries = retries + 1
+            if retries > 5:
+                break
+
+        # It should be available...
+        # TODO(justinsb): Mock doesn't yet do this...
+        #self.assertEqual('available', found_server['status'])
+
+        self._delete_server(created_server_id)
+
+    def _delete_server(self, server_id):
+        # Delete the server
+        self.api.delete_server(server_id)
+
+        # Wait (briefly) for deletion
+        for _retries in range(5):
+            try:
+                found_server = self.api.get_server(server_id)
+            except client.OpenStackApiNotFoundException:
+                found_server = None
+                LOG.debug("Got 404, proceeding")
+                break
+
+            LOG.debug("Found_server=%s" % found_server)
+
+            # TODO(justinsb): Mock doesn't yet do accurate state changes
+            #if found_server['status'] != 'deleting':
+            #    break
+            time.sleep(1)
+
+        # Should be gone
+        self.assertFalse(found_server)
+
+    def test_create_server_with_metadata(self):
+        """Creates a server with metadata."""
+
+        # Build the server data gradually, checking errors along the way
+        server = self._build_minimal_create_server_request()
+
+        metadata = {}
+        for i in range(30):
+            metadata['key_%s' % i] = 'value_%s' % i
+
+        server['metadata'] = metadata
+
+        post = {'server': server}
+        created_server = self.api.post_server(post)
+        LOG.debug("created_server: %s" % created_server)
+        self.assertTrue(created_server['id'])
+        created_server_id = created_server['id']
+
+        # Reenable when bug fixed
+        self.assertEqual(metadata, created_server.get('metadata'))
+        # Check it's there
+
+        found_server = self.api.get_server(created_server_id)
+        self.assertEqual(created_server_id, found_server['id'])
+        self.assertEqual(metadata, found_server.get('metadata'))
+
+        # The server should also be in the all-servers details list
+        servers = self.api.get_servers(detail=True)
+        server_map = dict((server['id'], server) for server in servers)
+        found_server = server_map.get(created_server_id)
+        self.assertTrue(found_server)
+        # Details do include metadata
+        self.assertEqual(metadata, found_server.get('metadata'))
+
+        # The server should also be in the all-servers summary list
+        servers = self.api.get_servers(detail=False)
+        server_map = dict((server['id'], server) for server in servers)
+        found_server = server_map.get(created_server_id)
+        self.assertTrue(found_server)
+        # Summary should not include metadata
+        self.assertFalse(found_server.get('metadata'))
+
+        # Cleanup
+        self._delete_server(created_server_id)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/nova/tests/integrated/test_volumes.py b/nova/tests/integrated/test_volumes.py
new file mode 100644
index 000000000..e9fb3c4d1
--- /dev/null
+++ b/nova/tests/integrated/test_volumes.py
@@ -0,0 +1,295 @@
+# 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
+import time
+
+from nova import flags
+from nova.log import logging
+from nova.tests.integrated import integrated_helpers
+from nova.tests.integrated.api import client
+from nova.volume import driver
+
+
+LOG = logging.getLogger('nova.tests.integrated')
+
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+class VolumesTest(integrated_helpers._IntegratedTestBase):
+    def setUp(self):
+        super(VolumesTest, self).setUp()
+        driver.LoggingVolumeDriver.clear_logs()
+
+    def _get_flags(self):
+        f = super(VolumesTest, self)._get_flags()
+        f['use_local_volumes'] = False  # Avoids calling local_path
+        f['volume_driver'] = 'nova.volume.driver.LoggingVolumeDriver'
+        return f
+
+    def test_get_volumes_summary(self):
+        """Simple check that listing volumes works."""
+        volumes = self.api.get_volumes(False)
+        for volume in volumes:
+            LOG.debug("volume: %s" % volume)
+
+    def test_get_volumes(self):
+        """Simple check that listing volumes works."""
+        volumes = self.api.get_volumes()
+        for volume in volumes:
+            LOG.debug("volume: %s" % volume)
+
+    def _poll_while(self, volume_id, continue_states, max_retries=5):
+        """Poll (briefly) while the state is in continue_states."""
+        retries = 0
+        while True:
+            try:
+                found_volume = self.api.get_volume(volume_id)
+            except client.OpenStackApiNotFoundException:
+                found_volume = None
+                LOG.debug("Got 404, proceeding")
+                break
+
+            LOG.debug("Found %s" % found_volume)
+
+            self.assertEqual(volume_id, found_volume['id'])
+
+            if not found_volume['status'] in continue_states:
+                break
+
+            time.sleep(1)
+            retries = retries + 1
+            if retries > max_retries:
+                break
+        return found_volume
+
+    def test_create_and_delete_volume(self):
+        """Creates and deletes a volume."""
+
+        # Create volume
+        created_volume = self.api.post_volume({'volume': {'size': 1}})
+        LOG.debug("created_volume: %s" % created_volume)
+        self.assertTrue(created_volume['id'])
+        created_volume_id = created_volume['id']
+
+        # Check it's there
+        found_volume = self.api.get_volume(created_volume_id)
+        self.assertEqual(created_volume_id, found_volume['id'])
+
+        # It should also be in the all-volume list
+        volumes = self.api.get_volumes()
+        volume_names = [volume['id'] for volume in volumes]
+        self.assertTrue(created_volume_id in volume_names)
+
+        # Wait (briefly) for creation. Delay is due to the 'message queue'
+        found_volume = self._poll_while(created_volume_id, ['creating'])
+
+        # It should be available...
+        self.assertEqual('available', found_volume['status'])
+
+        # Delete the volume
+        self.api.delete_volume(created_volume_id)
+
+        # Wait (briefly) for deletion. Delay is due to the 'message queue'
+        found_volume = self._poll_while(created_volume_id, ['deleting'])
+
+        # Should be gone
+        self.assertFalse(found_volume)
+
+        LOG.debug("Logs: %s" % driver.LoggingVolumeDriver.all_logs())
+
+        create_actions = driver.LoggingVolumeDriver.logs_like(
+                            'create_volume',
+                            id=created_volume_id)
+        LOG.debug("Create_Actions: %s" % create_actions)
+
+        self.assertEquals(1, len(create_actions))
+        create_action = create_actions[0]
+        self.assertEquals(create_action['id'], created_volume_id)
+        self.assertEquals(create_action['availability_zone'], 'nova')
+        self.assertEquals(create_action['size'], 1)
+
+        export_actions = driver.LoggingVolumeDriver.logs_like(
+                            'create_export',
+                            id=created_volume_id)
+        self.assertEquals(1, len(export_actions))
+        export_action = export_actions[0]
+        self.assertEquals(export_action['id'], created_volume_id)
+        self.assertEquals(export_action['availability_zone'], 'nova')
+
+        delete_actions = driver.LoggingVolumeDriver.logs_like(
+                            'delete_volume',
+                            id=created_volume_id)
+        self.assertEquals(1, len(delete_actions))
+        delete_action = export_actions[0]
+        self.assertEquals(delete_action['id'], created_volume_id)
+
+    def test_attach_and_detach_volume(self):
+        """Creates, attaches, detaches and deletes a volume."""
+
+        # Create server
+        server_req = {'server': self._build_minimal_create_server_request()}
+        # NOTE(justinsb): Create an extra server so that server_id != volume_id
+        self.api.post_server(server_req)
+        created_server = self.api.post_server(server_req)
+        LOG.debug("created_server: %s" % created_server)
+        server_id = created_server['id']
+
+        # Create volume
+        created_volume = self.api.post_volume({'volume': {'size': 1}})
+        LOG.debug("created_volume: %s" % created_volume)
+        volume_id = created_volume['id']
+        self._poll_while(volume_id, ['creating'])
+
+        # Check we've got different IDs
+        self.assertNotEqual(server_id, volume_id)
+
+        # List current server attachments - should be none
+        attachments = self.api.get_server_volumes(server_id)
+        self.assertEquals([], attachments)
+
+        # Template attach request
+        device = '/dev/sdc'
+        attach_req = {'device': device}
+        post_req = {'volumeAttachment': attach_req}
+
+        # Try to attach to a non-existent volume; should fail
+        attach_req['volumeId'] = 3405691582
+        self.assertRaises(client.OpenStackApiNotFoundException,
+                          self.api.post_server_volume, server_id, post_req)
+
+        # Try to attach to a non-existent server; should fail
+        attach_req['volumeId'] = volume_id
+        self.assertRaises(client.OpenStackApiNotFoundException,
+                          self.api.post_server_volume, 3405691582, post_req)
+
+        # Should still be no attachments...
+        attachments = self.api.get_server_volumes(server_id)
+        self.assertEquals([], attachments)
+
+        # Do a real attach
+        attach_req['volumeId'] = volume_id
+        attach_result = self.api.post_server_volume(server_id, post_req)
+        LOG.debug(_("Attachment = %s") % attach_result)
+
+        attachment_id = attach_result['id']
+        self.assertEquals(volume_id, attach_result['volumeId'])
+
+        # These fields aren't set because it's async
+        #self.assertEquals(server_id, attach_result['serverId'])
+        #self.assertEquals(device, attach_result['device'])
+
+        # This is just an implementation detail, but let's check it...
+        self.assertEquals(volume_id, attachment_id)
+
+        # NOTE(justinsb): There's an issue with the attach code, in that
+        # it's currently asynchronous and not recorded until the attach
+        # completes.  So the caller must be 'smart', like this...
+        attach_done = None
+        retries = 0
+        while True:
+            try:
+                attach_done = self.api.get_server_volume(server_id,
+                                                             attachment_id)
+                break
+            except client.OpenStackApiNotFoundException:
+                LOG.debug("Got 404, waiting")
+
+            time.sleep(1)
+            retries = retries + 1
+            if retries > 10:
+                break
+
+        expect_attach = {}
+        expect_attach['id'] = volume_id
+        expect_attach['volumeId'] = volume_id
+        expect_attach['serverId'] = server_id
+        expect_attach['device'] = device
+
+        self.assertEqual(expect_attach, attach_done)
+
+        # Should be one attachemnt
+        attachments = self.api.get_server_volumes(server_id)
+        self.assertEquals([expect_attach], attachments)
+
+        # Should be able to get details
+        attachment_info = self.api.get_server_volume(server_id, attachment_id)
+        self.assertEquals(expect_attach, attachment_info)
+
+        # Getting details on a different id should fail
+        self.assertRaises(client.OpenStackApiNotFoundException,
+                          self.api.get_server_volume, server_id, 3405691582)
+        self.assertRaises(client.OpenStackApiNotFoundException,
+                          self.api.get_server_volume,
+                          3405691582, attachment_id)
+
+        # Trying to detach a different id should fail
+        self.assertRaises(client.OpenStackApiNotFoundException,
+                          self.api.delete_server_volume, server_id, 3405691582)
+
+        # Detach should work
+        self.api.delete_server_volume(server_id, attachment_id)
+
+        # Again, it's async, so wait...
+        retries = 0
+        while True:
+            try:
+                attachment = self.api.get_server_volume(server_id,
+                                                        attachment_id)
+                LOG.debug("Attachment still there: %s" % attachment)
+            except client.OpenStackApiNotFoundException:
+                LOG.debug("Got 404, delete done")
+                break
+
+            time.sleep(1)
+            retries = retries + 1
+            self.assertTrue(retries < 10)
+
+        # Should be no attachments again
+        attachments = self.api.get_server_volumes(server_id)
+        self.assertEquals([], attachments)
+
+        LOG.debug("Logs: %s" % driver.LoggingVolumeDriver.all_logs())
+
+        # Discover_volume and undiscover_volume are called from compute
+        #  on attach/detach
+
+        disco_moves = driver.LoggingVolumeDriver.logs_like(
+                            'discover_volume',
+                            id=volume_id)
+        LOG.debug("discover_volume actions: %s" % disco_moves)
+
+        self.assertEquals(1, len(disco_moves))
+        disco_move = disco_moves[0]
+        self.assertEquals(disco_move['id'], volume_id)
+
+        last_days_of_disco_moves = driver.LoggingVolumeDriver.logs_like(
+                            'undiscover_volume',
+                            id=volume_id)
+        LOG.debug("undiscover_volume actions: %s" % last_days_of_disco_moves)
+
+        self.assertEquals(1, len(last_days_of_disco_moves))
+        undisco_move = last_days_of_disco_moves[0]
+        self.assertEquals(undisco_move['id'], volume_id)
+        self.assertEquals(undisco_move['mountpoint'], device)
+        self.assertEquals(undisco_move['instance_id'], server_id)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/nova/tests/integrated/test_xml.py b/nova/tests/integrated/test_xml.py
new file mode 100644
index 000000000..8a9754777
--- /dev/null
+++ b/nova/tests/integrated/test_xml.py
@@ -0,0 +1,56 @@
+# 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.
+
+from nova import flags
+from nova.log import logging
+from nova.tests.integrated import integrated_helpers
+from nova.api.openstack import common
+
+
+LOG = logging.getLogger('nova.tests.integrated')
+
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+class XmlTests(integrated_helpers._IntegratedTestBase):
+    """"Some basic XML sanity checks."""
+
+    def test_namespace_limits(self):
+        """/limits should have v1.0 namespace (hasn't changed in 1.1)."""
+        headers = {}
+        headers['Accept'] = 'application/xml'
+
+        response = self.api.api_request('/limits', headers=headers)
+        data = response.read()
+        LOG.debug("data: %s" % data)
+
+        prefix = '<limits xmlns="%s"' % common.XML_NS_V10
+        self.assertTrue(data.startswith(prefix))
+
+    def test_namespace_servers(self):
+        """/servers should have v1.1 namespace (has changed in 1.1)."""
+        headers = {}
+        headers['Accept'] = 'application/xml'
+
+        response = self.api.api_request('/servers', headers=headers)
+        data = response.read()
+        LOG.debug("data: %s" % data)
+
+        prefix = '<servers xmlns="%s"' % common.XML_NS_V11
+        self.assertTrue(data.startswith(prefix))
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/objectstore_unittest.py b/nova/tests/objectstore_unittest.py
deleted file mode 100644
index 5a1be08eb..000000000
--- a/nova/tests/objectstore_unittest.py
+++ /dev/null
@@ -1,315 +0,0 @@
-# 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.
-
-"""
-Unittets for S3 objectstore clone.
-"""
-
-import boto
-import glob
-import hashlib
-import os
-import shutil
-import tempfile
-
-from boto.s3.connection import S3Connection, OrdinaryCallingFormat
-from twisted.internet import reactor, threads, defer
-from twisted.web import http, server
-
-from nova import context
-from nova import flags
-from nova import objectstore
-from nova import test
-from nova.auth import manager
-from nova.exception import NotEmpty, NotFound
-from nova.objectstore import image
-from nova.objectstore.handler import S3
-
-
-FLAGS = flags.FLAGS
-
-# Create a unique temporary directory. We don't delete after test to
-# allow checking the contents after running tests. Users and/or tools
-# running the tests need to remove the tests directories.
-OSS_TEMPDIR = tempfile.mkdtemp(prefix='test_oss-')
-
-# Create bucket/images path
-os.makedirs(os.path.join(OSS_TEMPDIR, 'images'))
-os.makedirs(os.path.join(OSS_TEMPDIR, 'buckets'))
-
-
-class ObjectStoreTestCase(test.TestCase):
-    """Test objectstore API directly."""
-
-    def setUp(self):
-        """Setup users and projects."""
-        super(ObjectStoreTestCase, self).setUp()
-        self.flags(buckets_path=os.path.join(OSS_TEMPDIR, 'buckets'),
-                   images_path=os.path.join(OSS_TEMPDIR, 'images'),
-                   ca_path=os.path.join(os.path.dirname(__file__), 'CA'))
-
-        self.auth_manager = manager.AuthManager()
-        self.auth_manager.create_user('user1')
-        self.auth_manager.create_user('user2')
-        self.auth_manager.create_user('admin_user', admin=True)
-        self.auth_manager.create_project('proj1', 'user1', 'a proj', ['user1'])
-        self.auth_manager.create_project('proj2', 'user2', 'a proj', ['user2'])
-        self.context = context.RequestContext('user1', 'proj1')
-
-    def tearDown(self):
-        """Tear down users and projects."""
-        self.auth_manager.delete_project('proj1')
-        self.auth_manager.delete_project('proj2')
-        self.auth_manager.delete_user('user1')
-        self.auth_manager.delete_user('user2')
-        self.auth_manager.delete_user('admin_user')
-        super(ObjectStoreTestCase, self).tearDown()
-
-    def test_buckets(self):
-        """Test the bucket API."""
-        objectstore.bucket.Bucket.create('new_bucket', self.context)
-        bucket = objectstore.bucket.Bucket('new_bucket')
-
-        # creator is authorized to use bucket
-        self.assert_(bucket.is_authorized(self.context))
-
-        # another user is not authorized
-        context2 = context.RequestContext('user2', 'proj2')
-        self.assertFalse(bucket.is_authorized(context2))
-
-        # admin is authorized to use bucket
-        admin_context = context.RequestContext('admin_user', None)
-        self.assertTrue(bucket.is_authorized(admin_context))
-
-        # new buckets are empty
-        self.assertTrue(bucket.list_keys()['Contents'] == [])
-
-        # storing keys works
-        bucket['foo'] = "bar"
-
-        self.assertEquals(len(bucket.list_keys()['Contents']), 1)
-
-        self.assertEquals(bucket['foo'].read(), 'bar')
-
-        # md5 of key works
-        self.assertEquals(bucket['foo'].md5, hashlib.md5('bar').hexdigest())
-
-        # deleting non-empty bucket should throw a NotEmpty exception
-        self.assertRaises(NotEmpty, bucket.delete)
-
-        # deleting key
-        del bucket['foo']
-
-        # deleting empty bucket
-        bucket.delete()
-
-        # accessing deleted bucket throws exception
-        self.assertRaises(NotFound, objectstore.bucket.Bucket, 'new_bucket')
-
-    def test_images(self):
-        self.do_test_images('1mb.manifest.xml', True,
-                            'image_bucket1', 'i-testing1')
-
-    def test_images_no_kernel_or_ramdisk(self):
-        self.do_test_images('1mb.no_kernel_or_ramdisk.manifest.xml',
-                            False, 'image_bucket2', 'i-testing2')
-
-    def do_test_images(self, manifest_file, expect_kernel_and_ramdisk,
-                             image_bucket, image_name):
-        "Test the image API."
-
-        # create a bucket for our bundle
-        objectstore.bucket.Bucket.create(image_bucket, self.context)
-        bucket = objectstore.bucket.Bucket(image_bucket)
-
-        # upload an image manifest/parts
-        bundle_path = os.path.join(os.path.dirname(__file__), 'bundle')
-        for path in glob.glob(bundle_path + '/*'):
-            bucket[os.path.basename(path)] = open(path, 'rb').read()
-
-        # register an image
-        image.Image.register_aws_image(image_name,
-                                       '%s/%s' % (image_bucket, manifest_file),
-                                       self.context)
-
-        # verify image
-        my_img = image.Image(image_name)
-        result_image_file = os.path.join(my_img.path, 'image')
-        self.assertEqual(os.stat(result_image_file).st_size, 1048576)
-
-        sha = hashlib.sha1(open(result_image_file).read()).hexdigest()
-        self.assertEqual(sha, '3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3')
-
-        if expect_kernel_and_ramdisk:
-            # Verify the default kernel and ramdisk are set
-            self.assertEqual(my_img.metadata['kernelId'], 'aki-test')
-            self.assertEqual(my_img.metadata['ramdiskId'], 'ari-test')
-        else:
-            # Verify that the default kernel and ramdisk (the one from FLAGS)
-            # doesn't get embedded in the metadata
-            self.assertFalse('kernelId' in my_img.metadata)
-            self.assertFalse('ramdiskId' in my_img.metadata)
-
-        # verify image permissions
-        context2 = context.RequestContext('user2', 'proj2')
-        self.assertFalse(my_img.is_authorized(context2))
-
-        # change user-editable fields
-        my_img.update_user_editable_fields({'display_name': 'my cool image'})
-        self.assertEqual('my cool image', my_img.metadata['displayName'])
-        my_img.update_user_editable_fields({'display_name': ''})
-        self.assert_(not my_img.metadata['displayName'])
-
-
-class TestHTTPChannel(http.HTTPChannel):
-    """Dummy site required for twisted.web"""
-
-    def checkPersistence(self, _, __):  # pylint: disable-msg=C0103
-        """Otherwise we end up with an unclean reactor."""
-        return False
-
-
-class TestSite(server.Site):
-    """Dummy site required for twisted.web"""
-    protocol = TestHTTPChannel
-
-
-class S3APITestCase(test.TestCase):
-    """Test objectstore through S3 API."""
-
-    def setUp(self):
-        """Setup users, projects, and start a test server."""
-        super(S3APITestCase, self).setUp()
-
-        FLAGS.auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
-        FLAGS.buckets_path = os.path.join(OSS_TEMPDIR, 'buckets')
-
-        self.auth_manager = manager.AuthManager()
-        self.admin_user = self.auth_manager.create_user('admin', admin=True)
-        self.admin_project = self.auth_manager.create_project('admin',
-                                                              self.admin_user)
-
-        shutil.rmtree(FLAGS.buckets_path)
-        os.mkdir(FLAGS.buckets_path)
-
-        root = S3()
-        self.site = TestSite(root)
-        # pylint: disable-msg=E1101
-        self.listening_port = reactor.listenTCP(0, self.site,
-                                                interface='127.0.0.1')
-        # pylint: enable-msg=E1101
-        self.tcp_port = self.listening_port.getHost().port
-
-        if not boto.config.has_section('Boto'):
-            boto.config.add_section('Boto')
-        boto.config.set('Boto', 'num_retries', '0')
-        self.conn = S3Connection(aws_access_key_id=self.admin_user.access,
-                                 aws_secret_access_key=self.admin_user.secret,
-                                 host='127.0.0.1',
-                                 port=self.tcp_port,
-                                 is_secure=False,
-                                 calling_format=OrdinaryCallingFormat())
-
-        def get_http_connection(host, is_secure):
-            """Get a new S3 connection, don't attempt to reuse connections."""
-            return self.conn.new_http_connection(host, is_secure)
-
-        self.conn.get_http_connection = get_http_connection
-
-    def _ensure_no_buckets(self, buckets):  # pylint: disable-msg=C0111
-        self.assertEquals(len(buckets), 0, "Bucket list was not empty")
-        return True
-
-    def _ensure_one_bucket(self, buckets, name):  # pylint: disable-msg=C0111
-        self.assertEquals(len(buckets), 1,
-                          "Bucket list didn't have exactly one element in it")
-        self.assertEquals(buckets[0].name, name, "Wrong name")
-        return True
-
-    def test_000_list_buckets(self):
-        """Make sure we are starting with no buckets."""
-        deferred = threads.deferToThread(self.conn.get_all_buckets)
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
-
-    def test_001_create_and_delete_bucket(self):
-        """Test bucket creation and deletion."""
-        bucket_name = 'testbucket'
-
-        deferred = threads.deferToThread(self.conn.create_bucket, bucket_name)
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_all_buckets))
-
-        deferred.addCallback(self._ensure_one_bucket, bucket_name)
-
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.delete_bucket,
-                                                   bucket_name))
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_all_buckets))
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
-
-    def test_002_create_bucket_and_key_and_delete_key_again(self):
-        """Test key operations on buckets."""
-        bucket_name = 'testbucket'
-        key_name = 'somekey'
-        key_contents = 'somekey'
-
-        deferred = threads.deferToThread(self.conn.create_bucket, bucket_name)
-        deferred.addCallback(lambda b:
-                             threads.deferToThread(b.new_key, key_name))
-        deferred.addCallback(lambda k:
-                             threads.deferToThread(k.set_contents_from_string,
-                                                   key_contents))
-
-        def ensure_key_contents(bucket_name, key_name, contents):
-            """Verify contents for a key in the given bucket."""
-            bucket = self.conn.get_bucket(bucket_name)
-            key = bucket.get_key(key_name)
-            self.assertEquals(key.get_contents_as_string(), contents,
-                              "Bad contents")
-
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(ensure_key_contents,
-                                                   bucket_name, key_name,
-                                                   key_contents))
-
-        def delete_key(bucket_name, key_name):
-            """Delete a key for the given bucket."""
-            bucket = self.conn.get_bucket(bucket_name)
-            key = bucket.get_key(key_name)
-            key.delete()
-
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(delete_key, bucket_name,
-                                                   key_name))
-        deferred.addCallback(lambda _:
-                             threads.deferToThread(self.conn.get_bucket,
-                                                   bucket_name))
-        deferred.addCallback(lambda b: threads.deferToThread(b.get_all_keys))
-        deferred.addCallback(self._ensure_no_buckets)
-        return deferred
-
-    def tearDown(self):
-        """Tear down auth and test server."""
-        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 d5c54a1c3..97f401b87 100644
--- a/nova/tests/test_api.py
+++ b/nova/tests/test_api.py
@@ -20,6 +20,7 @@
 
 import boto
 from boto.ec2 import regioninfo
+from boto.exception import EC2ResponseError
 import datetime
 import httplib
 import random
@@ -27,10 +28,12 @@ import StringIO
 import webob
 
 from nova import context
+from nova import exception
 from nova import test
 from nova.api import ec2
-from nova.api.ec2 import cloud
 from nova.api.ec2 import apirequest
+from nova.api.ec2 import cloud
+from nova.api.ec2 import ec2utils
 from nova.auth import manager
 
 
@@ -100,6 +103,21 @@ class XmlConversionTestCase(test.TestCase):
         self.assertEqual(conv('-0'), 0)
 
 
+class Ec2utilsTestCase(test.TestCase):
+    def test_ec2_id_to_id(self):
+        self.assertEqual(ec2utils.ec2_id_to_id('i-0000001e'), 30)
+        self.assertEqual(ec2utils.ec2_id_to_id('ami-1d'), 29)
+
+    def test_bad_ec2_id(self):
+        self.assertRaises(exception.InvalidEc2Id,
+                          ec2utils.ec2_id_to_id,
+                          'badone')
+
+    def test_id_to_ec2_id(self):
+        self.assertEqual(ec2utils.id_to_ec2_id(30), 'i-0000001e')
+        self.assertEqual(ec2utils.id_to_ec2_id(29, 'ami-%08x'), 'ami-0000001d')
+
+
 class ApiEc2TestCase(test.TestCase):
     """Unit test for the cloud controller on an EC2 API"""
     def setUp(self):
@@ -124,7 +142,7 @@ class ApiEc2TestCase(test.TestCase):
         self.mox.StubOutWithMock(self.ec2, 'new_http_connection')
         self.http = FakeHttplibConnection(
                 self.app, '%s:8773' % (self.host), False)
-        # pylint: disable-msg=E1103
+        # pylint: disable=E1103
         self.ec2.new_http_connection(host, is_secure).AndReturn(self.http)
         return self.http
 
@@ -177,6 +195,17 @@ class ApiEc2TestCase(test.TestCase):
         self.manager.delete_project(project)
         self.manager.delete_user(user)
 
+    def test_terminate_invalid_instance(self):
+        """Attempt to terminate an invalid instance"""
+        self.expect_http()
+        self.mox.ReplayAll()
+        user = self.manager.create_user('fake', 'fake', 'fake')
+        project = self.manager.create_project('fake', 'fake', 'fake')
+        self.assertRaises(EC2ResponseError, self.ec2.terminate_instances,
+                            "i-00000005")
+        self.manager.delete_project(project)
+        self.manager.delete_user(user)
+
     def test_get_all_key_pairs(self):
         """Test that, after creating a user and project and generating
          a key pair, that the API call to list key pairs works properly"""
diff --git a/nova/tests/test_auth.py b/nova/tests/test_auth.py
index 2a7817032..f02dd94b7 100644
--- a/nova/tests/test_auth.py
+++ b/nova/tests/test_auth.py
@@ -80,10 +80,10 @@ class user_and_project_generator(object):
         self.manager.delete_project(self.project)
 
 
-class AuthManagerTestCase(object):
+class _AuthManagerBaseTestCase(test.TestCase):
     def setUp(self):
         FLAGS.auth_driver = self.auth_driver
-        super(AuthManagerTestCase, self).setUp()
+        super(_AuthManagerBaseTestCase, self).setUp()
         self.flags(connection_type='fake')
         self.manager = manager.AuthManager(new=True)
 
@@ -101,9 +101,43 @@ class AuthManagerTestCase(object):
             self.assertEqual('private-party', u.access)
 
     def test_004_signature_is_valid(self):
-        #self.assertTrue(self.manager.authenticate(**boto.generate_url ...? ))
-        pass
-        #raise NotImplementedError
+        with user_generator(self.manager, name='admin', secret='admin',
+                            access='admin'):
+            with project_generator(self.manager, name="admin",
+                                   manager_user='admin'):
+                accesskey = 'admin:admin'
+                expected_result = (self.manager.get_user('admin'),
+                                   self.manager.get_project('admin'))
+                # captured sig and query string using boto 1.9b/euca2ools 1.2
+                sig = 'd67Wzd9Bwz8xid9QU+lzWXcF2Y3tRicYABPJgrqfrwM='
+                auth_params = {'AWSAccessKeyId': 'admin:admin',
+                               'Action': 'DescribeAvailabilityZones',
+                               'SignatureMethod': 'HmacSHA256',
+                               'SignatureVersion': '2',
+                               'Timestamp': '2011-04-22T11:29:29',
+                               'Version': '2009-11-30'}
+                self.assertTrue(expected_result, self.manager.authenticate(
+                        accesskey,
+                        sig,
+                        auth_params,
+                        'GET',
+                        '127.0.0.1:8773',
+                        '/services/Cloud/'))
+                # captured sig and query string using RightAWS 1.10.0
+                sig = 'ECYLU6xdFG0ZqRVhQybPJQNJ5W4B9n8fGs6+/fuGD2c='
+                auth_params = {'AWSAccessKeyId': 'admin:admin',
+                               'Action': 'DescribeAvailabilityZones',
+                               'SignatureMethod': 'HmacSHA256',
+                               'SignatureVersion': '2',
+                               'Timestamp': '2011-04-22T11:29:49.000Z',
+                               'Version': '2008-12-01'}
+                self.assertTrue(expected_result, self.manager.authenticate(
+                        accesskey,
+                        sig,
+                        auth_params,
+                        'GET',
+                        '127.0.0.1',
+                        '/services/Cloud'))
 
     def test_005_can_get_credentials(self):
         return
@@ -299,6 +333,13 @@ class AuthManagerTestCase(object):
                 self.assertEqual('test2', project.project_manager_id)
                 self.assertEqual('new desc', project.description)
 
+    def test_modify_project_adds_new_manager(self):
+        with user_and_project_generator(self.manager):
+            with user_generator(self.manager, name='test2'):
+                self.manager.modify_project('testproj', 'test2', 'new desc')
+                project = self.manager.get_project('testproj')
+                self.assertTrue('test2' in project.member_ids)
+
     def test_can_delete_project(self):
         with user_generator(self.manager):
             self.manager.create_project('testproj', 'test1')
@@ -324,11 +365,11 @@ class AuthManagerTestCase(object):
             self.assertTrue(user.is_admin())
 
 
-class AuthManagerLdapTestCase(AuthManagerTestCase, test.TestCase):
+class AuthManagerLdapTestCase(_AuthManagerBaseTestCase):
     auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
 
 
-class AuthManagerDbTestCase(AuthManagerTestCase, test.TestCase):
+class AuthManagerDbTestCase(_AuthManagerBaseTestCase):
     auth_driver = 'nova.auth.dbdriver.DbDriver'
 
 
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index c49a39ed0..d25b73521 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -35,31 +35,24 @@ from nova import log as logging
 from nova import rpc
 from nova import service
 from nova import test
+from nova import utils
+from nova import exception
 from nova.auth import manager
 from nova.compute import power_state
 from nova.api.ec2 import cloud
 from nova.api.ec2 import ec2utils
 from nova.image import local
-from nova.objectstore import image
+from nova.exception import NotFound
 
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.cloud')
 
-# Temp dirs for working with image attributes through the cloud controller
-# (stole this from objectstore_unittest.py)
-OSS_TEMPDIR = tempfile.mkdtemp(prefix='test_oss-')
-IMAGES_PATH = os.path.join(OSS_TEMPDIR, 'images')
-os.makedirs(IMAGES_PATH)
 
-
-# TODO(termie): these tests are rather fragile, they should at the lest be
-#               wiping database state after each run
 class CloudTestCase(test.TestCase):
     def setUp(self):
         super(CloudTestCase, self).setUp()
-        self.flags(connection_type='fake',
-                   images_path=IMAGES_PATH)
+        self.flags(connection_type='fake')
 
         self.conn = rpc.Connection.instance()
 
@@ -70,6 +63,7 @@ class CloudTestCase(test.TestCase):
         self.compute = self.start_service('compute')
         self.scheduter = self.start_service('scheduler')
         self.network = self.start_service('network')
+        self.image_service = utils.import_object(FLAGS.image_service)
 
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
@@ -79,7 +73,8 @@ class CloudTestCase(test.TestCase):
         host = self.network.get_network_host(self.context.elevated())
 
         def fake_show(meh, context, id):
-            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}}
+            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1,
+                    'type': 'machine'}}
 
         self.stubs.Set(local.LocalImageService, 'show', fake_show)
         self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show)
@@ -224,6 +219,66 @@ class CloudTestCase(test.TestCase):
         db.service_destroy(self.context, comp1['id'])
         db.service_destroy(self.context, comp2['id'])
 
+    def test_describe_images(self):
+        describe_images = self.cloud.describe_images
+
+        def fake_detail(meh, context):
+            return [{'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1,
+                    'type': 'machine'}}]
+
+        def fake_show_none(meh, context, id):
+            raise NotFound
+
+        self.stubs.Set(local.LocalImageService, 'detail', fake_detail)
+        # list all
+        result1 = describe_images(self.context)
+        result1 = result1['imagesSet'][0]
+        self.assertEqual(result1['imageId'], 'ami-00000001')
+        # provided a valid image_id
+        result2 = describe_images(self.context, ['ami-00000001'])
+        self.assertEqual(1, len(result2['imagesSet']))
+        # provide more than 1 valid image_id
+        result3 = describe_images(self.context, ['ami-00000001',
+                                                 'ami-00000002'])
+        self.assertEqual(2, len(result3['imagesSet']))
+        # provide an non-existing image_id
+        self.stubs.UnsetAll()
+        self.stubs.Set(local.LocalImageService, 'show', fake_show_none)
+        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show_none)
+        self.assertRaises(NotFound, describe_images,
+                          self.context, ['ami-fake'])
+
+    def test_describe_image_attribute(self):
+        describe_image_attribute = self.cloud.describe_image_attribute
+
+        def fake_show(meh, context, id):
+            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1,
+                    'type': 'machine'}, 'is_public': True}
+
+        self.stubs.Set(local.LocalImageService, 'show', fake_show)
+        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show)
+        result = describe_image_attribute(self.context, 'ami-00000001',
+                                          'launchPermission')
+        self.assertEqual([{'group': 'all'}], result['launchPermission'])
+
+    def test_modify_image_attribute(self):
+        modify_image_attribute = self.cloud.modify_image_attribute
+
+        def fake_show(meh, context, id):
+            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1,
+                    'type': 'machine'}, 'is_public': False}
+
+        def fake_update(meh, context, image_id, metadata, data=None):
+            return metadata
+
+        self.stubs.Set(local.LocalImageService, 'show', fake_show)
+        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show)
+        self.stubs.Set(local.LocalImageService, 'update', fake_update)
+        result = modify_image_attribute(self.context, 'ami-00000001',
+                                          'launchPermission', 'add',
+                                           user_group=['all'])
+        self.assertEqual(True, result['is_public'])
+
     def test_console_output(self):
         instance_type = FLAGS.default_instance_type
         max_count = 1
@@ -235,7 +290,7 @@ class CloudTestCase(test.TestCase):
         instance_id = rv['instancesSet'][0]['instanceId']
         output = self.cloud.get_console_output(context=self.context,
                                                instance_id=[instance_id])
-        self.assertEquals(b64decode(output['output']), 'FAKE CONSOLE OUTPUT')
+        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)
@@ -348,40 +403,18 @@ class CloudTestCase(test.TestCase):
                 LOG.debug(_("Terminating instance %s"), instance_id)
                 rv = self.compute.terminate_instance(instance_id)
 
-    @staticmethod
-    def _fake_set_image_description(ctxt, image_id, description):
-        from nova.objectstore import handler
-
-        class req:
-            pass
-
-        request = req()
-        request.context = ctxt
-        request.args = {'image_id': [image_id],
-                        'description': [description]}
-
-        resource = handler.ImagesResource()
-        resource.render_POST(request)
-
-    def test_user_editable_image_endpoint(self):
-        pathdir = os.path.join(FLAGS.images_path, 'ami-testing')
-        os.mkdir(pathdir)
-        info = {'isPublic': False}
-        with open(os.path.join(pathdir, 'info.json'), 'w') as f:
-            json.dump(info, f)
-        img = image.Image('ami-testing')
-        # self.cloud.set_image_description(self.context, 'ami-testing',
-        #                                  'Foo Img')
-        # NOTE(vish): Above won't work unless we start objectstore or create
-        #             a fake version of api/ec2/images.py conn that can
-        #             call methods directly instead of going through boto.
-        #             for now, just cheat and call the method directly
-        self._fake_set_image_description(self.context, 'ami-testing',
-                                         'Foo Img')
-        self.assertEqual('Foo Img', img.metadata['description'])
-        self._fake_set_image_description(self.context, 'ami-testing', '')
-        self.assertEqual('', img.metadata['description'])
-        shutil.rmtree(pathdir)
+    def test_terminate_instances(self):
+        inst1 = db.instance_create(self.context, {'reservation_id': 'a',
+                                                  'image_id': 1,
+                                                  'host': 'host1'})
+        terminate_instances = self.cloud.terminate_instances
+        # valid instance_id
+        result = terminate_instances(self.context, ['i-00000001'])
+        self.assertTrue(result)
+        # non-existing instance_id
+        self.assertRaises(exception.InstanceNotFound, terminate_instances,
+                          self.context, ['i-2'])
+        db.instance_destroy(self.context, inst1['id'])
 
     def test_update_of_instance_display_fields(self):
         inst = db.instance_create(self.context, {})
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 643b2e93a..55e7ae0c4 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -20,6 +20,8 @@ Tests For Compute
 """
 
 import datetime
+import mox
+import stubout
 
 from nova import compute
 from nova import context
@@ -27,15 +29,32 @@ from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova import rpc
 from nova import test
 from nova import utils
 from nova.auth import manager
 from nova.compute import instance_types
+from nova.compute import manager as compute_manager
+from nova.compute import power_state
+from nova.db.sqlalchemy import models
 from nova.image import local
 
 LOG = logging.getLogger('nova.tests.compute')
 FLAGS = flags.FLAGS
 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
+
+
+def nop_report_driver_status(self):
+    pass
 
 
 class ComputeTestCase(test.TestCase):
@@ -70,12 +89,28 @@ class ComputeTestCase(test.TestCase):
         inst['launch_time'] = '10'
         inst['user_id'] = self.user.id
         inst['project_id'] = self.project.id
-        inst['instance_type'] = 'm1.tiny'
+        type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
+        inst['instance_type_id'] = type_id
         inst['mac_address'] = utils.generate_mac()
         inst['ami_launch_index'] = 0
         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',
@@ -83,12 +118,27 @@ class ComputeTestCase(test.TestCase):
                   'project_id': self.project.id}
         return db.security_group_create(self.context, values)
 
+    def _get_dummy_instance(self):
+        """Get mock-return-value instance object
+           Use this when any testcase executed later than test_run_terminate
+        """
+        vol1 = models.Volume()
+        vol1['id'] = 1
+        vol2 = models.Volume()
+        vol2['id'] = 2
+        instance_ref = models.Instance()
+        instance_ref['id'] = 1
+        instance_ref['volumes'] = [vol1, vol2]
+        instance_ref['hostname'] = 'i-00000001'
+        instance_ref['host'] = 'dummy'
+        return instance_ref
+
     def test_create_instance_defaults_display_name(self):
         """Verify that an instance cannot be created without a display_name."""
         cases = [dict(), dict(display_name=None)]
         for instance in cases:
             ref = self.compute_api.create(self.context,
-                FLAGS.default_instance_type, None, **instance)
+                instance_types.get_default_instance_type(), None, **instance)
             try:
                 self.assertNotEqual(ref[0]['display_name'], None)
             finally:
@@ -99,7 +149,7 @@ class ComputeTestCase(test.TestCase):
         group = self._create_group()
         ref = self.compute_api.create(
                 self.context,
-                instance_type=FLAGS.default_instance_type,
+                instance_type=instance_types.get_default_instance_type(),
                 image_id=None,
                 security_group=['testgroup'])
         try:
@@ -117,7 +167,7 @@ class ComputeTestCase(test.TestCase):
 
         ref = self.compute_api.create(
                 self.context,
-                instance_type=FLAGS.default_instance_type,
+                instance_type=instance_types.get_default_instance_type(),
                 image_id=None,
                 security_group=['testgroup'])
         try:
@@ -133,7 +183,7 @@ class ComputeTestCase(test.TestCase):
 
         ref = self.compute_api.create(
                 self.context,
-                instance_type=FLAGS.default_instance_type,
+                instance_type=instance_types.get_default_instance_type(),
                 image_id=None,
                 security_group=['testgroup'])
 
@@ -242,6 +292,16 @@ class ComputeTestCase(test.TestCase):
 
         console = self.compute.get_ajax_console(self.context,
                                                 instance_id)
+        self.assert_(set(['token', 'host', 'port']).issubset(console.keys()))
+        self.compute.terminate_instance(self.context, instance_id)
+
+    def test_vnc_console(self):
+        """Make sure we can a vnc console for an instance."""
+        instance_id = self._create_instance()
+        self.compute.run_instance(self.context, instance_id)
+
+        console = self.compute.get_vnc_console(self.context,
+                                               instance_id)
         self.assert_(console)
         self.compute.terminate_instance(self.context, instance_id)
 
@@ -278,18 +338,57 @@ 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)
+        inst_type = instance_types.get_instance_type_by_name('m1.xlarge')
+        db.instance_update(self.context, instance_id,
+                {'instance_type_id': inst_type['id']})
+
+        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')
+        type = instance_types.get_instance_type_by_flavor_id(1)
+        self.assertEqual(type['name'], 'm1.tiny')
 
     def test_resize_same_source_fails(self):
         """Ensure instance fails to migrate when source and destination are
@@ -297,7 +396,284 @@ 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)
+        self.network_manager = utils.import_object(FLAGS.network_manager)
+        self.compute_driver = utils.import_object(FLAGS.compute_driver)
+
+    def test_pre_live_migration_instance_has_no_fixed_ip(self):
+        """Confirm raising exception if instance doesn't have fixed_ip."""
+        instance_ref = self._get_dummy_instance()
+        c = context.get_admin_context()
+        i_id = instance_ref['id']
+
+        dbmock = self.mox.CreateMock(db)
+        dbmock.instance_get(c, i_id).AndReturn(instance_ref)
+        dbmock.instance_get_fixed_address(c, i_id).AndReturn(None)
+
+        self.compute.db = dbmock
+        self.mox.ReplayAll()
+        self.assertRaises(exception.NotFound,
+                          self.compute.pre_live_migration,
+                          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."""
+        i_ref = self._get_dummy_instance()
+        c = context.get_admin_context()
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        volmock = self.mox.CreateMock(self.volume_manager)
+        netmock = self.mox.CreateMock(self.network_manager)
+        drivermock = self.mox.CreateMock(self.compute_driver)
+
+        dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
+        dbmock.instance_get_fixed_address(c, i_ref['id']).AndReturn('dummy')
+        for i in range(len(i_ref['volumes'])):
+            vid = i_ref['volumes'][i]['id']
+            volmock.setup_compute_volume(c, vid).InAnyOrder('g1')
+        netmock.setup_compute_network(c, i_ref['id'])
+        drivermock.ensure_filtering_rules_for_instance(i_ref)
+
+        self.compute.db = dbmock
+        self.compute.volume_manager = volmock
+        self.compute.network_manager = netmock
+        self.compute.driver = drivermock
+
+        self.mox.ReplayAll()
+        ret = self.compute.pre_live_migration(c, i_ref['id'])
+        self.assertEqual(ret, None)
+
+    def test_pre_live_migration_instance_has_no_volume(self):
+        """Confirm log meg when instance doesn't mount any volumes."""
+        i_ref = self._get_dummy_instance()
+        i_ref['volumes'] = []
+        c = context.get_admin_context()
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        netmock = self.mox.CreateMock(self.network_manager)
+        drivermock = self.mox.CreateMock(self.compute_driver)
+
+        dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
+        dbmock.instance_get_fixed_address(c, i_ref['id']).AndReturn('dummy')
+        self.mox.StubOutWithMock(compute_manager.LOG, 'info')
+        compute_manager.LOG.info(_("%s has no volume."), i_ref['hostname'])
+        netmock.setup_compute_network(c, i_ref['id'])
+        drivermock.ensure_filtering_rules_for_instance(i_ref)
+
+        self.compute.db = dbmock
+        self.compute.network_manager = netmock
+        self.compute.driver = drivermock
+
+        self.mox.ReplayAll()
+        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):
+        """Confirm operation setup_compute_network() fails.
+
+        It retries and raise exception when timeout exceeded.
+
+        """
+
+        i_ref = self._get_dummy_instance()
+        c = context.get_admin_context()
+
+        self._setup_other_managers()
+        dbmock = self.mox.CreateMock(db)
+        netmock = self.mox.CreateMock(self.network_manager)
+        volmock = self.mox.CreateMock(self.volume_manager)
+
+        dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
+        dbmock.instance_get_fixed_address(c, i_ref['id']).AndReturn('dummy')
+        for i in range(len(i_ref['volumes'])):
+            volmock.setup_compute_volume(c, i_ref['volumes'][i]['id'])
+        for i in range(FLAGS.live_migration_retry_count):
+            netmock.setup_compute_network(c, i_ref['id']).\
+                AndRaise(exception.ProcessExecutionError())
+
+        self.compute.db = dbmock
+        self.compute.network_manager = netmock
+        self.compute.volume_manager = volmock
+
+        self.mox.ReplayAll()
+        self.assertRaises(exception.ProcessExecutionError,
+                          self.compute.pre_live_migration,
+                          c, i_ref['id'], time=FakeTime())
+
+    def test_live_migration_works_correctly_with_volume(self):
+        """Confirm check_for_export to confirm volume health check."""
+        i_ref = self._get_dummy_instance()
+        c = context.get_admin_context()
+        topic = db.queue_get_for(c, FLAGS.compute_topic, i_ref['host'])
+
+        dbmock = self.mox.CreateMock(db)
+        dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
+        self.mox.StubOutWithMock(rpc, 'call')
+        rpc.call(c, FLAGS.volume_topic, {"method": "check_for_export",
+                                         "args": {'instance_id': i_ref['id']}})
+        dbmock.queue_get_for(c, FLAGS.compute_topic, i_ref['host']).\
+                             AndReturn(topic)
+        rpc.call(c, topic, {"method": "pre_live_migration",
+                            "args": {'instance_id': i_ref['id']}})
+        self.mox.StubOutWithMock(self.compute.driver, 'live_migration')
+        self.compute.driver.live_migration(c, i_ref, i_ref['host'],
+                                  self.compute.post_live_migration,
+                                  self.compute.recover_live_migration)
+
+        self.compute.db = dbmock
+        self.mox.ReplayAll()
+        ret = self.compute.live_migration(c, i_ref['id'], i_ref['host'])
+        self.assertEqual(ret, None)
+
+    def test_live_migration_dest_raises_exception(self):
+        """Confirm exception when pre_live_migration fails."""
+        i_ref = self._get_dummy_instance()
+        c = context.get_admin_context()
+        topic = db.queue_get_for(c, FLAGS.compute_topic, i_ref['host'])
+
+        dbmock = self.mox.CreateMock(db)
+        dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
+        self.mox.StubOutWithMock(rpc, 'call')
+        rpc.call(c, FLAGS.volume_topic, {"method": "check_for_export",
+                                         "args": {'instance_id': i_ref['id']}})
+        dbmock.queue_get_for(c, FLAGS.compute_topic, i_ref['host']).\
+                             AndReturn(topic)
+        rpc.call(c, topic, {"method": "pre_live_migration",
+                            "args": {'instance_id': i_ref['id']}}).\
+                            AndRaise(rpc.RemoteError('', '', ''))
+        dbmock.instance_update(c, i_ref['id'], {'state_description': 'running',
+                                                'state': power_state.RUNNING,
+                                                'host': i_ref['host']})
+        for v in i_ref['volumes']:
+            dbmock.volume_update(c, v['id'], {'status': 'in-use'})
+
+        self.compute.db = dbmock
+        self.mox.ReplayAll()
+        self.assertRaises(rpc.RemoteError,
+                          self.compute.live_migration,
+                          c, i_ref['id'], i_ref['host'])
+
+    def test_live_migration_dest_raises_exception_no_volume(self):
+        """Same as above test(input pattern is different) """
+        i_ref = self._get_dummy_instance()
+        i_ref['volumes'] = []
+        c = context.get_admin_context()
+        topic = db.queue_get_for(c, FLAGS.compute_topic, i_ref['host'])
+
+        dbmock = self.mox.CreateMock(db)
+        dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
+        dbmock.queue_get_for(c, FLAGS.compute_topic, i_ref['host']).\
+                             AndReturn(topic)
+        self.mox.StubOutWithMock(rpc, 'call')
+        rpc.call(c, topic, {"method": "pre_live_migration",
+                            "args": {'instance_id': i_ref['id']}}).\
+                            AndRaise(rpc.RemoteError('', '', ''))
+        dbmock.instance_update(c, i_ref['id'], {'state_description': 'running',
+                                                'state': power_state.RUNNING,
+                                                'host': i_ref['host']})
+
+        self.compute.db = dbmock
+        self.mox.ReplayAll()
+        self.assertRaises(rpc.RemoteError,
+                          self.compute.live_migration,
+                          c, i_ref['id'], i_ref['host'])
+
+    def test_live_migration_works_correctly_no_volume(self):
+        """Confirm live_migration() works as expected correctly."""
+        i_ref = self._get_dummy_instance()
+        i_ref['volumes'] = []
+        c = context.get_admin_context()
+        topic = db.queue_get_for(c, FLAGS.compute_topic, i_ref['host'])
+
+        dbmock = self.mox.CreateMock(db)
+        dbmock.instance_get(c, i_ref['id']).AndReturn(i_ref)
+        self.mox.StubOutWithMock(rpc, 'call')
+        dbmock.queue_get_for(c, FLAGS.compute_topic, i_ref['host']).\
+                             AndReturn(topic)
+        rpc.call(c, topic, {"method": "pre_live_migration",
+                            "args": {'instance_id': i_ref['id']}})
+        self.mox.StubOutWithMock(self.compute.driver, 'live_migration')
+        self.compute.driver.live_migration(c, i_ref, i_ref['host'],
+                                  self.compute.post_live_migration,
+                                  self.compute.recover_live_migration)
+
+        self.compute.db = dbmock
+        self.mox.ReplayAll()
+        ret = self.compute.live_migration(c, i_ref['id'], i_ref['host'])
+        self.assertEqual(ret, None)
+
+    def test_post_live_migration_working_correctly(self):
+        """Confirm post_live_migration() works as expected correctly."""
+        dest = 'desthost'
+        flo_addr = '1.2.1.2'
+
+        # Preparing datas
+        c = context.get_admin_context()
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(c, instance_id)
+        db.instance_update(c, i_ref['id'], {'state_description': 'migrating',
+                                            'state': power_state.PAUSED})
+        v_ref = db.volume_create(c, {'size': 1, 'instance_id': instance_id})
+        fix_addr = db.fixed_ip_create(c, {'address': '1.1.1.1',
+                                          'instance_id': instance_id})
+        fix_ref = db.fixed_ip_get_by_address(c, fix_addr)
+        flo_ref = db.floating_ip_create(c, {'address': flo_addr,
+                                        'fixed_ip_id': fix_ref['id']})
+        # reload is necessary before setting mocks
+        i_ref = db.instance_get(c, instance_id)
+
+        # Preparing mocks
+        self.mox.StubOutWithMock(self.compute.volume_manager,
+                                 'remove_compute_volume')
+        for v in i_ref['volumes']:
+            self.compute.volume_manager.remove_compute_volume(c, v['id'])
+        self.mox.StubOutWithMock(self.compute.driver, 'unfilter_instance')
+        self.compute.driver.unfilter_instance(i_ref)
+
+        # executing
+        self.mox.ReplayAll()
+        ret = self.compute.post_live_migration(c, i_ref, dest)
+
+        # make sure every data is rewritten to dest
+        i_ref = db.instance_get(c, i_ref['id'])
+        c1 = (i_ref['host'] == dest)
+        flo_refs = db.floating_ip_get_all_by_host(c, dest)
+        c2 = (len(flo_refs) != 0 and flo_refs[0]['address'] == flo_addr)
+
+        # post operaton
+        self.assertTrue(c1 and c2)
+        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"""
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(compute_manager.ComputeManager,
+                '_report_driver_status', nop_report_driver_status)
+
+        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), 1)
+        self.assertEqual(power_state.SHUTOFF, instances[0]['state'])
diff --git a/nova/tests/test_console.py b/nova/tests/test_console.py
index d47c70d88..1a9a867ee 100644
--- a/nova/tests/test_console.py
+++ b/nova/tests/test_console.py
@@ -62,7 +62,7 @@ class ConsoleTestCase(test.TestCase):
         inst['launch_time'] = '10'
         inst['user_id'] = self.user.id
         inst['project_id'] = self.project.id
-        inst['instance_type'] = 'm1.tiny'
+        inst['instance_type_id'] = 1
         inst['mac_address'] = utils.generate_mac()
         inst['ami_launch_index'] = 0
         return db.instance_create(self.context, inst)['id']
diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index 80e4d2e1f..588a24b35 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -25,12 +25,18 @@ import webob
 from nova import compute
 from nova import context
 from nova import exception
+from nova import network
 from nova import test
+from nova import volume
 from nova import utils
 from nova.api import direct
 from nova.tests import test_cloud
 
 
+class ArbitraryObject(object):
+    pass
+
+
 class FakeService(object):
     def echo(self, context, data):
         return {'data': data}
@@ -39,6 +45,9 @@ class FakeService(object):
         return {'user': context.user_id,
                 'project': context.project_id}
 
+    def invalid_return(self, context):
+        return ArbitraryObject()
+
 
 class DirectTestCase(test.TestCase):
     def setUp(self):
@@ -84,6 +93,12 @@ class DirectTestCase(test.TestCase):
         resp_parsed = json.loads(resp.body)
         self.assertEqual(resp_parsed['data'], 'foo')
 
+    def test_invalid(self):
+        req = webob.Request.blank('/fake/invalid_return')
+        req.environ['openstack.context'] = self.context
+        req.method = 'POST'
+        self.assertRaises(exception.Error, req.get_response, self.router)
+
     def test_proxy(self):
         proxy = direct.Proxy(self.router)
         rv = proxy.fake.echo(self.context, data='baz')
@@ -93,12 +108,20 @@ class DirectTestCase(test.TestCase):
 class DirectCloudTestCase(test_cloud.CloudTestCase):
     def setUp(self):
         super(DirectCloudTestCase, self).setUp()
-        compute_handle = compute.API(network_api=self.cloud.network_api,
-                                     volume_api=self.cloud.volume_api)
+        compute_handle = compute.API(image_service=self.cloud.image_service)
+        volume_handle = volume.API()
+        network_handle = network.API()
         direct.register_service('compute', compute_handle)
+        direct.register_service('volume', volume_handle)
+        direct.register_service('network', network_handle)
+
         self.router = direct.JsonParamsMiddleware(direct.Router())
         proxy = direct.Proxy(self.router)
         self.cloud.compute_api = proxy.compute
+        self.cloud.volume_api = proxy.volume
+        self.cloud.network_api = proxy.network
+        compute_handle.volume_api = proxy.volume
+        compute_handle.network_api = proxy.network
 
     def tearDown(self):
         super(DirectCloudTestCase, self).tearDown()
diff --git a/nova/tests/test_exception.py b/nova/tests/test_exception.py
new file mode 100644
index 000000000..4d3b9cc73
--- /dev/null
+++ b/nova/tests/test_exception.py
@@ -0,0 +1,34 @@
+# 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.
+
+from nova import test
+from nova import exception
+
+
+class ApiErrorTestCase(test.TestCase):
+    def test_return_valid_error(self):
+        # without 'code' arg
+        err = exception.ApiError('fake error')
+        self.assertEqual(err.__str__(), 'fake error')
+        self.assertEqual(err.code, None)
+        self.assertEqual(err.msg, 'fake error')
+        # with 'code' arg
+        err = exception.ApiError('fake error', 'blah code')
+        self.assertEqual(err.__str__(), 'blah code: fake error')
+        self.assertEqual(err.code, 'blah code')
+        self.assertEqual(err.msg, 'fake error')
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_host_filter.py b/nova/tests/test_host_filter.py
new file mode 100644
index 000000000..c029d41e6
--- /dev/null
+++ b/nova/tests/test_host_filter.py
@@ -0,0 +1,208 @@
+# 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.
+"""
+Tests For Scheduler Host Filter Drivers.
+"""
+
+import json
+
+from nova import exception
+from nova import flags
+from nova import test
+from nova.scheduler import host_filter
+
+FLAGS = flags.FLAGS
+
+
+class FakeZoneManager:
+    pass
+
+
+class HostFilterTestCase(test.TestCase):
+    """Test case for host filter drivers."""
+
+    def _host_caps(self, multiplier):
+        # Returns host capabilities in the following way:
+        # host1 = memory:free 10 (100max)
+        #         disk:available 100 (1000max)
+        # hostN = memory:free 10 + 10N
+        #         disk:available 100 + 100N
+        # in other words: hostN has more resources than host0
+        # which means ... don't go above 10 hosts.
+        return {'host_name-description': 'XenServer %s' % multiplier,
+                'host_hostname': 'xs-%s' % multiplier,
+                'host_memory_total': 100,
+                'host_memory_overhead': 10,
+                'host_memory_free': 10 + multiplier * 10,
+                'host_memory_free-computed': 10 + multiplier * 10,
+                'host_other-config': {},
+                'host_ip_address': '192.168.1.%d' % (100 + multiplier),
+                'host_cpu_info': {},
+                'disk_available': 100 + multiplier * 100,
+                'disk_total': 1000,
+                'disk_used': 0,
+                'host_uuid': 'xxx-%d' % multiplier,
+                'host_name-label': 'xs-%s' % multiplier}
+
+    def setUp(self):
+        self.old_flag = FLAGS.default_host_filter_driver
+        FLAGS.default_host_filter_driver = \
+                            'nova.scheduler.host_filter.AllHostsFilter'
+        self.instance_type = dict(name='tiny',
+                memory_mb=50,
+                vcpus=10,
+                local_gb=500,
+                flavorid=1,
+                swap=500,
+                rxtx_quota=30000,
+                rxtx_cap=200)
+
+        self.zone_manager = FakeZoneManager()
+        states = {}
+        for x in xrange(10):
+            states['host%02d' % (x + 1)] = {'compute': self._host_caps(x)}
+        self.zone_manager.service_states = states
+
+    def tearDown(self):
+        FLAGS.default_host_filter_driver = self.old_flag
+
+    def test_choose_driver(self):
+        # Test default driver ...
+        driver = host_filter.choose_driver()
+        self.assertEquals(driver._full_name(),
+                        'nova.scheduler.host_filter.AllHostsFilter')
+        # Test valid driver ...
+        driver = host_filter.choose_driver(
+                        'nova.scheduler.host_filter.FlavorFilter')
+        self.assertEquals(driver._full_name(),
+                        'nova.scheduler.host_filter.FlavorFilter')
+        # Test invalid driver ...
+        try:
+            host_filter.choose_driver('does not exist')
+            self.fail("Should not find driver")
+        except exception.SchedulerHostFilterDriverNotFound:
+            pass
+
+    def test_all_host_driver(self):
+        driver = host_filter.AllHostsFilter()
+        cooked = driver.instance_type_to_filter(self.instance_type)
+        hosts = driver.filter_hosts(self.zone_manager, cooked)
+        self.assertEquals(10, len(hosts))
+        for host, capabilities in hosts:
+            self.assertTrue(host.startswith('host'))
+
+    def test_flavor_driver(self):
+        driver = host_filter.FlavorFilter()
+        # filter all hosts that can support 50 ram and 500 disk
+        name, cooked = driver.instance_type_to_filter(self.instance_type)
+        self.assertEquals('nova.scheduler.host_filter.FlavorFilter', name)
+        hosts = driver.filter_hosts(self.zone_manager, cooked)
+        self.assertEquals(6, len(hosts))
+        just_hosts = [host for host, caps in hosts]
+        just_hosts.sort()
+        self.assertEquals('host05', just_hosts[0])
+        self.assertEquals('host10', just_hosts[5])
+
+    def test_json_driver(self):
+        driver = host_filter.JsonFilter()
+        # filter all hosts that can support 50 ram and 500 disk
+        name, cooked = driver.instance_type_to_filter(self.instance_type)
+        self.assertEquals('nova.scheduler.host_filter.JsonFilter', name)
+        hosts = driver.filter_hosts(self.zone_manager, cooked)
+        self.assertEquals(6, len(hosts))
+        just_hosts = [host for host, caps in hosts]
+        just_hosts.sort()
+        self.assertEquals('host05', just_hosts[0])
+        self.assertEquals('host10', just_hosts[5])
+
+        # Try some custom queries
+
+        raw = ['or',
+                   ['and',
+                       ['<', '$compute.host_memory_free', 30],
+                       ['<', '$compute.disk_available', 300]
+                   ],
+                   ['and',
+                       ['>', '$compute.host_memory_free', 70],
+                       ['>', '$compute.disk_available', 700]
+                   ]
+              ]
+        cooked = json.dumps(raw)
+        hosts = driver.filter_hosts(self.zone_manager, cooked)
+
+        self.assertEquals(5, len(hosts))
+        just_hosts = [host for host, caps in hosts]
+        just_hosts.sort()
+        for index, host in zip([1, 2, 8, 9, 10], just_hosts):
+            self.assertEquals('host%02d' % index, host)
+
+        raw = ['not',
+                  ['=', '$compute.host_memory_free', 30],
+              ]
+        cooked = json.dumps(raw)
+        hosts = driver.filter_hosts(self.zone_manager, cooked)
+
+        self.assertEquals(9, len(hosts))
+        just_hosts = [host for host, caps in hosts]
+        just_hosts.sort()
+        for index, host in zip([1, 2, 4, 5, 6, 7, 8, 9, 10], just_hosts):
+            self.assertEquals('host%02d' % index, host)
+
+        raw = ['in', '$compute.host_memory_free', 20, 40, 60, 80, 100]
+        cooked = json.dumps(raw)
+        hosts = driver.filter_hosts(self.zone_manager, cooked)
+
+        self.assertEquals(5, len(hosts))
+        just_hosts = [host for host, caps in hosts]
+        just_hosts.sort()
+        for index, host in zip([2, 4, 6, 8, 10], just_hosts):
+            self.assertEquals('host%02d' % index, host)
+
+        # Try some bogus input ...
+        raw = ['unknown command', ]
+        cooked = json.dumps(raw)
+        try:
+            driver.filter_hosts(self.zone_manager, cooked)
+            self.fail("Should give KeyError")
+        except KeyError, e:
+            pass
+
+        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps([])))
+        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps({})))
+        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps(
+                ['not', True, False, True, False]
+            )))
+
+        try:
+            driver.filter_hosts(self.zone_manager, json.dumps(
+                'not', True, False, True, False
+            ))
+            self.fail("Should give KeyError")
+        except KeyError, e:
+            pass
+
+        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
+                ['=', '$foo', 100]
+            )))
+        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
+                ['=', '$.....', 100]
+            )))
+        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
+            ['>', ['and', ['or', ['not', ['<', ['>=', ['<=', ['in', ]]]]]]]]
+        )))
+
+        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
+                ['=', {}, ['>', '$missing....foo']]
+            )))
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index edc538879..ef271518c 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -40,7 +40,11 @@ class InstanceTypeTestCase(test.TestCase):
         max_flavorid = session.query(models.InstanceTypes).\
                                      order_by("flavorid desc").\
                                      first()
+        max_id = session.query(models.InstanceTypes).\
+                                     order_by("id desc").\
+                                     first()
         self.flavorid = max_flavorid["flavorid"] + 1
+        self.id = max_id["id"] + 1
         self.name = str(int(time.time()))
 
     def test_instance_type_create_then_delete(self):
@@ -53,7 +57,7 @@ class InstanceTypeTestCase(test.TestCase):
                             'instance type was not created')
         instance_types.destroy(self.name)
         self.assertEqual(1,
-                    instance_types.get_instance_type(self.name)["deleted"])
+                    instance_types.get_instance_type(self.id)["deleted"])
         self.assertEqual(starting_inst_list, instance_types.get_all_types())
         instance_types.purge(self.name)
         self.assertEqual(len(starting_inst_list),
@@ -71,16 +75,25 @@ class InstanceTypeTestCase(test.TestCase):
     def test_invalid_create_args_should_fail(self):
         """Ensures that instance type creation fails with invalid args"""
         self.assertRaises(
-                exception.InvalidInputException,
+                exception.InvalidInput,
                 instance_types.create, self.name, 0, 1, 120, self.flavorid)
         self.assertRaises(
-                exception.InvalidInputException,
+                exception.InvalidInput,
                 instance_types.create, self.name, 256, -1, 120, self.flavorid)
         self.assertRaises(
-                exception.InvalidInputException,
+                exception.InvalidInput,
                 instance_types.create, self.name, 256, 1, "aa", self.flavorid)
 
     def test_non_existant_inst_type_shouldnt_delete(self):
         """Ensures that instance type creation fails with invalid args"""
         self.assertRaises(exception.ApiError,
                           instance_types.destroy, "sfsfsdfdfs")
+
+    def test_repeated_inst_types_should_raise_api_error(self):
+        """Ensures that instance duplicates raises ApiError"""
+        new_name = self.name + "dup"
+        instance_types.create(new_name, 256, 1, 120, self.flavorid + 1)
+        instance_types.destroy(new_name)
+        self.assertRaises(
+                exception.ApiError,
+                instance_types.create, new_name, 256, 1, 120, self.flavorid)
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_middleware.py b/nova/tests/test_middleware.py
index 9d49167ba..6564a6955 100644
--- a/nova/tests/test_middleware.py
+++ b/nova/tests/test_middleware.py
@@ -40,12 +40,12 @@ def conditional_forbid(req):
 
 class LockoutTestCase(test.TestCase):
     """Test case for the Lockout middleware."""
-    def setUp(self):  # pylint: disable-msg=C0103
+    def setUp(self):  # pylint: disable=C0103
         super(LockoutTestCase, self).setUp()
         utils.set_time_override()
         self.lockout = ec2.Lockout(conditional_forbid)
 
-    def tearDown(self):  # pylint: disable-msg=C0103
+    def tearDown(self):  # pylint: disable=C0103
         utils.clear_time_override()
         super(LockoutTestCase, self).tearDown()
 
diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index a658e4978..cf8f4c05e 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -18,50 +18,71 @@ 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):
     def test_authors_up_to_date(self):
-        if os.path.exists('.bzr'):
-            contributors = set()
-
-            mailmap = parse_mailmap('.mailmap')
+        topdir = os.path.normpath(os.path.dirname(__file__) + '/../../')
+        missing = set()
+        contributors = set()
+        mailmap = parse_mailmap(os.path.join(topdir, '.mailmap'))
+        authors_file = open(os.path.join(topdir, 'Authors'), 'r').read()
 
+        if os.path.exists(os.path.join(topdir, '.bzr')):
             import bzrlib.workingtree
-            tree = bzrlib.workingtree.WorkingTree.open('.')
+            tree = bzrlib.workingtree.WorkingTree.open(topdir)
             tree.lock_read()
             try:
                 parents = tree.get_parent_ids()
                 g = tree.branch.repository.get_graph()
-                for p in parents[1:]:
+                for p in parents:
                     rev_ids = [r for r, _ in g.iter_ancestry(parents)
                                if r != "null:"]
                     revs = tree.branch.repository.get_revisions(rev_ids)
                     for r in revs:
                         for author in r.get_apparent_authors():
                             email = author.split(' ')[-1]
-                            contributors.add(str_dict_replace(email, mailmap))
+                            contributors.add(str_dict_replace(email,
+                                                              mailmap))
+            finally:
+                tree.unlock()
 
-                authors_file = open('Authors', 'r').read()
+        elif os.path.exists(os.path.join(topdir, '.git')):
+            import git
+            repo = git.Repo(topdir)
+            for commit in repo.head.commit.iter_parents():
+                email = commit.author.email
+                if email is None:
+                    email = commit.author.name
+                if 'nova-core' in email:
+                    continue
+                if email.split(' ')[-1] == '<>':
+                    email = email.split(' ')[-2]
+                email = '<' + email + '>'
+                contributors.add(str_dict_replace(email, mailmap))
 
-                missing = set()
-                for contributor in contributors:
-                    if contributor == 'nova-core':
-                        continue
-                    if not contributor in authors_file:
-                        missing.add(contributor)
+        else:
+            return
 
-                self.assertTrue(len(missing) == 0,
-                                '%r not listed in Authors' % missing)
-            finally:
-                tree.unlock()
+        for contributor in contributors:
+            if contributor == 'nova-core':
+                continue
+            if not contributor in authors_file:
+                missing.add(contributor)
+
+        self.assertTrue(len(missing) == 0,
+                        '%r not listed in Authors' % missing)
 
 
 class LockTestCase(test.TestCase):
     def test_synchronized_wrapped_function_metadata(self):
-        @synchronized('whatever')
+        @utils.synchronized('whatever')
         def foo():
             """Bar"""
             pass
@@ -70,11 +91,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 53e35ce7e..77f6aaff3 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -21,19 +21,9 @@ Unit Tests for 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.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',
@@ -174,338 +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 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_objectstore.py b/nova/tests/test_objectstore.py
new file mode 100644
index 000000000..c78772f27
--- /dev/null
+++ b/nova/tests/test_objectstore.py
@@ -0,0 +1,148 @@
+# 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.
+
+"""
+Unittets for S3 objectstore clone.
+"""
+
+import boto
+import glob
+import hashlib
+import os
+import shutil
+import tempfile
+
+from boto import exception as boto_exception
+from boto.s3 import connection as s3
+
+from nova import context
+from nova import exception
+from nova import flags
+from nova import wsgi
+from nova import test
+from nova.auth import manager
+from nova.objectstore import s3server
+
+
+FLAGS = flags.FLAGS
+
+# Create a unique temporary directory. We don't delete after test to
+# allow checking the contents after running tests. Users and/or tools
+# running the tests need to remove the tests directories.
+OSS_TEMPDIR = tempfile.mkdtemp(prefix='test_oss-')
+
+# Create bucket/images path
+os.makedirs(os.path.join(OSS_TEMPDIR, 'images'))
+os.makedirs(os.path.join(OSS_TEMPDIR, 'buckets'))
+
+
+class S3APITestCase(test.TestCase):
+    """Test objectstore through S3 API."""
+
+    def setUp(self):
+        """Setup users, projects, and start a test server."""
+        super(S3APITestCase, self).setUp()
+        self.flags(auth_driver='nova.auth.ldapdriver.FakeLdapDriver',
+                   buckets_path=os.path.join(OSS_TEMPDIR, 'buckets'),
+                   s3_host='127.0.0.1')
+
+        self.auth_manager = manager.AuthManager()
+        self.admin_user = self.auth_manager.create_user('admin', admin=True)
+        self.admin_project = self.auth_manager.create_project('admin',
+                                                              self.admin_user)
+
+        shutil.rmtree(FLAGS.buckets_path)
+        os.mkdir(FLAGS.buckets_path)
+
+        router = s3server.S3Application(FLAGS.buckets_path)
+        server = wsgi.Server()
+        server.start(router, FLAGS.s3_port, host=FLAGS.s3_host)
+
+        if not boto.config.has_section('Boto'):
+            boto.config.add_section('Boto')
+        boto.config.set('Boto', 'num_retries', '0')
+        conn = s3.S3Connection(aws_access_key_id=self.admin_user.access,
+                               aws_secret_access_key=self.admin_user.secret,
+                               host=FLAGS.s3_host,
+                               port=FLAGS.s3_port,
+                               is_secure=False,
+                               calling_format=s3.OrdinaryCallingFormat())
+        self.conn = conn
+
+        def get_http_connection(host, is_secure):
+            """Get a new S3 connection, don't attempt to reuse connections."""
+            return self.conn.new_http_connection(host, is_secure)
+
+        self.conn.get_http_connection = get_http_connection
+
+    def _ensure_no_buckets(self, buckets):  # pylint: disable=C0111
+        self.assertEquals(len(buckets), 0, "Bucket list was not empty")
+        return True
+
+    def _ensure_one_bucket(self, buckets, name):  # pylint: disable=C0111
+        self.assertEquals(len(buckets), 1,
+                          "Bucket list didn't have exactly one element in it")
+        self.assertEquals(buckets[0].name, name, "Wrong name")
+        return True
+
+    def test_000_list_buckets(self):
+        """Make sure we are starting with no buckets."""
+        self._ensure_no_buckets(self.conn.get_all_buckets())
+
+    def test_001_create_and_delete_bucket(self):
+        """Test bucket creation and deletion."""
+        bucket_name = 'testbucket'
+
+        self.conn.create_bucket(bucket_name)
+        self._ensure_one_bucket(self.conn.get_all_buckets(), bucket_name)
+        self.conn.delete_bucket(bucket_name)
+        self._ensure_no_buckets(self.conn.get_all_buckets())
+
+    def test_002_create_bucket_and_key_and_delete_key_again(self):
+        """Test key operations on buckets."""
+        bucket_name = 'testbucket'
+        key_name = 'somekey'
+        key_contents = 'somekey'
+
+        b = self.conn.create_bucket(bucket_name)
+        k = b.new_key(key_name)
+        k.set_contents_from_string(key_contents)
+
+        bucket = self.conn.get_bucket(bucket_name)
+
+        # make sure the contents are correct
+        key = bucket.get_key(key_name)
+        self.assertEquals(key.get_contents_as_string(), key_contents,
+                          "Bad contents")
+
+        # delete the key
+        key.delete()
+
+        self._ensure_no_buckets(bucket.get_all_keys())
+
+    def test_unknown_bucket(self):
+        bucket_name = 'falalala'
+        self.assertRaises(boto_exception.S3ResponseError,
+                          self.conn.get_bucket,
+                          bucket_name)
+
+    def tearDown(self):
+        """Tear down auth and test server."""
+        self.auth_manager.delete_user('admin')
+        self.auth_manager.delete_project('admin')
+        super(S3APITestCase, self).tearDown()
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 45b544753..39a123158 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -33,6 +33,12 @@ FLAGS = flags.FLAGS
 
 
 class QuotaTestCase(test.TestCase):
+
+    class StubImageService(object):
+
+        def show(self, *args, **kwargs):
+            return {"properties": {}}
+
     def setUp(self):
         super(QuotaTestCase, self).setUp()
         self.flags(connection_type='fake',
@@ -61,7 +67,7 @@ class QuotaTestCase(test.TestCase):
         inst['reservation_id'] = 'r-fakeres'
         inst['user_id'] = self.user.id
         inst['project_id'] = self.project.id
-        inst['instance_type'] = 'm1.large'
+        inst['instance_type_id'] = '3'  # m1.large
         inst['vcpus'] = cores
         inst['mac_address'] = utils.generate_mac()
         return db.instance_create(self.context, inst)['id']
@@ -118,11 +124,12 @@ class QuotaTestCase(test.TestCase):
         for i in range(FLAGS.quota_instances):
             instance_id = self._create_instance()
             instance_ids.append(instance_id)
+        inst_type = instance_types.get_instance_type_by_name('m1.small')
         self.assertRaises(quota.QuotaError, compute.API().create,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
-                                            instance_type='m1.small',
+                                            instance_type=inst_type,
                                             image_id=1)
         for instance_id in instance_ids:
             db.instance_destroy(self.context, instance_id)
@@ -131,11 +138,12 @@ class QuotaTestCase(test.TestCase):
         instance_ids = []
         instance_id = self._create_instance(cores=4)
         instance_ids.append(instance_id)
+        inst_type = instance_types.get_instance_type_by_name('m1.small')
         self.assertRaises(quota.QuotaError, compute.API().create,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
-                                            instance_type='m1.small',
+                                            instance_type=inst_type,
                                             image_id=1)
         for instance_id in instance_ids:
             db.instance_destroy(self.context, instance_id)
@@ -186,10 +194,77 @@ class QuotaTestCase(test.TestCase):
         metadata = {}
         for i in range(FLAGS.quota_metadata_items + 1):
             metadata['key%s' % i] = 'value%s' % i
+        inst_type = instance_types.get_instance_type_by_name('m1.small')
         self.assertRaises(quota.QuotaError, compute.API().create,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
-                                            instance_type='m1.small',
+                                            instance_type=inst_type,
                                             image_id='fake',
                                             metadata=metadata)
+
+    def test_allowed_injected_files(self):
+        self.assertEqual(
+                quota.allowed_injected_files(self.context),
+                FLAGS.quota_max_injected_files)
+
+    def _create_with_injected_files(self, files):
+        api = compute.API(image_service=self.StubImageService())
+        inst_type = instance_types.get_instance_type_by_name('m1.small')
+        api.create(self.context, min_count=1, max_count=1,
+                instance_type=inst_type, image_id='fake',
+                injected_files=files)
+
+    def test_no_injected_files(self):
+        api = compute.API(image_service=self.StubImageService())
+        inst_type = instance_types.get_instance_type_by_name('m1.small')
+        api.create(self.context, instance_type=inst_type, image_id='fake')
+
+    def test_max_injected_files(self):
+        files = []
+        for i in xrange(FLAGS.quota_max_injected_files):
+            files.append(('/my/path%d' % i, 'config = test\n'))
+        self._create_with_injected_files(files)  # no QuotaError
+
+    def test_too_many_injected_files(self):
+        files = []
+        for i in xrange(FLAGS.quota_max_injected_files + 1):
+            files.append(('/my/path%d' % i, 'my\ncontent%d\n' % i))
+        self.assertRaises(quota.QuotaError,
+                          self._create_with_injected_files, files)
+
+    def test_allowed_injected_file_content_bytes(self):
+        self.assertEqual(
+                quota.allowed_injected_file_content_bytes(self.context),
+                FLAGS.quota_max_injected_file_content_bytes)
+
+    def test_max_injected_file_content_bytes(self):
+        max = FLAGS.quota_max_injected_file_content_bytes
+        content = ''.join(['a' for i in xrange(max)])
+        files = [('/test/path', content)]
+        self._create_with_injected_files(files)  # no QuotaError
+
+    def test_too_many_injected_file_content_bytes(self):
+        max = FLAGS.quota_max_injected_file_content_bytes
+        content = ''.join(['a' for i in xrange(max + 1)])
+        files = [('/test/path', content)]
+        self.assertRaises(quota.QuotaError,
+                          self._create_with_injected_files, files)
+
+    def test_allowed_injected_file_path_bytes(self):
+        self.assertEqual(
+                quota.allowed_injected_file_path_bytes(self.context),
+                FLAGS.quota_max_injected_file_path_bytes)
+
+    def test_max_injected_file_path_bytes(self):
+        max = FLAGS.quota_max_injected_file_path_bytes
+        path = ''.join(['a' for i in xrange(max)])
+        files = [(path, 'config = quotatest')]
+        self._create_with_injected_files(files)  # no QuotaError
+
+    def test_too_many_injected_file_path_bytes(self):
+        max = FLAGS.quota_max_injected_file_path_bytes
+        path = ''.join(['a' for i in xrange(max + 1)])
+        files = [(path, 'config = quotatest')]
+        self.assertRaises(quota.QuotaError,
+                          self._create_with_injected_files, files)
diff --git a/nova/tests/test_rpc.py b/nova/tests/test_rpc.py
index 4820e04fb..44d7c91eb 100644
--- a/nova/tests/test_rpc.py
+++ b/nova/tests/test_rpc.py
@@ -36,7 +36,7 @@ class RpcTestCase(test.TestCase):
         super(RpcTestCase, self).setUp()
         self.conn = rpc.Connection.instance(True)
         self.receiver = TestReceiver()
-        self.consumer = rpc.AdapterConsumer(connection=self.conn,
+        self.consumer = rpc.TopicAdapterConsumer(connection=self.conn,
                                             topic='test',
                                             proxy=self.receiver)
         self.consumer.attach_to_eventlet()
@@ -97,7 +97,7 @@ class RpcTestCase(test.TestCase):
 
         nested = Nested()
         conn = rpc.Connection.instance(True)
-        consumer = rpc.AdapterConsumer(connection=conn,
+        consumer = rpc.TopicAdapterConsumer(connection=conn,
                                        topic='nested',
                                        proxy=nested)
         consumer.attach_to_eventlet()
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index bb279ac4b..968ef9d6c 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -20,23 +20,32 @@ Tests For Scheduler
 """
 
 import datetime
+import mox
+import novaclient.exceptions
+import stubout
+import webob
 
 from mox import IgnoreArg
 from nova import context
 from nova import db
+from nova import exception
 from nova import flags
 from nova import service
 from nova import test
 from nova import rpc
 from nova import utils
 from nova.auth import manager as auth_manager
+from nova.scheduler import api
 from nova.scheduler import manager
 from nova.scheduler import driver
+from nova.compute import power_state
+from nova.db.sqlalchemy import models
 
 
 FLAGS = flags.FLAGS
 flags.DECLARE('max_cores', 'nova.scheduler.simple')
 flags.DECLARE('stub_network', 'nova.compute.manager')
+flags.DECLARE('instances_path', 'nova.compute.manager')
 
 
 class TestDriver(driver.Scheduler):
@@ -54,6 +63,34 @@ class SchedulerTestCase(test.TestCase):
         super(SchedulerTestCase, self).setUp()
         self.flags(scheduler_driver='nova.tests.test_scheduler.TestDriver')
 
+    def _create_compute_service(self):
+        """Create compute-manager(ComputeNode and Service record)."""
+        ctxt = context.get_admin_context()
+        dic = {'host': 'dummy', 'binary': 'nova-compute', 'topic': 'compute',
+               'report_count': 0, 'availability_zone': 'dummyzone'}
+        s_ref = db.service_create(ctxt, dic)
+
+        dic = {'service_id': s_ref['id'],
+               'vcpus': 16, 'memory_mb': 32, 'local_gb': 100,
+               'vcpus_used': 16, 'memory_mb_used': 32, 'local_gb_used': 10,
+               'hypervisor_type': 'qemu', 'hypervisor_version': 12003,
+               'cpu_info': ''}
+        db.compute_node_create(ctxt, dic)
+
+        return db.service_get(ctxt, s_ref['id'])
+
+    def _create_instance(self, **kwargs):
+        """Create a test instance"""
+        ctxt = context.get_admin_context()
+        inst = {}
+        inst['user_id'] = 'admin'
+        inst['project_id'] = kwargs.get('project_id', 'fake')
+        inst['host'] = kwargs.get('host', 'dummy')
+        inst['vcpus'] = kwargs.get('vcpus', 1)
+        inst['memory_mb'] = kwargs.get('memory_mb', 10)
+        inst['local_gb'] = kwargs.get('local_gb', 20)
+        return db.instance_create(ctxt, inst)
+
     def test_fallback(self):
         scheduler = manager.SchedulerManager()
         self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
@@ -76,6 +113,72 @@ class SchedulerTestCase(test.TestCase):
         self.mox.ReplayAll()
         scheduler.named_method(ctxt, 'topic', num=7)
 
+    def test_show_host_resources_host_not_exit(self):
+        """A host given as an argument does not exists."""
+
+        scheduler = manager.SchedulerManager()
+        dest = 'dummydest'
+        ctxt = context.get_admin_context()
+
+        self.assertRaises(exception.NotFound, scheduler.show_host_resources,
+                          ctxt, dest)
+        #TODO(bcwaldon): reimplement this functionality
+        #c1 = (e.message.find(_("does not exist or is not a "
+        #                       "compute node.")) >= 0)
+
+    def _dic_is_equal(self, dic1, dic2, keys=None):
+        """Compares 2 dictionary contents(Helper method)"""
+        if not keys:
+            keys = ['vcpus', 'memory_mb', 'local_gb',
+                    'vcpus_used', 'memory_mb_used', 'local_gb_used']
+
+        for key in keys:
+            if not (dic1[key] == dic2[key]):
+                return False
+        return True
+
+    def test_show_host_resources_no_project(self):
+        """No instance are running on the given host."""
+
+        scheduler = manager.SchedulerManager()
+        ctxt = context.get_admin_context()
+        s_ref = self._create_compute_service()
+
+        result = scheduler.show_host_resources(ctxt, s_ref['host'])
+
+        # result checking
+        c1 = ('resource' in result and 'usage' in result)
+        compute_node = s_ref['compute_node'][0]
+        c2 = self._dic_is_equal(result['resource'], compute_node)
+        c3 = result['usage'] == {}
+        self.assertTrue(c1 and c2 and c3)
+        db.service_destroy(ctxt, s_ref['id'])
+
+    def test_show_host_resources_works_correctly(self):
+        """Show_host_resources() works correctly as expected."""
+
+        scheduler = manager.SchedulerManager()
+        ctxt = context.get_admin_context()
+        s_ref = self._create_compute_service()
+        i_ref1 = self._create_instance(project_id='p-01', host=s_ref['host'])
+        i_ref2 = self._create_instance(project_id='p-02', vcpus=3,
+                                       host=s_ref['host'])
+
+        result = scheduler.show_host_resources(ctxt, s_ref['host'])
+
+        c1 = ('resource' in result and 'usage' in result)
+        compute_node = s_ref['compute_node'][0]
+        c2 = self._dic_is_equal(result['resource'], compute_node)
+        c3 = result['usage'].keys() == ['p-01', 'p-02']
+        keys = ['vcpus', 'memory_mb', 'local_gb']
+        c4 = self._dic_is_equal(result['usage']['p-01'], i_ref1, keys)
+        c5 = self._dic_is_equal(result['usage']['p-02'], i_ref2, keys)
+        self.assertTrue(c1 and c2 and c3 and c4 and c5)
+
+        db.service_destroy(ctxt, s_ref['id'])
+        db.instance_destroy(ctxt, i_ref1['id'])
+        db.instance_destroy(ctxt, i_ref2['id'])
+
 
 class ZoneSchedulerTestCase(test.TestCase):
     """Test case for zone scheduler"""
@@ -159,11 +262,17 @@ class SimpleDriverTestCase(test.TestCase):
         inst['reservation_id'] = 'r-fakeres'
         inst['user_id'] = self.user.id
         inst['project_id'] = self.project.id
-        inst['instance_type'] = 'm1.tiny'
+        inst['instance_type_id'] = '1'
         inst['mac_address'] = utils.generate_mac()
+        inst['vcpus'] = kwargs.get('vcpus', 1)
         inst['ami_launch_index'] = 0
-        inst['vcpus'] = 1
         inst['availability_zone'] = kwargs.get('availability_zone', None)
+        inst['host'] = kwargs.get('host', 'dummy')
+        inst['memory_mb'] = kwargs.get('memory_mb', 20)
+        inst['local_gb'] = kwargs.get('local_gb', 30)
+        inst['launched_on'] = kwargs.get('launghed_on', 'dummy')
+        inst['state_description'] = kwargs.get('state_description', 'running')
+        inst['state'] = kwargs.get('state', power_state.RUNNING)
         return db.instance_create(self.context, inst)['id']
 
     def _create_volume(self):
@@ -173,6 +282,211 @@ class SimpleDriverTestCase(test.TestCase):
         vol['availability_zone'] = 'test'
         return db.volume_create(self.context, vol)['id']
 
+    def _create_compute_service(self, **kwargs):
+        """Create a compute service."""
+
+        dic = {'binary': 'nova-compute', 'topic': 'compute',
+               'report_count': 0, 'availability_zone': 'dummyzone'}
+        dic['host'] = kwargs.get('host', 'dummy')
+        s_ref = db.service_create(self.context, dic)
+        if 'created_at' in kwargs.keys() or 'updated_at' in kwargs.keys():
+            t = datetime.datetime.utcnow() - datetime.timedelta(0)
+            dic['created_at'] = kwargs.get('created_at', t)
+            dic['updated_at'] = kwargs.get('updated_at', t)
+            db.service_update(self.context, s_ref['id'], dic)
+
+        dic = {'service_id': s_ref['id'],
+               'vcpus': 16, 'memory_mb': 32, 'local_gb': 100,
+               'vcpus_used': 16, 'local_gb_used': 10,
+               'hypervisor_type': 'qemu', 'hypervisor_version': 12003,
+               'cpu_info': ''}
+        dic['memory_mb_used'] = kwargs.get('memory_mb_used', 32)
+        dic['hypervisor_type'] = kwargs.get('hypervisor_type', 'qemu')
+        dic['hypervisor_version'] = kwargs.get('hypervisor_version', 12003)
+        db.compute_node_create(self.context, dic)
+        return db.service_get(self.context, s_ref['id'])
+
+    def test_doesnt_report_disabled_hosts_as_up(self):
+        """Ensures driver doesn't find hosts before they are enabled"""
+        # NOTE(vish): constructing service without create method
+        #             because we are going to use it without queue
+        compute1 = service.Service('host1',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute1.start()
+        compute2 = service.Service('host2',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute2.start()
+        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
+        s2 = db.service_get_by_args(self.context, 'host2', 'nova-compute')
+        db.service_update(self.context, s1['id'], {'disabled': True})
+        db.service_update(self.context, s2['id'], {'disabled': True})
+        hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
+        self.assertEqual(0, len(hosts))
+        compute1.kill()
+        compute2.kill()
+
+    def test_reports_enabled_hosts_as_up(self):
+        """Ensures driver can find the hosts that are up"""
+        # NOTE(vish): constructing service without create method
+        #             because we are going to use it without queue
+        compute1 = service.Service('host1',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute1.start()
+        compute2 = service.Service('host2',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute2.start()
+        hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
+        self.assertEqual(2, len(hosts))
+        compute1.kill()
+        compute2.kill()
+
+    def test_least_busy_host_gets_instance(self):
+        """Ensures the host with less cores gets the next one"""
+        compute1 = service.Service('host1',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute1.start()
+        compute2 = service.Service('host2',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute2.start()
+        instance_id1 = self._create_instance()
+        compute1.run_instance(self.context, instance_id1)
+        instance_id2 = self._create_instance()
+        host = self.scheduler.driver.schedule_run_instance(self.context,
+                                                           instance_id2)
+        self.assertEqual(host, 'host2')
+        compute1.terminate_instance(self.context, instance_id1)
+        db.instance_destroy(self.context, instance_id2)
+        compute1.kill()
+        compute2.kill()
+
+    def test_specific_host_gets_instance(self):
+        """Ensures if you set availability_zone it launches on that zone"""
+        compute1 = service.Service('host1',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute1.start()
+        compute2 = service.Service('host2',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute2.start()
+        instance_id1 = self._create_instance()
+        compute1.run_instance(self.context, instance_id1)
+        instance_id2 = self._create_instance(availability_zone='nova:host1')
+        host = self.scheduler.driver.schedule_run_instance(self.context,
+                                                           instance_id2)
+        self.assertEqual('host1', host)
+        compute1.terminate_instance(self.context, instance_id1)
+        db.instance_destroy(self.context, instance_id2)
+        compute1.kill()
+        compute2.kill()
+
+    def test_wont_sechedule_if_specified_host_is_down(self):
+        compute1 = service.Service('host1',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute1.start()
+        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
+        now = datetime.datetime.utcnow()
+        delta = datetime.timedelta(seconds=FLAGS.service_down_time * 2)
+        past = now - delta
+        db.service_update(self.context, s1['id'], {'updated_at': past})
+        instance_id2 = self._create_instance(availability_zone='nova:host1')
+        self.assertRaises(driver.WillNotSchedule,
+                          self.scheduler.driver.schedule_run_instance,
+                          self.context,
+                          instance_id2)
+        db.instance_destroy(self.context, instance_id2)
+        compute1.kill()
+
+    def test_will_schedule_on_disabled_host_if_specified(self):
+        compute1 = service.Service('host1',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute1.start()
+        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
+        db.service_update(self.context, s1['id'], {'disabled': True})
+        instance_id2 = self._create_instance(availability_zone='nova:host1')
+        host = self.scheduler.driver.schedule_run_instance(self.context,
+                                                           instance_id2)
+        self.assertEqual('host1', host)
+        db.instance_destroy(self.context, instance_id2)
+        compute1.kill()
+
+    def test_too_many_cores(self):
+        """Ensures we don't go over max cores"""
+        compute1 = service.Service('host1',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute1.start()
+        compute2 = service.Service('host2',
+                                   'nova-compute',
+                                   'compute',
+                                   FLAGS.compute_manager)
+        compute2.start()
+        instance_ids1 = []
+        instance_ids2 = []
+        for index in xrange(FLAGS.max_cores):
+            instance_id = self._create_instance()
+            compute1.run_instance(self.context, instance_id)
+            instance_ids1.append(instance_id)
+            instance_id = self._create_instance()
+            compute2.run_instance(self.context, instance_id)
+            instance_ids2.append(instance_id)
+        instance_id = self._create_instance()
+        self.assertRaises(driver.NoValidHost,
+                          self.scheduler.driver.schedule_run_instance,
+                          self.context,
+                          instance_id)
+        for instance_id in instance_ids1:
+            compute1.terminate_instance(self.context, instance_id)
+        for instance_id in instance_ids2:
+            compute2.terminate_instance(self.context, instance_id)
+        compute1.kill()
+        compute2.kill()
+
+    def test_least_busy_host_gets_volume(self):
+        """Ensures the host with less gigabytes gets the next one"""
+        volume1 = service.Service('host1',
+                                   'nova-volume',
+                                   'volume',
+                                   FLAGS.volume_manager)
+        volume1.start()
+        volume2 = service.Service('host2',
+                                   'nova-volume',
+                                   'volume',
+                                   FLAGS.volume_manager)
+        volume2.start()
+        volume_id1 = self._create_volume()
+        volume1.create_volume(self.context, volume_id1)
+        volume_id2 = self._create_volume()
+        host = self.scheduler.driver.schedule_create_volume(self.context,
+                                                            volume_id2)
+        self.assertEqual(host, 'host2')
+        volume1.delete_volume(self.context, volume_id1)
+        db.volume_destroy(self.context, volume_id2)
+        dic = {'service_id': s_ref['id'],
+               'vcpus': 16, 'memory_mb': 32, 'local_gb': 100,
+               'vcpus_used': 16, 'memory_mb_used': 12, 'local_gb_used': 10,
+               'hypervisor_type': 'qemu', 'hypervisor_version': 12003,
+               'cpu_info': ''}
+
     def test_doesnt_report_disabled_hosts_as_up(self):
         """Ensures driver doesn't find hosts before they are enabled"""
         compute1 = self.start_service('compute', host='host1')
@@ -316,3 +630,436 @@ class SimpleDriverTestCase(test.TestCase):
             volume2.delete_volume(self.context, volume_id)
         volume1.kill()
         volume2.kill()
+
+    def test_scheduler_live_migration_with_volume(self):
+        """scheduler_live_migration() works correctly as expected.
+
+        Also, checks instance state is changed from 'running' -> 'migrating'.
+
+        """
+
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        dic = {'instance_id': instance_id, 'size': 1}
+        v_ref = db.volume_create(self.context, dic)
+
+        # cannot check 2nd argument b/c the addresses of instance object
+        # is different.
+        driver_i = self.scheduler.driver
+        nocare = mox.IgnoreArg()
+        self.mox.StubOutWithMock(driver_i, '_live_migration_src_check')
+        self.mox.StubOutWithMock(driver_i, '_live_migration_dest_check')
+        self.mox.StubOutWithMock(driver_i, '_live_migration_common_check')
+        driver_i._live_migration_src_check(nocare, nocare)
+        driver_i._live_migration_dest_check(nocare, nocare, i_ref['host'])
+        driver_i._live_migration_common_check(nocare, nocare, i_ref['host'])
+        self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
+        kwargs = {'instance_id': instance_id, 'dest': i_ref['host']}
+        rpc.cast(self.context,
+                 db.queue_get_for(nocare, FLAGS.compute_topic, i_ref['host']),
+                 {"method": 'live_migration', "args": kwargs})
+
+        self.mox.ReplayAll()
+        self.scheduler.live_migration(self.context, FLAGS.compute_topic,
+                                      instance_id=instance_id,
+                                      dest=i_ref['host'])
+
+        i_ref = db.instance_get(self.context, instance_id)
+        self.assertTrue(i_ref['state_description'] == 'migrating')
+        db.instance_destroy(self.context, instance_id)
+        db.volume_destroy(self.context, v_ref['id'])
+
+    def test_live_migration_src_check_instance_not_running(self):
+        """The instance given by instance_id is not running."""
+
+        instance_id = self._create_instance(state_description='migrating')
+        i_ref = db.instance_get(self.context, instance_id)
+
+        try:
+            self.scheduler.driver._live_migration_src_check(self.context,
+                                                            i_ref)
+        except exception.Invalid, e:
+            c = (e.message.find('is not running') > 0)
+
+        self.assertTrue(c)
+        db.instance_destroy(self.context, instance_id)
+
+    def test_live_migration_src_check_volume_node_not_alive(self):
+        """Raise exception when volume node is not alive."""
+
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        dic = {'instance_id': instance_id, 'size': 1}
+        v_ref = db.volume_create(self.context, {'instance_id': instance_id,
+                                                'size': 1})
+        t1 = datetime.datetime.utcnow() - datetime.timedelta(1)
+        dic = {'created_at': t1, 'updated_at': t1, 'binary': 'nova-volume',
+               'topic': 'volume', 'report_count': 0}
+        s_ref = db.service_create(self.context, dic)
+
+        self.assertRaises(exception.VolumeServiceUnavailable,
+                          self.scheduler.driver.schedule_live_migration,
+                          self.context, instance_id, i_ref['host'])
+
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+        db.volume_destroy(self.context, v_ref['id'])
+
+    def test_live_migration_src_check_compute_node_not_alive(self):
+        """Confirms src-compute node is alive."""
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        t = datetime.datetime.utcnow() - datetime.timedelta(10)
+        s_ref = self._create_compute_service(created_at=t, updated_at=t,
+                                             host=i_ref['host'])
+
+        self.assertRaises(exception.ComputeServiceUnavailable,
+                          self.scheduler.driver._live_migration_src_check,
+                          self.context, i_ref)
+
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+
+    def test_live_migration_src_check_works_correctly(self):
+        """Confirms this method finishes with no error."""
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        s_ref = self._create_compute_service(host=i_ref['host'])
+
+        ret = self.scheduler.driver._live_migration_src_check(self.context,
+                                                              i_ref)
+
+        self.assertTrue(ret is None)
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+
+    def test_live_migration_dest_check_not_alive(self):
+        """Confirms exception raises in case dest host does not exist."""
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        t = datetime.datetime.utcnow() - datetime.timedelta(10)
+        s_ref = self._create_compute_service(created_at=t, updated_at=t,
+                                             host=i_ref['host'])
+
+        self.assertRaises(exception.ComputeServiceUnavailable,
+                          self.scheduler.driver._live_migration_dest_check,
+                          self.context, i_ref, i_ref['host'])
+
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+
+    def test_live_migration_dest_check_service_same_host(self):
+        """Confirms exceptioin raises in case dest and src is same host."""
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        s_ref = self._create_compute_service(host=i_ref['host'])
+
+        self.assertRaises(exception.UnableToMigrateToSelf,
+                          self.scheduler.driver._live_migration_dest_check,
+                          self.context, i_ref, i_ref['host'])
+
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+
+    def test_live_migration_dest_check_service_lack_memory(self):
+        """Confirms exception raises when dest doesn't have enough memory."""
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        s_ref = self._create_compute_service(host='somewhere',
+                                             memory_mb_used=12)
+
+        self.assertRaises(exception.MigrationError,
+                          self.scheduler.driver._live_migration_dest_check,
+                          self.context, i_ref, 'somewhere')
+
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+
+    def test_live_migration_dest_check_service_works_correctly(self):
+        """Confirms method finishes with no error."""
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        s_ref = self._create_compute_service(host='somewhere',
+                                             memory_mb_used=5)
+
+        ret = self.scheduler.driver._live_migration_dest_check(self.context,
+                                                             i_ref,
+                                                             'somewhere')
+        self.assertTrue(ret is None)
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+
+    def test_live_migration_common_check_service_orig_not_exists(self):
+        """Destination host does not exist."""
+
+        dest = 'dummydest'
+        # mocks for live_migration_common_check()
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+        t1 = datetime.datetime.utcnow() - datetime.timedelta(10)
+        s_ref = self._create_compute_service(created_at=t1, updated_at=t1,
+                                             host=dest)
+
+        # mocks for mounted_on_same_shared_storage()
+        fpath = '/test/20110127120000'
+        self.mox.StubOutWithMock(driver, 'rpc', use_mock_anything=True)
+        topic = FLAGS.compute_topic
+        driver.rpc.call(mox.IgnoreArg(),
+            db.queue_get_for(self.context, topic, dest),
+            {"method": 'create_shared_storage_test_file'}).AndReturn(fpath)
+        driver.rpc.call(mox.IgnoreArg(),
+            db.queue_get_for(mox.IgnoreArg(), topic, i_ref['host']),
+            {"method": 'check_shared_storage_test_file',
+             "args": {'filename': fpath}})
+        driver.rpc.call(mox.IgnoreArg(),
+            db.queue_get_for(mox.IgnoreArg(), topic, dest),
+            {"method": 'cleanup_shared_storage_test_file',
+             "args": {'filename': fpath}})
+
+        self.mox.ReplayAll()
+        self.assertRaises(exception.SourceHostUnavailable,
+                          self.scheduler.driver._live_migration_common_check,
+                          self.context, i_ref, dest)
+
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+
+    def test_live_migration_common_check_service_different_hypervisor(self):
+        """Original host and dest host has different hypervisor type."""
+        dest = 'dummydest'
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+
+        # compute service for destination
+        s_ref = self._create_compute_service(host=i_ref['host'])
+        # compute service for original host
+        s_ref2 = self._create_compute_service(host=dest, hypervisor_type='xen')
+
+        # mocks
+        driver = self.scheduler.driver
+        self.mox.StubOutWithMock(driver, 'mounted_on_same_shared_storage')
+        driver.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
+
+        self.mox.ReplayAll()
+        self.assertRaises(exception.InvalidHypervisorType,
+                          self.scheduler.driver._live_migration_common_check,
+                          self.context, i_ref, dest)
+
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+        db.service_destroy(self.context, s_ref2['id'])
+
+    def test_live_migration_common_check_service_different_version(self):
+        """Original host and dest host has different hypervisor version."""
+        dest = 'dummydest'
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+
+        # compute service for destination
+        s_ref = self._create_compute_service(host=i_ref['host'])
+        # compute service for original host
+        s_ref2 = self._create_compute_service(host=dest,
+                                              hypervisor_version=12002)
+
+        # mocks
+        driver = self.scheduler.driver
+        self.mox.StubOutWithMock(driver, 'mounted_on_same_shared_storage')
+        driver.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
+
+        self.mox.ReplayAll()
+        self.assertRaises(exception.DestinationHypervisorTooOld,
+                          self.scheduler.driver._live_migration_common_check,
+                          self.context, i_ref, dest)
+
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+        db.service_destroy(self.context, s_ref2['id'])
+
+    def test_live_migration_common_check_checking_cpuinfo_fail(self):
+        """Raise excetion when original host doen't have compatible cpu."""
+
+        dest = 'dummydest'
+        instance_id = self._create_instance()
+        i_ref = db.instance_get(self.context, instance_id)
+
+        # compute service for destination
+        s_ref = self._create_compute_service(host=i_ref['host'])
+        # compute service for original host
+        s_ref2 = self._create_compute_service(host=dest)
+
+        # mocks
+        driver = self.scheduler.driver
+        self.mox.StubOutWithMock(driver, 'mounted_on_same_shared_storage')
+        driver.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
+        self.mox.StubOutWithMock(rpc, 'call', use_mock_anything=True)
+        rpc.call(mox.IgnoreArg(), mox.IgnoreArg(),
+            {"method": 'compare_cpu',
+            "args": {'cpu_info': s_ref2['compute_node'][0]['cpu_info']}}).\
+             AndRaise(rpc.RemoteError("doesn't have compatibility to", "", ""))
+
+        self.mox.ReplayAll()
+        try:
+            self.scheduler.driver._live_migration_common_check(self.context,
+                                                               i_ref,
+                                                               dest)
+        except rpc.RemoteError, e:
+            c = (e.message.find(_("doesn't have compatibility to")) >= 0)
+
+        self.assertTrue(c)
+        db.instance_destroy(self.context, instance_id)
+        db.service_destroy(self.context, s_ref['id'])
+        db.service_destroy(self.context, s_ref2['id'])
+
+
+class FakeZone(object):
+    def __init__(self, api_url, username, password):
+        self.api_url = api_url
+        self.username = username
+        self.password = password
+
+
+def zone_get_all(context):
+    return [
+                FakeZone('http://example.com', 'bob', 'xxx'),
+           ]
+
+
+class FakeRerouteCompute(api.reroute_compute):
+    def _call_child_zones(self, zones, function):
+        return []
+
+    def get_collection_context_and_id(self, args, kwargs):
+        return ("servers", None, 1)
+
+    def unmarshall_result(self, zone_responses):
+        return dict(magic="found me")
+
+
+def go_boom(self, context, instance):
+    raise exception.InstanceNotFound(instance_id=instance)
+
+
+def found_instance(self, context, instance):
+    return dict(name='myserver')
+
+
+class FakeResource(object):
+    def __init__(self, attribute_dict):
+        for k, v in attribute_dict.iteritems():
+            setattr(self, k, v)
+
+    def pause(self):
+        pass
+
+
+class ZoneRedirectTest(test.TestCase):
+    def setUp(self):
+        super(ZoneRedirectTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+
+        self.stubs.Set(db, 'zone_get_all', zone_get_all)
+
+        self.enable_zone_routing = FLAGS.enable_zone_routing
+        FLAGS.enable_zone_routing = True
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.enable_zone_routing = self.enable_zone_routing
+        super(ZoneRedirectTest, self).tearDown()
+
+    def test_trap_found_locally(self):
+        decorator = FakeRerouteCompute("foo")
+        try:
+            result = decorator(found_instance)(None, None, 1)
+        except api.RedirectResult, e:
+            self.fail(_("Successful database hit should succeed"))
+
+    def test_trap_not_found_locally(self):
+        decorator = FakeRerouteCompute("foo")
+        try:
+            result = decorator(go_boom)(None, None, 1)
+            self.assertFail(_("Should have rerouted."))
+        except api.RedirectResult, e:
+            self.assertEquals(e.results['magic'], 'found me')
+
+    def test_routing_flags(self):
+        FLAGS.enable_zone_routing = False
+        decorator = FakeRerouteCompute("foo")
+        self.assertRaises(exception.InstanceNotFound, decorator(go_boom),
+                          None, None, 1)
+
+    def test_get_collection_context_and_id(self):
+        decorator = api.reroute_compute("foo")
+        self.assertEquals(decorator.get_collection_context_and_id(
+            (None, 10, 20), {}), ("servers", 10, 20))
+        self.assertEquals(decorator.get_collection_context_and_id(
+            (None, 11,),  dict(instance_id=21)), ("servers", 11, 21))
+        self.assertEquals(decorator.get_collection_context_and_id(
+            (None,), dict(context=12, instance_id=22)), ("servers", 12, 22))
+
+    def test_unmarshal_single_server(self):
+        decorator = api.reroute_compute("foo")
+        self.assertEquals(decorator.unmarshall_result([]), {})
+        self.assertEquals(decorator.unmarshall_result(
+                [FakeResource(dict(a=1, b=2)), ]),
+                dict(server=dict(a=1, b=2)))
+        self.assertEquals(decorator.unmarshall_result(
+                [FakeResource(dict(a=1, _b=2)), ]),
+                dict(server=dict(a=1,)))
+        self.assertEquals(decorator.unmarshall_result(
+                [FakeResource(dict(a=1, manager=2)), ]),
+                dict(server=dict(a=1,)))
+        self.assertEquals(decorator.unmarshall_result(
+                [FakeResource(dict(_a=1, manager=2)), ]),
+                dict(server={}))
+
+
+class FakeServerCollection(object):
+    def get(self, instance_id):
+        return FakeResource(dict(a=10, b=20))
+
+    def find(self, name):
+        return FakeResource(dict(a=11, b=22))
+
+
+class FakeEmptyServerCollection(object):
+    def get(self, f):
+        raise novaclient.NotFound(1)
+
+    def find(self, name):
+        raise novaclient.NotFound(2)
+
+
+class FakeNovaClient(object):
+    def __init__(self, collection):
+        self.servers = collection
+
+
+class DynamicNovaClientTest(test.TestCase):
+    def test_issue_novaclient_command_found(self):
+        zone = FakeZone('http://example.com', 'bob', 'xxx')
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeServerCollection()),
+                    zone, "servers", "get", 100).a, 10)
+
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeServerCollection()),
+                    zone, "servers", "find", "name").b, 22)
+
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeServerCollection()),
+                    zone, "servers", "pause", 100), None)
+
+    def test_issue_novaclient_command_not_found(self):
+        zone = FakeZone('http://example.com', 'bob', 'xxx')
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeEmptyServerCollection()),
+                    zone, "servers", "get", 100), None)
+
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeEmptyServerCollection()),
+                    zone, "servers", "find", "name"), None)
+
+        self.assertEquals(api._issue_novaclient_command(
+                    FakeNovaClient(FakeEmptyServerCollection()),
+                    zone, "servers", "any", "name"), None)
diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index 45d9afa6c..d48de2057 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -30,6 +30,7 @@ from nova import rpc
 from nova import test
 from nova import service
 from nova import manager
+from nova.compute import manager as compute_manager
 
 FLAGS = flags.FLAGS
 flags.DEFINE_string("fake_manager", "nova.tests.test_service.FakeManager",
@@ -108,20 +109,29 @@ class ServiceTestCase(test.TestCase):
         app = service.Service.create(host=host, binary=binary)
 
         self.mox.StubOutWithMock(rpc,
-                                 'AdapterConsumer',
+                                 'TopicAdapterConsumer',
                                  use_mock_anything=True)
-        rpc.AdapterConsumer(connection=mox.IgnoreArg(),
+        self.mox.StubOutWithMock(rpc,
+                                 'FanoutAdapterConsumer',
+                                 use_mock_anything=True)
+        rpc.TopicAdapterConsumer(connection=mox.IgnoreArg(),
                             topic=topic,
                             proxy=mox.IsA(service.Service)).AndReturn(
-                                    rpc.AdapterConsumer)
+                                    rpc.TopicAdapterConsumer)
 
-        rpc.AdapterConsumer(connection=mox.IgnoreArg(),
+        rpc.TopicAdapterConsumer(connection=mox.IgnoreArg(),
                             topic='%s.%s' % (topic, host),
                             proxy=mox.IsA(service.Service)).AndReturn(
-                                    rpc.AdapterConsumer)
+                                    rpc.TopicAdapterConsumer)
 
-        rpc.AdapterConsumer.attach_to_eventlet()
-        rpc.AdapterConsumer.attach_to_eventlet()
+        rpc.FanoutAdapterConsumer(connection=mox.IgnoreArg(),
+                            topic=topic,
+                            proxy=mox.IsA(service.Service)).AndReturn(
+                                    rpc.FanoutAdapterConsumer)
+
+        rpc.TopicAdapterConsumer.attach_to_eventlet()
+        rpc.TopicAdapterConsumer.attach_to_eventlet()
+        rpc.FanoutAdapterConsumer.attach_to_eventlet()
 
         service_create = {'host': host,
                           'binary': binary,
@@ -251,3 +261,44 @@ class ServiceTestCase(test.TestCase):
         serv.report_state()
 
         self.assert_(not serv.model_disconnected)
+
+    def test_compute_can_update_available_resource(self):
+        """Confirm compute updates their record of compute-service table."""
+        host = 'foo'
+        binary = 'nova-compute'
+        topic = 'compute'
+
+        # Any mocks are not working without UnsetStubs() here.
+        self.mox.UnsetStubs()
+        ctxt = context.get_admin_context()
+        service_ref = db.service_create(ctxt, {'host': host,
+                                               'binary': binary,
+                                               'topic': topic})
+        serv = service.Service(host,
+                               binary,
+                               topic,
+                               'nova.compute.manager.ComputeManager')
+
+        # This testcase want to test calling update_available_resource.
+        # No need to call periodic call, then below variable must be set 0.
+        serv.report_interval = 0
+        serv.periodic_interval = 0
+
+        # Creating mocks
+        self.mox.StubOutWithMock(service.rpc.Connection, 'instance')
+        service.rpc.Connection.instance(new=mox.IgnoreArg())
+        service.rpc.Connection.instance(new=mox.IgnoreArg())
+        service.rpc.Connection.instance(new=mox.IgnoreArg())
+        self.mox.StubOutWithMock(serv.manager.driver,
+                                 'update_available_resource')
+        serv.manager.driver.update_available_resource(mox.IgnoreArg(), host)
+
+        # Just doing start()-stop(), not confirm new db record is created,
+        # because update_available_resource() works only in
+        # libvirt environment. This testcase confirms
+        # update_available_resource() is called. Otherwise, mox complains.
+        self.mox.ReplayAll()
+        serv.start()
+        serv.stop()
+
+        db.service_destroy(ctxt, service_ref['id'])
diff --git a/nova/tests/test_test.py b/nova/tests/test_test.py
index e237674e6..35c838065 100644
--- a/nova/tests/test_test.py
+++ b/nova/tests/test_test.py
@@ -34,7 +34,7 @@ class IsolationTestCase(test.TestCase):
 
     def test_rpc_consumer_isolation(self):
         connection = rpc.Connection.instance(new=True)
-        consumer = rpc.TopicConsumer(connection, topic='compute')
+        consumer = rpc.TopicAdapterConsumer(connection, topic='compute')
         consumer.register_callback(
                 lambda x, y: self.fail('I should never be called'))
         consumer.attach_to_eventlet()
diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py
index 34a407f1a..8f7e83c3e 100644
--- a/nova/tests/test_utils.py
+++ b/nova/tests/test_utils.py
@@ -14,9 +14,87 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import os
+import tempfile
+
+from nova import exception
 from nova import test
 from nova import utils
-from nova import exception
+
+
+class ExecuteTestCase(test.TestCase):
+    def test_retry_on_failure(self):
+        fd, tmpfilename = tempfile.mkstemp()
+        _, tmpfilename2 = tempfile.mkstemp()
+        try:
+            fp = os.fdopen(fd, 'w+')
+            fp.write('''#!/bin/sh
+# If stdin fails to get passed during one of the runs, make a note.
+if ! grep -q foo
+then
+    echo 'failure' > "$1"
+fi
+# If stdin has failed to get passed during this or a previous run, exit early.
+if grep failure "$1"
+then
+    exit 1
+fi
+runs="$(cat $1)"
+if [ -z "$runs" ]
+then
+    runs=0
+fi
+runs=$(($runs + 1))
+echo $runs > "$1"
+exit 1
+''')
+            fp.close()
+            os.chmod(tmpfilename, 0755)
+            self.assertRaises(exception.ProcessExecutionError,
+                              utils.execute,
+                              tmpfilename, tmpfilename2, attempts=10,
+                              process_input='foo',
+                              delay_on_retry=False)
+            fp = open(tmpfilename2, 'r+')
+            runs = fp.read()
+            fp.close()
+            self.assertNotEquals(runs.strip(), 'failure', 'stdin did not '
+                                                          'always get passed '
+                                                          'correctly')
+            runs = int(runs.strip())
+            self.assertEquals(runs, 10,
+                              'Ran %d times instead of 10.' % (runs,))
+        finally:
+            os.unlink(tmpfilename)
+            os.unlink(tmpfilename2)
+
+    def test_unknown_kwargs_raises_error(self):
+        self.assertRaises(exception.Error,
+                          utils.execute,
+                          '/bin/true', this_is_not_a_valid_kwarg=True)
+
+    def test_no_retry_on_success(self):
+        fd, tmpfilename = tempfile.mkstemp()
+        _, tmpfilename2 = tempfile.mkstemp()
+        try:
+            fp = os.fdopen(fd, 'w+')
+            fp.write('''#!/bin/sh
+# If we've already run, bail out.
+grep -q foo "$1" && exit 1
+# Mark that we've run before.
+echo foo > "$1"
+# Check that stdin gets passed correctly.
+grep foo
+''')
+            fp.close()
+            os.chmod(tmpfilename, 0755)
+            utils.execute(tmpfilename,
+                          tmpfilename2,
+                          process_input='foo',
+                          attempts=2)
+        finally:
+            os.unlink(tmpfilename)
+            os.unlink(tmpfilename2)
 
 
 class GetFromPathTestCase(test.TestCase):
@@ -172,3 +250,28 @@ class GetFromPathTestCase(test.TestCase):
         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"))
+
+
+class GenericUtilsTestCase(test.TestCase):
+    def test_parse_server_string(self):
+        result = utils.parse_server_string('::1')
+        self.assertEqual(('::1', ''), result)
+        result = utils.parse_server_string('[::1]:8773')
+        self.assertEqual(('::1', '8773'), result)
+        result = utils.parse_server_string('2001:db8::192.168.1.1')
+        self.assertEqual(('2001:db8::192.168.1.1', ''), result)
+        result = utils.parse_server_string('[2001:db8::192.168.1.1]:8773')
+        self.assertEqual(('2001:db8::192.168.1.1', '8773'), result)
+        result = utils.parse_server_string('192.168.1.1')
+        self.assertEqual(('192.168.1.1', ''), result)
+        result = utils.parse_server_string('192.168.1.2:8773')
+        self.assertEqual(('192.168.1.2', '8773'), result)
+        result = utils.parse_server_string('192.168.1.3')
+        self.assertEqual(('192.168.1.3', ''), result)
+        result = utils.parse_server_string('www.example.com:8443')
+        self.assertEqual(('www.example.com', '8443'), result)
+        result = utils.parse_server_string('www.example.com')
+        self.assertEqual(('www.example.com', ''), result)
+        # error case
+        result = utils.parse_server_string('www.exa:mple.com:8443')
+        self.assertEqual(('', ''), result)
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 27893043a..1311ba361 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -14,22 +14,27 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import re
+import eventlet
+import mox
 import os
+import re
+import sys
 
-import eventlet
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
 
 from nova import context
 from nova import db
+from nova import exception
 from nova import flags
 from nova import test
 from nova import utils
 from nova.api.ec2 import cloud
 from nova.auth import manager
+from nova.compute import power_state
 from nova.virt import libvirt_conn
 
+libvirt = None
 FLAGS = flags.FLAGS
 flags.DECLARE('instances_path', 'nova.compute.manager')
 
@@ -39,6 +44,27 @@ def _concurrency(wait, done, target):
     done.send()
 
 
+def _create_network_info(count=1, ipv6=None):
+    if ipv6 is None:
+        ipv6 = FLAGS.use_ipv6
+    fake = 'fake'
+    fake_ip = '0.0.0.0/0'
+    fake_ip_2 = '0.0.0.1/0'
+    fake_ip_3 = '0.0.0.1/0'
+    network = {'gateway': fake,
+               'gateway_v6': fake,
+               'bridge': fake,
+               'cidr': fake_ip,
+               'cidr_v6': fake_ip}
+    mapping = {'mac': fake,
+               'ips': [{'ip': fake_ip}, {'ip': fake_ip}]}
+    if ipv6:
+        mapping['ip6s'] = [{'ip': fake_ip},
+                           {'ip': fake_ip_2},
+                           {'ip': fake_ip_3}]
+    return [(network, mapping) for x in xrange(0, count)]
+
+
 class CacheConcurrencyTestCase(test.TestCase):
     def setUp(self):
         super(CacheConcurrencyTestCase, self).setUp()
@@ -70,13 +96,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"""
@@ -104,11 +128,28 @@ class LibvirtConnTestCase(test.TestCase):
         libvirt_conn._late_load_cheetah()
         self.flags(fake_call=True)
         self.manager = manager.AuthManager()
+
+        try:
+            pjs = self.manager.get_projects()
+            pjs = [p for p in pjs if p.name == 'fake']
+            if 0 != len(pjs):
+                self.manager.delete_project(pjs[0])
+
+            users = self.manager.get_users()
+            users = [u for u in users if u.name == 'fake']
+            if 0 != len(users):
+                self.manager.delete_user(users[0])
+        except Exception, e:
+            pass
+
+        users = self.manager.get_users()
         self.user = self.manager.create_user('fake', 'fake', 'fake',
                                              admin=True)
         self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.network = utils.import_object(FLAGS.network_manager)
+        self.context = context.get_admin_context()
         FLAGS.instances_path = ''
+        self.call_libvirt_dependant_setup = False
 
     test_ip = '10.11.12.13'
     test_instance = {'memory_kb':     '1024000',
@@ -118,7 +159,90 @@ class LibvirtConnTestCase(test.TestCase):
                      'vcpus':         2,
                      'project_id':    'fake',
                      'bridge':        'br101',
-                     'instance_type': 'm1.small'}
+                     'instance_type_id': '5'}  # m1.small
+
+    def lazy_load_library_exists(self):
+        """check if libvirt is available."""
+        # try to connect libvirt. if fail, skip test.
+        try:
+            import libvirt
+            import libxml2
+        except ImportError:
+            return False
+        global libvirt
+        libvirt = __import__('libvirt')
+        libvirt_conn.libvirt = __import__('libvirt')
+        libvirt_conn.libxml2 = __import__('libxml2')
+        return True
+
+    def create_fake_libvirt_mock(self, **kwargs):
+        """Defining mocks for LibvirtConnection(libvirt is not used)."""
+
+        # A fake libvirt.virConnect
+        class FakeLibvirtConnection(object):
+            pass
+
+        # A fake libvirt_conn.IptablesFirewallDriver
+        class FakeIptablesFirewallDriver(object):
+
+            def __init__(self, **kwargs):
+                pass
+
+            def setattr(self, key, val):
+                self.__setattr__(key, val)
+
+        # Creating mocks
+        fake = FakeLibvirtConnection()
+        fakeip = FakeIptablesFirewallDriver
+        # Customizing above fake if necessary
+        for key, val in kwargs.items():
+            fake.__setattr__(key, val)
+
+        # Inevitable mocks for libvirt_conn.LibvirtConnection
+        self.mox.StubOutWithMock(libvirt_conn.utils, 'import_class')
+        libvirt_conn.utils.import_class(mox.IgnoreArg()).AndReturn(fakeip)
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection, '_conn')
+        libvirt_conn.LibvirtConnection._conn = fake
+
+    def create_service(self, **kwargs):
+        service_ref = {'host': kwargs.get('host', 'dummy'),
+                       'binary': 'nova-compute',
+                       'topic': 'compute',
+                       'report_count': 0,
+                       'availability_zone': 'zone'}
+
+        return db.service_create(context.get_admin_context(), service_ref)
+
+    def test_preparing_xml_info(self):
+        conn = libvirt_conn.LibvirtConnection(True)
+        instance_ref = db.instance_create(self.context, self.test_instance)
+
+        result = conn._prepare_xml_info(instance_ref, False)
+        self.assertFalse(result['nics'])
+
+        result = conn._prepare_xml_info(instance_ref, False,
+                                        _create_network_info())
+        self.assertTrue(len(result['nics']) == 1)
+
+        result = conn._prepare_xml_info(instance_ref, False,
+                                        _create_network_info(2))
+        self.assertTrue(len(result['nics']) == 2)
+
+    def test_get_nic_for_xml_v4(self):
+        conn = libvirt_conn.LibvirtConnection(True)
+        network, mapping = _create_network_info()[0]
+        self.flags(use_ipv6=False)
+        params = conn._get_nic_for_xml(network, mapping)['extra_params']
+        self.assertTrue(params.find('PROJNETV6') == -1)
+        self.assertTrue(params.find('PROJMASKV6') == -1)
+
+    def test_get_nic_for_xml_v6(self):
+        conn = libvirt_conn.LibvirtConnection(True)
+        network, mapping = _create_network_info()[0]
+        self.flags(use_ipv6=True)
+        params = conn._get_nic_for_xml(network, mapping)['extra_params']
+        self.assertTrue(params.find('PROJNETV6') > -1)
+        self.assertTrue(params.find('PROJMASKV6') > -1)
 
     def test_xml_and_uri_no_ramdisk_no_kernel(self):
         instance_data = dict(self.test_instance)
@@ -151,6 +275,65 @@ class LibvirtConnTestCase(test.TestCase):
         self._check_xml_and_uri(instance_data, expect_kernel=True,
                                 expect_ramdisk=True, rescue=True)
 
+    def test_lxc_container_and_uri(self):
+        instance_data = dict(self.test_instance)
+        self._check_xml_and_container(instance_data)
+
+    def test_multi_nic(self):
+        instance_data = dict(self.test_instance)
+        network_info = _create_network_info(2)
+        conn = libvirt_conn.LibvirtConnection(True)
+        instance_ref = db.instance_create(self.context, instance_data)
+        xml = conn.to_xml(instance_ref, False, network_info)
+        tree = xml_to_tree(xml)
+        interfaces = tree.findall("./devices/interface")
+        self.assertEquals(len(interfaces), 2)
+        parameters = interfaces[0].findall('./filterref/parameter')
+        self.assertEquals(interfaces[0].get('type'), 'bridge')
+        self.assertEquals(parameters[0].get('name'), 'IP')
+        self.assertEquals(parameters[0].get('value'), '0.0.0.0/0')
+        self.assertEquals(parameters[1].get('name'), 'DHCPSERVER')
+        self.assertEquals(parameters[1].get('value'), 'fake')
+
+    def _check_xml_and_container(self, instance):
+        user_context = context.RequestContext(project=self.project,
+                                              user=self.user)
+        instance_ref = db.instance_create(user_context, instance)
+        host = self.network.get_network_host(user_context.elevated())
+        network_ref = db.project_get_network(context.get_admin_context(),
+                                             self.project.id)
+
+        fixed_ip = {'address': self.test_ip,
+                    'network_id': network_ref['id']}
+
+        ctxt = context.get_admin_context()
+        fixed_ip_ref = db.fixed_ip_create(ctxt, fixed_ip)
+        db.fixed_ip_update(ctxt, self.test_ip,
+                                 {'allocated': True,
+                                  'instance_id': instance_ref['id']})
+
+        self.flags(libvirt_type='lxc')
+        conn = libvirt_conn.LibvirtConnection(True)
+
+        uri = conn.get_uri()
+        self.assertEquals(uri, 'lxc:///')
+
+        xml = conn.to_xml(instance_ref)
+        tree = xml_to_tree(xml)
+
+        check = [
+        (lambda t: t.find('.').get('type'), 'lxc'),
+        (lambda t: t.find('./os/type').text, 'exe'),
+        (lambda t: t.find('./devices/filesystem/target').get('dir'), '/')]
+
+        for i, (check, expected_result) in enumerate(check):
+            self.assertEqual(check(tree),
+                             expected_result,
+                             '%s failed common check %d' % (xml, i))
+
+        target = tree.find('./devices/filesystem/source').get('dir')
+        self.assertTrue(len(target) > 0)
+
     def _check_xml_and_uri(self, instance, expect_ramdisk, expect_kernel,
                            rescue=False):
         user_context = context.RequestContext(project=self.project,
@@ -210,19 +393,13 @@ class LibvirtConnTestCase(test.TestCase):
                     check = (lambda t: t.find('./os/initrd'), None)
                 check_list.append(check)
 
+        parameter = './devices/interface/filterref/parameter'
         common_checks = [
             (lambda t: t.find('.').tag, 'domain'),
-            (lambda t: t.find(
-                './devices/interface/filterref/parameter').get('name'), 'IP'),
-            (lambda t: t.find(
-                './devices/interface/filterref/parameter').get(
-                    'value'), '10.11.12.13'),
-            (lambda t: t.findall(
-                './devices/interface/filterref/parameter')[1].get(
-                    'name'), 'DHCPSERVER'),
-            (lambda t: t.findall(
-                './devices/interface/filterref/parameter')[1].get(
-                    'value'), '10.0.0.1'),
+            (lambda t: t.find(parameter).get('name'), 'IP'),
+            (lambda t: t.find(parameter).get('value'), '10.11.12.13'),
+            (lambda t: t.findall(parameter)[1].get('name'), 'DHCPSERVER'),
+            (lambda t: t.findall(parameter)[1].get('value'), '10.0.0.1'),
             (lambda t: t.find('./devices/serial/source').get(
                 'path').split('/')[1], 'console.log'),
             (lambda t: t.find('./memory').text, '2097152')]
@@ -259,8 +436,8 @@ class LibvirtConnTestCase(test.TestCase):
                                  expected_result,
                                  '%s failed common check %d' % (xml, i))
 
-        # This test is supposed to make sure we don't override a specifically
-        # set uri
+        # This test is supposed to make sure we don't
+        # override a specifically set uri
         #
         # Deliberately not just assigning this string to FLAGS.libvirt_uri and
         # checking against that later on. This way we make sure the
@@ -274,6 +451,206 @@ class LibvirtConnTestCase(test.TestCase):
             self.assertEquals(uri, testuri)
         db.instance_destroy(user_context, instance_ref['id'])
 
+    def test_update_available_resource_works_correctly(self):
+        """Confirm compute_node table is updated successfully."""
+        org_path = FLAGS.instances_path = ''
+        FLAGS.instances_path = '.'
+
+        # Prepare mocks
+        def getVersion():
+            return 12003
+
+        def getType():
+            return 'qemu'
+
+        def listDomainsID():
+            return []
+
+        service_ref = self.create_service(host='dummy')
+        self.create_fake_libvirt_mock(getVersion=getVersion,
+                                      getType=getType,
+                                      listDomainsID=listDomainsID)
+        self.mox.StubOutWithMock(libvirt_conn.LibvirtConnection,
+                                 'get_cpu_info')
+        libvirt_conn.LibvirtConnection.get_cpu_info().AndReturn('cpuinfo')
+
+        # Start test
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        conn.update_available_resource(self.context, 'dummy')
+        service_ref = db.service_get(self.context, service_ref['id'])
+        compute_node = service_ref['compute_node'][0]
+
+        if sys.platform.upper() == 'LINUX2':
+            self.assertTrue(compute_node['vcpus'] >= 0)
+            self.assertTrue(compute_node['memory_mb'] > 0)
+            self.assertTrue(compute_node['local_gb'] > 0)
+            self.assertTrue(compute_node['vcpus_used'] == 0)
+            self.assertTrue(compute_node['memory_mb_used'] > 0)
+            self.assertTrue(compute_node['local_gb_used'] > 0)
+            self.assertTrue(len(compute_node['hypervisor_type']) > 0)
+            self.assertTrue(compute_node['hypervisor_version'] > 0)
+        else:
+            self.assertTrue(compute_node['vcpus'] >= 0)
+            self.assertTrue(compute_node['memory_mb'] == 0)
+            self.assertTrue(compute_node['local_gb'] > 0)
+            self.assertTrue(compute_node['vcpus_used'] == 0)
+            self.assertTrue(compute_node['memory_mb_used'] == 0)
+            self.assertTrue(compute_node['local_gb_used'] > 0)
+            self.assertTrue(len(compute_node['hypervisor_type']) > 0)
+            self.assertTrue(compute_node['hypervisor_version'] > 0)
+
+        db.service_destroy(self.context, service_ref['id'])
+        FLAGS.instances_path = org_path
+
+    def test_update_resource_info_no_compute_record_found(self):
+        """Raise exception if no recorde found on services table."""
+        org_path = FLAGS.instances_path = ''
+        FLAGS.instances_path = '.'
+        self.create_fake_libvirt_mock()
+
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertRaises(exception.ComputeServiceUnavailable,
+                          conn.update_available_resource,
+                          self.context, 'dummy')
+
+        FLAGS.instances_path = org_path
+
+    def test_ensure_filtering_rules_for_instance_timeout(self):
+        """ensure_filtering_fules_for_instance() finishes with timeout."""
+        # Skip if non-libvirt environment
+        if not self.lazy_load_library_exists():
+            return
+
+        # Preparing mocks
+        def fake_none(self):
+            return
+
+        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()
+        instance_ref = db.instance_create(self.context, self.test_instance)
+
+        # Start test
+        self.mox.ReplayAll()
+        try:
+            conn = libvirt_conn.LibvirtConnection(False)
+            conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
+            conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
+            conn.firewall_driver.setattr('instance_filter_exists', fake_none)
+            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):
+        """Confirms recover method is called when exceptions are raised."""
+        # Skip if non-libvirt environment
+        if not self.lazy_load_library_exists():
+            return
+
+        # Preparing data
+        self.compute = utils.import_object(FLAGS.compute_manager)
+        instance_dict = {'host': 'fake', 'state': power_state.RUNNING,
+                         'state_description': 'running'}
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        instance_ref = db.instance_update(self.context, instance_ref['id'],
+                                          instance_dict)
+        vol_dict = {'status': 'migrating', 'size': 1}
+        volume_ref = db.volume_create(self.context, vol_dict)
+        db.volume_attached(self.context, volume_ref['id'], instance_ref['id'],
+                           '/dev/fake')
+
+        # Preparing mocks
+        vdmock = self.mox.CreateMock(libvirt.virDomain)
+        self.mox.StubOutWithMock(vdmock, "migrateToURI")
+        vdmock.migrateToURI(FLAGS.live_migration_uri % 'dest',
+                            mox.IgnoreArg(),
+                            None, FLAGS.live_migration_bandwidth).\
+                            AndRaise(libvirt.libvirtError('ERR'))
+
+        def fake_lookup(instance_name):
+            if instance_name == instance_ref.name:
+                return vdmock
+
+        self.create_fake_libvirt_mock(lookupByName=fake_lookup)
+
+        # Start test
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        self.assertRaises(libvirt.libvirtError,
+                      conn._live_migration,
+                      self.context, instance_ref, 'dest', '',
+                      self.compute.recover_live_migration)
+
+        instance_ref = db.instance_get(self.context, instance_ref['id'])
+        self.assertTrue(instance_ref['state_description'] == 'running')
+        self.assertTrue(instance_ref['state'] == power_state.RUNNING)
+        volume_ref = db.volume_get(self.context, volume_ref['id'])
+        self.assertTrue(volume_ref['status'] == 'in-use')
+
+        db.volume_destroy(self.context, volume_ref['id'])
+        db.instance_destroy(self.context, instance_ref['id'])
+
+    def test_spawn_with_network_info(self):
+        # Skip if non-libvirt environment
+        if not self.lazy_load_library_exists():
+            return
+
+        # Preparing mocks
+        def fake_none(self, instance):
+            return
+
+        self.create_fake_libvirt_mock()
+        instance = db.instance_create(self.context, self.test_instance)
+
+        # Start test
+        self.mox.ReplayAll()
+        conn = libvirt_conn.LibvirtConnection(False)
+        conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
+        conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
+
+        network = db.project_get_network(context.get_admin_context(),
+                                         self.project.id)
+        ip_dict = {'ip': self.test_ip,
+                   'netmask': network['netmask'],
+                   'enabled': '1'}
+        mapping = {'label': network['label'],
+                   'gateway': network['gateway'],
+                   'mac': instance['mac_address'],
+                   'dns': [network['dns']],
+                   'ips': [ip_dict]}
+        network_info = [(network, mapping)]
+
+        try:
+            conn.spawn(instance, network_info)
+        except Exception, e:
+            count = (0 <= e.message.find('Unexpected method call'))
+
+        self.assertTrue(count)
+
+    def test_get_host_ip_addr(self):
+        conn = libvirt_conn.LibvirtConnection(False)
+        ip = conn.get_host_ip_addr()
+        self.assertEquals(ip, FLAGS.my_ip)
+
     def tearDown(self):
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
@@ -339,11 +716,15 @@ class IptablesFirewallTestCase(test.TestCase):
       '# Completed on Tue Jan 18 23:47:56 2011',
     ]
 
+    def _create_instance_ref(self):
+        return db.instance_create(self.context,
+                                  {'user_id': 'fake',
+                                   'project_id': 'fake',
+                                   'mac_address': '56:12:12:12:12:12',
+                                   'instance_type_id': 1})
+
     def test_static_filters(self):
-        instance_ref = db.instance_create(self.context,
-                                          {'user_id': 'fake',
-                                          'project_id': 'fake',
-                                          'mac_address': '56:12:12:12:12:12'})
+        instance_ref = self._create_instance_ref()
         ip = '10.11.12.13'
 
         network_ref = db.project_get_network(self.context,
@@ -454,6 +835,40 @@ class IptablesFirewallTestCase(test.TestCase):
                         "TCP port 80/81 acceptance rule wasn't added")
         db.instance_destroy(admin_ctxt, instance_ref['id'])
 
+    def test_filters_for_instance_with_ip_v6(self):
+        self.flags(use_ipv6=True)
+        network_info = _create_network_info()
+        rulesv4, rulesv6 = self.fw._filters_for_instance("fake", network_info)
+        self.assertEquals(len(rulesv4), 2)
+        self.assertEquals(len(rulesv6), 3)
+
+    def test_filters_for_instance_without_ip_v6(self):
+        self.flags(use_ipv6=False)
+        network_info = _create_network_info()
+        rulesv4, rulesv6 = self.fw._filters_for_instance("fake", network_info)
+        self.assertEquals(len(rulesv4), 2)
+        self.assertEquals(len(rulesv6), 0)
+
+    def multinic_iptables_test(self):
+        ipv4_rules_per_network = 2
+        ipv6_rules_per_network = 3
+        networks_count = 5
+        instance_ref = self._create_instance_ref()
+        network_info = _create_network_info(networks_count)
+        ipv4_len = len(self.fw.iptables.ipv4['filter'].rules)
+        ipv6_len = len(self.fw.iptables.ipv6['filter'].rules)
+        inst_ipv4, inst_ipv6 = self.fw.instance_rules(instance_ref,
+                                                      network_info)
+        self.fw.add_filters_for_instance(instance_ref, network_info)
+        ipv4 = self.fw.iptables.ipv4['filter'].rules
+        ipv6 = self.fw.iptables.ipv6['filter'].rules
+        ipv4_network_rules = len(ipv4) - len(inst_ipv4) - ipv4_len
+        ipv6_network_rules = len(ipv6) - len(inst_ipv6) - ipv6_len
+        self.assertEquals(ipv4_network_rules,
+                          ipv4_rules_per_network * networks_count)
+        self.assertEquals(ipv6_network_rules,
+                          ipv6_rules_per_network * networks_count)
+
 
 class NWFilterTestCase(test.TestCase):
     def setUp(self):
@@ -535,6 +950,28 @@ class NWFilterTestCase(test.TestCase):
 
         return db.security_group_get_by_name(self.context, 'fake', 'testgroup')
 
+    def _create_instance(self):
+        return db.instance_create(self.context,
+                                  {'user_id': 'fake',
+                                   'project_id': 'fake',
+                                   'mac_address': '00:A0:C9:14:C8:29',
+                                   'instance_type_id': 1})
+
+    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 test_creates_base_rule_first(self):
         # These come pre-defined by libvirt
         self.defined_filters = ['no-mac-spoofing',
@@ -563,26 +1000,22 @@ class NWFilterTestCase(test.TestCase):
 
         self.fake_libvirt_connection.nwfilterDefineXML = _filterDefineXMLMock
 
-        instance_ref = db.instance_create(self.context,
-                                          {'user_id': 'fake',
-                                          'project_id': 'fake'})
+        instance_ref = self._create_instance()
         inst_id = instance_ref['id']
 
         ip = '10.11.12.13'
 
-        network_ref = db.project_get_network(self.context,
-                                             'fake')
-
-        fixed_ip = {'address': ip,
-                    'network_id': network_ref['id']}
+        network_ref = db.project_get_network(self.context, 'fake')
+        fixed_ip = {'address': ip, 'network_id': network_ref['id']}
 
         admin_ctxt = context.get_admin_context()
         db.fixed_ip_create(admin_ctxt, fixed_ip)
         db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': instance_ref['id']})
+                                            'instance_id': inst_id})
 
         def _ensure_all_called():
-            instance_filter = 'nova-instance-%s' % instance_ref['name']
+            instance_filter = 'nova-instance-%s-%s' % (instance_ref['name'],
+                                                       '00A0C914C829')
             secgroup_filter = 'nova-secgroup-%s' % self.security_group['id']
             for required in [secgroup_filter, 'allow-dhcp-server',
                              'no-arp-spoofing', 'no-ip-spoofing',
@@ -604,3 +1037,11 @@ class NWFilterTestCase(test.TestCase):
         _ensure_all_called()
         self.teardown_security_group()
         db.instance_destroy(admin_ctxt, instance_ref['id'])
+
+    def test_create_network_filters(self):
+        instance_ref = self._create_instance()
+        network_info = _create_network_info(3)
+        result = self.fw._create_network_filters(instance_ref,
+                                                 network_info,
+                                                 "fake")
+        self.assertEquals(len(result), 3)
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/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
new file mode 100644
index 000000000..22b66010a
--- /dev/null
+++ b/nova/tests/test_vmwareapi.py
@@ -0,0 +1,252 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

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

+

+"""

+Test suite for VMWareAPI.

+"""

+

+import stubout

+

+from nova import context

+from nova import db

+from nova import flags

+from nova import test

+from nova import utils

+from nova.auth import manager

+from nova.compute import power_state

+from nova.tests.glance import stubs as glance_stubs

+from nova.tests.vmwareapi import db_fakes

+from nova.tests.vmwareapi import stubs

+from nova.virt import vmwareapi_conn

+from nova.virt.vmwareapi import fake as vmwareapi_fake

+

+

+FLAGS = flags.FLAGS

+

+

+class VMWareAPIVMTestCase(test.TestCase):

+    """Unit tests for Vmware API connection calls."""

+

+    def setUp(self):

+        super(VMWareAPIVMTestCase, self).setUp()

+        self.flags(vmwareapi_host_ip='test_url',

+                   vmwareapi_host_username='test_username',

+                   vmwareapi_host_password='test_pass')

+        self.manager = manager.AuthManager()

+        self.user = self.manager.create_user('fake', 'fake', 'fake',

+                                             admin=True)

+        self.project = self.manager.create_project('fake', 'fake', 'fake')

+        self.network = utils.import_object(FLAGS.network_manager)

+        self.stubs = stubout.StubOutForTesting()

+        vmwareapi_fake.reset()

+        db_fakes.stub_out_db_instance_api(self.stubs)

+        stubs.set_stubs(self.stubs)

+        glance_stubs.stubout_glance_client(self.stubs,

+                                           glance_stubs.FakeGlance)

+        self.conn = vmwareapi_conn.get_connection(False)

+

+    def _create_instance_in_the_db(self):

+        values = {'name': 1,

+                  'id': 1,

+                  'project_id': self.project.id,

+                  'user_id': self.user.id,

+                  'image_id': "1",

+                  'kernel_id': "1",

+                  'ramdisk_id': "1",

+                  'instance_type': 'm1.large',

+                  'mac_address': 'aa:bb:cc:dd:ee:ff',

+                  }

+        self.instance = db.instance_create(values)

+

+    def _create_vm(self):

+        """Create and spawn the VM."""

+        self._create_instance_in_the_db()

+        self.type_data = db.instance_type_get_by_name(None, 'm1.large')

+        self.conn.spawn(self.instance)

+        self._check_vm_record()

+

+    def _check_vm_record(self):

+        """

+        Check if the spawned VM's properties correspond to the instance in

+        the db.

+        """

+        instances = self.conn.list_instances()

+        self.assertEquals(len(instances), 1)

+

+        # Get Nova record for VM

+        vm_info = self.conn.get_info(1)

+

+        # Get record for VM

+        vms = vmwareapi_fake._get_objects("VirtualMachine")

+        vm = vms[0]

+

+        # Check that m1.large above turned into the right thing.

+        mem_kib = long(self.type_data['memory_mb']) << 10

+        vcpus = self.type_data['vcpus']

+        self.assertEquals(vm_info['max_mem'], mem_kib)

+        self.assertEquals(vm_info['mem'], mem_kib)

+        self.assertEquals(vm.get("summary.config.numCpu"), vcpus)

+        self.assertEquals(vm.get("summary.config.memorySizeMB"),

+                          self.type_data['memory_mb'])

+

+        # Check that the VM is running according to Nova

+        self.assertEquals(vm_info['state'], power_state.RUNNING)

+

+        # Check that the VM is running according to vSphere API.

+        self.assertEquals(vm.get("runtime.powerState"), 'poweredOn')

+

+    def _check_vm_info(self, info, pwr_state=power_state.RUNNING):

+        """

+        Check if the get_info returned values correspond to the instance

+        object in the db.

+        """

+        mem_kib = long(self.type_data['memory_mb']) << 10

+        self.assertEquals(info["state"], pwr_state)

+        self.assertEquals(info["max_mem"], mem_kib)

+        self.assertEquals(info["mem"], mem_kib)

+        self.assertEquals(info["num_cpu"], self.type_data['vcpus'])

+

+    def test_list_instances(self):

+        instances = self.conn.list_instances()

+        self.assertEquals(len(instances), 0)

+

+    def test_list_instances_1(self):

+        self._create_vm()

+        instances = self.conn.list_instances()

+        self.assertEquals(len(instances), 1)

+

+    def test_spawn(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+

+    def test_snapshot(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+        self.conn.snapshot(self.instance, "Test-Snapshot")

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+

+    def test_snapshot_non_existent(self):

+        self._create_instance_in_the_db()

+        self.assertRaises(Exception, self.conn.snapshot, self.instance,

+                          "Test-Snapshot")

+

+    def test_reboot(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+        self.conn.reboot(self.instance)

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+

+    def test_reboot_non_existent(self):

+        self._create_instance_in_the_db()

+        self.assertRaises(Exception, self.conn.reboot, self.instance)

+

+    def test_reboot_not_poweredon(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+        self.conn.suspend(self.instance, self.dummy_callback_handler)

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.PAUSED)

+        self.assertRaises(Exception, self.conn.reboot, self.instance)

+

+    def test_suspend(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+        self.conn.suspend(self.instance, self.dummy_callback_handler)

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.PAUSED)

+

+    def test_suspend_non_existent(self):

+        self._create_instance_in_the_db()

+        self.assertRaises(Exception, self.conn.suspend, self.instance,

+                          self.dummy_callback_handler)

+

+    def test_resume(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+        self.conn.suspend(self.instance, self.dummy_callback_handler)

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.PAUSED)

+        self.conn.resume(self.instance, self.dummy_callback_handler)

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+

+    def test_resume_non_existent(self):

+        self._create_instance_in_the_db()

+        self.assertRaises(Exception, self.conn.resume, self.instance,

+                          self.dummy_callback_handler)

+

+    def test_resume_not_suspended(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+        self.assertRaises(Exception, self.conn.resume, self.instance,

+                          self.dummy_callback_handler)

+

+    def test_get_info(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+

+    def test_destroy(self):

+        self._create_vm()

+        info = self.conn.get_info(1)

+        self._check_vm_info(info, power_state.RUNNING)

+        instances = self.conn.list_instances()

+        self.assertEquals(len(instances), 1)

+        self.conn.destroy(self.instance)

+        instances = self.conn.list_instances()

+        self.assertEquals(len(instances), 0)

+

+    def test_destroy_non_existent(self):

+        self._create_instance_in_the_db()

+        self.assertEquals(self.conn.destroy(self.instance), None)

+

+    def test_pause(self):

+        pass

+

+    def test_unpause(self):

+        pass

+

+    def test_diagnostics(self):

+        pass

+

+    def test_get_console_output(self):

+        pass

+

+    def test_get_ajax_console(self):

+        pass

+

+    def dummy_callback_handler(self, ret):

+        """

+        Dummy callback function to be passed to suspend, resume, etc., calls.

+        """

+        pass

+

+    def tearDown(self):

+        super(VMWareAPIVMTestCase, self).tearDown()

+        vmwareapi_fake.cleanup()

+        self.manager.delete_project(self.project)

+        self.manager.delete_user(self.user)

+        self.stubs.UnsetAll()

diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index f698c85b5..236d12434 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -20,6 +20,8 @@ Tests for Volume Code.
 
 """
 
+import cStringIO
+
 from nova import context
 from nova import exception
 from nova import db
@@ -104,7 +106,7 @@ class VolumeTestCase(test.TestCase):
         inst['launch_time'] = '10'
         inst['user_id'] = 'fake'
         inst['project_id'] = 'fake'
-        inst['instance_type'] = 'm1.tiny'
+        inst['instance_type_id'] = '2'  # m1.tiny
         inst['mac_address'] = utils.generate_mac()
         inst['ami_launch_index'] = 0
         instance_id = db.instance_create(self.context, inst)['id']
@@ -140,7 +142,7 @@ class VolumeTestCase(test.TestCase):
         self.assertEqual(vol['status'], "available")
 
         self.volume.delete_volume(self.context, volume_id)
-        self.assertRaises(exception.Error,
+        self.assertRaises(exception.VolumeNotFound,
                           db.volume_get,
                           self.context,
                           volume_id)
@@ -173,3 +175,197 @@ class VolumeTestCase(test.TestCase):
         # each of them having a different FLAG for storage_node
         # This will allow us to test cross-node interactions
         pass
+
+
+class DriverTestCase(test.TestCase):
+    """Base Test class for Drivers."""
+    driver_name = "nova.volume.driver.FakeAOEDriver"
+
+    def setUp(self):
+        super(DriverTestCase, self).setUp()
+        self.flags(volume_driver=self.driver_name,
+                   logging_default_format_string="%(message)s")
+        self.volume = utils.import_object(FLAGS.volume_manager)
+        self.context = context.get_admin_context()
+        self.output = ""
+
+        def _fake_execute(_command, *_args, **_kwargs):
+            """Fake _execute."""
+            return self.output, None
+        self.volume.driver._execute = _fake_execute
+        self.volume.driver._sync_execute = _fake_execute
+
+        log = logging.getLogger()
+        self.stream = cStringIO.StringIO()
+        log.addHandler(logging.StreamHandler(self.stream))
+
+        inst = {}
+        self.instance_id = db.instance_create(self.context, inst)['id']
+
+    def tearDown(self):
+        super(DriverTestCase, self).tearDown()
+
+    def _attach_volume(self):
+        """Attach volumes to an instance. This function also sets
+           a fake log message."""
+        return []
+
+    def _detach_volume(self, volume_id_list):
+        """Detach volumes from an instance."""
+        for volume_id in volume_id_list:
+            db.volume_detached(self.context, volume_id)
+            self.volume.delete_volume(self.context, volume_id)
+
+
+class AOETestCase(DriverTestCase):
+    """Test Case for AOEDriver"""
+    driver_name = "nova.volume.driver.AOEDriver"
+
+    def setUp(self):
+        super(AOETestCase, self).setUp()
+
+    def tearDown(self):
+        super(AOETestCase, self).tearDown()
+
+    def _attach_volume(self):
+        """Attach volumes to an instance. This function also sets
+           a fake log message."""
+        volume_id_list = []
+        for index in xrange(3):
+            vol = {}
+            vol['size'] = 0
+            volume_id = db.volume_create(self.context,
+                                         vol)['id']
+            self.volume.create_volume(self.context, volume_id)
+
+            # each volume has a different mountpoint
+            mountpoint = "/dev/sd" + chr((ord('b') + index))
+            db.volume_attached(self.context, volume_id, self.instance_id,
+                               mountpoint)
+
+            (shelf_id, blade_id) = db.volume_get_shelf_and_blade(self.context,
+                                                                 volume_id)
+            self.output += "%s %s eth0 /dev/nova-volumes/vol-foo auto run\n" \
+                      % (shelf_id, blade_id)
+
+            volume_id_list.append(volume_id)
+
+        return volume_id_list
+
+    def test_check_for_export_with_no_volume(self):
+        """No log message when no volume is attached to an instance."""
+        self.stream.truncate(0)
+        self.volume.check_for_export(self.context, self.instance_id)
+        self.assertEqual(self.stream.getvalue(), '')
+
+    def test_check_for_export_with_all_vblade_processes(self):
+        """No log message when all the vblade processes are running."""
+        volume_id_list = self._attach_volume()
+
+        self.stream.truncate(0)
+        self.volume.check_for_export(self.context, self.instance_id)
+        self.assertEqual(self.stream.getvalue(), '')
+
+        self._detach_volume(volume_id_list)
+
+    def test_check_for_export_with_vblade_process_missing(self):
+        """Output a warning message when some vblade processes aren't
+           running."""
+        volume_id_list = self._attach_volume()
+
+        # the first vblade process isn't running
+        self.output = self.output.replace("run", "down", 1)
+        (shelf_id, blade_id) = db.volume_get_shelf_and_blade(self.context,
+                                                             volume_id_list[0])
+
+        msg_is_match = False
+        self.stream.truncate(0)
+        try:
+            self.volume.check_for_export(self.context, self.instance_id)
+        except exception.ProcessExecutionError, e:
+            volume_id = volume_id_list[0]
+            msg = _("Cannot confirm exported volume id:%(volume_id)s. "
+                    "vblade process for e%(shelf_id)s.%(blade_id)s "
+                    "isn't running.") % locals()
+
+            msg_is_match = (0 <= e.message.find(msg))
+
+        self.assertTrue(msg_is_match)
+        self._detach_volume(volume_id_list)
+
+
+class ISCSITestCase(DriverTestCase):
+    """Test Case for ISCSIDriver"""
+    driver_name = "nova.volume.driver.ISCSIDriver"
+
+    def setUp(self):
+        super(ISCSITestCase, self).setUp()
+
+    def tearDown(self):
+        super(ISCSITestCase, self).tearDown()
+
+    def _attach_volume(self):
+        """Attach volumes to an instance. This function also sets
+           a fake log message."""
+        volume_id_list = []
+        for index in xrange(3):
+            vol = {}
+            vol['size'] = 0
+            vol_ref = db.volume_create(self.context, vol)
+            self.volume.create_volume(self.context, vol_ref['id'])
+            vol_ref = db.volume_get(self.context, vol_ref['id'])
+
+            # each volume has a different mountpoint
+            mountpoint = "/dev/sd" + chr((ord('b') + index))
+            db.volume_attached(self.context, vol_ref['id'], self.instance_id,
+                               mountpoint)
+            volume_id_list.append(vol_ref['id'])
+
+        return volume_id_list
+
+    def test_check_for_export_with_no_volume(self):
+        """No log message when no volume is attached to an instance."""
+        self.stream.truncate(0)
+        self.volume.check_for_export(self.context, self.instance_id)
+        self.assertEqual(self.stream.getvalue(), '')
+
+    def test_check_for_export_with_all_volume_exported(self):
+        """No log message when all the vblade processes are running."""
+        volume_id_list = self._attach_volume()
+
+        self.mox.StubOutWithMock(self.volume.driver, '_execute')
+        for i in volume_id_list:
+            tid = db.volume_get_iscsi_target_num(self.context, i)
+            self.volume.driver._execute("sudo", "ietadm", "--op", "show",
+                                        "--tid=%(tid)d" % locals())
+
+        self.stream.truncate(0)
+        self.mox.ReplayAll()
+        self.volume.check_for_export(self.context, self.instance_id)
+        self.assertEqual(self.stream.getvalue(), '')
+        self.mox.UnsetStubs()
+
+        self._detach_volume(volume_id_list)
+
+    def test_check_for_export_with_some_volume_missing(self):
+        """Output a warning message when some volumes are not recognied
+           by ietd."""
+        volume_id_list = self._attach_volume()
+
+        # the first vblade process isn't running
+        tid = db.volume_get_iscsi_target_num(self.context, volume_id_list[0])
+        self.mox.StubOutWithMock(self.volume.driver, '_execute')
+        self.volume.driver._execute("sudo", "ietadm", "--op", "show",
+                                    "--tid=%(tid)d" % locals()).AndRaise(
+                                            exception.ProcessExecutionError())
+
+        self.mox.ReplayAll()
+        self.assertRaises(exception.ProcessExecutionError,
+                          self.volume.check_for_export,
+                          self.context,
+                          self.instance_id)
+        msg = _("Cannot confirm exported volume id:%s.") % volume_id_list[0]
+        self.assertTrue(0 <= self.stream.getvalue().find(msg))
+        self.mox.UnsetStubs()
+
+        self._detach_volume(volume_id_list)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index cd125a301..6072f5455 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -14,16 +14,19 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Test suite for XenAPI
-"""
+"""Test suite for XenAPI."""
 
 import functools
+import json
+import os
+import re
 import stubout
+import ast
 
 from nova import db
 from nova import context
 from nova import flags
+from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
@@ -38,6 +41,9 @@ from nova.virt.xenapi.vmops import VMOps
 from nova.tests.db import fakes as db_fakes
 from nova.tests.xenapi import stubs
 from nova.tests.glance import stubs as glance_stubs
+from nova.tests import fake_utils
+
+LOG = logging.getLogger('nova.tests.test_xenapi')
 
 FLAGS = flags.FLAGS
 
@@ -58,28 +64,26 @@ def stub_vm_utils_with_vdi_attached_here(function, should_return=True):
 
 
 class XenAPIVolumeTestCase(test.TestCase):
-    """
-    Unit tests for Volume operations
-    """
+    """Unit tests for Volume operations."""
     def setUp(self):
         super(XenAPIVolumeTestCase, self).setUp()
         self.stubs = stubout.StubOutForTesting()
+        self.context = context.RequestContext('fake', 'fake', False)
         FLAGS.target_host = '127.0.0.1'
         FLAGS.xenapi_connection_url = 'test_url'
         FLAGS.xenapi_connection_password = 'test_pass'
         db_fakes.stub_out_db_instance_api(self.stubs)
         stubs.stub_out_get_target(self.stubs)
         xenapi_fake.reset()
-        self.values = {'name': 1, 'id': 1,
+        self.values = {'id': 1,
                   'project_id': 'fake',
                   'user_id': 'fake',
                   'image_id': 1,
                   'kernel_id': 2,
                   'ramdisk_id': 3,
-                  'instance_type': 'm1.large',
+                  'instance_type_id': '3',  # m1.large
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': 'linux'
-                  }
+                  'os_type': 'linux'}
 
     def _create_volume(self, size='0'):
         """Create a volume object."""
@@ -91,10 +95,10 @@ class XenAPIVolumeTestCase(test.TestCase):
         vol['availability_zone'] = FLAGS.storage_availability_zone
         vol['status'] = "creating"
         vol['attach_status'] = "detached"
-        return db.volume_create(context.get_admin_context(), vol)
+        return db.volume_create(self.context, vol)
 
     def test_create_iscsi_storage(self):
-        """ This shows how to test helper classes' methods """
+        """This shows how to test helper classes' methods."""
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVolumeTests)
         session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
         helper = volume_utils.VolumeHelper
@@ -109,7 +113,7 @@ class XenAPIVolumeTestCase(test.TestCase):
         db.volume_destroy(context.get_admin_context(), vol['id'])
 
     def test_parse_volume_info_raise_exception(self):
-        """ This shows how to test helper classes' methods """
+        """This shows how to test helper classes' methods."""
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVolumeTests)
         session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
         helper = volume_utils.VolumeHelper
@@ -123,11 +127,11 @@ class XenAPIVolumeTestCase(test.TestCase):
         db.volume_destroy(context.get_admin_context(), vol['id'])
 
     def test_attach_volume(self):
-        """ This shows how to test Ops classes' methods """
+        """This shows how to test Ops classes' methods."""
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVolumeTests)
         conn = xenapi_conn.get_connection(False)
         volume = self._create_volume()
-        instance = db.instance_create(self.values)
+        instance = db.instance_create(self.context, self.values)
         vm = xenapi_fake.create_vm(instance.name, 'Running')
         result = conn.attach_volume(instance.name, volume['id'], '/dev/sdc')
 
@@ -142,12 +146,12 @@ class XenAPIVolumeTestCase(test.TestCase):
         check()
 
     def test_attach_volume_raise_exception(self):
-        """ This shows how to test when exceptions are raised """
+        """This shows how to test when exceptions are raised."""
         stubs.stubout_session(self.stubs,
                               stubs.FakeSessionForVolumeFailedTests)
         conn = xenapi_conn.get_connection(False)
         volume = self._create_volume()
-        instance = db.instance_create(self.values)
+        instance = db.instance_create(self.context, self.values)
         xenapi_fake.create_vm(instance.name, 'Running')
         self.assertRaises(Exception,
                           conn.attach_volume,
@@ -165,9 +169,7 @@ def reset_network(*args):
 
 
 class XenAPIVMTestCase(test.TestCase):
-    """
-    Unit tests for VM operations
-    """
+    """Unit tests for VM operations."""
     def setUp(self):
         super(XenAPIVMTestCase, self).setUp()
         self.manager = manager.AuthManager()
@@ -176,10 +178,12 @@ class XenAPIVMTestCase(test.TestCase):
         self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.network = utils.import_object(FLAGS.network_manager)
         self.stubs = stubout.StubOutForTesting()
-        FLAGS.xenapi_connection_url = 'test_url'
-        FLAGS.xenapi_connection_password = 'test_pass'
+        self.flags(xenapi_connection_url='test_url',
+                   xenapi_connection_password='test_pass',
+                   instance_name_template='%d')
         xenapi_fake.reset()
         xenapi_fake.create_local_srs()
+        xenapi_fake.create_local_pifs()
         db_fakes.stub_out_db_instance_api(self.stubs)
         xenapi_fake.create_network('fake', FLAGS.flat_network_bridge)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
@@ -187,8 +191,11 @@ class XenAPIVMTestCase(test.TestCase):
         stubs.stubout_stream_disk(self.stubs)
         stubs.stubout_is_vdi_pv(self.stubs)
         self.stubs.Set(VMOps, 'reset_network', reset_network)
+        stubs.stub_out_vm_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
+        fake_utils.stub_out_utils_execute(self.stubs)
+        self.context = context.RequestContext('fake', 'fake', False)
         self.conn = xenapi_conn.get_connection(False)
 
     def test_list_instances_0(self):
@@ -213,7 +220,7 @@ class XenAPIVMTestCase(test.TestCase):
                 if not vm_rec["is_control_domain"]:
                     vm_labels.append(vm_rec["name_label"])
 
-            self.assertEquals(vm_labels, [1])
+            self.assertEquals(vm_labels, ['1'])
 
         def ensure_vbd_was_torn_down():
             vbd_labels = []
@@ -221,7 +228,7 @@ class XenAPIVMTestCase(test.TestCase):
                 vbd_rec = xenapi_fake.get_record('VBD', vbd_ref)
                 vbd_labels.append(vbd_rec["vm_name_label"])
 
-            self.assertEquals(vbd_labels, [1])
+            self.assertEquals(vbd_labels, ['1'])
 
         def ensure_vdi_was_torn_down():
             for vdi_ref in xenapi_fake.get_all('VDI'):
@@ -236,13 +243,12 @@ class XenAPIVMTestCase(test.TestCase):
 
         check()
 
-    def create_vm_record(self, conn, os_type):
+    def create_vm_record(self, conn, os_type, instance_id=1):
         instances = conn.list_instances()
-        self.assertEquals(instances, [1])
+        self.assertEquals(instances, [str(instance_id)])
 
         # Get Nova record for VM
-        vm_info = conn.get_info(1)
-
+        vm_info = conn.get_info(instance_id)
         # Get XenAPI record for VM
         vms = [rec for ref, rec
                in xenapi_fake.get_all_records('VM').iteritems()
@@ -251,7 +257,7 @@ class XenAPIVMTestCase(test.TestCase):
         self.vm_info = vm_info
         self.vm = vm
 
-    def check_vm_record(self, conn):
+    def check_vm_record(self, conn, check_injection=False):
         # Check that m1.large above turned into the right thing.
         instance_type = db.instance_type_get_by_name(conn, 'm1.large')
         mem_kib = long(instance_type['memory_mb']) << 10
@@ -271,6 +277,25 @@ class XenAPIVMTestCase(test.TestCase):
         # Check that the VM is running according to XenAPI.
         self.assertEquals(self.vm['power_state'], 'Running')
 
+        if check_injection:
+            xenstore_data = self.vm['xenstore_data']
+            key = 'vm-data/networking/aabbccddeeff'
+            xenstore_value = xenstore_data[key]
+            tcpip_data = ast.literal_eval(xenstore_value)
+            self.assertEquals(tcpip_data,
+                              {'label': 'fake_flat_network',
+                               'broadcast': '10.0.0.255',
+                               'ips': [{'ip': '10.0.0.3',
+                                        'netmask':'255.255.255.0',
+                                        'enabled':'1'}],
+                                'ip6s': [{'ip': 'fe80::a8bb:ccff:fedd:eeff',
+                                          'netmask': '120',
+                                          'enabled': '1'}],
+                                'mac': 'aa:bb:cc:dd:ee:ff',
+                                'dns': ['10.0.0.2'],
+                                'gateway': '10.0.0.1',
+                                'gateway6': 'fe80::a00:1'})
+
     def check_vm_params_for_windows(self):
         self.assertEquals(self.vm['platform']['nx'], 'true')
         self.assertEquals(self.vm['HVM_boot_params'], {'order': 'dc'})
@@ -304,30 +329,28 @@ class XenAPIVMTestCase(test.TestCase):
         self.assertEquals(self.vm['HVM_boot_policy'], '')
 
     def _test_spawn(self, image_id, kernel_id, ramdisk_id,
-                    instance_type="m1.large", os_type="linux"):
-        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
-        values = {'name': 1,
-                  'id': 1,
+                    instance_type_id="3", os_type="linux",
+                    instance_id=1, check_injection=False):
+        stubs.stubout_loopingcall_start(self.stubs)
+        values = {'id': instance_id,
                   'project_id': self.project.id,
                   'user_id': self.user.id,
                   'image_id': image_id,
                   'kernel_id': kernel_id,
                   'ramdisk_id': ramdisk_id,
-                  'instance_type': instance_type,
+                  'instance_type_id': instance_type_id,
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': os_type
-                  }
-        conn = xenapi_conn.get_connection(False)
-        instance = db.instance_create(values)
-        conn.spawn(instance)
-        self.create_vm_record(conn, os_type)
-        self.check_vm_record(conn)
+                  'os_type': os_type}
+        instance = db.instance_create(self.context, values)
+        self.conn.spawn(instance)
+        self.create_vm_record(self.conn, os_type, instance_id)
+        self.check_vm_record(self.conn, check_injection)
 
     def test_spawn_not_enough_memory(self):
         FLAGS.xenapi_image_service = 'glance'
         self.assertRaises(Exception,
                           self._test_spawn,
-                          1, 2, 3, "m1.xlarge")
+                          1, 2, 3, "4")  # m1.xlarge
 
     def test_spawn_raw_objectstore(self):
         FLAGS.xenapi_image_service = 'objectstore'
@@ -362,6 +385,127 @@ class XenAPIVMTestCase(test.TestCase):
                          glance_stubs.FakeGlance.IMAGE_RAMDISK)
         self.check_vm_params_for_linux_with_external_kernel()
 
+    def test_spawn_netinject_file(self):
+        FLAGS.xenapi_image_service = 'glance'
+        db_fakes.stub_out_db_instance_api(self.stubs, injected=True)
+
+        self._tee_executed = False
+
+        def _tee_handler(cmd, **kwargs):
+            input = kwargs.get('process_input', None)
+            self.assertNotEqual(input, None)
+            config = [line.strip() for line in input.split("\n")]
+            # Find the start of eth0 configuration and check it
+            index = config.index('auto eth0')
+            self.assertEquals(config[index + 1:index + 8], [
+                'iface eth0 inet static',
+                'address 10.0.0.3',
+                'netmask 255.255.255.0',
+                'broadcast 10.0.0.255',
+                'gateway 10.0.0.1',
+                'dns-nameservers 10.0.0.2',
+                ''])
+            self._tee_executed = True
+            return '', ''
+
+        fake_utils.fake_execute_set_repliers([
+            # Capture the sudo tee .../etc/network/interfaces command
+            (r'(sudo\s+)?tee.*interfaces', _tee_handler),
+        ])
+        FLAGS.xenapi_image_service = 'glance'
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
+                         glance_stubs.FakeGlance.IMAGE_KERNEL,
+                         glance_stubs.FakeGlance.IMAGE_RAMDISK,
+                         check_injection=True)
+        self.assertTrue(self._tee_executed)
+
+    def test_spawn_netinject_xenstore(self):
+        FLAGS.xenapi_image_service = 'glance'
+        db_fakes.stub_out_db_instance_api(self.stubs, injected=True)
+
+        self._tee_executed = False
+
+        def _mount_handler(cmd, *ignore_args, **ignore_kwargs):
+            # When mounting, create real files under the mountpoint to simulate
+            # files in the mounted filesystem
+
+            # mount point will be the last item of the command list
+            self._tmpdir = cmd[len(cmd) - 1]
+            LOG.debug(_('Creating files in %s to simulate guest agent' %
+                self._tmpdir))
+            os.makedirs(os.path.join(self._tmpdir, 'usr', 'sbin'))
+            # Touch the file using open
+            open(os.path.join(self._tmpdir, 'usr', 'sbin',
+                'xe-update-networking'), 'w').close()
+            return '', ''
+
+        def _umount_handler(cmd, *ignore_args, **ignore_kwargs):
+            # Umount would normall make files in the m,ounted filesystem
+            # disappear, so do that here
+            LOG.debug(_('Removing simulated guest agent files in %s' %
+                self._tmpdir))
+            os.remove(os.path.join(self._tmpdir, 'usr', 'sbin',
+                'xe-update-networking'))
+            os.rmdir(os.path.join(self._tmpdir, 'usr', 'sbin'))
+            os.rmdir(os.path.join(self._tmpdir, 'usr'))
+            return '', ''
+
+        def _tee_handler(cmd, *ignore_args, **ignore_kwargs):
+            self._tee_executed = True
+            return '', ''
+
+        fake_utils.fake_execute_set_repliers([
+            (r'(sudo\s+)?mount', _mount_handler),
+            (r'(sudo\s+)?umount', _umount_handler),
+            (r'(sudo\s+)?tee.*interfaces', _tee_handler)])
+        self._test_spawn(1, 2, 3, check_injection=True)
+
+        # tee must not run in this case, where an injection-capable
+        # guest agent is detected
+        self.assertFalse(self._tee_executed)
+
+    def test_spawn_vlanmanager(self):
+        self.flags(xenapi_image_service='glance',
+                   network_manager='nova.network.manager.VlanManager',
+                   network_driver='nova.network.xenapi_net',
+                   vlan_interface='fake0')
+        # Reset network table
+        xenapi_fake.reset_table('network')
+        # Instance id = 2 will use vlan network (see db/fakes.py)
+        fake_instance_id = 2
+        network_bk = self.network
+        # Ensure we use xenapi_net driver
+        self.network = utils.import_object(FLAGS.network_manager)
+        self.network.setup_compute_network(None, fake_instance_id)
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
+                         glance_stubs.FakeGlance.IMAGE_KERNEL,
+                         glance_stubs.FakeGlance.IMAGE_RAMDISK,
+                         instance_id=fake_instance_id)
+        # TODO(salvatore-orlando): a complete test here would require
+        # a check for making sure the bridge for the VM's VIF is
+        # consistent with bridge specified in nova db
+        self.network = network_bk
+
+    def test_spawn_with_network_qos(self):
+        self._create_instance()
+        for vif_ref in xenapi_fake.get_all('VIF'):
+            vif_rec = xenapi_fake.get_record('VIF', vif_ref)
+            self.assertEquals(vif_rec['qos_algorithm_type'], 'ratelimit')
+            self.assertEquals(vif_rec['qos_algorithm_params']['kbps'],
+                              str(4 * 1024))
+
+    def test_rescue(self):
+        self.flags(xenapi_inject_image=False)
+        instance = self._create_instance()
+        conn = xenapi_conn.get_connection(False)
+        conn.rescue(instance, None)
+
+    def test_unrescue(self):
+        instance = self._create_instance()
+        conn = xenapi_conn.get_connection(False)
+        # Ensure that it will not unrescue a non-rescued instance.
+        self.assertRaises(Exception, conn.unrescue, instance, None)
+
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
         self.manager.delete_project(self.project)
@@ -371,27 +515,25 @@ class XenAPIVMTestCase(test.TestCase):
         self.stubs.UnsetAll()
 
     def _create_instance(self):
-        """Creates and spawns a test instance"""
+        """Creates and spawns a test instance."""
+        stubs.stubout_loopingcall_start(self.stubs)
         values = {
-            'name': 1,
             'id': 1,
             'project_id': self.project.id,
             'user_id': self.user.id,
             'image_id': 1,
             'kernel_id': 2,
             'ramdisk_id': 3,
-            'instance_type': 'm1.large',
+            'instance_type_id': '3',  # m1.large
             'mac_address': 'aa:bb:cc:dd:ee:ff',
             'os_type': 'linux'}
-        instance = db.instance_create(values)
+        instance = db.instance_create(self.context, values)
         self.conn.spawn(instance)
         return instance
 
 
 class XenAPIDiffieHellmanTestCase(test.TestCase):
-    """
-    Unit tests for Diffie-Hellman code
-    """
+    """Unit tests for Diffie-Hellman code."""
     def setUp(self):
         super(XenAPIDiffieHellmanTestCase, self).setUp()
         self.alice = SimpleDH()
@@ -415,9 +557,7 @@ class XenAPIDiffieHellmanTestCase(test.TestCase):
 
 
 class XenAPIMigrateInstance(test.TestCase):
-    """
-    Unit test for verifying migration-related actions
-    """
+    """Unit test for verifying migration-related actions."""
 
     def setUp(self):
         super(XenAPIMigrateInstance, self).setUp()
@@ -428,21 +568,26 @@ class XenAPIMigrateInstance(test.TestCase):
         db_fakes.stub_out_db_instance_api(self.stubs)
         stubs.stub_out_get_target(self.stubs)
         xenapi_fake.reset()
+        xenapi_fake.create_network('fake', FLAGS.flat_network_bridge)
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake',
                                              admin=True)
         self.project = self.manager.create_project('fake', 'fake', 'fake')
-        self.values = {'name': 1, 'id': 1,
+        self.context = context.RequestContext('fake', 'fake', False)
+        self.values = {'id': 1,
                   'project_id': self.project.id,
                   'user_id': self.user.id,
                   'image_id': 1,
                   'kernel_id': None,
                   'ramdisk_id': None,
-                  'instance_type': 'm1.large',
+                  'local_gb': 5,
+                  'instance_type_id': '3',  # m1.large
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': 'linux'
-                  }
+                  'os_type': 'linux'}
+
+        fake_utils.stub_out_utils_execute(self.stubs)
         stubs.stub_out_migration_methods(self.stubs)
+        stubs.stubout_get_this_vm_uuid(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
 
@@ -453,22 +598,21 @@ class XenAPIMigrateInstance(test.TestCase):
         self.stubs.UnsetAll()
 
     def test_migrate_disk_and_power_off(self):
-        instance = db.instance_create(self.values)
+        instance = db.instance_create(self.context, self.values)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
         conn = xenapi_conn.get_connection(False)
         conn.migrate_disk_and_power_off(instance, '127.0.0.1')
 
     def test_finish_resize(self):
-        instance = db.instance_create(self.values)
+        instance = db.instance_create(self.context, self.values)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
+        stubs.stubout_loopingcall_start(self.stubs)
         conn = xenapi_conn.get_connection(False)
         conn.finish_resize(instance, dict(base_copy='hurr', cow='durr'))
 
 
 class XenAPIDetermineDiskImageTestCase(test.TestCase):
-    """
-    Unit tests for code that detects the ImageType
-    """
+    """Unit tests for code that detects the ImageType."""
     def setUp(self):
         super(XenAPIDetermineDiskImageTestCase, self).setUp()
         glance_stubs.stubout_glance_client(self.stubs,
@@ -487,9 +631,7 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
         self.assertEqual(disk_type, dt)
 
     def test_instance_disk(self):
-        """
-        If a kernel is specified then the image type is DISK (aka machine)
-        """
+        """If a kernel is specified, the image type is DISK (aka machine)."""
         FLAGS.xenapi_image_service = 'objectstore'
         self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_MACHINE
         self.fake_instance.kernel_id = glance_stubs.FakeGlance.IMAGE_KERNEL
@@ -524,3 +666,52 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
         self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_VHD
         self.fake_instance.kernel_id = None
         self.assert_disk_type(vm_utils.ImageType.DISK_VHD)
+
+
+class FakeXenApi(object):
+    """Fake XenApi for testing HostState."""
+
+    class FakeSR(object):
+        def get_record(self, ref):
+            return {'virtual_allocation': 10000,
+                    'physical_utilisation': 20000}
+
+    SR = FakeSR()
+
+
+class FakeSession(object):
+    """Fake Session class for HostState testing."""
+
+    def async_call_plugin(self, *args):
+        return None
+
+    def wait_for_task(self, *args):
+        vm = {'total': 10,
+              'overhead': 20,
+              'free': 30,
+              'free-computed': 40}
+        return json.dumps({'host_memory': vm})
+
+    def get_xenapi(self):
+        return FakeXenApi()
+
+
+class HostStateTestCase(test.TestCase):
+    """Tests HostState, which holds metrics from XenServer that get
+    reported back to the Schedulers."""
+
+    def _fake_safe_find_sr(self, session):
+        """None SR ref since we're ignoring it in FakeSR."""
+        return None
+
+    def test_host_state(self):
+        self.stubs = stubout.StubOutForTesting()
+        self.stubs.Set(vm_utils, 'safe_find_sr', self._fake_safe_find_sr)
+        host_state = xenapi_conn.HostState(FakeSession())
+        stats = host_state._stats
+        self.assertEquals(stats['disk_total'], 10000)
+        self.assertEquals(stats['disk_used'], 20000)
+        self.assertEquals(stats['host_memory_total'], 10)
+        self.assertEquals(stats['host_memory_overhead'], 20)
+        self.assertEquals(stats['host_memory_free'], 30)
+        self.assertEquals(stats['host_memory_free_computed'], 40)
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 5a52a0506..e132809dc 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -76,6 +76,34 @@ class ZoneManagerTestCase(test.TestCase):
         self.assertEquals(len(zm.zone_states), 1)
         self.assertEquals(zm.zone_states[1].username, 'user1')
 
+    def test_service_capabilities(self):
+        zm = zone_manager.ZoneManager()
+        caps = zm.get_zone_capabilities(None)
+        self.assertEquals(caps, {})
+
+        zm.update_service_capabilities("svc1", "host1", dict(a=1, b=2))
+        caps = zm.get_zone_capabilities(None)
+        self.assertEquals(caps, dict(svc1_a=(1, 1), svc1_b=(2, 2)))
+
+        zm.update_service_capabilities("svc1", "host1", dict(a=2, b=3))
+        caps = zm.get_zone_capabilities(None)
+        self.assertEquals(caps, dict(svc1_a=(2, 2), svc1_b=(3, 3)))
+
+        zm.update_service_capabilities("svc1", "host2", dict(a=20, b=30))
+        caps = zm.get_zone_capabilities(None)
+        self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30)))
+
+        zm.update_service_capabilities("svc10", "host1", dict(a=99, b=99))
+        caps = zm.get_zone_capabilities(None)
+        self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
+                                     svc10_a=(99, 99), svc10_b=(99, 99)))
+
+        zm.update_service_capabilities("svc1", "host3", dict(c=5))
+        caps = zm.get_zone_capabilities(None)
+        self.assertEquals(caps, dict(svc1_a=(2, 20), svc1_b=(3, 30),
+                                     svc1_c=(5, 5), svc10_a=(99, 99),
+                                     svc10_b=(99, 99)))
+
     def test_refresh_from_db_replace_existing(self):
         zm = zone_manager.ZoneManager()
         zone_state = zone_manager.ZoneState()
diff --git a/nova/tests/vmwareapi/__init__.py b/nova/tests/vmwareapi/__init__.py
new file mode 100644
index 000000000..478ee742b
--- /dev/null
+++ b/nova/tests/vmwareapi/__init__.py
@@ -0,0 +1,21 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

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

+

+"""

+:mod:`vmwareapi` -- Stubs for VMware API

+=======================================

+"""

diff --git a/nova/tests/vmwareapi/db_fakes.py b/nova/tests/vmwareapi/db_fakes.py
new file mode 100644
index 000000000..0addd5573
--- /dev/null
+++ b/nova/tests/vmwareapi/db_fakes.py
@@ -0,0 +1,109 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

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

+

+"""

+Stubouts, mocks and fixtures for the test suite

+"""

+

+import time

+

+from nova import db

+from nova import utils

+

+

+def stub_out_db_instance_api(stubs):

+    """Stubs out the db API for creating Instances."""

+

+    INSTANCE_TYPES = {

+        'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),

+        'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),

+        'm1.medium':

+            dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),

+        'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),

+        'm1.xlarge':

+            dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}

+

+    class FakeModel(object):

+        """Stubs out for model."""

+

+        def __init__(self, values):

+            self.values = values

+

+        def __getattr__(self, name):

+            return self.values[name]

+

+        def __getitem__(self, key):

+            if key in self.values:

+                return self.values[key]

+            else:

+                raise NotImplementedError()

+

+    def fake_instance_create(values):

+        """Stubs out the db.instance_create method."""

+

+        type_data = INSTANCE_TYPES[values['instance_type']]

+

+        base_options = {

+            'name': values['name'],

+            'id': values['id'],

+            'reservation_id': utils.generate_uid('r'),

+            'image_id': values['image_id'],

+            'kernel_id': values['kernel_id'],

+            'ramdisk_id': values['ramdisk_id'],

+            'state_description': 'scheduling',

+            'user_id': values['user_id'],

+            'project_id': values['project_id'],

+            'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),

+            'instance_type': values['instance_type'],

+            'memory_mb': type_data['memory_mb'],

+            'mac_address': values['mac_address'],

+            'vcpus': type_data['vcpus'],

+            'local_gb': type_data['local_gb'],

+            }

+        return FakeModel(base_options)

+

+    def fake_network_get_by_instance(context, instance_id):

+        """Stubs out the db.network_get_by_instance method."""

+

+        fields = {

+            'bridge': 'vmnet0',

+            'netmask': '255.255.255.0',

+            'gateway': '10.10.10.1',

+            'vlan': 100}

+        return FakeModel(fields)

+

+    def fake_instance_action_create(context, action):

+        """Stubs out the db.instance_action_create method."""

+        pass

+

+    def fake_instance_get_fixed_address(context, instance_id):

+        """Stubs out the db.instance_get_fixed_address method."""

+        return '10.10.10.10'

+

+    def fake_instance_type_get_all(context, inactive=0):

+        return INSTANCE_TYPES

+

+    def fake_instance_type_get_by_name(context, name):

+        return INSTANCE_TYPES[name]

+

+    stubs.Set(db, 'instance_create', fake_instance_create)

+    stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)

+    stubs.Set(db, 'instance_action_create', fake_instance_action_create)

+    stubs.Set(db, 'instance_get_fixed_address',

+                fake_instance_get_fixed_address)

+    stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)

+    stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)

diff --git a/nova/tests/vmwareapi/stubs.py b/nova/tests/vmwareapi/stubs.py
new file mode 100644
index 000000000..a648efb16
--- /dev/null
+++ b/nova/tests/vmwareapi/stubs.py
@@ -0,0 +1,46 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

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

+

+"""

+Stubouts for the test suite

+"""

+

+from nova.virt import vmwareapi_conn

+from nova.virt.vmwareapi import fake

+from nova.virt.vmwareapi import vmware_images

+

+

+def fake_get_vim_object(arg):

+    """Stubs out the VMWareAPISession's get_vim_object method."""

+    return fake.FakeVim()

+

+

+def fake_is_vim_object(arg, module):

+    """Stubs out the VMWareAPISession's is_vim_object method."""

+    return isinstance(module, fake.FakeVim)

+

+

+def set_stubs(stubs):

+    """Set the stubs."""

+    stubs.Set(vmware_images, 'fetch_image', fake.fake_fetch_image)

+    stubs.Set(vmware_images, 'get_vmdk_size_and_properties',

+              fake.fake_get_vmdk_size_and_properties)

+    stubs.Set(vmware_images, 'upload_image', fake.fake_upload_image)

+    stubs.Set(vmwareapi_conn.VMWareAPISession, "_get_vim_object",

+              fake_get_vim_object)

+    stubs.Set(vmwareapi_conn.VMWareAPISession, "_is_vim_object",

+              fake_is_vim_object)

diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 70d46a1fb..205f6c902 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -21,6 +21,7 @@ from nova.virt.xenapi import fake
 from nova.virt.xenapi import volume_utils
 from nova.virt.xenapi import vm_utils
 from nova.virt.xenapi import vmops
+from nova import utils
 
 
 def stubout_instance_snapshot(stubs):
@@ -137,14 +138,17 @@ def stubout_is_vdi_pv(stubs):
     stubs.Set(vm_utils, '_is_vdi_pv', f)
 
 
+def stubout_loopingcall_start(stubs):
+    def fake_start(self, interval, now=True):
+        self.f(*self.args, **self.kw)
+    stubs.Set(utils.LoopingCall, 'start', fake_start)
+
+
 class FakeSessionForVMTests(fake.SessionBase):
     """ Stubs out a XenAPISession for VM tests """
     def __init__(self, uri):
         super(FakeSessionForVMTests, self).__init__(uri)
 
-    def network_get_all_records_where(self, _1, _2):
-        return self.xenapi.network.get_all_records()
-
     def host_call_plugin(self, _1, _2, _3, _4, _5):
         sr_ref = fake.get_all('SR')[0]
         vdi_ref = fake.create_vdi('', False, sr_ref, False)
@@ -185,6 +189,25 @@ class FakeSessionForVMTests(fake.SessionBase):
         pass
 
 
+def stub_out_vm_methods(stubs):
+    def fake_shutdown(self, inst, vm, method="clean"):
+        pass
+
+    def fake_acquire_bootlock(self, vm):
+        pass
+
+    def fake_release_bootlock(self, vm):
+        pass
+
+    def fake_spawn_rescue(self, inst):
+        inst._rescue = False
+
+    stubs.Set(vmops.VMOps, "_shutdown", fake_shutdown)
+    stubs.Set(vmops.VMOps, "_acquire_bootlock", fake_acquire_bootlock)
+    stubs.Set(vmops.VMOps, "_release_bootlock", fake_release_bootlock)
+    stubs.Set(vmops.VMOps, "spawn_rescue", fake_spawn_rescue)
+
+
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
     def __init__(self, uri):
@@ -228,6 +251,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 +266,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 +275,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