← Back to branch summary

~cbehrens/nova/servers-search

« back to all changes in this revision

Viewing changes to nova/tests/api/openstack/test_server_metadata.py

  • Committer: Chris Behrens
  • Date: 2011-08-04 21:58:42 UTC
  • mfrom: (1250.1.127 nova)
  • Revision ID: cbehrens@codestud.com-20110804215842-nfykqar8k74l33tj
merged trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/api/openstack/test_server_metadata.py
17
17
 
18
18
import json
19
19
import webob
20
 
 
 
20
from xml.dom import minidom
21
21
 
22
22
from nova import exception
23
23
from nova import flags
51
51
 
52
52
def stub_server_metadata():
53
53
    metadata = {
54
 
            "key1": "value1",
55
 
            "key2": "value2",
56
 
            "key3": "value3",
57
 
            "key4": "value4",
58
 
            "key5": "value5"}
 
54
        "key1": "value1",
 
55
        "key2": "value2",
 
56
        "key3": "value3",
 
57
    }
59
58
    return metadata
60
59
 
61
60
 
84
83
    def test_index(self):
85
84
        self.stubs.Set(nova.db.api, 'instance_metadata_get',
86
85
                       return_server_metadata)
87
 
        req = webob.Request.blank('/v1.1/servers/1/meta')
88
 
        req.environ['api.version'] = '1.1'
 
86
        req = webob.Request.blank('/v1.1/servers/1/metadata')
89
87
        res = req.get_response(fakes.wsgi_app())
 
88
        self.assertEqual(200, res.status_int)
90
89
        res_dict = json.loads(res.body)
91
 
        self.assertEqual(200, res.status_int)
92
90
        self.assertEqual('application/json', res.headers['Content-Type'])
93
 
        self.assertEqual('value1', res_dict['metadata']['key1'])
 
91
        expected = {
 
92
            'metadata': {
 
93
                'key1': 'value1',
 
94
                'key2': 'value2',
 
95
                'key3': 'value3',
 
96
            },
 
97
        }
 
98
        self.assertEqual(expected, res_dict)
 
99
 
 
100
    def test_index_xml(self):
 
101
        self.stubs.Set(nova.db.api, 'instance_metadata_get',
 
102
                       return_server_metadata)
 
103
        request = webob.Request.blank("/v1.1/servers/1/metadata")
 
104
        request.accept = "application/xml"
 
105
        response = request.get_response(fakes.wsgi_app())
 
106
        self.assertEqual(200, response.status_int)
 
107
        self.assertEqual("application/xml", response.content_type)
 
108
 
 
109
        actual_metadata = minidom.parseString(response.body.replace("  ", ""))
 
110
 
 
111
        expected_metadata = minidom.parseString("""
 
112
            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
 
113
                <meta key="key3">value3</meta>
 
114
                <meta key="key2">value2</meta>
 
115
                <meta key="key1">value1</meta>
 
116
            </metadata>
 
117
        """.replace("  ", "").replace("\n", ""))
 
118
 
 
119
        self.assertEqual(expected_metadata.toxml(), actual_metadata.toxml())
94
120
 
95
121
    def test_index_nonexistant_server(self):
96
122
        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
97
 
        req = webob.Request.blank('/v1.1/servers/1/meta')
98
 
        req.environ['api.version'] = '1.1'
 
123
        req = webob.Request.blank('/v1.1/servers/1/metadata')
99
124
        res = req.get_response(fakes.wsgi_app())
100
125
        self.assertEqual(404, res.status_int)
101
126
 
102
127
    def test_index_no_data(self):
103
128
        self.stubs.Set(nova.db.api, 'instance_metadata_get',
104
129
                       return_empty_server_metadata)
105
 
        req = webob.Request.blank('/v1.1/servers/1/meta')
106
 
        req.environ['api.version'] = '1.1'
 
130
        req = webob.Request.blank('/v1.1/servers/1/metadata')
107
131
        res = req.get_response(fakes.wsgi_app())
 
