Merge "Assert quota related API behavior when noop"

Author: Zuul

nova/conf/quota.py

@@ -181,6 +181,8 @@
              'on-demand.'),
             ('nova.quota.NoopQuotaDriver', 'Ignores quota and treats all '
              'resources as unlimited.'),
+            ('nova.quota.UnifiedLimitsDriver', 'Do not use. Still being '
+             'developed.')
         ],
         help="""
 Provides abstraction for quota checks. Users can configure a specific

nova/quota.py

@@ -882,13 +882,23 @@ def __init__(self, quota_driver=None, resources=None):
         }
         # NOTE(mriedem): quota_driver is ever only supplied in tests with a
         # fake driver.
-        self.__driver = quota_driver
+        self.__driver_override = quota_driver
+        self.__driver = None
+        self.__driver_name = None
 
     @property
     def _driver(self):
-        if self.__driver:
-            return self.__driver
-        self.__driver = importutils.import_object(CONF.quota.driver)
+        if self.__driver_override:
+            return self.__driver_override
+
+        # NOTE(johngarbutt) to allow unit tests to change the driver by
+        # simply overriding config, double check if we have the correct
+        # driver cached before we return the currently cached driver
+        driver_name_in_config = CONF.quota.driver
+        if self.__driver_name != driver_name_in_config:
+            self.__driver = importutils.import_object(driver_name_in_config)
+            self.__driver_name = driver_name_in_config
+
         return self.__driver
 
     def get_defaults(self, context):

nova/tests/unit/api/openstack/compute/test_limits.py

@@ -477,3 +477,75 @@ def test_index_additional_query_param(self):
         self.assertRaises(
             exception.ValidationError,
             self.controller.index, req=req)
+
+
+class NoopLimitsControllerTest(test.NoDBTestCase):
+    quota_driver = "nova.quota.NoopQuotaDriver"
+
+    def setUp(self):
+        super(NoopLimitsControllerTest, self).setUp()
+        self.flags(driver=self.quota_driver, group="quota")
+        self.controller = limits_v21.LimitsController()
+        # remove policy checks
+        patcher = self.mock_can = mock.patch('nova.context.RequestContext.can')
+        self.mock_can = patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_index_v21(self):
+        req = fakes.HTTPRequest.blank("/")
+        response = self.controller.index(req)
+        expected_response = {
+            "limits": {
+                "rate": [],
+                "absolute": {
+                    'maxImageMeta': -1,
+                    'maxPersonality': -1,
+                    'maxPersonalitySize': -1,
+                    'maxSecurityGroupRules': -1,
+                    'maxSecurityGroups': -1,
+                    'maxServerGroupMembers': -1,
+                    'maxServerGroups': -1,
+                    'maxServerMeta': -1,
+                    'maxTotalCores': -1,
+                    'maxTotalFloatingIps': -1,
+                    'maxTotalInstances': -1,
+                    'maxTotalKeypairs': -1,
+                    'maxTotalRAMSize': -1,
+                    'totalCoresUsed': -1,
+                    'totalFloatingIpsUsed': -1,
+                    'totalInstancesUsed': -1,
+                    'totalRAMUsed': -1,
+                    'totalSecurityGroupsUsed': -1,
+                    'totalServerGroupsUsed': -1,
+                },
+            },
+        }
+        self.assertEqual(expected_response, response)
+
+    def test_index_v275(self):
+        req = fakes.HTTPRequest.blank("/?tenant_id=faketenant",
+                                      version='2.75')
+        response = self.controller.index(req)
+        expected_response = {
+            "limits": {
+                "rate": [],
+                "absolute": {
+                    'maxServerGroupMembers': -1,
+                    'maxServerGroups': -1,
+                    'maxServerMeta': -1,
+                    'maxTotalCores': -1,
+                    'maxTotalInstances': -1,
+                    'maxTotalKeypairs': -1,
+                    'maxTotalRAMSize': -1,
+                    'totalCoresUsed': -1,
+                    'totalInstancesUsed': -1,
+                    'totalRAMUsed': -1,
+                    'totalServerGroupsUsed': -1,
+                },
+            },
+        }
+        self.assertEqual(expected_response, response)
+
+
+class UnifiedLimitsControllerTest(NoopLimitsControllerTest):
+    quota_driver = "nova.quota.UnifiedLimitsDriver"

nova/tests/unit/api/openstack/compute/test_quota_classes.py

@@ -13,11 +13,13 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 import copy
+import mock
 import webob
 
 from nova.api.openstack.compute import quota_classes \
        as quota_classes_v21
 from nova import exception
+from nova import objects
 from nova import test
 from nova.tests.unit.api.openstack import fakes
 
@@ -156,3 +158,107 @@ def setUp(self):
         for resource in quota_classes_v21.FILTERED_QUOTAS_2_57:
             self.quota_resources.pop(resource, None)
         self.filtered_quotas.extend(quota_classes_v21.FILTERED_QUOTAS_2_57)
+
+
+class NoopQuotaClassesTest(test.NoDBTestCase):
+    quota_driver = "nova.quota.NoopQuotaDriver"
+
+    def setUp(self):
+        super(NoopQuotaClassesTest, self).setUp()
+        self.flags(driver=self.quota_driver, group="quota")
+        self.controller = quota_classes_v21.QuotaClassSetsController()
+
+    def test_show_v21(self):
+        req = fakes.HTTPRequest.blank("")
+        response = self.controller.show(req, "test_class")
+        expected_response = {
+            'quota_class_set': {
+                'id': 'test_class',
+                'cores': -1,
+                'fixed_ips': -1,
+                'floating_ips': -1,
+                'injected_file_content_bytes': -1,
+                'injected_file_path_bytes': -1,
+                'injected_files': -1,
+                'instances': -1,
+                'key_pairs': -1,
+                'metadata_items': -1,
+                'ram': -1,
+                'security_group_rules': -1,
+                'security_groups': -1
+            }
+        }
+        self.assertEqual(expected_response, response)
+
+    def test_show_v257(self):
+        req = fakes.HTTPRequest.blank("", version='2.57')
+        response = self.controller.show(req, "default")
+        expected_response = {
+            'quota_class_set': {
+                'id': 'default',
+                'cores': -1,
+                'instances': -1,
+                'key_pairs': -1,
+                'metadata_items': -1,
+                'ram': -1,
+                'server_group_members': -1,
+                'server_groups': -1,
+            }
+        }
+        self.assertEqual(expected_response, response)
+
+    def test_update_v21_still_rejects_badrequests(self):
+        req = fakes.HTTPRequest.blank("")
+        body = {'quota_class_set': {'instances': 50, 'cores': 50,
+                                    'ram': 51200, 'unsupported': 12}}
+        self.assertRaises(exception.ValidationError, self.controller.update,
+                          req, 'test_class', body=body)
+
+    @mock.patch.object(objects.Quotas, "update_class")
+    def test_update_v21(self, mock_update):
+        req = fakes.HTTPRequest.blank("")
+        body = {'quota_class_set': {'ram': 51200}}
+        response = self.controller.update(req, 'default', body=body)
+        expected_response = {
+            'quota_class_set': {
+                'cores': -1,
+                'fixed_ips': -1,
+                'floating_ips': -1,
+                'injected_file_content_bytes': -1,
+                'injected_file_path_bytes': -1,
+                'injected_files': -1,
+                'instances': -1,
+                'key_pairs': -1,
+                'metadata_items': -1,
+                'ram': -1,
+                'security_group_rules': -1,
+                'security_groups': -1
+            }
+        }
+        self.assertEqual(expected_response, response)
+        mock_update.assert_called_once_with(req.environ['nova.context'],
+                                            "default", "ram", 51200)
+
+    @mock.patch.object(objects.Quotas, "update_class")
+    def test_update_v257(self, mock_update):
+        req = fakes.HTTPRequest.blank("", version='2.57')
+        body = {'quota_class_set': {'ram': 51200}}
+        response = self.controller.update(req, 'default', body=body)
+        expected_response = {
+            'quota_class_set': {
+                'cores': -1,
+                'instances': -1,
+                'key_pairs': -1,
+                'metadata_items': -1,
+                'ram': -1,
+                'server_group_members': -1,
+                'server_groups': -1,
+            }
+        }
+        self.assertEqual(expected_response, response)
+        mock_update.assert_called_once_with(req.environ['nova.context'],
+                                            "default", "ram", 51200)
+
+
+class UnifiedLimitsQuotaClassesTest(NoopQuotaClassesTest):
+    quota_driver = "nova.quota.UnifiedLimitsDriver"