Merge trunk

15 files changed, 203 insertions, 179 deletions

diff --git a/nova/tests/access_unittest.py b/nova/tests/access_unittest.py
index 4b40ffd0a..8167259c4 100644
--- a/nova/tests/access_unittest.py
+++ b/nova/tests/access_unittest.py
@@ -20,6 +20,7 @@ import unittest
 import logging
 import webob
 
+from nova import context
 from nova import exception
 from nova import flags
 from nova import test
@@ -35,44 +36,25 @@ class AccessTestCase(test.TrialTestCase):
     def setUp(self):
         super(AccessTestCase, self).setUp()
         um = manager.AuthManager()
+        self.context = context.get_admin_context()
         # Make test users
-        try:
-            self.testadmin = um.create_user('testadmin')
-        except Exception, err:
-            logging.error(str(err))
-        try:
-            self.testpmsys = um.create_user('testpmsys')
-        except: pass
-        try:
-            self.testnet = um.create_user('testnet')
-        except: pass
-        try:
-            self.testsys = um.create_user('testsys')
-        except: pass
+        self.testadmin = um.create_user('testadmin')
+        self.testpmsys = um.create_user('testpmsys')
+        self.testnet = um.create_user('testnet')
+        self.testsys = um.create_user('testsys')
         # Assign some rules
-        try:
-            um.add_role('testadmin', 'cloudadmin')
-        except: pass
-        try:
-            um.add_role('testpmsys', 'sysadmin')
-        except: pass
-        try:
-            um.add_role('testnet', 'netadmin')
-        except: pass
-        try:
-            um.add_role('testsys', 'sysadmin')
-        except: pass
+        um.add_role('testadmin', 'cloudadmin')
+        um.add_role('testpmsys', 'sysadmin')
+        um.add_role('testnet', 'netadmin')
+        um.add_role('testsys', 'sysadmin')
 
         # Make a test project
-        try:
-            self.project = um.create_project('testproj', 'testpmsys', 'a test project', ['testpmsys', 'testnet', 'testsys'])
-        except: pass
-        try:
-            self.project.add_role(self.testnet, 'netadmin')
-        except: pass
-        try:
-            self.project.add_role(self.testsys, 'sysadmin')
-        except: pass
+        self.project = um.create_project('testproj',
+                                         'testpmsys',
+                                         'a test project',
+                                         ['testpmsys', 'testnet', 'testsys'])
+        self.project.add_role(self.testnet, 'netadmin')
+        self.project.add_role(self.testsys, 'sysadmin')
         #user is set in each test
         def noopWSGIApp(environ, start_response):
             start_response('200 OK', [])
@@ -97,10 +79,8 @@ class AccessTestCase(test.TrialTestCase):
         super(AccessTestCase, self).tearDown()
 
     def response_status(self, user, methodName):
