Merging in Sandy's changes adding Noop Cost Fn with tests

10 files changed, 345 insertions, 102 deletions

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/test_cloud.py b/nova/tests/test_cloud.py
index f271c03f2..c8559615a 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -279,6 +279,26 @@ class CloudTestCase(test.TestCase):
                                            user_group=['all'])
         self.assertEqual(True, result['is_public'])
 
+    def test_deregister_image(self):
+        deregister_image = self.cloud.deregister_image
+
+        def fake_delete(self, context, id):
+            return None
+
+        self.stubs.Set(local.LocalImageService, 'delete', fake_delete)
+        # valid image
+        result = deregister_image(self.context, 'ami-00000001')
+        self.assertEqual(result['imageId'], 'ami-00000001')
+        # invalid image
+        self.stubs.UnsetAll()
+
+        def fake_detail_empty(self, context):
+            return []
+
+        self.stubs.Set(local.LocalImageService, 'detail', fake_detail_empty)
+        self.assertRaises(exception.ImageNotFound, deregister_image,
+                          self.context, 'ami-bad001')
+
     def test_console_output(self):
         instance_type = FLAGS.default_instance_type
         max_count = 1
@@ -338,41 +358,6 @@ class CloudTestCase(test.TestCase):
         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_host_filter.py b/nova/tests/test_host_filter.py
index c029d41e6..1a2a86a79 100644
--- a/nova/tests/test_host_filter.py
+++ b/nova/tests/test_host_filter.py
@@ -57,6 +57,7 @@ class HostFilterTestCase(test.TestCase):
                 'host_name-label': 'xs-%s' % multiplier}
 
     def setUp(self):
+        super(HostFilterTestCase, self).setUp()
         self.old_flag = FLAGS.default_host_filter_driver
         FLAGS.default_host_filter_driver = \
                             'nova.scheduler.host_filter.AllHostsFilter'
@@ -77,6 +78,7 @@ class HostFilterTestCase(test.TestCase):
 
     def tearDown(self):
         FLAGS.default_host_filter_driver = self.old_flag
+        super(HostFilterTestCase, self).tearDown()
 
     def test_choose_driver(self):
         # Test default driver ...
@@ -85,9 +87,9 @@ class HostFilterTestCase(test.TestCase):
                         'nova.scheduler.host_filter.AllHostsFilter')
         # Test valid driver ...
         driver = host_filter.choose_driver(
-                        'nova.scheduler.host_filter.FlavorFilter')
+                        'nova.scheduler.host_filter.InstanceTypeFilter')
         self.assertEquals(driver._full_name(),
-                        'nova.scheduler.host_filter.FlavorFilter')
+                        'nova.scheduler.host_filter.InstanceTypeFilter')
         # Test invalid driver ...
         try:
             host_filter.choose_driver('does not exist')
@@ -103,11 +105,12 @@ class HostFilterTestCase(test.TestCase):
         for host, capabilities in hosts:
             self.assertTrue(host.startswith('host'))
 
-    def test_flavor_driver(self):
-        driver = host_filter.FlavorFilter()
+    def test_instance_type_driver(self):
+        driver = host_filter.InstanceTypeFilter()
         # 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)
+        self.assertEquals('nova.scheduler.host_filter.InstanceTypeFilter',
+                          name)
         hosts = driver.filter_hosts(self.zone_manager, cooked)
         self.assertEquals(6, len(hosts))
         just_hosts = [host for host, caps in hosts]
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_least_cost_scheduler.py b/nova/tests/test_least_cost_scheduler.py
index a3a18a09f..b2318a3bf 100644
--- a/nova/tests/test_least_cost_scheduler.py
+++ b/nova/tests/test_least_cost_scheduler.py
@@ -1,7 +1,28 @@
+# 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 Least Cost Scheduler
+"""
+
+from nova import flags
 from nova import test
 from nova.scheduler import least_cost
 
 MB = 1024 * 1024
+FLAGS = flags.FLAGS
+
 
 class FakeHost(object):
     def __init__(self, host_id, free_ram, io):
@@ -9,7 +30,7 @@ class FakeHost(object):
         self.free_ram = free_ram
         self.io = io
 
-class WeightedSumTest(test.TestCase):
+class WeightedSumTestCase(test.TestCase):
     def test_empty_domain(self):
         domain = []
         weighted_fns = []
@@ -37,3 +58,91 @@ class WeightedSumTest(test.TestCase):
         #   cost = 2 * (100/400) = 2 * 0.25 = 0.5
         expected = [1.5, 2.5, 1.5]
         self.assertEqual(expected, costs) 
+
+
+# TODO(sirp): unify this with test_host_filter tests? possibility of sharing
+# test setup code
+class FakeZoneManager:
+    pass
+
+class LeastCostSchedulerTestCase(test.TestCase):
+    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):
+        super(LeastCostSchedulerTestCase, self).setUp()
+        #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)
+
+        zone_manager = FakeZoneManager()
+        states = {}
+        for x in xrange(10):
+            states['host%02d' % (x + 1)] = {'compute': self._host_caps(x)}
+        zone_manager.service_states = states
+
+        self.sched = least_cost.LeastCostScheduler()
+        self.sched.zone_manager = zone_manager
+
+    def tearDown(self):
+        #FLAGS.default_host_filter_driver = self.old_flag
+        super(LeastCostSchedulerTestCase, self).tearDown()
+
+
+    def assertWeights(self, expected, num, request_spec, hosts):
+        weighted = self.sched.weigh_hosts(num, request_spec, hosts)
+        self.assertDictListMatch(weighted, expected)
+
+    def test_no_hosts(self):
+        num = 1
+        request_spec = {}
+        hosts = []
+
+        expected = []
+        self.assertWeights(expected, num, request_spec, hosts)
+
+    def test_noop_cost_fn(self):
+        FLAGS.least_cost_scheduler_cost_functions = [
+            'nova.scheduler.least_cost.noop_cost_fn'
+        ]
+        FLAGS.noop_cost_fn_weight = 1
+
+        num = 1
+        request_spec = {}
+
+        hosts = self.sched.filter_hosts(num, request_spec)
+        
+        expected = [ dict(weight=1, hostname=hostname) for hostname, caps in hosts]
+        self.assertWeights(expected, num, request_spec, hosts)
+
+        FLAGS.noop_cost_fn_weight = 2
+        expected = [ dict(weight=2, hostname=hostname) for hostname, caps in hosts]
+        self.assertWeights(expected, num, request_spec, hosts)
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 1311ba361..d743f94f7 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)
 
diff --git a/nova/tests/test_zone_aware_scheduler.py b/nova/tests/test_zone_aware_scheduler.py
index fdcde34c9..37169fb97 100644
--- a/nova/tests/test_zone_aware_scheduler.py
+++ b/nova/tests/test_zone_aware_scheduler.py
@@ -116,4 +116,6 @@ class ZoneAwareSchedulerTestCase(test.TestCase):
         sched.set_zone_manager(zm)
 
         fake_context = {}
-        self.assertRaises(driver.NoValidHost, sched.schedule, fake_context, {})
+        self.assertRaises(driver.NoValidHost, sched.schedule_run_instance,
+                          fake_context, 1,
+                          dict(host_filter=None, instance_type={}))