← Back to branch summary

~ubuntu-branches/ubuntu/utopic/cinder/utopic

« back to all changes in this revision

Viewing changes to cinder/tests/api/v1/test_volume_metadata.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, James Page, Adam Gandelman, Chuck Short
  • Date: 2013-09-08 21:09:46 UTC
  • mfrom: (1.1.18)
  • Revision ID: package-import@ubuntu.com-20130908210946-3dbzq1jy5uji4wad
Tags: 1:2013.2~b3-0ubuntu1
https://launchpad.net/bugs/1190791
[ James Page ]
* d/control: Switch ceph-common -> python-ceph inline with upstream
  refactoring of Ceph RBD driver, move to Suggests of python-cinder.
  (LP: #1190791). 

[ Adam Gandelman ]
* debian/patches/avoid_paramiko_vers_depends.patch: Dropped, no longer
  required.
* Add minimum requirement python-greenlet (>= 0.3.2).
* Add minimum requirement python-eventlet (>= 0.12.0).
* Add minimum requirement python-paramiko (>= 1.8).

[ Chuck Short ]
* New upstream release.
* debian/patches/skip-sqlachemy-failures.patch: Skip testfailures
  with sqlalchemy 0.8 until they are fixed upstream.
* debian/control: Add python-babel to build-depends.
* debian/control: Add python-novaclient to build-depends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cinder/tests/api/v1/test_volume_metadata.py
106
106
        self.ext_mgr.extensions = {}
107
107
        self.volume_controller = volumes.VolumeController(self.ext_mgr)
108
108
        self.controller = volume_metadata.Controller()
109
 
        self.id = str(uuid.uuid4())
110
 
        self.url = '/v1/fake/volumes/%s/metadata' % self.id
 
109
        self.req_id = str(uuid.uuid4())
 
110
        self.url = '/v1/fake/volumes/%s/metadata' % self.req_id
111
111
 
112
112
        vol = {"size": 100,
113
113
               "display_name": "Volume Test Name",
120
120
 
121
121
    def test_index(self):
122
122
        req = fakes.HTTPRequest.blank(self.url)
123
 
        res_dict = self.controller.index(req, self.id)
 
123
        res_dict = self.controller.index(req, self.req_id)
124
124
 
125
125
        expected = {
126
126
            'metadata': {
142
142
        self.stubs.Set(cinder.db, 'volume_metadata_get',
143
143
                       return_empty_volume_metadata)
144
144
        req = fakes.HTTPRequest.blank(self.url)
145
 
        res_dict = self.controller.index(req, self.id)
 
145
        res_dict = self.controller.index(req, self.req_id)
146
146
        expected = {'metadata': {}}
147
147
        self.assertEqual(expected, res_dict)
148
148
 
149
149
    def test_show(self):
150
150
        req = fakes.HTTPRequest.blank(self.url + '/key2')
151
 
        res_dict = self.controller.show(req, self.id, 'key2')
 
151
        res_dict = self.controller.show(req, self.req_id, 'key2')
152
152
        expected = {'meta': {'key2': 'value2'}}
153
153
        self.assertEqual(expected, res_dict)
154
154
 
157
157
                       return_volume_nonexistent)
158
158
        req = fakes.HTTPRequest.blank(self.url + '/key2')
159
159
        self.assertRaises(webob.exc.HTTPNotFound,
160
 
                          self.controller.show, req, self.id, 'key2')
 
160
                          self.controller.show, req, self.req_id, 'key2')
161
161
 
162
162
    def test_show_meta_not_found(self):
163
163
        self.stubs.Set(cinder.db, 'volume_metadata_get',
164
164
                       return_empty_volume_metadata)
165
165
        req = fakes.HTTPRequest.blank(self.url + '/key6')
166
166
        self.assertRaises(webob.exc.HTTPNotFound,
167
 
                          self.controller.show, req, self.id, 'key6')
 
167
                          self.controller.show, req, self.req_id, 'key6')
168
168
 
169
169
    def test_delete(self):
170
170
        self.stubs.Set(cinder.db, 'volume_metadata_get',
173
173
                       delete_volume_metadata)
174
174
        req = fakes.HTTPRequest.blank(self.url + '/key2')
175
175
        req.method = 'DELETE'
176
 
        res = self.controller.delete(req, self.id, 'key2')
 
176
        res = self.controller.delete(req, self.req_id, 'key2')
177
177
 
178
178
        self.assertEqual(200, res.status_int)
179
179
 
183
183
        req = fakes.HTTPRequest.blank(self.url + '/key1')
184
184
        req.method = 'DELETE'
185
185
        self.assertRaises(webob.exc.HTTPNotFound,
186
 
                          self.controller.delete, req, self.id, 'key1')
 
186
                          self.controller.delete, req, self.req_id, 'key1')