132
        self.assertEqual(200, res.status_int)
108
133
        res_dict = json.loads(res.body)
109
 
        self.assertEqual(200, res.status_int)
110
 
        self.assertEqual('application/json', res.headers['Content-Type'])
111
 
        self.assertEqual(0, len(res_dict['metadata']))
 
134
        expected = {'metadata': {}}
 
135
        self.assertEqual(expected, res_dict)
112
136
 
113
137
    def test_show(self):
114
138
        self.stubs.Set(nova.db.api, 'instance_metadata_get',
115
139
                       return_server_metadata)
116
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
117
 
        req.environ['api.version'] = '1.1'
 
140
        req = webob.Request.blank('/v1.1/servers/1/metadata/key2')
118
141
        res = req.get_response(fakes.wsgi_app())
119
142
        res_dict = json.loads(res.body)
120
143
        self.assertEqual(200, res.status_int)
121
 
        self.assertEqual('application/json', res.headers['Content-Type'])
122
 
        self.assertEqual('value5', res_dict['key5'])
 
144
        expected = {'meta': {'key2': 'value2'}}
 
145
        self.assertEqual(expected, res_dict)
 
146
 
 
147
    def test_show_xml(self):
 
148
        self.stubs.Set(nova.db.api, 'instance_metadata_get',
 
149
                       return_server_metadata)
 
150
        request = webob.Request.blank("/v1.1/servers/1/metadata/key2")
 
151
        request.accept = "application/xml"
 
152
        response = request.get_response(fakes.wsgi_app())
 
153
        self.assertEqual(200, response.status_int)
 
154
        self.assertEqual("application/xml", response.content_type)
 
155
 
 
156
        actual_metadata = minidom.parseString(response.body.replace("  ", ""))
 
157
 
 
158
        expected_metadata = minidom.parseString("""
 
159
            <meta xmlns="http://docs.openstack.org/compute/api/v1.1"
 
160
                 key="key2">value2</meta>
 
161
        """.replace("  ", "").replace("\n", ""))
 
162
 
 
163
        self.assertEqual(expected_metadata.toxml(), actual_metadata.toxml())
123
164
 
124
165
    def test_show_nonexistant_server(self):
125
166
        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
126
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
127
 
        req.environ['api.version'] = '1.1'
 
167
        req = webob.Request.blank('/v1.1/servers/1/metadata/key2')
128
168
        res = req.get_response(fakes.wsgi_app())
129
169
        self.assertEqual(404, res.status_int)
130
170
 
131
171
    def test_show_meta_not_found(self):
132
172
        self.stubs.Set(nova.db.api, 'instance_metadata_get',
133
173
                       return_empty_server_metadata)
134
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key6')
135
 
        req.environ['api.version'] = '1.1'
 
174
        req = webob.Request.blank('/v1.1/servers/1/metadata/key6')
136
175
        res = req.get_response(fakes.wsgi_app())
137
176
        self.assertEqual(404, res.status_int)
138
177
 
139
178
    def test_delete(self):
 
179
        self.stubs.Set(nova.db.api, 'instance_metadata_get',
 
180
                       return_server_metadata)
140
181
        self.stubs.Set(nova.db.api, 'instance_metadata_delete',
141
182
                       delete_server_metadata)
142
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
143
 
        req.environ['api.version'] = '1.1'
 
183
        req = webob.Request.blank('/v1.1/servers/1/metadata/key2')
144
184
        req.method = 'DELETE'
145
185
        res = req.get_response(fakes.wsgi_app())
146
 
        self.assertEqual(200, res.status_int)
 
186
        self.assertEqual(204, res.status_int)
 
187
        self.assertEqual('', res.body)
147
188
 
148
189
    def test_delete_nonexistant_server(self):
149
190
        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
150
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
151
 
        req.environ['api.version'] = '1.1'
 
191
        req = webob.Request.blank('/v1.1/servers/1/metadata/key1')
 
192
        req.method = 'DELETE'
 
193
        res = req.get_response(fakes.wsgi_app())
 
