merge with trunk

12 files changed, 390 insertions, 97 deletions

diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 8b0729c35..bf51239e6 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -228,6 +228,9 @@ class FakeToken(object):
     # FIXME(sirp): let's not use id here
     id = 0
 
+    def __getitem__(self, key):
+        return getattr(self, key)
+
     def __init__(self, **kwargs):
         FakeToken.id += 1
         self.id = FakeToken.id
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 89edece42..e8182b6a9 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -183,7 +183,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
 
-    def test_get_server_by_id_v11(self):
+    def test_get_server_by_id_v1_1(self):
         req = webob.Request.blank('/v1.1/servers/1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -246,7 +246,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(len(addresses["private"]), 1)
         self.assertEqual(addresses["private"][0], private)
 
-    def test_get_server_addresses_V10(self):
+    def test_get_server_addresses_v1_0(self):
         private = '192.168.0.3'
         public = ['1.2.3.4']
         new_return_server = return_server_with_addresses(private, public)
@@ -257,7 +257,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict, {
             'addresses': {'public': public, 'private': [private]}})
 
-    def test_get_server_addresses_xml_V10(self):
+    def test_get_server_addresses_xml_v1_0(self):
         private_expected = "192.168.0.3"
         public_expected = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private_expected,
@@ -276,7 +276,7 @@ class ServersTest(test.TestCase):
         (ip,) = private.getElementsByTagName('ip')
         self.assertEquals(ip.getAttribute('addr'), private_expected)
 
-    def test_get_server_addresses_public_V10(self):
+    def test_get_server_addresses_public_v1_0(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
@@ -286,7 +286,7 @@ class ServersTest(test.TestCase):
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict, {'public': public})
 
-    def test_get_server_addresses_private_V10(self):
+    def test_get_server_addresses_private_v1_0(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
@@ -296,7 +296,7 @@ class ServersTest(test.TestCase):
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict, {'private': [private]})
 
