Remove deprecated quota code.

This completes blueprint quota-refactor by removing the now-unused
classic quotas code.

This change is fairly substantial.  To make it easier to review, it has been
broken up into 3 parts.  This is the third part.

Change-Id: I8856f84655ef2e6d61b3d1f52190b83a96c87fdb

1 files changed, 2 insertions, 456 deletions

diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 4bb0e8b2e..f17243cdc 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -37,233 +37,7 @@ from nova import volume
 FLAGS = flags.FLAGS
 
 
-class GetQuotaTestCase(test.TestCase):
-    def setUp(self):
-        super(GetQuotaTestCase, self).setUp()
-        self.flags(quota_instances=10,
-                   quota_cores=20,
-                   quota_ram=50 * 1024,
-                   quota_volumes=10,
-                   quota_gigabytes=1000,
-                   quota_floating_ips=10,
-                   quota_security_groups=10,
-                   quota_security_group_rules=20,
-                   quota_key_pairs=10,
-                   quota_metadata_items=128,
-                   quota_injected_files=5,
-                   quota_injected_file_content_bytes=10 * 1024)
-        self.context = context.RequestContext('admin', 'admin', is_admin=True)
-
-    def _stub_class(self):
-        def fake_quota_class_get_all_by_name(context, quota_class):
-            result = dict(class_name=quota_class)
-            if quota_class == 'test_class':
-                result.update(
-                    instances=5,
-                    cores=10,
-                    ram=25 * 1024,
-                    volumes=5,
-                    gigabytes=500,
-                    floating_ips=5,
-                    quota_security_groups=10,
-                    quota_security_group_rules=20,
-                    quota_key_pairs=10,
-                    metadata_items=64,
-                    injected_files=2,
-                    injected_file_content_bytes=5 * 1024,
-                    invalid_quota=100,
-                    )
-            return result
-
-        self.stubs.Set(db, 'quota_class_get_all_by_name',
-                       fake_quota_class_get_all_by_name)
-
-    def _stub_project(self, override=False):
-        def fake_quota_get_all_by_project(context, project_id):
-            result = dict(project_id=project_id)
-            if override:
-                result.update(
-                    instances=2,
-                    cores=5,
-                    ram=12 * 1024,
-                    volumes=2,
-                    gigabytes=250,
-                    floating_ips=2,
-                    security_groups=5,
-                    security_group_rules=10,
-                    key_pairs=5,
-                    metadata_items=32,
-                    injected_files=1,
-                    injected_file_content_bytes=2 * 1024,
-                    invalid_quota=50,
-                    )
-            return result
-
-        self.stubs.Set(db, 'quota_get_all_by_project',
-                       fake_quota_get_all_by_project)
-
-    def test_default_quotas(self):
-        result = quota._get_default_quotas()
-        self.assertEqual(result, dict(
-                instances=10,
-                cores=20,
-                ram=50 * 1024,
-                volumes=10,
-                gigabytes=1000,
-                floating_ips=10,
-                security_groups=10,
-                security_group_rules=20,
-                key_pairs=10,
-                metadata_items=128,
-                injected_files=5,
-                injected_file_content_bytes=10 * 1024,
-                ))
-
-    def test_default_quotas_unlimited(self):
-        self.flags(quota_instances=-1,
-                   quota_cores=-1,
-                   quota_ram=-1,
-                   quota_volumes=-1,
-                   quota_gigabytes=-1,
-                   quota_floating_ips=-1,
-                   quota_security_groups=-1,
-                   quota_security_group_rules=-1,
-                   quota_key_pairs=-1,
-                   quota_metadata_items=-1,
-                   quota_injected_files=-1,
-                   quota_injected_file_content_bytes=-1)
-        result = quota._get_default_quotas()
-        self.assertEqual(result, dict(
-                instances=-1,
-                cores=-1,
-                ram=-1,
-                volumes=-1,
-                gigabytes=-1,
-                floating_ips=-1,
-                security_groups=-1,
-                security_group_rules=-1,
-                key_pairs=-1,
-                metadata_items=-1,
-                injected_files=-1,
-                injected_file_content_bytes=-1,
-                ))
-
-    def test_class_quotas_noclass(self):
-        self._stub_class()
-        result = quota.get_class_quotas(self.context, 'noclass')
-        self.assertEqual(result, dict(
-                instances=10,
-                cores=20,
-                ram=50 * 1024,
-                volumes=10,
-                gigabytes=1000,
-                floating_ips=10,
-                security_groups=10,
-                security_group_rules=20,
-                key_pairs=10,
-                metadata_items=128,
-                injected_files=5,
-                injected_file_content_bytes=10 * 1024,
-                ))
-
-    def test_class_quotas(self):
-        self._stub_class()
-        result = quota.get_class_quotas(self.context, 'test_class')
-        self.assertEqual(result, dict(
-                instances=5,
-                cores=10,
-                ram=25 * 1024,
-                volumes=5,
-                gigabytes=500,
-                floating_ips=5,
-                security_groups=10,
-                security_group_rules=20,
-                key_pairs=10,
-                metadata_items=64,
-                injected_files=2,
-                injected_file_content_bytes=5 * 1024,
-                ))
-
-    def test_project_quotas_defaults_noclass(self):
-        self._stub_class()
-        self._stub_project()
-        result = quota.get_project_quotas(self.context, 'admin')
-        self.assertEqual(result, dict(
-                instances=10,
-                cores=20,
-                ram=50 * 1024,
-                volumes=10,
-                gigabytes=1000,
-                floating_ips=10,
-                security_groups=10,
-                security_group_rules=20,
-                key_pairs=10,
-                metadata_items=128,
-                injected_files=5,
-                injected_file_content_bytes=10 * 1024,
-                ))
-
-    def test_project_quotas_overrides_noclass(self):
-        self._stub_class()
-        self._stub_project(True)
-        result = quota.get_project_quotas(self.context, 'admin')
-        self.assertEqual(result, dict(
-                instances=2,
-                cores=5,
-                ram=12 * 1024,
-                volumes=2,
-                gigabytes=250,
-                floating_ips=2,
-                security_groups=5,
-                security_group_rules=10,
-                key_pairs=5,
-                metadata_items=32,
-                injected_files=1,
-                injected_file_content_bytes=2 * 1024,
-                ))
-
-    def test_project_quotas_defaults_withclass(self):
-        self._stub_class()
-        self._stub_project()
-        self.context.quota_class = 'test_class'
-        result = quota.get_project_quotas(self.context, 'admin')
-        self.assertEqual(result, dict(
-                instances=5,
-                cores=10,
-                ram=25 * 1024,
-                volumes=5,
-                gigabytes=500,
-                floating_ips=5,
-                security_groups=10,
-                security_group_rules=20,
-                key_pairs=10,
-                metadata_items=64,
-                injected_files=2,
-                injected_file_content_bytes=5 * 1024,
-                ))
-
-    def test_project_quotas_overrides_withclass(self):
-        self._stub_class()
-        self._stub_project(True)
-        self.context.quota_class = 'test_class'
-        result = quota.get_project_quotas(self.context, 'admin')
-        self.assertEqual(result, dict(
-                instances=2,
-                cores=5,
-                ram=12 * 1024,
-                volumes=2,
-                gigabytes=250,
-                floating_ips=2,
-                security_groups=5,
-                security_group_rules=10,
-                key_pairs=5,
-                metadata_items=32,
-                injected_files=1,
-                injected_file_content_bytes=2 * 1024,
-                ))
-
-
-class OldQuotaTestCase(test.TestCase):
+class QuotaIntegrationTestCase(test.TestCase):
 
     class StubImageService(object):
 