194
        self.assertEqual(404, res.status_int)
 
195
 
 
196
    def test_delete_meta_not_found(self):
 
197
        self.stubs.Set(nova.db.api, 'instance_metadata_get',
 
198
                       return_empty_server_metadata)
 
199
        req = webob.Request.blank('/v1.1/servers/1/metadata/key6')
152
200
        req.method = 'DELETE'
153
201
        res = req.get_response(fakes.wsgi_app())
154
202
        self.assertEqual(404, res.status_int)
156
204
    def test_create(self):
157
205
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
158
206
                       return_create_instance_metadata)
159
 
        req = webob.Request.blank('/v1.1/servers/1/meta')
160
 
        req.environ['api.version'] = '1.1'
 
207
        req = webob.Request.blank('/v1.1/servers/1/metadata')
161
208
        req.method = 'POST'
162
 
        req.body = '{"metadata": {"key1": "value1"}}'
163
 
        req.headers["content-type"] = "application/json"
 
209
        req.content_type = "application/json"
 
210
        expected = {"metadata": {"key1": "value1"}}
 
211
        req.body = json.dumps(expected)
164
212
        res = req.get_response(fakes.wsgi_app())
 
213
 
165
214
        self.assertEqual(200, res.status_int)
166
215
        res_dict = json.loads(res.body)
167
 
        self.assertEqual('application/json', res.headers['Content-Type'])
168
 
        self.assertEqual('value1', res_dict['metadata']['key1'])
 
216
        self.assertEqual(expected, res_dict)
 
217
 
 
218
    def test_create_xml(self):
 
219
        self.stubs.Set(nova.db.api, "instance_metadata_update_or_create",
 
220
                       return_create_instance_metadata)
 
221
        req = webob.Request.blank("/v1.1/servers/1/metadata")
 
222
        req.method = "POST"
 
223
        req.content_type = "application/xml"
 
224
        req.accept = "application/xml"
 
225
 
 
226
        request_metadata = minidom.parseString("""
 
227
            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
 
228
                <meta key="key3">value3</meta>
 
229
                <meta key="key2">value2</meta>
 
230
                <meta key="key1">value1</meta>
 
231
            </metadata>
 
232
        """.replace("  ", "").replace("\n", ""))
 
233
 
 
234
        req.body = str(request_metadata.toxml())
 
235
        response = req.get_response(fakes.wsgi_app())
 
236
 
 
237
        self.assertEqual(200, response.status_int)
 
238
        actual_metadata = minidom.parseString(response.body)
 
239
 
 
240
        self.assertEqual(request_metadata.toxml(), actual_metadata.toxml())
169
241
 
170
242
    def test_create_empty_body(self):
171
243
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
172
244
                       return_create_instance_metadata)
173
 
        req = webob.Request.blank('/v1.1/servers/1/meta')
174
 
        req.environ['api.version'] = '1.1'
 
245
        req = webob.Request.blank('/v1.1/servers/1/metadata')
175
246
        req.method = 'POST'
176
247
        req.headers["content-type"] = "application/json"
177
248
        res = req.get_response(fakes.wsgi_app())
179
250
 
180
251
    def test_create_nonexistant_server(self):
181
252
        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
182
 
        req = webob.Request.blank('/v1.1/servers/100/meta')
183
 
        req.environ['api.version'] = '1.1'
 
253
        req = webob.Request.blank('/v1.1/servers/100/metadata')
184
254
        req.method = 'POST'
185
255
        req.body = '{"metadata": {"key1": "value1"}}'
186
256
        req.headers["content-type"] = "application/json"
187
257
        res = req.get_response(fakes.wsgi_app())
188
258
        self.assertEqual(404, res.status_int)
189
259
 
 
260
    def test_update_all(self):
 
261
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
 
262
                       return_create_instance_metadata)
 
263
        req = webob.Request.blank('/v1.1/servers/1/metadata')
 
264
        req.method = 'PUT'
 
265
        req.content_type = "application/json"
 
