← Back to branch summary

~ttx/nova/d4-merge

« back to all changes in this revision

Viewing changes to nova/tests/test_quota.py

  • Committer: Thierry Carrez
  • Date: 2011-08-23 12:23:07 UTC
  • mfrom: (1130.75.258 nova)
  • Revision ID: thierry@openstack.org-20110823122307-f0vtuyg1ikc14n87
Merge diablo-4 development from trunk (rev1479)

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_quota.py
20
20
from nova import context
21
21
from nova import db
22
22
from nova import flags
23
 
from nova import network
24
23
from nova import quota
25
24
from nova import test
26
 
from nova import utils
27
25
from nova import volume
28
 
from nova.auth import manager
29
26
from nova.compute import instance_types
30
27
 
31
28
 
48
45
                   quota_gigabytes=20,
49
46
                   quota_floating_ips=1)
50
47
 
51
 
        self.manager = manager.AuthManager()
52
 
        self.user = self.manager.create_user('admin', 'admin', 'admin', True)
53
 
        self.project = self.manager.create_project('admin', 'admin', 'admin')
54
48
        self.network = self.network = self.start_service('network')
55
 
        self.context = context.RequestContext(project=self.project,
56
 
                                              user=self.user)
57
 
 
58
 
    def tearDown(self):
59
 
        manager.AuthManager().delete_project(self.project)
60
 
        manager.AuthManager().delete_user(self.user)
61
 
        super(QuotaTestCase, self).tearDown()
 
49
        self.user_id = 'admin'
 
50
        self.project_id = 'admin'
 
51
        self.context = context.RequestContext(self.user_id,
 
52
                                              self.project_id,
 
53
                                              True)
62
54
 
63
55
    def _create_instance(self, cores=2):
64
56
        """Create a test instance"""
65
57
        inst = {}
66
58
        inst['image_id'] = 1
67
59
        inst['reservation_id'] = 'r-fakeres'
68
 
        inst['user_id'] = self.user.id
69
 
        inst['project_id'] = self.project.id
 
60
        inst['user_id'] = self.user_id
 
61
        inst['project_id'] = self.project_id
70
62
        inst['instance_type_id'] = '3'  # m1.large
71
63
        inst['vcpus'] = cores
72
64
        return db.instance_create(self.context, inst)['id']
74
66
    def _create_volume(self, size=10):
75
67
        """Create a test volume"""
76
68
        vol = {}
77
 
        vol['user_id'] = self.user.id
78
 
        vol['project_id'] = self.project.id
 
69
        vol['user_id'] = self.user_id
 
70
        vol['project_id'] = self.project_id
79
71
        vol['size'] = size
80
72
        return db.volume_create(self.context, vol)['id']
81
73
 
95
87
        num_instances = quota.allowed_instances(self.context, 100,
96
88
            self._get_instance_type('m1.small'))
97
89
        self.assertEqual(num_instances, 2)
98
 
        db.quota_create(self.context, self.project.id, 'instances', 10)
 
90
        db.quota_create(self.context, self.project_id, 'instances', 10)
99
91
        num_instances = quota.allowed_instances(self.context, 100,
100
92
            self._get_instance_type('m1.small'))
101
93
        self.assertEqual(num_instances, 4)
102
 
        db.quota_create(self.context, self.project.id, 'cores', 100)
 
94
        db.quota_create(self.context, self.project_id, 'cores', 100)
103
95
        num_instances = quota.allowed_instances(self.context, 100,
104
96
            self._get_instance_type('m1.small'))
105
97
        self.assertEqual(num_instances, 10)
106
 
        db.quota_create(self.context, self.project.id, 'ram', 3 * 2048)
 
98
        db.quota_create(self.context, self.project_id, 'ram', 3 * 2048)
107
99
        num_instances = quota.allowed_instances(self.context, 100,
108
100
            self._get_instance_type('m1.small'))
109
101
        self.assertEqual(num_instances, 3)
113
105
        num_metadata_items = quota.allowed_metadata_items(self.context,
114
106
                                                          too_many_items)
115
107
        self.assertEqual(num_metadata_items, FLAGS.quota_metadata_items)
116
 
        db.quota_create(self.context, self.project.id, 'metadata_items', 5)
 
108
        db.quota_create(self.context, self.project_id, 'metadata_items', 5)
117
109
        num_metadata_items = quota.allowed_metadata_items(self.context,
118
110
                                                          too_many_items)
119
111
        self.assertEqual(num_metadata_items, 5)
120
112
 
121
113
        # Cleanup
122
 
        db.quota_destroy_all_by_project(self.context, self.project.id)
 
114
        db.quota_destroy_all_by_project(self.context, self.project_id)
123
115
 
124
116
    def test_unlimited_instances(self):
125
 
        FLAGS.quota_instances = 2
126
 
        FLAGS.quota_ram = -1
127
 
        FLAGS.quota_cores = -1
 
117
        self.flags(quota_instances=2, quota_ram=-1, quota_cores=-1)
128
118
        instance_type = self._get_instance_type('m1.small')