-        context = Context()
-        context.project = self.project
-        context.user = user
-        environ = {'ec2.context' : context,
+        ctxt = context.RequestContext(user, self.project)
+        environ = {'ec2.context' : ctxt,
                    'ec2.controller': 'some string',
                    'ec2.action': methodName}
         req = webob.Request.blank('/', environ)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 58022bfde..041e2cf76 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -170,6 +170,10 @@ def stub_out_glance(stubs, initial_fixtures=[]):
     stubs.Set(nova.image.services.glance.GlanceImageService, 'delete_all',
               fake_parallax_client.fake_delete_all)
 
+class FakeToken(object):
+    def __init__(self, **kwargs):
+        for k,v in kwargs.iteritems():
+            setattr(self, k, v)
 
 class FakeAuthDatabase(object):
     data = {}
@@ -180,12 +184,13 @@ class FakeAuthDatabase(object):
 
     @staticmethod
     def auth_create_token(context, token):
-        token['created_at'] = datetime.datetime.now()
-        FakeAuthDatabase.data[token['token_hash']] = token
+        fake_token = FakeToken(created_at=datetime.datetime.now(), **token)
+        FakeAuthDatabase.data[fake_token.token_hash] = fake_token
+        return fake_token
 
     @staticmethod
     def auth_destroy_token(context, token):
-        if FakeAuthDatabase.data.has_key(token['token_hash']):
+        if token.token_hash in FakeAuthDatabase.data:
             del FakeAuthDatabase.data['token_hash']
 
 
@@ -197,7 +202,7 @@ class FakeAuthManager(object):
 
     def get_user(self, uid):
         for k, v in FakeAuthManager.auth_data.iteritems():
-            if v['uid'] == uid:
+            if v.id == uid:
                 return v
         return None
 
diff --git a/nova/tests/api/openstack/test_auth.py b/nova/tests/api/openstack/test_auth.py
index d2ba80243..bbfb0fcea 100644
--- a/nova/tests/api/openstack/test_auth.py
+++ b/nova/tests/api/openstack/test_auth.py
@@ -7,6 +7,7 @@ import webob.dec
 
 import nova.api
 import nova.api.openstack.auth
+import nova.auth.manager
 from nova import auth
 from nova.tests.api.openstack import fakes
 
@@ -26,7 +27,7 @@ class Test(unittest.TestCase):
 
     def test_authorize_user(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', { 'uid': 1, 'name':'herp' } )
+        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
 
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'herp'
@@ -40,7 +41,7 @@ class Test(unittest.TestCase):
 
     def test_authorize_token(self):
         f = fakes.FakeAuthManager()
-        f.add_user('derp', { 'uid': 1, 'name':'herp' } )
+        f.add_user('derp', nova.auth.manager.User(1, 'herp', None, None, None))
             
         req = webob.Request.blank('/v1.0/')
         req.headers['X-Auth-User'] = 'herp'
@@ -71,8 +72,9 @@ class Test(unittest.TestCase):
             self.destroy_called = True
         
         def bad_token(meh, context, token_hash):
-            return { 'token_hash':token_hash,  
-                     'created_at':datetime.datetime(1990, 1, 1) }
+            return fakes.FakeToken(
+                    token_hash=token_hash,
+                    created_at=datetime.datetime(1990, 1, 1))
 
         self.stubs.Set(fakes.FakeAuthDatabase, 'auth_destroy_token',
             destroy_token_mock)
diff --git a/nova/tests/api_unittest.py b/nova/tests/api_unittest.py
index 7ab27e000..414db1e11 100644
--- a/nova/tests/api_unittest.py
+++ b/nova/tests/api_unittest.py
@@ -25,6 +25,7 @@ import random
 import StringIO
 import webob
 
+from nova import context
 from nova import flags
 from nova import test
 from nova import api
@@ -131,7 +132,7 @@ class ApiEc2TestCase(test.BaseTestCase):
         user = self.manager.create_user('fake', 'fake', 'fake')
         project = self.manager.create_project('fake', 'fake', 'fake')
         # NOTE(vish): create depends on pool, so call helper directly
-        cloud._gen_key(None, user.id, keyname)
+        cloud._gen_key(context.get_admin_context(), user.id, keyname)
 
         rv = self.ec2.get_all_key_pairs()
         results = [k for k in rv if k.name == keyname]
diff --git a/nova/tests/auth_unittest.py b/nova/tests/auth_unittest.py
index 99f7ab599..97d22d702 100644
--- a/nova/tests/auth_unittest.py
+++ b/nova/tests/auth_unittest.py
@@ -80,7 +80,7 @@ class AuthManagerTestCase(object):
         FLAGS.auth_driver = self.auth_driver
         super(AuthManagerTestCase, self).setUp()
         self.flags(connection_type='fake')
-        self.manager = manager.AuthManager()
+        self.manager = manager.AuthManager(new=True)
 
     def test_create_and_find_user(self):
         with user_generator(self.manager):
@@ -117,7 +117,7 @@ class AuthManagerTestCase(object):
                 self.assert_(filter(lambda u: u.id == 'test1', users))
                 self.assert_(filter(lambda u: u.id == 'test2', users))
                 self.assert_(not filter(lambda u: u.id == 'test3', users))
-        
+
     def test_can_add_and_remove_user_role(self):
         with user_generator(self.manager):
             self.assertFalse(self.manager.has_role('test1', 'itsec'))
@@ -324,6 +324,19 @@ class AuthManagerTestCase(object):
 class AuthManagerLdapTestCase(AuthManagerTestCase, test.TrialTestCase):
     auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
 
+    def __init__(self, *args, **kwargs):
+        AuthManagerTestCase.__init__(self)
+        test.TrialTestCase.__init__(self, *args, **kwargs)
+        import nova.auth.fakeldap as fakeldap
+        FLAGS.redis_db = 8
+        if FLAGS.flush_db:
+            logging.info("Flushing redis datastore")
+            try:
+                r = fakeldap.Redis.instance()
+                r.flushdb()
+            except:
+                self.skip = True
+
 class AuthManagerDbTestCase(AuthManagerTestCase, test.TrialTestCase):
     auth_driver = 'nova.auth.dbdriver.DbDriver'
 
diff --git a/nova/tests/cloud_unittest.py b/nova/tests/cloud_unittest.py
index ff466135d..20099069c 100644
--- a/nova/tests/cloud_unittest.py
+++ b/nova/tests/cloud_unittest.py
@@ -30,6 +30,7 @@ from twisted.internet import defer
 import unittest
 from xml.etree import ElementTree
 
+from nova import context
 from nova import crypto
 from nova import db
 from nova import flags
@@ -38,7 +39,6 @@ from nova import test
 from nova import utils
 from nova.auth import manager
 from nova.compute import power_state
-from nova.api.ec2 import context
 from nova.api.ec2 import cloud
 from nova.objectstore import image
 
@@ -78,7 +78,7 @@ class CloudTestCase(test.TrialTestCase):
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
         self.project = self.manager.create_project('proj', 'admin', 'proj')
-        self.context = context.APIRequestContext(user=self.user,
+        self.context = context.RequestContext(user=self.user,
                                                  project=self.project)
 
     def tearDown(self):
@@ -243,34 +243,34 @@ class CloudTestCase(test.TrialTestCase):
         self.assertEqual('', img.metadata['description'])
 
     def test_update_of_instance_display_fields(self):
-        inst = db.instance_create({}, {})
+        inst = db.instance_create(self.context, {})
         ec2_id = cloud.internal_id_to_ec2_id(inst['internal_id'])
         self.cloud.update_instance(self.context, ec2_id,
                                    display_name='c00l 1m4g3')
-        inst = db.instance_get({}, inst['id'])
+        inst = db.instance_get(self.context, inst['id'])
         self.assertEqual('c00l 1m4g3', inst['display_name'])
-        db.instance_destroy({}, inst['id'])
+        db.instance_destroy(self.context, inst['id'])
 
     def test_update_of_instance_wont_update_private_fields(self):
-        inst = db.instance_create({}, {})
+        inst = db.instance_create(self.context, {})
         self.cloud.update_instance(self.context, inst['id'],
                                    mac_address='DE:AD:BE:EF')
-        inst = db.instance_get({}, inst['id'])
+        inst = db.instance_get(self.context, inst['id'])
         self.assertEqual(None, inst['mac_address'])
-        db.instance_destroy({}, inst['id'])
+        db.instance_destroy(self.context, inst['id'])
 
     def test_update_of_volume_display_fields(self):
-        vol = db.volume_create({}, {})
+        vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context, vol['id'],
                                  display_name='c00l v0lum3')
-        vol = db.volume_get({}, vol['id'])
+        vol = db.volume_get(self.context, vol['id'])
         self.assertEqual('c00l v0lum3', vol['display_name'])
-        db.volume_destroy({}, vol['id'])
+        db.volume_destroy(self.context, vol['id'])
 
     def test_update_of_volume_wont_update_private_fields(self):
-        vol = db.volume_create({}, {})
+        vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context, vol['id'],
                                    mountpoint='/not/here')
-        vol = db.volume_get({}, vol['id'])
+        vol = db.volume_get(self.context, vol['id'])
         self.assertEqual(None, vol['mountpoint'])
-        db.volume_destroy({}, vol['id'])
+        db.volume_destroy(self.context, vol['id'])
diff --git a/nova/tests/compute_unittest.py b/nova/tests/compute_unittest.py
index 5a7f170f3..01e1bcd30 100644
--- a/nova/tests/compute_unittest.py
+++ b/nova/tests/compute_unittest.py
@@ -24,13 +24,13 @@ import logging
 
 from twisted.internet import defer
 
+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.auth import manager
-from nova.api import context
 
 FLAGS = flags.FLAGS
 
@@ -46,7 +46,7 @@ class ComputeTestCase(test.TrialTestCase):
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')
         self.project = self.manager.create_project('fake', 'fake', 'fake')
-        self.context = None
+        self.context = context.get_admin_context()
 
     def tearDown(self):  # pylint: disable-msg=C0103
         self.manager.delete_user(self.user)
@@ -73,13 +73,13 @@ class ComputeTestCase(test.TrialTestCase):
 
         yield self.compute.run_instance(self.context, instance_id)
 
-        instances = db.instance_get_all(None)
+        instances = db.instance_get_all(context.get_admin_context())
         logging.info("Running instances: %s", instances)
         self.assertEqual(len(instances), 1)
 
         yield self.compute.terminate_instance(self.context, instance_id)
 
-        instances = db.instance_get_all(None)
+        instances = db.instance_get_all(context.get_admin_context())
         logging.info("After terminating instances: %s", instances)
         self.assertEqual(len(instances), 0)
 
@@ -97,8 +97,7 @@ class ComputeTestCase(test.TrialTestCase):
         self.assertEqual(instance_ref['deleted_at'], None)
         terminate = datetime.datetime.utcnow()
         yield self.compute.terminate_instance(self.context, instance_id)
-        self.context = context.get_admin_context(user=self.user,
-                                                 read_deleted=True)
+        self.context = self.context.elevated(True)
         instance_ref = db.instance_get(self.context, instance_id)
         self.assert_(instance_ref['launched_at'] < terminate)
         self.assert_(instance_ref['deleted_at'] > terminate)
diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py
index 3afb4d19e..e8dd2624f 100644
--- a/nova/tests/network_unittest.py
+++ b/nova/tests/network_unittest.py
@@ -22,13 +22,13 @@ import IPy
 import os
 import logging
 
+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.auth import manager
-from nova.api.ec2 import context
 
 FLAGS = flags.FLAGS
 
@@ -49,13 +49,13 @@ class NetworkTestCase(test.TrialTestCase):
         self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
         self.projects = []
         self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.APIRequestContext(project=None, user=self.user)
+        self.context = context.RequestContext(project=None, user=self.user)
         for i in range(5):
             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.APIRequestContext(project=self.projects[i],
+            user_context = context.RequestContext(project=self.projects[i],
                                                      user=self.user)
             network_ref = self.network.get_network(user_context)
             self.network.set_network_host(context.get_admin_context(),
@@ -69,8 +69,8 @@ class NetworkTestCase(test.TrialTestCase):
         super(NetworkTestCase, self).tearDown()
         # TODO(termie): this should really be instantiating clean datastores
         #               in between runs, one failure kills all the tests
-        db.instance_destroy(None, self.instance_id)
-        db.instance_destroy(None, self.instance2_id)
+        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)
@@ -79,7 +79,8 @@ class NetworkTestCase(test.TrialTestCase):
         if not mac:
             mac = utils.generate_mac()
         project = self.projects[project_num]
-        self.context.project = project
+        self.context._project = project
+        self.context.project_id = project.id
         return db.instance_create(self.context,
                                   {'project_id': project.id,
                                    'mac_address': mac})
@@ -88,35 +89,39 @@ class NetworkTestCase(test.TrialTestCase):
         """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 = 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 = self.projects[project_num]
+        self.context.project_id = self.projects[project_num].id
         self.network.deallocate_fixed_ip(self.context, address)
 
 
     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 = 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(None, address)
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
         except exception.NotFound:
-            db.floating_ip_create(None, {'address': address,
-                                         'host': FLAGS.host})
+            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(None, self.instance_id)
+        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(None, self.instance_id)
+        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)
@@ -178,7 +183,8 @@ class NetworkTestCase(test.TrialTestCase):
             lease_ip(address)
             lease_ip(address2)
             lease_ip(address3)
-            self.context.project = self.projects[i]
+            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,
@@ -192,8 +198,9 @@ class NetworkTestCase(test.TrialTestCase):
             release_ip(address2)
             release_ip(address3)
         for instance_id in instance_ids:
-            db.instance_destroy(None, instance_id)
-        self.context.project = self.projects[0]
+            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)
@@ -208,16 +215,17 @@ class NetworkTestCase(test.TrialTestCase):
     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(None)
+        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(None, project.id)
+            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,
-                          None,
+                          context.get_admin_context(),
                           project.id)
         for project in projects:
             self.manager.delete_project(project)
@@ -246,18 +254,18 @@ class NetworkTestCase(test.TrialTestCase):
         There are ips reserved at the bottom and top of the range.
         services (network, gateway, CloudPipe, broadcast)
         """
-        network = db.project_get_network(None, self.projects[0].id)
+        network = db.project_get_network(context.get_admin_context(), self.projects[0].id)
         net_size = flags.FLAGS.network_size
-        total_ips = (db.network_count_available_ips(None, network['id']) +
-                     db.network_count_reserved_ips(None, network['id']) +
-                     db.network_count_allocated_ips(None, network['id']))
+        total_ips = (db.network_count_available_ips(context.get_admin_context(), network['id']) +
+                     db.network_count_reserved_ips(context.get_admin_context(), network['id']) +
+                     db.network_count_allocated_ips(context.get_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.
         """
-        network = db.project_get_network(None, self.projects[0].id)
-        num_available_ips = db.network_count_available_ips(None,
+        network = db.project_get_network(context.get_admin_context(), self.projects[0].id)
+        num_available_ips = db.network_count_available_ips(context.get_admin_context(),
                                                            network['id'])
         addresses = []
         instance_ids = []
@@ -268,7 +276,7 @@ class NetworkTestCase(test.TrialTestCase):
             addresses.append(address)
             lease_ip(address)
 
-        self.assertEqual(db.network_count_available_ips(None,
+        self.assertEqual(db.network_count_available_ips(context.get_admin_context(),
                                                         network['id']), 0)
         self.assertRaises(db.NoMoreAddresses,
                           self.network.allocate_fixed_ip,
@@ -278,17 +286,17 @@ class NetworkTestCase(test.TrialTestCase):
         for i in range(num_available_ips):
             self.network.deallocate_fixed_ip(self.context, addresses[i])
             release_ip(addresses[i])
-            db.instance_destroy(None, instance_ids[i])
-        self.assertEqual(db.network_count_available_ips(None,
+            db.instance_destroy(context.get_admin_context(), instance_ids[i])
+        self.assertEqual(db.network_count_available_ips(context.get_admin_context(),
                                                         network['id']),
                          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(None, project_id)
-    network = db.fixed_ip_get_network(None, address)
-    instance = db.fixed_ip_get_instance(None, address)
+    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']
 
@@ -300,8 +308,8 @@ def binpath(script):
 
 def lease_ip(private_ip):
     """Run add command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(None, private_ip)
-    instance_ref = db.fixed_ip_get_instance(None, private_ip)
+    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 = "%s add %s %s fake" % (binpath('nova-dhcpbridge'),
                                  instance_ref['mac_address'],
                                  private_ip)
@@ -314,8 +322,8 @@ def lease_ip(private_ip):
 
 def release_ip(private_ip):
     """Run del command on dhcpbridge"""
-    network_ref = db.fixed_ip_get_network(None, private_ip)
-    instance_ref = db.fixed_ip_get_instance(None, private_ip)
+    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 = "%s del %s %s fake" % (binpath('nova-dhcpbridge'),
                                  instance_ref['mac_address'],
                                  private_ip)
diff --git a/nova/tests/objectstore_unittest.py b/nova/tests/objectstore_unittest.py
index 872f1ab23..f096ac6fe 100644
--- a/nova/tests/objectstore_unittest.py
+++ b/nova/tests/objectstore_unittest.py
@@ -32,6 +32,7 @@ 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
@@ -70,13 +71,7 @@ class ObjectStoreTestCase(test.TrialTestCase):
         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'])
-
-        class Context(object):
-            """Dummy context for running tests."""
-            user = None
-            project = None
-
-        self.context = Context()
+        self.context = context.RequestContext('user1', 'proj1')
 
     def tearDown(self): # pylint: disable-msg=C0103
         """Tear down users and projects."""
@@ -89,8 +84,6 @@ class ObjectStoreTestCase(test.TrialTestCase):
 
     def test_buckets(self):
         """Test the bucket API."""
-        self.context.user = self.auth_manager.get_user('user1')
-        self.context.project = self.auth_manager.get_project('proj1')
         objectstore.bucket.Bucket.create('new_bucket', self.context)
         bucket = objectstore.bucket.Bucket('new_bucket')
 
@@ -98,14 +91,12 @@ class ObjectStoreTestCase(test.TrialTestCase):
         self.assert_(bucket.is_authorized(self.context))
 
         # another user is not authorized
-        self.context.user = self.auth_manager.get_user('user2')
-        self.context.project = self.auth_manager.get_project('proj2')
-        self.assertFalse(bucket.is_authorized(self.context))
+        context2 = context.RequestContext('user2', 'proj2')
+        self.assertFalse(bucket.is_authorized(context2))
 
         # admin is authorized to use bucket
-        self.context.user = self.auth_manager.get_user('admin_user')
-        self.context.project = None
-        self.assertTrue(bucket.is_authorized(self.context))
+        admin_context = context.RequestContext('admin_user', None)
+        self.assertTrue(bucket.is_authorized(admin_context))
 
         # new buckets are empty
         self.assertTrue(bucket.list_keys()['Contents'] == [])
@@ -143,8 +134,6 @@ class ObjectStoreTestCase(test.TrialTestCase):
     def do_test_images(self, manifest_file, expect_kernel_and_ramdisk,
                              image_bucket, image_name):
         "Test the image API."
-        self.context.user = self.auth_manager.get_user('user1')
-        self.context.project = self.auth_manager.get_project('proj1')
 
         # create a bucket for our bundle
         objectstore.bucket.Bucket.create(image_bucket, self.context)
@@ -179,9 +168,8 @@ class ObjectStoreTestCase(test.TrialTestCase):
             self.assertFalse('ramdiskId' in my_img.metadata)
 
         # verify image permissions
-        self.context.user = self.auth_manager.get_user('user2')
-        self.context.project = self.auth_manager.get_project('proj2')
-        self.assertFalse(my_img.is_authorized(self.context))
+        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'})
diff --git a/nova/tests/quota_unittest.py b/nova/tests/quota_unittest.py
index 370ccd506..72e44bf52 100644
--- a/nova/tests/quota_unittest.py
+++ b/nova/tests/quota_unittest.py
@@ -18,6 +18,7 @@
 
 import logging
 
+from nova import context
 from nova import db
 from nova import exception
 from nova import flags
@@ -26,7 +27,6 @@ from nova import test
 from nova import utils
 from nova.auth import manager
 from nova.api.ec2 import cloud
-from nova.api.ec2 import context
 
 
 FLAGS = flags.FLAGS
@@ -48,8 +48,8 @@ class QuotaTestCase(test.TrialTestCase):
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
         self.project = self.manager.create_project('admin', 'admin', 'admin')
         self.network = utils.import_object(FLAGS.network_manager)
-        self.context = context.APIRequestContext(project=self.project,
-                                                 user=self.user)
+        self.context = context.RequestContext(project=self.project,
+                                              user=self.user)
 
     def tearDown(self):  # pylint: disable-msg=C0103
         manager.AuthManager().delete_project(self.project)
@@ -94,7 +94,7 @@ class QuotaTestCase(test.TrialTestCase):
         for i in range(FLAGS.quota_instances):
             instance_id = self._create_instance()
             instance_ids.append(instance_id)
-        self.assertRaises(cloud.QuotaError, self.cloud.run_instances, 
+        self.assertRaises(cloud.QuotaError, self.cloud.run_instances,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
@@ -106,7 +106,7 @@ class QuotaTestCase(test.TrialTestCase):
         instance_ids = []
         instance_id = self._create_instance(cores=4)
         instance_ids.append(instance_id)
-        self.assertRaises(cloud.QuotaError, self.cloud.run_instances, 
+        self.assertRaises(cloud.QuotaError, self.cloud.run_instances,
                                             self.context,
                                             min_count=1,
                                             max_count=1,
@@ -139,9 +139,9 @@ class QuotaTestCase(test.TrialTestCase):
     def test_too_many_addresses(self):
         address = '192.168.0.100'
         try:
-            db.floating_ip_get_by_address(None, address)
+            db.floating_ip_get_by_address(context.get_admin_context(), address)
         except exception.NotFound:
-            db.floating_ip_create(None, {'address': address,
+            db.floating_ip_create(context.get_admin_context(), {'address': address,
                                          'host': FLAGS.host})
         float_addr = self.network.allocate_floating_ip(self.context,
                                                        self.project.id)
diff --git a/nova/tests/rpc_unittest.py b/nova/tests/rpc_unittest.py
index 9652841f2..5d2bb1046 100644
--- a/nova/tests/rpc_unittest.py
+++ b/nova/tests/rpc_unittest.py
@@ -22,6 +22,7 @@ import logging
 
 from twisted.internet import defer
 
+from nova import context
 from nova import flags
 from nova import rpc
 from nova import test
@@ -40,14 +41,24 @@ class RpcTestCase(test.TrialTestCase):
                                             topic='test',
                                             proxy=self.receiver)
         self.consumer.attach_to_twisted()
+        self.context= context.get_admin_context()
 
     def test_call_succeed(self):
         """Get a value through rpc call"""
         value = 42
-        result = yield rpc.call_twisted('test', {"method": "echo",
+        result = yield rpc.call_twisted(self.context,
+                                        'test', {"method": "echo",
                                                  "args": {"value": value}})
         self.assertEqual(value, result)
 
+    def test_context_passed(self):
+        """Makes sure a context is passed through rpc call"""
+        value = 42
+        result = yield rpc.call_twisted(self.context,
+                                        'test', {"method": "context",
+                                                 "args": {"value": value}})
+        self.assertEqual(self.context.to_dict(), result)
+
     def test_call_exception(self):
         """Test that exception gets passed back properly
 
@@ -56,11 +67,13 @@ class RpcTestCase(test.TrialTestCase):
         to an int in the test.
         """
         value = 42
-        self.assertFailure(rpc.call_twisted('test', {"method": "fail",
+        self.assertFailure(rpc.call_twisted(self.context,
+                                            'test', {"method": "fail",
                                                      "args": {"value": value}}),
                            rpc.RemoteError)
         try:
-            yield rpc.call_twisted('test', {"method": "fail",
+            yield rpc.call_twisted(self.context,
+                                   'test', {"method": "fail",
                                             "args": {"value": value}})
             self.fail("should have thrown rpc.RemoteError")
         except rpc.RemoteError as exc:
@@ -73,12 +86,19 @@ class TestReceiver(object):
     Uses static methods because we aren't actually storing any state"""
 
     @staticmethod
-    def echo(value):
+    def echo(context, value):
         """Simply returns whatever value is sent in"""
         logging.debug("Received %s", value)
         return defer.succeed(value)
 
     @staticmethod
-    def fail(value):
+    def context(context, value):
+        """Returns dictionary version of context"""
+        logging.debug("Received %s", context)
+        return defer.succeed(context.to_dict())
+
+    @staticmethod
+    def fail(context, value):
         """Raises an exception with the value sent in"""
         raise Exception(value)
+
diff --git a/nova/tests/scheduler_unittest.py b/nova/tests/scheduler_unittest.py
index 80100fc2f..379f8cdc8 100644
--- a/nova/tests/scheduler_unittest.py
+++ b/nova/tests/scheduler_unittest.py
@@ -19,6 +19,7 @@
 Tests For Scheduler
 """
 
+from nova import context
 from nova import db
 from nova import flags
 from nova import service
@@ -50,22 +51,24 @@ class SchedulerTestCase(test.TrialTestCase):
     def test_fallback(self):
         scheduler = manager.SchedulerManager()
         self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
-        rpc.cast('topic.fallback_host',
+        ctxt = context.get_admin_context()
+        rpc.cast(ctxt,
+                 'topic.fallback_host',
                  {'method': 'noexist',
-                  'args': {'context': None,
-                           'num': 7}})
+                  'args': {'num': 7}})
         self.mox.ReplayAll()
-        scheduler.noexist(None, 'topic', num=7)
+        scheduler.noexist(ctxt, 'topic', num=7)
 
     def test_named_method(self):
         scheduler = manager.SchedulerManager()
         self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
-        rpc.cast('topic.named_host',
+        ctxt = context.get_admin_context()
+        rpc.cast(ctxt,
+                 'topic.named_host',
                  {'method': 'named_method',
-                  'args': {'context': None,
-                           'num': 7}})
+                  'args': {'num': 7}})
         self.mox.ReplayAll()
-        scheduler.named_method(None, 'topic', num=7)
+        scheduler.named_method(ctxt, 'topic', num=7)
 
 
 class SimpleDriverTestCase(test.TrialTestCase):
@@ -79,11 +82,10 @@ class SimpleDriverTestCase(test.TrialTestCase):
                    volume_driver='nova.volume.driver.FakeAOEDriver',
                    scheduler_driver='nova.scheduler.simple.SimpleScheduler')
         self.scheduler = manager.SchedulerManager()
-        self.context = None
         self.manager = auth_manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')
         self.project = self.manager.create_project('fake', 'fake', 'fake')
-        self.context = None
+        self.context = context.get_admin_context()
 
     def tearDown(self):  # pylint: disable-msg=C0103
         self.manager.delete_user(self.user)
diff --git a/nova/tests/service_unittest.py b/nova/tests/service_unittest.py
index 6afeec377..61db52742 100644
--- a/nova/tests/service_unittest.py
+++ b/nova/tests/service_unittest.py
@@ -24,6 +24,7 @@ import mox
 
 from twisted.application.app import startApplication
 
+from nova import context
 from nova import exception
 from nova import flags
 from nova import rpc
@@ -47,6 +48,7 @@ class ServiceTestCase(test.BaseTestCase):
     def setUp(self):  # pylint: disable=C0103
         super(ServiceTestCase, self).setUp()
         self.mox.StubOutWithMock(service, 'db')
+        self.context = context.get_admin_context()
 
     def test_create(self):
         host = 'foo'
@@ -90,10 +92,10 @@ class ServiceTestCase(test.BaseTestCase):
                        'report_count': 0,
                        'id': 1}
 
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(mox.IgnoreArg(),
                                        host,
                                        binary).AndRaise(exception.NotFound())
-        service.db.service_create(None,
+        service.db.service_create(mox.IgnoreArg(),
                                   service_create).AndReturn(service_ref)
         self.mox.ReplayAll()
 
@@ -113,10 +115,10 @@ class ServiceTestCase(test.BaseTestCase):
                        'report_count': 0,
                        'id': 1}
         service.db.__getattr__('report_state')
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(self.context,
                                        host,
                                        binary).AndReturn(service_ref)
-        service.db.service_update(None, service_ref['id'],
+        service.db.service_update(self.context, service_ref['id'],
                                   mox.ContainsKeyValue('report_count', 1))
 
         self.mox.ReplayAll()
@@ -135,13 +137,13 @@ class ServiceTestCase(test.BaseTestCase):
                        'id': 1}
 
         service.db.__getattr__('report_state')
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(self.context,
                                       host,
                                       binary).AndRaise(exception.NotFound())
-        service.db.service_create(None,
+        service.db.service_create(self.context,
                                   service_create).AndReturn(service_ref)
-        service.db.service_get(None, service_ref['id']).AndReturn(service_ref)
-        service.db.service_update(None, service_ref['id'],
+        service.db.service_get(self.context, service_ref['id']).AndReturn(service_ref)
+        service.db.service_update(self.context, service_ref['id'],
                                   mox.ContainsKeyValue('report_count', 1))
 
         self.mox.ReplayAll()
@@ -157,7 +159,7 @@ class ServiceTestCase(test.BaseTestCase):
                        'id': 1}
 
         service.db.__getattr__('report_state')
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(self.context,
                                        host,
                                        binary).AndRaise(Exception())
 
@@ -176,10 +178,10 @@ class ServiceTestCase(test.BaseTestCase):
                        'id': 1}
 
         service.db.__getattr__('report_state')
-        service.db.service_get_by_args(None,
+        service.db.service_get_by_args(self.context,
                                        host,
                                        binary).AndReturn(service_ref)
-        service.db.service_update(None, service_ref['id'],
+        service.db.service_update(self.context, service_ref['id'],
                                   mox.ContainsKeyValue('report_count', 1))
 
         self.mox.ReplayAll()
diff --git a/nova/tests/virt_unittest.py b/nova/tests/virt_unittest.py
index edcdba425..76af5cabd 100644
--- a/nova/tests/virt_unittest.py
+++ b/nova/tests/virt_unittest.py
@@ -17,11 +17,11 @@
 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 flags
 from nova import test
 from nova import utils
-from nova.api import context
 from nova.api.ec2 import cloud
 from nova.auth import manager
 from nova.virt import libvirt_conn
@@ -51,9 +51,9 @@ class LibvirtConnTestCase(test.TrialTestCase):
                      'bridge'         : 'br101',
                      'instance_type'  : 'm1.small'}
 
-        instance_ref = db.instance_create(None, instance)
-        user_context = context.APIRequestContext(project=self.project,
-                                                 user=self.user)
+        user_context = context.RequestContext(project=self.project,
+                                              user=self.user)
+        instance_ref = db.instance_create(user_context, instance)
         network_ref = self.network.get_network(user_context)
         self.network.set_network_host(context.get_admin_context(),
                                       network_ref['id'])
@@ -61,9 +61,10 @@ class LibvirtConnTestCase(test.TrialTestCase):
         fixed_ip = { 'address'    : ip,
                      'network_id' : network_ref['id'] }
 
-        fixed_ip_ref = db.fixed_ip_create(None, fixed_ip)
-        db.fixed_ip_update(None, ip, { 'allocated'   : True,
-                                          'instance_id' : instance_ref['id'] })
+        ctxt = context.get_admin_context()
+        fixed_ip_ref = db.fixed_ip_create(ctxt, fixed_ip)
+        db.fixed_ip_update(ctxt, ip, {'allocated': True,
+                                      'instance_id': instance_ref['id'] })
 
         type_uri_map = { 'qemu' : ('qemu:///system',
                               [(lambda t: t.find('.').get('type'), 'qemu'),
@@ -132,7 +133,7 @@ class NWFilterTestCase(test.TrialTestCase):
         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.context = context.APIRequestContext(self.user, self.project)
+        self.context = context.RequestContext(self.user, self.project)
 
         self.fake_libvirt_connection = Mock()
 
diff --git a/nova/tests/volume_unittest.py b/nova/tests/volume_unittest.py
index 1d665b502..8e2fa11c1 100644
--- a/nova/tests/volume_unittest.py
+++ b/nova/tests/volume_unittest.py
@@ -22,6 +22,7 @@ import logging
 
 from twisted.internet import defer
 
+from nova import context
 from nova import exception
 from nova import db
 from nova import flags
@@ -39,7 +40,7 @@ class VolumeTestCase(test.TrialTestCase):
         self.compute = utils.import_object(FLAGS.compute_manager)
         self.flags(connection_type='fake')
         self.volume = utils.import_object(FLAGS.volume_manager)
-        self.context = None
+        self.context = context.get_admin_context()
 
     @staticmethod
     def _create_volume(size='0'):
@@ -51,19 +52,19 @@ class VolumeTestCase(test.TrialTestCase):
         vol['availability_zone'] = FLAGS.storage_availability_zone
         vol['status'] = "creating"
         vol['attach_status'] = "detached"
-        return db.volume_create(None, vol)['id']
+        return db.volume_create(context.get_admin_context(), vol)['id']
 
     @defer.inlineCallbacks
     def test_create_delete_volume(self):
         """Test volume can be created and deleted"""
         volume_id = self._create_volume()
         yield self.volume.create_volume(self.context, volume_id)
-        self.assertEqual(volume_id, db.volume_get(None, volume_id).id)
+        self.assertEqual(volume_id, db.volume_get(context.get_admin_context(), volume_id).id)
 
         yield self.volume.delete_volume(self.context, volume_id)
         self.assertRaises(exception.NotFound,
                           db.volume_get,
-                          None,
+                          self.context,
                           volume_id)
 
     @defer.inlineCallbacks
@@ -92,7 +93,7 @@ class VolumeTestCase(test.TrialTestCase):
         self.assertFailure(self.volume.create_volume(self.context,
                                                      volume_id),
                            db.NoMoreBlades)
-        db.volume_destroy(None, volume_id)
+        db.volume_destroy(context.get_admin_context(), volume_id)
         for volume_id in vols:
             yield self.volume.delete_volume(self.context, volume_id)
 
@@ -113,12 +114,13 @@ class VolumeTestCase(test.TrialTestCase):
         volume_id = self._create_volume()
         yield self.volume.create_volume(self.context, volume_id)
         if FLAGS.fake_tests:
-            db.volume_attached(None, volume_id, instance_id, mountpoint)
+            db.volume_attached(self.context, volume_id, instance_id, mountpoint)
         else:
-            yield self.compute.attach_volume(instance_id,
+            yield self.compute.attach_volume(self.context,
+                                             instance_id,
                                              volume_id,
                                              mountpoint)
-        vol = db.volume_get(None, volume_id)
+        vol = db.volume_get(context.get_admin_context(), volume_id)
         self.assertEqual(vol['status'], "in-use")
         self.assertEqual(vol['attach_status'], "attached")
         self.assertEqual(vol['mountpoint'], mountpoint)
@@ -128,17 +130,18 @@ class VolumeTestCase(test.TrialTestCase):
         self.assertFailure(self.volume.delete_volume(self.context, volume_id),
                            exception.Error)
         if FLAGS.fake_tests:
-            db.volume_detached(None, volume_id)
+            db.volume_detached(self.context, volume_id)
         else:
-            yield self.compute.detach_volume(instance_id,
+            yield self.compute.detach_volume(self.context,
+                                             instance_id,
                                              volume_id)
-        vol = db.volume_get(None, volume_id)
+        vol = db.volume_get(self.context, volume_id)
         self.assertEqual(vol['status'], "available")
 
         yield self.volume.delete_volume(self.context, volume_id)
         self.assertRaises(exception.Error,
                           db.volume_get,
-                          None,
+                          self.context,
                           volume_id)
         db.instance_destroy(self.context, instance_id)
 
@@ -151,7 +154,7 @@ class VolumeTestCase(test.TrialTestCase):
         def _check(volume_id):
             """Make sure blades aren't duplicated"""
             volume_ids.append(volume_id)
-            (shelf_id, blade_id) = db.volume_get_shelf_and_blade(None,
+            (shelf_id, blade_id) = db.volume_get_shelf_and_blade(context.get_admin_context(),
                                                                  volume_id)
             shelf_blade = '%s.%s' % (shelf_id, blade_id)
             self.assert_(shelf_blade not in shelf_blades)