266
        expected = {
 
267
            'metadata': {
 
268
                'key10': 'value10',
 
269
                'key99': 'value99',
 
270
            },
 
271
        }
 
272
        req.body = json.dumps(expected)
 
273
        res = req.get_response(fakes.wsgi_app())
 
274
        self.assertEqual(200, res.status_int)
 
275
        res_dict = json.loads(res.body)
 
276
        self.assertEqual(expected, res_dict)
 
277
 
 
278
    def test_update_all_empty_container(self):
 
279
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
 
280
                       return_create_instance_metadata)
 
281
        req = webob.Request.blank('/v1.1/servers/1/metadata')
 
282
        req.method = 'PUT'
 
283
        req.content_type = "application/json"
 
284
        expected = {'metadata': {}}
 
285
        req.body = json.dumps(expected)
 
286
        res = req.get_response(fakes.wsgi_app())
 
287
        self.assertEqual(200, res.status_int)
 
288
        res_dict = json.loads(res.body)
 
289
        self.assertEqual(expected, res_dict)
 
290
 
 
291
    def test_update_all_malformed_container(self):
 
292
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
 
293
                       return_create_instance_metadata)
 
294
        req = webob.Request.blank('/v1.1/servers/1/metadata')
 
295
        req.method = 'PUT'
 
296
        req.content_type = "application/json"
 
297
        expected = {'meta': {}}
 
298
        req.body = json.dumps(expected)
 
299
        res = req.get_response(fakes.wsgi_app())
 
300
        self.assertEqual(400, res.status_int)
 
301
 
 
302
    def test_update_all_malformed_data(self):
 
303
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
 
304
                       return_create_instance_metadata)
 
305
        req = webob.Request.blank('/v1.1/servers/1/metadata')
 
306
        req.method = 'PUT'
 
307
        req.content_type = "application/json"
 
308
        expected = {'metadata': ['asdf']}
 
309
        req.body = json.dumps(expected)
 
310
        res = req.get_response(fakes.wsgi_app())
 
311
        self.assertEqual(400, res.status_int)
 
312
 
 
313
    def test_update_all_nonexistant_server(self):
 
314
        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
 
315
        req = webob.Request.blank('/v1.1/servers/100/metadata')
 
316
        req.method = 'PUT'
 
317
        req.content_type = "application/json"
 
318
        req.body = json.dumps({'metadata': {'key10': 'value10'}})
 
319
        res = req.get_response(fakes.wsgi_app())
 
320
        self.assertEqual(404, res.status_int)
 
321
 
190
322
    def test_update_item(self):
191
323
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
192
324
                       return_create_instance_metadata)
193
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
194
 
        req.environ['api.version'] = '1.1'
 
325
        req = webob.Request.blank('/v1.1/servers/1/metadata/key1')
195
326
        req.method = 'PUT'
196
 
        req.body = '{"key1": "value1"}'
 
327
        req.body = '{"meta": {"key1": "value1"}}'
197
328
        req.headers["content-type"] = "application/json"
198
329
        res = req.get_response(fakes.wsgi_app())
199
330
        self.assertEqual(200, res.status_int)
200
331
        self.assertEqual('application/json', res.headers['Content-Type'])
201
332
        res_dict = json.loads(res.body)
202
 
        self.assertEqual('value1', res_dict['key1'])
 
333
        expected = {'meta': {'key1': 'value1'}}
 
334
        self.assertEqual(expected, res_dict)
 
335
 
 
336
    def test_update_item_xml(self):
 
337
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
 
338
                       return_create_instance_metadata)
 
339
        req = webob.Request.blank('/v1.1/servers/1/metadata/key9')
 
340
        req.method = 'PUT'
 
341
        req.accept = "application/json"
 
342
        req.content_type = "application/xml"
 
343
        req.body = """
 
344
            <meta xmlns="http://docs.openstack.org/compute/api/v1.1"
 
345
                  key="key9">value9</meta>
 
346
        """
 
347
        res = req.get_response(fakes.wsgi_app())
 