@@ -271,7 +45,7 @@ class OldQuotaTestCase(test.TestCase):
             return {"properties": {}}
 
     def setUp(self):
-        super(OldQuotaTestCase, self).setUp()
+        super(QuotaIntegrationTestCase, self).setUp()
         self.flags(connection_type='fake',
                    quota_instances=2,
                    quota_cores=4,
@@ -324,178 +98,6 @@ class OldQuotaTestCase(test.TestCase):
         vol['size'] = size
         return db.volume_create(self.context, vol)['id']
 
-    def _get_instance_type(self, name):
-        instance_types = {
-            'm1.tiny': dict(memory_mb=512, vcpus=1, root_gb=0, flavorid=1),
-            'm1.small': dict(memory_mb=2048, vcpus=1, root_gb=20, flavorid=2),
-            'm1.medium':
-                dict(memory_mb=4096, vcpus=2, root_gb=40, flavorid=3),
-            'm1.large': dict(memory_mb=8192, vcpus=4, root_gb=80, flavorid=4),
-            'm1.xlarge':
-                dict(memory_mb=16384, vcpus=8, root_gb=160, flavorid=5),
-            'm1.nocpu': dict(memory_mb=512, vcpus=0, root_gb=0, flavorid=6),
-            'm1.nomem': dict(memory_mb=0, vcpus=1, root_gb=0, flavorid=7)}
-        return instance_types[name]
-
-    def test_quota_no_mem_no_cpu(self):
-        num_instances = quota.allowed_instances(self.context, 100,
-            self._get_instance_type('m1.nocpu'))
-        self.assertEqual(num_instances, 2)
-        num_instances = quota.allowed_instances(self.context, 100,
-            self._get_instance_type('m1.nomem'))
-        self.assertEqual(num_instances, 2)
-
-    def test_quota_overrides(self):
-        """Make sure overriding a projects quotas works"""
-        num_instances = quota.allowed_instances(self.context, 100,
-            self._get_instance_type('m1.small'))
-        self.assertEqual(num_instances, 2)
-        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_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)
-        db.quota_create(self.context, self.project_id, 'ram', 3 * 2048)
-        num_instances = quota.allowed_instances(self.context, 100,
-            self._get_instance_type('m1.small'))
-        self.assertEqual(num_instances, 3)
-
-        # metadata_items
-        too_many_items = FLAGS.quota_metadata_items + 1000
-        num_metadata_items = quota.allowed_metadata_items(self.context,
-                                                          too_many_items)
-        self.assertEqual(num_metadata_items, FLAGS.quota_metadata_items)
-        db.quota_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_all_by_project(self.context, self.project_id)
-
-    def test_unlimited_instances(self):
-        self.flags(quota_instances=2, quota_ram=-1, quota_cores=-1)
-        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', -1)
-        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_ram(self):
-        self.flags(quota_instances=-1, quota_ram=2 * 2048, quota_cores=-1)
-        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, 'ram', -1)
-        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):
-        self.flags(quota_instances=-1, quota_ram=-1, 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', -1)
-        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):
-        self.flags(quota_volumes=10, quota_gigabytes=-1)
-        volumes = quota.allowed_volumes(self.context, 100, 1)
-        self.assertEqual(volumes, 10)
-        db.quota_create(self.context, self.project_id, 'volumes', -1)
-        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):
-        self.flags(quota_volumes=-1, quota_gigabytes=10)
-        volumes = quota.allowed_volumes(self.context, 100, 1)
-        self.assertEqual(volumes, 10)
-        db.quota_create(self.context, self.project_id, 'gigabytes', -1)
-        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):
-        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', -1)
-        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_security_groups(self):
-        self.flags(quota_security_groups=10)
-        security_groups = quota.allowed_security_groups(self.context, 100)
-        self.assertEqual(security_groups, 10)
-        db.quota_create(self.context, self.project_id, 'security_groups', -1)
-        security_groups = quota.allowed_security_groups(self.context, 100)
-        self.assertEqual(security_groups, 100)
-        security_groups = quota.allowed_security_groups(self.context, 101)
-        self.assertEqual(security_groups, 101)
-
-    def test_unlimited_key_pairs(self):
-        self.flags(quota_key_pairs=10)
-        key_pairs = quota.allowed_key_pairs(self.context, 100)
-        self.assertEqual(key_pairs, 10)
-        db.quota_create(self.context, self.project_id, 'key_pairs', -1)
-        key_pairs = quota.allowed_key_pairs(self.context, 100)
-        self.assertEqual(key_pairs, 100)
-        key_pairs = quota.allowed_key_pairs(self.context, 101)
-        self.assertEqual(key_pairs, 101)
-
-    def test_unlimited_security_group_rules(self):
-
-        def fake_security_group_rule_count_by_group(context, sec_group_id):
-            return 0
-
-        self.stubs.Set(db, 'security_group_rule_count_by_group',
-                       fake_security_group_rule_count_by_group)
-
-        self.flags(quota_security_group_rules=20)
-        rules = quota.allowed_security_group_rules(self.context, 1234, 100)
-        self.assertEqual(rules, 20)
-        db.quota_create(self.context, self.project_id, 'security_group_rules',
-                        -1)
-        rules = quota.allowed_security_group_rules(self.context, 1234, 100)
-        self.assertEqual(rules, 100)
-        rules = quota.allowed_security_group_rules(self.context, 1234, 101)
-        self.assertEqual(rules, 101)
-
-    def test_unlimited_metadata_items(self):
-        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', -1)
-        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 = []
         for i in range(FLAGS.quota_instances):