187
187
 
188
188
    def test_delete_meta_not_found(self):
189
189
        self.stubs.Set(cinder.db, 'volume_metadata_get',
191
191
        req = fakes.HTTPRequest.blank(self.url + '/key6')
192
192
        req.method = 'DELETE'
193
193
        self.assertRaises(webob.exc.HTTPNotFound,
194
 
                          self.controller.delete, req, self.id, 'key6')
 
194
                          self.controller.delete, req, self.req_id, 'key6')
195
195
 
196
196
    def test_create(self):
197
197
        self.stubs.Set(cinder.db, 'volume_metadata_get',
204
204
        req.content_type = "application/json"
205
205
        body = {"metadata": {"key9": "value9"}}
206
206
        req.body = jsonutils.dumps(body)
207
 
        res_dict = self.controller.create(req, self.id, body)
 
207
        res_dict = self.controller.create(req, self.req_id, body)
208
208
        self.assertEqual(body, res_dict)
209
209
 
210
210
    def test_create_empty_body(self):
215
215
        req.headers["content-type"] = "application/json"
216
216
 
217
217
        self.assertRaises(webob.exc.HTTPBadRequest,
218
 
                          self.controller.create, req, self.id, None)
 
218
                          self.controller.create, req, self.req_id, None)
219
219
 
220
220
    def test_create_item_empty_key(self):
221
221
        self.stubs.Set(cinder.db, 'volume_metadata_update',
227
227
        req.headers["content-type"] = "application/json"
228
228
 
229
229
        self.assertRaises(webob.exc.HTTPBadRequest,
230
 
                          self.controller.create, req, self.id, body)
 
230
                          self.controller.create, req, self.req_id, body)
231
231
 
232
232
    def test_create_item_key_too_long(self):
233
233
        self.stubs.Set(cinder.db, 'volume_metadata_update',
240
240
 
241
241
        self.assertRaises(webob.exc.HTTPBadRequest,
242
242
                          self.controller.create,
243
 
                          req, self.id, body)
 
243
                          req, self.req_id, body)
244
244
 
245
245
    def test_create_nonexistent_volume(self):
246
246
        self.stubs.Set(cinder.db, 'volume_get',
256
256
        body = {"metadata": {"key9": "value9"}}
257
257
        req.body = jsonutils.dumps(body)
258
258
        self.assertRaises(webob.exc.HTTPNotFound,
259
 
                          self.controller.create, req, self.id, body)
 
259
                          self.controller.create, req, self.req_id, body)
260
260
 
261
261
    def test_update_all(self):
262
262
        self.stubs.Set(cinder.db, 'volume_metadata_update',
271
271
            },
272
272
        }
273
273
        req.body = jsonutils.dumps(expected)
274
 
        res_dict = self.controller.update_all(req, self.id, expected)
 
274
        res_dict = self.controller.update_all(req, self.req_id, expected)
275
275
 
276
276
        self.assertEqual(expected, res_dict)
277
277
 
283
283
        req.content_type = "application/json"
284
284
        expected = {'metadata': {}}
285
285
        req.body = jsonutils.dumps(expected)
286
 
        res_dict = self.controller.update_all(req, self.id, expected)
 
286
        res_dict = self.controller.update_all(req, self.req_id, expected)
287
287
 
288
288
        self.assertEqual(expected, res_dict)
289
289
 
297
297
        req.body = jsonutils.dumps(expected)
298
298
 
299
299
        self.assertRaises(webob.exc.HTTPBadRequest,
300
 
                          self.controller.update_all, req, self.id, expected)
 
300
                          self.controller.update_all, req, self.req_id,
 
301
                          expected)
301
302
 
302
303
    def test_update_all_malformed_data(self):
303
304
        self.stubs.Set(cinder.db, 'volume_metadata_update',
309
310
        req.body = jsonutils.dumps(expected)
310
311
 
311
312
        self.assertRaises(webob.exc.HTTPBadRequest,
312
 
                          self.controller.update_all, req, self.id, expected)
 
313
                          self.controller.update_all, req, self.req_id,
 
314
                          expected)
313
315
 