348
        self.assertEqual(200, res.status_int)
 
349
        self.assertEqual('application/json', res.headers['Content-Type'])
 
350
        res_dict = json.loads(res.body)
 
351
        expected = {'meta': {'key9': 'value9'}}
 
352
        self.assertEqual(expected, res_dict)
203
353
 
204
354
    def test_update_item_nonexistant_server(self):
205
355
        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
206
 
        req = webob.Request.blank('/v1.1/servers/asdf/100/key1')
207
 
        req.environ['api.version'] = '1.1'
 
356
        req = webob.Request.blank('/v1.1/servers/asdf/metadata/key1')
208
357
        req.method = 'PUT'
209
 
        req.body = '{"key1": "value1"}'
 
358
        req.body = '{"meta":{"key1": "value1"}}'
210
359
        req.headers["content-type"] = "application/json"
211
360
        res = req.get_response(fakes.wsgi_app())
212
361
        self.assertEqual(404, res.status_int)
214
363
    def test_update_item_empty_body(self):
215
364
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
216
365
                       return_create_instance_metadata)
217
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
218
 
        req.environ['api.version'] = '1.1'
 
366
        req = webob.Request.blank('/v1.1/servers/1/metadata/key1')
219
367
        req.method = 'PUT'
220
368
        req.headers["content-type"] = "application/json"
221
369
        res = req.get_response(fakes.wsgi_app())
224
372
    def test_update_item_too_many_keys(self):
225
373
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
226
374
                       return_create_instance_metadata)
227
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
228
 
        req.environ['api.version'] = '1.1'
 
375
        req = webob.Request.blank('/v1.1/servers/1/metadata/key1')
229
376
        req.method = 'PUT'
230
 
        req.body = '{"key1": "value1", "key2": "value2"}'
 
377
        req.body = '{"meta": {"key1": "value1", "key2": "value2"}}'
231
378
        req.headers["content-type"] = "application/json"
232
379
        res = req.get_response(fakes.wsgi_app())
233
380
        self.assertEqual(400, res.status_int)
235
382
    def test_update_item_body_uri_mismatch(self):
236
383
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
237
384
                       return_create_instance_metadata)
238
 
        req = webob.Request.blank('/v1.1/servers/1/meta/bad')
239
 
        req.environ['api.version'] = '1.1'
 
385
        req = webob.Request.blank('/v1.1/servers/1/metadata/bad')
240
386
        req.method = 'PUT'
241
 
        req.body = '{"key1": "value1"}'
 
387
        req.body = '{"meta": {"key1": "value1"}}'
242
388
        req.headers["content-type"] = "application/json"
243
389
        res = req.get_response(fakes.wsgi_app())
244
390
        self.assertEqual(400, res.status_int)
250
396
        for num in range(FLAGS.quota_metadata_items + 1):
251
397
            data['metadata']['key%i' % num] = "blah"
252
398
        json_string = str(data).replace("\'", "\"")
253
 
        req = webob.Request.blank('/v1.1/servers/1/meta')
254
 
        req.environ['api.version'] = '1.1'
 
399
        req = webob.Request.blank('/v1.1/servers/1/metadata')
255
400
        req.method = 'POST'
256
401
        req.body = json_string
257
402
        req.headers["content-type"] = "application/json"
261
406
    def test_to_many_metadata_items_on_update_item(self):
262
407
        self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
263
408
                       return_create_instance_metadata_max)
264
 
        req = webob.Request.blank('/v1.1/servers/1/meta/key1')
265
 
        req.environ['api.version'] = '1.1'
 
409
        req = webob.Request.blank('/v1.1/servers/1/metadata/key1')
266
410
        req.method = 'PUT'
267
 
        req.body = '{"a new key": "a new value"}'
 
411
        req.body = '{"meta": {"a new key": "a new value"}}'
268
412
        req.headers["content-type"] = "application/json"
269
413
        res = req.get_response(fakes.wsgi_app())
270
414
        self.assertEqual(400, res.status_int)