129
119
        num_instances = quota.allowed_instances(self.context, 100,
130
120
                                                instance_type)
131
121
        self.assertEqual(num_instances, 2)
132
 
        db.quota_create(self.context, self.project.id, 'instances', None)
 
122
        db.quota_create(self.context, self.project_id, 'instances', None)
133
123
        num_instances = quota.allowed_instances(self.context, 100,
134
124
                                                instance_type)
135
125
        self.assertEqual(num_instances, 100)
138
128
        self.assertEqual(num_instances, 101)
139
129
 
140
130
    def test_unlimited_ram(self):
141
 
        FLAGS.quota_instances = -1
142
 
        FLAGS.quota_ram = 2 * 2048
143
 
        FLAGS.quota_cores = -1
 
131
        self.flags(quota_instances=-1, quota_ram=2 * 2048, quota_cores=-1)
144
132
        instance_type = self._get_instance_type('m1.small')
145
133
        num_instances = quota.allowed_instances(self.context, 100,
146
134
                                                instance_type)
147
135
        self.assertEqual(num_instances, 2)
148
 
        db.quota_create(self.context, self.project.id, 'ram', None)
 
136
        db.quota_create(self.context, self.project_id, 'ram', None)
149
137
        num_instances = quota.allowed_instances(self.context, 100,
150
138
                                                instance_type)
151
139
        self.assertEqual(num_instances, 100)
154
142
        self.assertEqual(num_instances, 101)
155
143
 
156
144
    def test_unlimited_cores(self):
157
 
        FLAGS.quota_instances = -1
158
 
        FLAGS.quota_ram = -1
159
 
        FLAGS.quota_cores = 2
 
145
        self.flags(quota_instances=-1, quota_ram=-1, quota_cores=2)
160
146
        instance_type = self._get_instance_type('m1.small')
161
147
        num_instances = quota.allowed_instances(self.context, 100,
162
148
                                                instance_type)
163
149
        self.assertEqual(num_instances, 2)
164
 
        db.quota_create(self.context, self.project.id, 'cores', None)
 
150
        db.quota_create(self.context, self.project_id, 'cores', None)
165
151
        num_instances = quota.allowed_instances(self.context, 100,
166
152
                                                instance_type)
167
153
        self.assertEqual(num_instances, 100)
170
156
        self.assertEqual(num_instances, 101)
171
157
 
172
158
    def test_unlimited_volumes(self):
173
 
        FLAGS.quota_volumes = 10
174
 
        FLAGS.quota_gigabytes = -1
 
159
        self.flags(quota_volumes=10, quota_gigabytes=-1)
175
160
        volumes = quota.allowed_volumes(self.context, 100, 1)
176
161
        self.assertEqual(volumes, 10)
177
 
        db.quota_create(self.context, self.project.id, 'volumes', None)
 
162
        db.quota_create(self.context, self.project_id, 'volumes', None)
178
163
        volumes = quota.allowed_volumes(self.context, 100, 1)
179
164
        self.assertEqual(volumes, 100)
180
165
        volumes = quota.allowed_volumes(self.context, 101, 1)
181
166
        self.assertEqual(volumes, 101)
182
167
 
183
168
    def test_unlimited_gigabytes(self):
184
 
        FLAGS.quota_volumes = -1
185
 
        FLAGS.quota_gigabytes = 10
 
169
        self.flags(quota_volumes=-1, quota_gigabytes=10)
186
170
        volumes = quota.allowed_volumes(self.context, 100, 1)
187
171
        self.assertEqual(volumes, 10)
188
 
        db.quota_create(self.context, self.project.id, 'gigabytes', None)
 
172
        db.quota_create(self.context, self.project_id, 'gigabytes', None)
189
173
        volumes = quota.allowed_volumes(self.context, 100, 1)
190
174
        self.assertEqual(volumes, 100)
191
175
        volumes = quota.allowed_volumes(self.context, 101, 1)
192
176
        self.assertEqual(volumes, 101)
193
177
 
194
178
    def test_unlimited_floating_ips(self):
195
 
        FLAGS.quota_floating_ips = 10
 
179
        self.flags(quota_floating_ips=10)
196
180
        floating_ips = quota.allowed_floating_ips(self.context, 100)
197
181
        self.assertEqual(floating_ips, 10)
198
 
        db.quota_create(self.context, self.project.id, 'floating_ips', None)
 
182
        db.quota_create(self.context, self.project_id, 'floating_ips', None)
199
183
        floating_ips = quota.allowed_floating_ips(self.context, 100)
200
184
        self.assertEqual(floating_ips, 100)
201
185
        floating_ips = quota.allowed_floating_ips(self.context, 101)
202
186
        self.assertEqual(floating_ips, 101)
203
187
 
204
188
    def test_unlimited_metadata_items(self):
205
 
        FLAGS.quota_metadata_items = 10
 
189
        self.flags(quota_metadata_items=10)
206
190
        items = quota.allowed_metadata_items(self.context, 100)
207
191
        self.assertEqual(items, 10)