-    def test_get_server_addresses_public_xml_V10(self):
+    def test_get_server_addresses_public_xml_v1_0(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
@@ -310,7 +310,7 @@ class ServersTest(test.TestCase):
         (ip,) = public_node.getElementsByTagName('ip')
         self.assertEquals(ip.getAttribute('addr'), public[0])
 
-    def test_get_server_addresses_private_xml_V10(self):
+    def test_get_server_addresses_private_xml_v1_0(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
@@ -324,7 +324,7 @@ class ServersTest(test.TestCase):
         (ip,) = private_node.getElementsByTagName('ip')
         self.assertEquals(ip.getAttribute('addr'), private)
 
-    def test_get_server_by_id_with_addresses_v11(self):
+    def test_get_server_by_id_with_addresses_v1_1(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
         new_return_server = return_server_with_addresses(private, public)
@@ -354,7 +354,7 @@ class ServersTest(test.TestCase):
             self.assertEqual(s.get('imageId', None), None)
             i += 1
 
-    def test_get_server_list_v11(self):
+    def test_get_server_list_v1_1(self):
         req = webob.Request.blank('/v1.1/servers')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
@@ -576,16 +576,16 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-    def test_create_instance_v11(self):
+    def test_create_instance_v1_1(self):
         self._setup_for_create_instance()
 
-        imageRef = 'http://localhost/v1.1/images/2'
-        flavorRef = 'http://localhost/v1.1/flavors/3'
+        image_ref = 'http://localhost/v1.1/images/2'
+        flavor_ref = 'http://localhost/v1.1/flavors/3'
         body = {
             'server': {
                 'name': 'server_test',
-                'imageRef': imageRef,
-                'flavorRef': flavorRef,
+                'imageRef': image_ref,
+                'flavorRef': flavor_ref,
                 'metadata': {
                     'hello': 'world',
                     'open': 'stack',
@@ -605,17 +605,17 @@ class ServersTest(test.TestCase):
         self.assertEqual(16, len(server['adminPass']))
         self.assertEqual('server_test', server['name'])
         self.assertEqual(1, server['id'])
-        self.assertEqual(flavorRef, server['flavorRef'])
-        self.assertEqual(imageRef, server['imageRef'])
+        self.assertEqual(flavor_ref, server['flavorRef'])
+        self.assertEqual(image_ref, server['imageRef'])
         self.assertEqual(res.status_int, 200)
 
-    def test_create_instance_v11_bad_href(self):
+    def test_create_instance_v1_1_bad_href(self):
         self._setup_for_create_instance()
 
-        imageRef = 'http://localhost/v1.1/images/asdf'
-        flavorRef = 'http://localhost/v1.1/flavors/3'
+        image_ref = 'http://localhost/v1.1/images/asdf'
+        flavor_ref = 'http://localhost/v1.1/flavors/3'
         body = dict(server=dict(
-            name='server_test', imageRef=imageRef, flavorRef=flavorRef,
+            name='server_test', imageRef=image_ref, flavorRef=flavor_ref,
             metadata={'hello': 'world', 'open': 'stack'},
             personality={}))
         req = webob.Request.blank('/v1.1/servers')
@@ -625,17 +625,17 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-    def test_create_instance_v11_local_href(self):
+    def test_create_instance_v1_1_local_href(self):
         self._setup_for_create_instance()
 
-        imageRef = 'http://localhost/v1.1/images/2'
-        imageRefLocal = '2'
-        flavorRef = 'http://localhost/v1.1/flavors/3'
+        image_ref = 'http://localhost/v1.1/images/2'
+        image_ref_local = '2'
+        flavor_ref = 'http://localhost/v1.1/flavors/3'
         body = {
             'server': {
                 'name': 'server_test',
-                'imageRef': imageRefLocal,
-                'flavorRef': flavorRef,
+                'imageRef': image_ref_local,
+                'flavorRef': flavor_ref,
             },
         }
 
@@ -648,11 +648,11 @@ class ServersTest(test.TestCase):
 
         server = json.loads(res.body)['server']
         self.assertEqual(1, server['id'])
-        self.assertEqual(flavorRef, server['flavorRef'])
-        self.assertEqual(imageRef, server['imageRef'])
+        self.assertEqual(flavor_ref, server['flavorRef'])
+        self.assertEqual(image_ref, server['imageRef'])
         self.assertEqual(res.status_int, 200)
 
-    def test_create_instance_with_admin_pass_v10(self):
+    def test_create_instance_with_admin_pass_v1_0(self):
         self._setup_for_create_instance()
 
         body = {
@@ -673,16 +673,16 @@ class ServersTest(test.TestCase):
         self.assertNotEqual(res['server']['adminPass'],
                             body['server']['adminPass'])
 
-    def test_create_instance_with_admin_pass_v11(self):
+    def test_create_instance_with_admin_pass_v1_1(self):
         self._setup_for_create_instance()
 
-        imageRef = 'http://localhost/v1.1/images/2'
-        flavorRef = 'http://localhost/v1.1/flavors/3'
+        image_ref = 'http://localhost/v1.1/images/2'
+        flavor_ref = 'http://localhost/v1.1/flavors/3'
         body = {
             'server': {
                 'name': 'server_test',
-                'imageRef': imageRef,
-                'flavorRef': flavorRef,
+                'imageRef': image_ref,
+                'flavorRef': flavor_ref,
                 'adminPass': 'testpass',
             },
         }
@@ -695,16 +695,16 @@ class ServersTest(test.TestCase):
         server = json.loads(res.body)['server']
         self.assertEqual(server['adminPass'], body['server']['adminPass'])
 
-    def test_create_instance_with_empty_admin_pass_v11(self):
+    def test_create_instance_with_empty_admin_pass_v1_1(self):
         self._setup_for_create_instance()
 
-        imageRef = 'http://localhost/v1.1/images/2'
-        flavorRef = 'http://localhost/v1.1/flavors/3'
+        image_ref = 'http://localhost/v1.1/images/2'
+        flavor_ref = 'http://localhost/v1.1/flavors/3'
         body = {
             'server': {
                 'name': 'server_test',
-                'imageRef': imageRef,
-                'flavorRef': flavorRef,
+                'imageRef': image_ref,
+                'flavorRef': flavor_ref,
                 'adminPass': '',
             },
         }
@@ -758,7 +758,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-    def test_update_server_v10(self):
+    def test_update_server_v1_0(self):
         inst_dict = dict(name='server_test', adminPass='bacon')
         self.body = json.dumps(dict(server=inst_dict))
 
@@ -781,7 +781,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 204)
 
-    def test_update_server_adminPass_ignored_v11(self):
+    def test_update_server_adminPass_ignored_v1_1(self):
         inst_dict = dict(name='server_test', adminPass='bacon')
         self.body = json.dumps(dict(server=inst_dict))
 
@@ -822,7 +822,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 501)
 
-    def test_server_backup_schedule_deprecated_v11(self):
+    def test_server_backup_schedule_deprecated_v1_1(self):
         req = webob.Request.blank('/v1.1/servers/1/backup_schedule')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
@@ -1113,7 +1113,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-    def test_server_rebuild_accepted_minimum_v11(self):
+    def test_server_rebuild_accepted_minimum_v1_1(self):
         body = {
             "rebuild": {
                 "imageRef": "http://localhost/images/2",
@@ -1128,7 +1128,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 202)
 
-    def test_server_rebuild_rejected_when_building_v11(self):
+    def test_server_rebuild_rejected_when_building_v1_1(self):
         body = {
             "rebuild": {
                 "imageRef": "http://localhost/images/2",
@@ -1147,7 +1147,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 409)
 
-    def test_server_rebuild_accepted_with_metadata_v11(self):
+    def test_server_rebuild_accepted_with_metadata_v1_1(self):
         body = {
             "rebuild": {
                 "imageRef": "http://localhost/images/2",
@@ -1165,7 +1165,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 202)
 
-    def test_server_rebuild_accepted_with_bad_metadata_v11(self):
+    def test_server_rebuild_accepted_with_bad_metadata_v1_1(self):
         body = {
             "rebuild": {
                 "imageRef": "http://localhost/images/2",
@@ -1181,7 +1181,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-    def test_server_rebuild_bad_entity_v11(self):
+    def test_server_rebuild_bad_entity_v1_1(self):
         body = {
             "rebuild": {
                 "imageId": 2,
@@ -1196,7 +1196,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-    def test_server_rebuild_bad_personality_v11(self):
+    def test_server_rebuild_bad_personality_v1_1(self):
         body = {
             "rebuild": {
                 "imageRef": "http://localhost/images/2",
@@ -1215,7 +1215,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-    def test_server_rebuild_personality_v11(self):
+    def test_server_rebuild_personality_v1_1(self):
         body = {
             "rebuild": {
                 "imageRef": "http://localhost/images/2",
@@ -1654,6 +1654,19 @@ b25zLiINCg0KLVJpY2hhcmQgQmFjaA==""",
         request = self.deserializer.deserialize(serial_request)
         self.assertEqual(request, expected)
 
+    def test_request_xmlser_with_flavor_image_ref(self):
+        serial_request = """
+                <server xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    name="new-server-test"
+                    imageRef="http://localhost:8774/v1.1/images/1"
+                    flavorRef="http://localhost:8774/v1.1/flavors/1">
+                </server>"""
+        request = self.deserializer.deserialize(serial_request)
+        self.assertEquals(request["server"]["flavorRef"],
+                          "http://localhost:8774/v1.1/flavors/1")
+        self.assertEquals(request["server"]["imageRef"],
+                          "http://localhost:8774/v1.1/images/1")
+
 
 class TestServerInstanceCreation(test.TestCase):
 
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 58d251b1e..8bdea359a 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -124,7 +124,6 @@ def stub_out_db_instance_api(stubs, injected=True):
             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
diff --git a/nova/tests/network/base.py b/nova/tests/network/base.py
index 988a1de72..b06271c99 100644
--- a/nova/tests/network/base.py
+++ b/nova/tests/network/base.py
@@ -25,6 +25,7 @@ from nova import context
 from nova import db
 from nova import exception
 from nova import flags
+from nova import ipv6
 from nova import log as logging
 from nova import test
 from nova import utils
@@ -117,15 +118,15 @@ class NetworkTestCase(test.TestCase):
                                                  context.get_admin_context(),
                                                  instance_ref['id'])
             self.assertEqual(instance_ref['mac_address'],
-                             utils.to_mac(address_v6))
+                             ipv6.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']))
+                             ipv6.to_global(network_ref['cidr_v6'],
+                                            instance_ref['mac_address'],
+                                            'test'))
             self._deallocate_address(0, address)
             db.instance_destroy(context.get_admin_context(),
                                 instance_ref['id'])
diff --git a/nova/tests/public_key/dummy.fingerprint b/nova/tests/public_key/dummy.fingerprint
new file mode 100644
index 000000000..715bca27a
--- /dev/null
+++ b/nova/tests/public_key/dummy.fingerprint
@@ -0,0 +1 @@
+1c:87:d1:d9:32:fd:62:3c:78:2b:c0:ad:c0:15:88:df
diff --git a/nova/tests/public_key/dummy.pub b/nova/tests/public_key/dummy.pub
new file mode 100644
index 000000000..d4cf2bc0d
--- /dev/null
+++ b/nova/tests/public_key/dummy.pub
@@ -0,0 +1 @@
+ssh-dss AAAAB3NzaC1kc3MAAACBAMGJlY9XEIm2X234pdO5yFWMp2JuOQx8U0E815IVXhmKxYCBK9ZakgZOIQmPbXoGYyV+mziDPp6HJ0wKYLQxkwLEFr51fAZjWQvRss0SinURRuLkockDfGFtD4pYJthekr/rlqMKlBSDUSpGq8jUWW60UJ18FGooFpxR7ESqQRx/AAAAFQC96LRglaUeeP+E8U/yblEJocuiWwAAAIA3XiMR8Skiz/0aBm5K50SeQznQuMJTyzt9S9uaz5QZWiFu69hOyGSFGw8fqgxEkXFJIuHobQQpGYQubLW0NdaYRqyE/Vud3JUJUb8Texld6dz8vGemyB5d1YvtSeHIo8/BGv2msOqR3u5AZTaGCBD9DhpSGOKHEdNjTtvpPd8S8gAAAIBociGZ5jf09iHLVENhyXujJbxfGRPsyNTyARJfCOGl0oFV6hEzcQyw8U/ePwjgvjc2UizMWLl8tsb2FXKHRdc2v+ND3Us+XqKQ33X3ADP4FZ/+Oj213gMyhCmvFTP0u5FmHog9My4CB7YcIWRuUR42WlhQ2IfPvKwUoTk3R+T6Og== www-data@mk
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index af1dbfd4d..54c0454de 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -354,45 +354,40 @@ class CloudTestCase(test.TestCase):
         self.assertTrue(filter(lambda k: k['keyName'] == 'test1', keys))
         self.assertTrue(filter(lambda k: k['keyName'] == 'test2', keys))
 
+    def test_import_public_key(self):
+        # test when user provides all values
+        result1 = self.cloud.import_public_key(self.context,
+                                               'testimportkey1',
+                                               'mytestpubkey',
+                                               'mytestfprint')
+        self.assertTrue(result1)
+        keydata = db.key_pair_get(self.context,
+                                  self.context.user.id,
+                                  'testimportkey1')
+        self.assertEqual('mytestpubkey', keydata['public_key'])
+        self.assertEqual('mytestfprint', keydata['fingerprint'])
+        # test when user omits fingerprint
+        pubkey_path = os.path.join(os.path.dirname(__file__), 'public_key')
+        f = open(pubkey_path + '/dummy.pub', 'r')
+        dummypub = f.readline().rstrip()
+        f.close
+        f = open(pubkey_path + '/dummy.fingerprint', 'r')
+        dummyfprint = f.readline().rstrip()
+        f.close
+        result2 = self.cloud.import_public_key(self.context,
+                                               'testimportkey2',
+                                               dummypub)
+        self.assertTrue(result2)
+        keydata = db.key_pair_get(self.context,
+                                  self.context.user.id,
+                                  'testimportkey2')
+        self.assertEqual(dummypub, keydata['public_key'])
+        self.assertEqual(dummyfprint, keydata['fingerprint'])
+
     def test_delete_key_pair(self):
         self._create_key('test')
         self.cloud.delete_key_pair(self.context, 'test')
 
-    def test_run_instances(self):
-        if FLAGS.connection_type == 'fake':
-            LOG.debug(_("Can't test instances without a real virtual env."))
-            return
-        image_id = FLAGS.default_image
-        instance_type = FLAGS.default_instance_type
-        max_count = 1
-        kwargs = {'image_id': image_id,
-                  'instance_type': instance_type,
-                  'max_count': max_count}
-        rv = self.cloud.run_instances(self.context, **kwargs)
-        # TODO: check for proper response
-        instance_id = rv['reservationSet'][0].keys()[0]
-        instance = rv['reservationSet'][0][instance_id][0]
-        LOG.debug(_("Need to watch instance %s until it's running..."),
-                  instance['instance_id'])
-        while True:
-            greenthread.sleep(1)
-            info = self.cloud._get_instance(instance['instance_id'])
-            LOG.debug(info['state'])
-            if info['state'] == power_state.RUNNING:
-                break
-        self.assert_(rv)
-
-        if FLAGS.connection_type != 'fake':
-            time.sleep(45)  # Should use boto for polling here
-        for reservations in rv['reservationSet']:
-            # for res_id in reservations.keys():
-            #     LOG.debug(reservations[res_id])
-            # for instance in reservations[res_id]:
-            for instance in reservations[reservations.keys()[0]]:
-                instance_id = instance['instance_id']
-                LOG.debug(_("Terminating instance %s"), instance_id)
-                rv = self.compute.terminate_instance(instance_id)
-
     def test_terminate_instances(self):
         inst1 = db.instance_create(self.context, {'reservation_id': 'a',
                                                   'image_id': 1,
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 55e7ae0c4..9170837b6 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -334,6 +334,28 @@ class ComputeTestCase(test.TestCase):
 
         self.compute.terminate_instance(self.context, instance_id)
 
+    def test_finish_resize(self):
+        """Contrived test to ensure finish_resize doesn't raise anything"""
+
+        def fake(*args, **kwargs):
+            pass
+
+        self.stubs.Set(self.compute.driver, 'finish_resize', fake)
+        context = self.context.elevated()
+        instance_id = self._create_instance()
+        self.compute.prep_resize(context, instance_id, 1)
+        migration_ref = db.migration_get_by_instance_and_status(context,
+                instance_id, 'pre-migrating')
+        try:
+            self.compute.finish_resize(context, instance_id,
+                    int(migration_ref['id']), {})
+        except KeyError, e:
+            # Only catch key errors. We want other reasons for the test to
+            # fail to actually error out so we don't obscure anything
+            self.fail()
+
+        self.compute.terminate_instance(self.context, instance_id)
+
     def test_resize_instance(self):
         """Ensure instance can be migrated/resized"""
         instance_id = self._create_instance()
diff --git a/nova/tests/test_ipv6.py b/nova/tests/test_ipv6.py
new file mode 100644
index 000000000..11dc2ec98
--- /dev/null
+++ b/nova/tests/test_ipv6.py
@@ -0,0 +1,60 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright (c) 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 IPv6."""
+
+from nova import flags
+from nova import ipv6
+from nova import log as logging
+from nova import test
+
+LOG = logging.getLogger('nova.tests.test_ipv6')
+
+FLAGS = flags.FLAGS
+
+import sys
+
+
+class IPv6RFC2462TestCase(test.TestCase):
+    """Unit tests for IPv6 rfc2462 backend operations."""
+    def setUp(self):
+        super(IPv6RFC2462TestCase, self).setUp()
+        self.flags(ipv6_backend='rfc2462')
+        ipv6.reset_backend()
+
+    def test_to_global(self):
+        addr = ipv6.to_global('2001:db8::', '02:16:3e:33:44:55', 'test')
+        self.assertEquals(addr, '2001:db8::16:3eff:fe33:4455')
+
+    def test_to_mac(self):
+        mac = ipv6.to_mac('2001:db8::216:3eff:fe33:4455')
+        self.assertEquals(mac, '00:16:3e:33:44:55')
+
+
+class IPv6AccountIdentiferTestCase(test.TestCase):
+    """Unit tests for IPv6 account_identifier backend operations."""
+    def setUp(self):
+        super(IPv6AccountIdentiferTestCase, self).setUp()
+        self.flags(ipv6_backend='account_identifier')
+        ipv6.reset_backend()
+
+    def test_to_global(self):
+        addr = ipv6.to_global('2001:db8::', '02:16:3e:33:44:55', 'test')
+        self.assertEquals(addr, '2001:db8::a94a:8fe5:ff33:4455')
+
+    def test_to_mac(self):
+        mac = ipv6.to_mac('2001:db8::a94a:8fe5:ff33:4455')
+        self.assertEquals(mac, '02:16:3e:33:44:55')
diff --git a/nova/tests/test_notifier.py b/nova/tests/test_notifier.py
new file mode 100644
index 000000000..b6b0fcc68
--- /dev/null
+++ b/nova/tests/test_notifier.py
@@ -0,0 +1,117 @@
+# 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 nova
+
+from nova import context
+from nova import flags
+from nova import rpc
+import nova.notifier.api
+from nova.notifier.api import notify
+from nova.notifier import no_op_notifier
+from nova.notifier import rabbit_notifier
+from nova import test
+
+import stubout
+
+
+class NotifierTestCase(test.TestCase):
+    """Test case for notifications"""
+    def setUp(self):
+        super(NotifierTestCase, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        super(NotifierTestCase, self).tearDown()
+
+    def test_send_notification(self):
+        self.notify_called = False
+
+        def mock_notify(cls, *args):
+            self.notify_called = True
+
+        self.stubs.Set(nova.notifier.no_op_notifier, 'notify',
+                mock_notify)
+
+        class Mock(object):
+            pass
+        notify('publisher_id', 'event_type',
+                nova.notifier.api.WARN, dict(a=3))
+        self.assertEqual(self.notify_called, True)
+
+    def test_verify_message_format(self):
+        """A test to ensure changing the message format is prohibitively
+        annoying"""
+
+        def message_assert(message):
+            fields = [('publisher_id', 'publisher_id'),
+                      ('event_type', 'event_type'),
+                      ('priority', 'WARN'),
+                      ('payload', dict(a=3))]
+            for k, v in fields:
+                self.assertEqual(message[k], v)
+            self.assertTrue(len(message['message_id']) > 0)
+            self.assertTrue(len(message['timestamp']) > 0)
+
+        self.stubs.Set(nova.notifier.no_op_notifier, 'notify',
+                message_assert)
+        notify('publisher_id', 'event_type',
+                nova.notifier.api.WARN, dict(a=3))
+
+    def test_send_rabbit_notification(self):
+        self.stubs.Set(nova.flags.FLAGS, 'notification_driver',
+                'nova.notifier.rabbit_notifier')
+        self.mock_cast = False
+
+        def mock_cast(cls, *args):
+            self.mock_cast = True
+
+        class Mock(object):
+            pass
+
+        self.stubs.Set(nova.rpc, 'cast', mock_cast)
+        notify('publisher_id', 'event_type',
+                nova.notifier.api.WARN, dict(a=3))
+
+        self.assertEqual(self.mock_cast, True)
+
+    def test_invalid_priority(self):
+        def mock_cast(cls, *args):
+            pass
+
+        class Mock(object):
+            pass
+
+        self.stubs.Set(nova.rpc, 'cast', mock_cast)
+        self.assertRaises(nova.notifier.api.BadPriorityException,
+                notify, 'publisher_id',
+                'event_type', 'not a priority', dict(a=3))
+
+    def test_rabbit_priority_queue(self):
+        self.stubs.Set(nova.flags.FLAGS, 'notification_driver',
+                'nova.notifier.rabbit_notifier')
+        self.stubs.Set(nova.flags.FLAGS, 'notification_topic',
+                'testnotify')
+
+        self.test_topic = None
+
+        def mock_cast(context, topic, msg):
+            self.test_topic = topic
+
+        self.stubs.Set(nova.rpc, 'cast', mock_cast)
+        notify('publisher_id',
+                'event_type', 'DEBUG', dict(a=3))
+        self.assertEqual(self.test_topic, 'testnotify.debug')
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 39a123158..7ace2ad7d 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -96,12 +96,11 @@ class QuotaTestCase(test.TestCase):
         num_instances = quota.allowed_instances(self.context, 100,
             self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 2)
-        db.quota_create(self.context, {'project_id': self.project.id,
-                                       'instances': 10})
+        db.quota_create(self.context, self.project.id, 'instances', 10)
         num_instances = quota.allowed_instances(self.context, 100,
             self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 4)
-        db.quota_update(self.context, self.project.id, {'cores': 100})
+        db.quota_create(self.context, self.project.id, 'cores', 100)
         num_instances = quota.allowed_instances(self.context, 100,
             self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 10)
@@ -111,13 +110,85 @@ class QuotaTestCase(test.TestCase):
         num_metadata_items = quota.allowed_metadata_items(self.context,
                                                           too_many_items)
         self.assertEqual(num_metadata_items, FLAGS.quota_metadata_items)
-        db.quota_update(self.context, self.project.id, {'metadata_items': 5})
+        db.quota_create(self.context, self.project.id, 'metadata_items', 5)
         num_metadata_items = quota.allowed_metadata_items(self.context,
                                                           too_many_items)
         self.assertEqual(num_metadata_items, 5)
 
         # Cleanup
-        db.quota_destroy(self.context, self.project.id)
+        db.quota_destroy_all_by_project(self.context, self.project.id)
+
+    def test_unlimited_instances(self):
+        FLAGS.quota_instances = 2
+        FLAGS.quota_cores = 1000
+        instance_type = self._get_instance_type('m1.small')
+        num_instances = quota.allowed_instances(self.context, 100,
+                                                instance_type)
+        self.assertEqual(num_instances, 2)
+        db.quota_create(self.context, self.project.id, 'instances', None)
+        num_instances = quota.allowed_instances(self.context, 100,
+                                                instance_type)
+        self.assertEqual(num_instances, 100)
+        num_instances = quota.allowed_instances(self.context, 101,
+                                                instance_type)
+        self.assertEqual(num_instances, 101)
+
+    def test_unlimited_cores(self):
+        FLAGS.quota_instances = 1000
+        FLAGS.quota_cores = 2
+        instance_type = self._get_instance_type('m1.small')
+        num_instances = quota.allowed_instances(self.context, 100,
+                                                instance_type)
+        self.assertEqual(num_instances, 2)
+        db.quota_create(self.context, self.project.id, 'cores', None)
+        num_instances = quota.allowed_instances(self.context, 100,
+                                                instance_type)
+        self.assertEqual(num_instances, 100)
+        num_instances = quota.allowed_instances(self.context, 101,
+                                                instance_type)
+        self.assertEqual(num_instances, 101)
+
+    def test_unlimited_volumes(self):
+        FLAGS.quota_volumes = 10
+        FLAGS.quota_gigabytes = 1000
+        volumes = quota.allowed_volumes(self.context, 100, 1)
+        self.assertEqual(volumes, 10)
+        db.quota_create(self.context, self.project.id, 'volumes', None)
+        volumes = quota.allowed_volumes(self.context, 100, 1)
+        self.assertEqual(volumes, 100)
+        volumes = quota.allowed_volumes(self.context, 101, 1)
+        self.assertEqual(volumes, 101)
+
+    def test_unlimited_gigabytes(self):
+        FLAGS.quota_volumes = 1000
+        FLAGS.quota_gigabytes = 10
+        volumes = quota.allowed_volumes(self.context, 100, 1)
+        self.assertEqual(volumes, 10)
+        db.quota_create(self.context, self.project.id, 'gigabytes', None)
+        volumes = quota.allowed_volumes(self.context, 100, 1)
+        self.assertEqual(volumes, 100)
+        volumes = quota.allowed_volumes(self.context, 101, 1)
+        self.assertEqual(volumes, 101)
+
+    def test_unlimited_floating_ips(self):
+        FLAGS.quota_floating_ips = 10
+        floating_ips = quota.allowed_floating_ips(self.context, 100)
+        self.assertEqual(floating_ips, 10)
+        db.quota_create(self.context, self.project.id, 'floating_ips', None)
+        floating_ips = quota.allowed_floating_ips(self.context, 100)
+        self.assertEqual(floating_ips, 100)
+        floating_ips = quota.allowed_floating_ips(self.context, 101)
+        self.assertEqual(floating_ips, 101)
+
+    def test_unlimited_metadata_items(self):
+        FLAGS.quota_metadata_items = 10
+        items = quota.allowed_metadata_items(self.context, 100)
+        self.assertEqual(items, 10)
+        db.quota_create(self.context, self.project.id, 'metadata_items', None)
+        items = quota.allowed_metadata_items(self.context, 100)
+        self.assertEqual(items, 100)
+        items = quota.allowed_metadata_items(self.context, 101)
+        self.assertEqual(items, 101)
 
     def test_too_many_instances(self):
         instance_ids = []
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 3b5a3867d..4bc5fed16 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -642,7 +642,7 @@ class LibvirtConnTestCase(test.TestCase):
         try:
             conn.spawn(instance, network_info)
         except Exception, e:
-            count = (0 <= e.message.find('Unexpected method call'))
+            count = (0 <= str(e.message).find('Unexpected method call'))
 
         self.assertTrue(count)
 
@@ -864,7 +864,7 @@ class IptablesFirewallTestCase(test.TestCase):
         self.assertEquals(len(rulesv4), 2)
         self.assertEquals(len(rulesv6), 0)
 
-    def multinic_iptables_test(self):
+    def test_multinic_iptables(self):
         ipv4_rules_per_network = 2
         ipv6_rules_per_network = 3
         networks_count = 5
@@ -884,7 +884,17 @@ class IptablesFirewallTestCase(test.TestCase):
         self.assertEquals(ipv6_network_rules,
                           ipv6_rules_per_network * networks_count)
 
-    def test_unfilter_instance_undefines_nwfilters(self):
+    def test_do_refresh_security_group_rules(self):
+        instance_ref = self._create_instance_ref()
+        self.mox.StubOutWithMock(self.fw,
+                                 'add_filters_for_instance',
+                                 use_mock_anything=True)
+        self.fw.add_filters_for_instance(instance_ref, mox.IgnoreArg())
+        self.fw.instances[instance_ref['id']] = instance_ref
+        self.mox.ReplayAll()
+        self.fw.do_refresh_security_group_rules("fake")
+
+    def test_unfilter_instance_undefines_nwfilter(self):
         admin_ctxt = context.get_admin_context()
 
         fakefilter = FakeNWFilter()