314
316
    def test_update_all_nonexistent_volume(self):
315
317
        self.stubs.Set(cinder.db, 'volume_get', return_volume_nonexistent)
330
332
        body = {"meta": {"key1": "value1"}}
331
333
        req.body = jsonutils.dumps(body)
332
334
        req.headers["content-type"] = "application/json"
333
 
        res_dict = self.controller.update(req, self.id, 'key1', body)
 
335
        res_dict = self.controller.update(req, self.req_id, 'key1', body)
334
336
        expected = {'meta': {'key1': 'value1'}}
335
337
        self.assertEqual(expected, res_dict)
336
338
 
344
346
        req.headers["content-type"] = "application/json"
345
347
 
346
348
        self.assertRaises(webob.exc.HTTPNotFound,
347
 
                          self.controller.update, req, self.id, 'key1', body)
 
349
                          self.controller.update, req, self.req_id, 'key1',
 
350
                          body)
348
351
 
349
352
    def test_update_item_empty_body(self):
350
353
        self.stubs.Set(cinder.db, 'volume_metadata_update',
354
357
        req.headers["content-type"] = "application/json"
355
358
 
356
359
        self.assertRaises(webob.exc.HTTPBadRequest,
357
 
                          self.controller.update, req, self.id, 'key1', None)
 
360
                          self.controller.update, req, self.req_id, 'key1',
 
361
                          None)
358
362
 
359
363
    def test_update_item_empty_key(self):
360
364
        self.stubs.Set(cinder.db, 'volume_metadata_update',
366
370
        req.headers["content-type"] = "application/json"
367
371
 
368
372
        self.assertRaises(webob.exc.HTTPBadRequest,
369
 
                          self.controller.update, req, self.id, '', body)
 
373
                          self.controller.update, req, self.req_id, '', body)
370
374
 
371
375
    def test_update_item_key_too_long(self):
372
376
        self.stubs.Set(cinder.db, 'volume_metadata_update',
379
383
 
380
384
        self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
381
385
                          self.controller.update,
382
 
                          req, self.id, ("a" * 260), body)
 
386
                          req, self.req_id, ("a" * 260), body)
383
387
 
384
388
    def test_update_item_value_too_long(self):
385
389
        self.stubs.Set(cinder.db, 'volume_metadata_update',
392
396
 
393
397
        self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
394
398
                          self.controller.update,
395
 
                          req, self.id, "key1", body)
 
399
                          req, self.req_id, "key1", body)
396
400
 
397
401
    def test_update_item_too_many_keys(self):
398
402
        self.stubs.Set(cinder.db, 'volume_metadata_update',
404
408
        req.headers["content-type"] = "application/json"
405
409
 
406
410
        self.assertRaises(webob.exc.HTTPBadRequest,
407
 
                          self.controller.update, req, self.id, 'key1', body)
 
411
                          self.controller.update, req, self.req_id, 'key1',
 
412
                          body)
408
413
 
409
414
    def test_update_item_body_uri_mismatch(self):
410
415
        self.stubs.Set(cinder.db, 'volume_metadata_update',
416
421
        req.headers["content-type"] = "application/json"
417
422
 
418
423
        self.assertRaises(webob.exc.HTTPBadRequest,
419
 
                          self.controller.update, req, self.id, 'bad', body)
 
424
                          self.controller.update, req, self.req_id, 'bad',
 
425
                          body)
420
426
 
421
427
    def test_invalid_metadata_items_on_create(self):
422
428
        self.stubs.Set(cinder.db, 'volume_metadata_update',
429
435
        data = {"metadata": {"a" * 260: "value1"}}
430
436
        req.body = jsonutils.dumps(data)
431
437
        self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
432
 
                          self.controller.create, req, self.id, data)
 
438
                          self.controller.create, req, self.req_id, data)
433
439
 
434
440
        #test for long value
435
441
        data = {"metadata": {"key": "v" * 260}}
436
442
        req.body = jsonutils.dumps(data)
437
443
        self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
438
 
                          self.controller.create, req, self.id, data)
 
444
                          self.controller.create, req, self.req_id, data)
439
445
 
440
446
        #test for empty key.
441
447
        data = {"metadata": {"": "value1"}}
442
448
        req.body = jsonutils.dumps(data)
443
449
        self.assertRaises(webob.exc.HTTPBadRequest,
444
 
                          self.controller.create, req, self.id, data)
 
450
                          self.controller.create, req, self.req_id, data)