← Back to branch summary

~ntt-pf-lab/nova/monkey_patch_notification

« back to all changes in this revision

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

  • Committer: Lvov Maxim
  • Date: 2011-07-26 05:50:05 UTC
  • mfrom: (1320 nova)
  • mto: This revision was merged to the branch mainline in revision 1322.
  • Revision ID: usrleon@gmail.com-20110726055005-7olsp0giqup3pao7
merge with trunk, resolve conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/api/openstack/test_extensions.py
16
16
#    under the License.
17
17
 
18
18
import json
 
19
import os.path
19
20
import stubout
20
21
import unittest
21
22
import webob
22
 
import os.path
 
23
from xml.etree import ElementTree
23
24
 
24
25
from nova import context
25
26
from nova import flags
30
31
from nova.tests.api.openstack import fakes
31
32
 
32
33
FLAGS = flags.FLAGS
33
 
 
 
34
NS = "{http://docs.openstack.org/compute/api/v1.1}"
 
35
ATOMNS = "{http://www.w3.org/2005/Atom}"
34
36
response_body = "Try to say this Mr. Knox, sir..."
35
37
 
36
38
 
80
82
 
81
83
class ExtensionControllerTest(unittest.TestCase):
82
84
 
83
 
    def test_index(self):
84
 
        app = openstack.APIRouterV11()
85
 
        ext_midware = extensions.ExtensionMiddleware(app)
86
 
        request = webob.Request.blank("/extensions")
87
 
        response = request.get_response(ext_midware)
88
 
        self.assertEqual(200, response.status_int)
89
 
 
90
 
    def test_get_by_alias(self):
91
 
        app = openstack.APIRouterV11()
92
 
        ext_midware = extensions.ExtensionMiddleware(app)
93
 
        request = webob.Request.blank("/extensions/FOXNSOX")
94
 
        response = request.get_response(ext_midware)
95
 
        self.assertEqual(200, response.status_int)
 
85
    def setUp(self):
 
86
        FLAGS.osapi_extensions_path = os.path.join(
 
87
            os.path.dirname(__file__), "extensions")
 
88
 
 
89
    def test_list_extensions_json(self):
 
90
        app = openstack.APIRouterV11()
 
91
        ext_midware = extensions.ExtensionMiddleware(app)
 
92
        request = webob.Request.blank("/extensions")
 
93
        response = request.get_response(ext_midware)
 
94
        self.assertEqual(200, response.status_int)
 
95
 
 
96
        # Make sure we have all the extensions.
 
97
        data = json.loads(response.body)
 
98
        names = [x['name'] for x in data['extensions']]
 
99
        names.sort()
 
100
        self.assertEqual(names, ["FlavorExtraSpecs", "Floating_ips",
 
101
            "Fox In Socks", "Hosts", "Multinic", "Volumes"])
 
102
 
 
103
        # Make sure that at least Fox in Sox is correct.
 
104
        (fox_ext,) = [
 
105
            x for x in data['extensions'] if x['alias'] == 'FOXNSOX']
 
106
        self.assertEqual(fox_ext, {
 
107
                'namespace': 'http://www.fox.in.socks/api/ext/pie/v1.0',
 
108
                'name': 'Fox In Socks',
 
109
                'updated': '2011-01-22T13:25:27-06:00',
 
110
                'description': 'The Fox In Socks Extension',
 
111
                'alias': 'FOXNSOX',
 
112
                'links': []
 
113
            }
 
114
        )
 
115
 
 
116
    def test_get_extension_json(self):
 
117
        app = openstack.APIRouterV11()
 
118
        ext_midware = extensions.ExtensionMiddleware(app)
 
119
        request = webob.Request.blank("/extensions/FOXNSOX")
 
120
        response = request.get_response(ext_midware)
 
121
        self.assertEqual(200, response.status_int)
 
122
 
 
123
        data = json.loads(response.body)
 
124
        self.assertEqual(data['extension'], {
 
125
                "namespace": "http://www.fox.in.socks/api/ext/pie/v1.0",
 
126
                "name": "Fox In Socks",
 
127
                "updated": "2011-01-22T13:25:27-06:00",
 
128
                "description": "The Fox In Socks Extension",
 
129
                "alias": "FOXNSOX",
 
130
                "links": []
 
131
            }
 
132
        )
 