208
 
        db.quota_create(self.context, self.project.id, 'metadata_items', None)
 
192
        db.quota_create(self.context, self.project_id, 'metadata_items', None)
209
193
        items = quota.allowed_metadata_items(self.context, 100)
210
194
        self.assertEqual(items, 100)
211
195
        items = quota.allowed_metadata_items(self.context, 101)
273
257
        address = '192.168.0.100'
274
258
        db.floating_ip_create(context.get_admin_context(),
275
259
                              {'address': address,
276
 
                               'project_id': self.project.id})
 
260
                               'project_id': self.project_id})
277
261
        self.assertRaises(quota.QuotaError,
278
262
                          self.network.allocate_floating_ip,
279
263
                          self.context,
280
 
                          self.project.id)
 
264
                          self.project_id)
281
265
        db.floating_ip_destroy(context.get_admin_context(), address)
282
266
 
283
267
    def test_too_many_metadata_items(self):
294
278
                                            metadata=metadata)
295
279
 
296
280
    def test_default_allowed_injected_files(self):
297
 
        FLAGS.quota_max_injected_files = 55
 
281
        self.flags(quota_max_injected_files=55)
298
282
        self.assertEqual(quota.allowed_injected_files(self.context, 100), 55)
299
283
 
300
284
    def test_overridden_allowed_injected_files(self):
301
 
        FLAGS.quota_max_injected_files = 5
302
 
        db.quota_create(self.context, self.project.id, 'injected_files', 77)
 
285
        self.flags(quota_max_injected_files=5)
 
286
        db.quota_create(self.context, self.project_id, 'injected_files', 77)
303
287
        self.assertEqual(quota.allowed_injected_files(self.context, 100), 77)
304
288
 
305
289
    def test_unlimited_default_allowed_injected_files(self):
306
 
        FLAGS.quota_max_injected_files = -1
 
290
        self.flags(quota_max_injected_files=-1)
307
291
        self.assertEqual(quota.allowed_injected_files(self.context, 100), 100)
308
292
 
309
293
    def test_unlimited_db_allowed_injected_files(self):
310
 
        FLAGS.quota_max_injected_files = 5
311
 
        db.quota_create(self.context, self.project.id, 'injected_files', None)
 
294
        self.flags(quota_max_injected_files=5)
 
295
        db.quota_create(self.context, self.project_id, 'injected_files', None)
312
296
        self.assertEqual(quota.allowed_injected_files(self.context, 100), 100)
313
297
 
314
298
    def test_default_allowed_injected_file_content_bytes(self):
315
 
        FLAGS.quota_max_injected_file_content_bytes = 12345
 
299
        self.flags(quota_max_injected_file_content_bytes=12345)
316
300
        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
317
301
        self.assertEqual(limit, 12345)
318
302
 
319
303
    def test_overridden_allowed_injected_file_content_bytes(self):
320
 
        FLAGS.quota_max_injected_file_content_bytes = 12345
321
 
        db.quota_create(self.context, self.project.id,
 
304
        self.flags(quota_max_injected_file_content_bytes=12345)
 
305
        db.quota_create(self.context, self.project_id,
322
306
                        'injected_file_content_bytes', 5678)
323
307
        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
324
308
        self.assertEqual(limit, 5678)
325
309
 
326
310
    def test_unlimited_default_allowed_injected_file_content_bytes(self):
327
 
        FLAGS.quota_max_injected_file_content_bytes = -1
 
311
        self.flags(quota_max_injected_file_content_bytes=-1)
328
312
        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
329
313
        self.assertEqual(limit, 23456)
330
314
 
331
315
    def test_unlimited_db_allowed_injected_file_content_bytes(self):
332
 
        FLAGS.quota_max_injected_file_content_bytes = 12345
333
 
        db.quota_create(self.context, self.project.id,
 
316
        self.flags(quota_max_injected_file_content_bytes=12345)
 
317
        db.quota_create(self.context, self.project_id,
334
318
                        'injected_file_content_bytes', None)
335
319
        limit = quota.allowed_injected_file_content_bytes(self.context, 23456)
336
320
        self.assertEqual(limit, 23456)
337
321
 
338
322
    def _create_with_injected_files(self, files):
339
 
        FLAGS.image_service = 'nova.image.fake.FakeImageService'
 
323
        self.flags(image_service='nova.image.fake.FakeImageService')
340
324
        api = compute.API(image_service=self.StubImageService())
341
325
        inst_type = instance_types.get_instance_type_by_name('m1.small')
342
326
        api.create(self.context, min_count=1, max_count=1,
344
328
                injected_files=files)
345
329
 
346
330
    def test_no_injected_files(self):
347
 
        FLAGS.image_service = 'nova.image.fake.FakeImageService'
 
331
        self.flags(image_service='nova.image.fake.FakeImageService')
348
332
        api = compute.API(image_service=self.StubImageService())
349
333
        inst_type = instance_types.get_instance_type_by_name('m1.small')
350
334
        api.create(self.context, instance_type=inst_type, image_href='3')