@@ -573,48 +175,6 @@ class OldQuotaTestCase(test.TestCase):
                                             image_href=image_uuid,
                                             metadata=metadata)
 
-    def test_default_allowed_injected_files(self):
-        self.flags(quota_injected_files=55)
-        self.assertEqual(quota.allowed_injected_files(self.context, 100), 55)
-
-    def test_overridden_allowed_injected_files(self):
-        self.flags(quota_injected_files=5)
-        db.quota_create(self.context, self.project_id, 'injected_files', 77)
-        self.assertEqual(quota.allowed_injected_files(self.context, 100), 77)
-
-    def test_unlimited_default_allowed_injected_files(self):
-        self.flags(quota_injected_files=-1)
-        self.assertEqual(quota.allowed_injected_files(self.context, 100), 100)
-
-    def test_unlimited_db_allowed_injected_files(self):
-        self.flags(quota_injected_files=5)
-        db.quota_create(self.context, self.project_id, 'injected_files', -1)
-        self.assertEqual(quota.allowed_injected_files(self.context, 100), 100)
-
-    def test_default_allowed_injected_file_content_bytes(self):
-        self.flags(quota_injected_file_content_bytes=12345)
-        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
-        self.assertEqual(limit, 12345)
-
-    def test_overridden_allowed_injected_file_content_bytes(self):
-        self.flags(quota_injected_file_content_bytes=12345)
-        db.quota_create(self.context, self.project_id,
-                        'injected_file_content_bytes', 5678)
-        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
-        self.assertEqual(limit, 5678)
-
-    def test_unlimited_default_allowed_injected_file_content_bytes(self):
-        self.flags(quota_injected_file_content_bytes=-1)
-        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
-        self.assertEqual(limit, 23456)
-
-    def test_unlimited_db_allowed_injected_file_content_bytes(self):
-        self.flags(quota_injected_file_content_bytes=12345)
-        db.quota_create(self.context, self.project_id,
-                        'injected_file_content_bytes', -1)
-        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
-        self.assertEqual(limit, 23456)
-
     def _create_with_injected_files(self, files):
         self.flags(image_service='nova.image.fake.FakeImageService')
         api = compute.API(image_service=self.StubImageService())
@@ -659,11 +219,6 @@ class OldQuotaTestCase(test.TestCase):
         self.assertRaises(exception.QuotaError,
                           self._create_with_injected_files, files)
 
-    def test_allowed_injected_file_path_bytes(self):
-        self.assertEqual(
-                quota.allowed_injected_file_path_bytes(self.context),
-                FLAGS.quota_injected_file_path_bytes)
-
     def test_max_injected_file_path_bytes(self):
         max = FLAGS.quota_injected_file_path_bytes
         path = ''.join(['a' for i in xrange(max)])
@@ -677,15 +232,6 @@ class OldQuotaTestCase(test.TestCase):
         self.assertRaises(exception.QuotaError,
                           self._create_with_injected_files, files)
 
-    def test_quota_class_unlimited(self):
-        self.flags(quota_floating_ips=10)
-        items = quota.allowed_floating_ips(self.context, 10)
-        self.assertEqual(items, 10)
-        self.context.quota_class = 'foo'
-        db.quota_class_create(self.context, 'foo', 'floating_ips', -1)
-        items = quota.allowed_floating_ips(self.context, 100)
-        self.assertEqual(items, 100)
-
 
 class FakeContext(object):
     def __init__(self, project_id, quota_class):