133
 
 
134
    def test_list_extensions_xml(self):
 
135
        app = openstack.APIRouterV11()
 
136
        ext_midware = extensions.ExtensionMiddleware(app)
 
137
        request = webob.Request.blank("/extensions")
 
138
        request.accept = "application/xml"
 
139
        response = request.get_response(ext_midware)
 
140
        self.assertEqual(200, response.status_int)
 
141
        print response.body
 
142
 
 
143
        root = ElementTree.XML(response.body)
 
144
        self.assertEqual(root.tag.split('extensions')[0], NS)
 
145
 
 
146
        # Make sure we have all the extensions.
 
147
        exts = root.findall('{0}extension'.format(NS))
 
148
        self.assertEqual(len(exts), 6)
 
149
 
 
150
        # Make sure that at least Fox in Sox is correct.
 
151
        (fox_ext,) = [x for x in exts if x.get('alias') == 'FOXNSOX']
 
152
        self.assertEqual(fox_ext.get('name'), 'Fox In Socks')
 
153
        self.assertEqual(fox_ext.get('namespace'),
 
154
            'http://www.fox.in.socks/api/ext/pie/v1.0')
 
155
        self.assertEqual(fox_ext.get('updated'), '2011-01-22T13:25:27-06:00')
 
156
        self.assertEqual(fox_ext.findtext('{0}description'.format(NS)),
 
157
            'The Fox In Socks Extension')
 
158
 
 
159
    def test_get_extension_xml(self):
 
160
        app = openstack.APIRouterV11()
 
161
        ext_midware = extensions.ExtensionMiddleware(app)
 
162
        request = webob.Request.blank("/extensions/FOXNSOX")
 
163
        request.accept = "application/xml"
 
164
        response = request.get_response(ext_midware)
 
165
        self.assertEqual(200, response.status_int)
 
166
        print response.body
 
167
 
 
168
        root = ElementTree.XML(response.body)
 
169
        self.assertEqual(root.tag.split('extension')[0], NS)
 
170
        self.assertEqual(root.get('alias'), 'FOXNSOX')
 
171
        self.assertEqual(root.get('name'), 'Fox In Socks')
 
172
        self.assertEqual(root.get('namespace'),
 
173
            'http://www.fox.in.socks/api/ext/pie/v1.0')
 
174
        self.assertEqual(root.get('updated'), '2011-01-22T13:25:27-06:00')
 
175
        self.assertEqual(root.findtext('{0}description'.format(NS)),
 
176
            'The Fox In Socks Extension')
96
177
 
97
178
 
98
179
class ResourceExtensionTest(unittest.TestCase):
192
273
 
193
274
    def test_invalid_action(self):
194
275
        body = dict(blah=dict(name="test"))
195
 
        response = self._send_server_action_request("/asdf/1/action", body)
 
276
        response = self._send_server_action_request("/fdsa/1/action", body)
196
277
        self.assertEqual(404, response.status_int)
197
278
 
198
279
 
244
325
        response_data = json.loads(response.body)
245
326
        self.assertEqual('newblue', response_data['flavor']['googoose'])
246
327
        self.assertEqual("Pig Bands!", response_data['big_bands'])
 
328
 
 
329
 
 
330
class ExtensionsXMLSerializerTest(unittest.TestCase):
 
331
 
 
332
    def test_serialize_extenstion(self):
 
333
        serializer = extensions.ExtensionsXMLSerializer()
 
334
        data = {
 
335
            'extension': {
 
336
                'name': 'ext1',
 
337
                'namespace': 'http://docs.rack.com/servers/api/ext/pie/v1.0',
 
338
                'alias': 'RS-PIE',
 
339
                'updated': '2011-01-22T13:25:27-06:00',
 
340
                'description': 'Adds the capability to share an image.',
 
341
                'links': [
 
342
                    {
 
343
                        'rel': 'describedby',
 
344
                        'type': 'application/pdf',
 
345
                        'href': 'http://docs.rack.com/servers/api/ext/cs.pdf'
 
346
                    },
 
347
                    {
 
348
                        'rel': 'describedby',
 
349
                        'type': 'application/vnd.sun.wadl+xml',
 
350
                        'href': 'http://docs.rack.com/servers/api/ext/cs.wadl'
 
351
                    }
 
352
                ]
 
353
            }
 
354
        }
 
355
 
 
356
        xml = serializer.serialize(data, 'show')
 
357
        root = ElementTree.XML(xml)
 
358
        ext_dict = data['extension']
 
359
        self.assertEqual(root.findtext('{0}description'.format(NS)),
 
360
            ext_dict['description'])
 
361
 
 
362
        for key in ['name', 'namespace', 'alias', 'updated']:
 
363
            self.assertEqual(root.get(key), ext_dict[key])
 
364
 
 
365
        link_nodes = root.findall('{0}link'.format(ATOMNS))
 
366
        self.assertEqual(len(link_nodes), 2)
 
367
        for i, link in enumerate(ext_dict['links']):
 
368
            for key, value in link.items():
 
369
                self.assertEqual(link_nodes[i].get(key), value)
 
370
 
 
371
    def test_serialize_extensions(self):
 
372
        serializer = extensions.ExtensionsXMLSerializer()
 
373
        data = {
 
374
            "extensions": [
 
375
                {
 
376
                    "name": "Public Image Extension",
 
377
                    "namespace": "http://foo.com/api/ext/pie/v1.0",
 
378
                    "alias": "RS-PIE",
 
379
                    "updated": "2011-01-22T13:25:27-06:00",
 
380
                    "description": "Adds the capability to share an image.",
 
381
                    "links": [
 
382
                        {
 
383
                            "rel": "describedby",
 
384
                            "type": "application/pdf",
 
385
                            "href": "http://foo.com/api/ext/cs-pie.pdf"
 
386
                        },
 
387
                        {
 
388
                            "rel": "describedby",
 
389
                            "type": "application/vnd.sun.wadl+xml",
 
390
                            "href": "http://foo.com/api/ext/cs-pie.wadl"
 
391
                        }
 
392
                    ]
 
393
                },
 
394
                {
 
395
                    "name": "Cloud Block Storage",
 
396
                    "namespace": "http://foo.com/api/ext/cbs/v1.0",
 
397
                    "alias": "RS-CBS",
 
398
                    "updated": "2011-01-12T11:22:33-06:00",
 
399
                    "description": "Allows mounting cloud block storage.",
 
400
                    "links": [
 
401
                        {
 
402
                            "rel": "describedby",
 
403
                            "type": "application/pdf",
 
404
                            "href": "http://foo.com/api/ext/cs-cbs.pdf"
 
405
                        },
 
406
                        {
 
407
                            "rel": "describedby",
 
408
                            "type": "application/vnd.sun.wadl+xml",
 
409
                            "href": "http://foo.com/api/ext/cs-cbs.wadl"
 
410
                        }
 
411
                    ]
 
412
                }
 
413
            ]
 
414
        }
 
415
 
 
416
        xml = serializer.serialize(data, 'index')
 
417
        print xml
 
418
        root = ElementTree.XML(xml)
 
419
        ext_elems = root.findall('{0}extension'.format(NS))
 
420
        self.assertEqual(len(ext_elems), 2)
 
421
        for i, ext_elem in enumerate(ext_elems):
 
422
            ext_dict = data['extensions'][i]
 
423
            self.assertEqual(ext_elem.findtext('{0}description'.format(NS)),
 
424
                ext_dict['description'])
 
425
 
 
426
            for key in ['name', 'namespace', 'alias', 'updated']:
 
427
                self.assertEqual(ext_elem.get(key), ext_dict[key])
 
428
 
 
429
            link_nodes = ext_elem.findall('{0}link'.format(ATOMNS))
 
430
            self.assertEqual(len(link_nodes), 2)
 
431
            for i, link in enumerate(ext_dict['links']):
 
432
                for key, value in link.items():
 
433
                    self.assertEqual(link_nodes[i].get(key), value)