def test_serialize_extension(self): serializer = extensions.ExtensionsXMLSerializer() data = {'extension': { 'name': 'ext1', 'namespace': 'http://docs.rack.com/servers/api/ext/pie/v1.0', 'alias': 'RS-PIE', 'updated': '2011-01-22T13:25:27-06:00', 'description': 'Adds the capability to share an image.', 'links': [{'rel': 'describedby', 'type': 'application/pdf', 'href': 'http://docs.rack.com/servers/api/ext/cs.pdf'}, {'rel': 'describedby', 'type': 'application/vnd.sun.wadl+xml', 'href': 'http://docs.rack.com/servers/api/ext/cs.wadl'}]}} xml = serializer.serialize(data, 'show') print xml root = etree.XML(xml) ext_dict = data['extension'] self.assertEqual(root.findtext('{0}description'.format(NS)), ext_dict['description']) for key in ['name', 'namespace', 'alias', 'updated']: self.assertEqual(root.get(key), ext_dict[key]) link_nodes = root.findall('{0}link'.format(ATOMNS)) self.assertEqual(len(link_nodes), 2) for i, link in enumerate(ext_dict['links']): for key, value in link.items(): self.assertEqual(link_nodes[i].get(key), value) xmlutil.validate_schema(root, 'extension')
def test_list_extensions_xml(self): app = v2.APIRouter() ext_midware = extensions.ExtensionMiddleware(app) ser_midware = wsgi.LazySerializationMiddleware(ext_midware) request = webob.Request.blank("/123/extensions") request.accept = "application/xml" response = request.get_response(ser_midware) self.assertEqual(200, response.status_int) print response.body root = etree.XML(response.body) self.assertEqual(root.tag.split('extensions')[0], NS) # Make sure we have all the extensions. exts = root.findall('{0}extension'.format(NS)) self.assertEqual(len(exts), len(self.ext_list)) # Make sure that at least Fox in Sox is correct. (fox_ext, ) = [x for x in exts if x.get('alias') == 'FOXNSOX'] self.assertEqual(fox_ext.get('name'), 'Fox In Socks') self.assertEqual(fox_ext.get('namespace'), 'http://www.fox.in.socks/api/ext/pie/v1.0') self.assertEqual(fox_ext.get('updated'), '2011-01-22T13:25:27-06:00') self.assertEqual(fox_ext.findtext('{0}description'.format(NS)), 'The Fox In Socks Extension') xmlutil.validate_schema(root, 'extensions')
def test_create(self): serializer = common.MetadataXMLSerializer() fixture = {"metadata": {"key9": "value9", "key2": "value2", "key1": "value1"}} output = serializer.serialize(fixture, "create") print output root = etree.XML(output) xmlutil.validate_schema(root, "metadata") metadata_dict = fixture["metadata"] metadata_elems = root.findall("{0}meta".format(NS)) self.assertEqual(len(metadata_elems), 3) for i, metadata_elem in enumerate(metadata_elems): (meta_key, meta_value) = metadata_dict.items()[i] self.assertEqual(str(metadata_elem.get("key")), str(meta_key)) self.assertEqual(str(metadata_elem.text).strip(), str(meta_value)) actual = minidom.parseString(output.replace(" ", "")) expected = minidom.parseString( """ <metadata xmlns="http://docs.x7.org/compute/api/v1.1"> <meta key="key2">value2</meta> <meta key="key9">value9</meta> <meta key="key1">value1</meta> </metadata> """.replace( " ", "" ).replace( "\n", "" ) ) self.assertEqual(expected.toxml(), actual.toxml())
def test_index(self): serializer = limits.LimitsTemplate() fixture = { "limits": { "rate": [{ "uri": "*", "regex": ".*", "limit": [{ "value": 10, "verb": "POST", "remaining": 2, "unit": "MINUTE", "next-available": "2011-12-15T22:42:45Z"}]}, {"uri": "*/servers", "regex": "^/servers", "limit": [{ "value": 50, "verb": "POST", "remaining": 10, "unit": "DAY", "next-available": "2011-12-15T22:42:45Z"}]}], "absolute": {"maxServerMeta": 1, "maxImageMeta": 1, "maxPersonality": 5, "maxPersonalitySize": 10240}}} output = serializer.serialize(fixture) print output root = etree.XML(output) xmlutil.validate_schema(root, 'limits') #verify absolute limits absolutes = root.xpath('ns:absolute/ns:limit', namespaces=NS) self.assertEqual(len(absolutes), 4) for limit in absolutes: name = limit.get('name') value = limit.get('value') self.assertEqual(value, str(fixture['limits']['absolute'][name])) #verify rate limits rates = root.xpath('ns:rates/ns:rate', namespaces=NS) self.assertEqual(len(rates), 2) for i, rate in enumerate(rates): for key in ['uri', 'regex']: self.assertEqual(rate.get(key), str(fixture['limits']['rate'][i][key])) rate_limits = rate.xpath('ns:limit', namespaces=NS) self.assertEqual(len(rate_limits), 1) for j, limit in enumerate(rate_limits): for key in ['verb', 'value', 'remaining', 'unit', 'next-available']: self.assertEqual(limit.get(key), str(fixture['limits']['rate'][i]['limit'][j][key]))
def test_index_empty(self): serializer = flavors.MinimalFlavorsTemplate() fixture = { "flavors": [], } output = serializer.serialize(fixture) print output root = etree.XML(output) xmlutil.validate_schema(root, 'flavors_index') flavor_elems = root.findall('{0}flavor'.format(NS)) self.assertEqual(len(flavor_elems), 0)
def test_update_all(self): serializer = common.MetadataXMLSerializer() fixture = {"metadata": {"key6": "value6", "key4": "value4"}} output = serializer.serialize(fixture, "update_all") print output root = etree.XML(output) xmlutil.validate_schema(root, "metadata") metadata_dict = fixture["metadata"] metadata_elems = root.findall("{0}meta".format(NS)) self.assertEqual(len(metadata_elems), 2) for i, metadata_elem in enumerate(metadata_elems): (meta_key, meta_value) = metadata_dict.items()[i] self.assertEqual(str(metadata_elem.get("key")), str(meta_key)) self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
def test_index_unicode(self): serializer = common.MetadataXMLSerializer() fixture = {"metadata": {u"three": u"Jos\xe9"}} output = serializer.serialize(fixture, "index") print output root = etree.XML(output) xmlutil.validate_schema(root, "metadata") metadata_dict = fixture["metadata"] metadata_elems = root.findall("{0}meta".format(NS)) self.assertEqual(len(metadata_elems), 1) for i, metadata_elem in enumerate(metadata_elems): (meta_key, meta_value) = metadata_dict.items()[i] self.assertEqual(str(metadata_elem.get("key")), str(meta_key)) self.assertEqual(metadata_elem.text.strip(), meta_value)
def test_serialize_extensions(self): serializer = extensions.ExtensionsXMLSerializer() data = {"extensions": [{ "name": "Public Image Extension", "namespace": "http://foo.com/api/ext/pie/v1.0", "alias": "RS-PIE", "updated": "2011-01-22T13:25:27-06:00", "description": "Adds the capability to share an image.", "links": [{"rel": "describedby", "type": "application/pdf", "type": "application/vnd.sun.wadl+xml", "href": "http://foo.com/api/ext/cs-pie.pdf"}, {"rel": "describedby", "type": "application/vnd.sun.wadl+xml", "href": "http://foo.com/api/ext/cs-pie.wadl"}]}, {"name": "Cloud Block Storage", "namespace": "http://foo.com/api/ext/cbs/v1.0", "alias": "RS-CBS", "updated": "2011-01-12T11:22:33-06:00", "description": "Allows mounting cloud block storage.", "links": [{"rel": "describedby", "type": "application/pdf", "href": "http://foo.com/api/ext/cs-cbs.pdf"}, {"rel": "describedby", "type": "application/vnd.sun.wadl+xml", "href": "http://foo.com/api/ext/cs-cbs.wadl"}]}]} xml = serializer.serialize(data, 'index') print xml root = etree.XML(xml) ext_elems = root.findall('{0}extension'.format(NS)) self.assertEqual(len(ext_elems), 2) for i, ext_elem in enumerate(ext_elems): ext_dict = data['extensions'][i] self.assertEqual(ext_elem.findtext('{0}description'.format(NS)), ext_dict['description']) for key in ['name', 'namespace', 'alias', 'updated']: self.assertEqual(ext_elem.get(key), ext_dict[key]) link_nodes = ext_elem.findall('{0}link'.format(ATOMNS)) self.assertEqual(len(link_nodes), 2) for i, link in enumerate(ext_dict['links']): for key, value in link.items(): self.assertEqual(link_nodes[i].get(key), value) xmlutil.validate_schema(root, 'extensions')
def test_show_handles_integers(self): serializer = flavors.FlavorTemplate() fixture = { "flavor": { "id": 12, "name": "asdf", "ram": 256, "disk": 10, "rxtx_factor": "1", "swap": "", "vcpus": "", "links": [ { "rel": "self", "href": "http://localhost/v2/fake/flavors/12", }, { "rel": "bookmark", "href": "http://localhost/fake/flavors/12", }, ], }, } output = serializer.serialize(fixture) print output root = etree.XML(output) xmlutil.validate_schema(root, 'flavor') flavor_dict = fixture['flavor'] for key in ['name', 'id', 'ram', 'disk']: self.assertEqual(root.get(key), str(flavor_dict[key])) link_nodes = root.findall('{0}link'.format(ATOMNS)) self.assertEqual(len(link_nodes), 2) for i, link in enumerate(flavor_dict['links']): for key, value in link.items(): self.assertEqual(link_nodes[i].get(key), value)
def test_index_no_limits(self): serializer = limits.LimitsTemplate() fixture = {"limits": {"rate": [], "absolute": {}}} output = serializer.serialize(fixture) print output root = etree.XML(output) xmlutil.validate_schema(root, 'limits') #verify absolute limits absolutes = root.xpath('ns:absolute/ns:limit', namespaces=NS) self.assertEqual(len(absolutes), 0) #verify rate limits rates = root.xpath('ns:rates/ns:rate', namespaces=NS) self.assertEqual(len(rates), 0)
def test_index_unicode(self): serializer = common.MetadataXMLSerializer() fixture = { 'metadata': { u'three': u'Jos\xe9', }, } output = serializer.serialize(fixture, 'index') print output root = etree.XML(output) xmlutil.validate_schema(root, 'metadata') metadata_dict = fixture['metadata'] metadata_elems = root.findall('{0}meta'.format(NS)) self.assertEqual(len(metadata_elems), 1) for i, metadata_elem in enumerate(metadata_elems): (meta_key, meta_value) = metadata_dict.items()[i] self.assertEqual(str(metadata_elem.get('key')), str(meta_key)) self.assertEqual(metadata_elem.text.strip(), meta_value)
def test_index_no_limits(self): serializer = limits.LimitsTemplate() fixture = {"limits": { "rate": [], "absolute": {}}} output = serializer.serialize(fixture) print output root = etree.XML(output) xmlutil.validate_schema(root, 'limits') #verify absolute limits absolutes = root.xpath('ns:absolute/ns:limit', namespaces=NS) self.assertEqual(len(absolutes), 0) #verify rate limits rates = root.xpath('ns:rates/ns:rate', namespaces=NS) self.assertEqual(len(rates), 0)
def test_update_all(self): serializer = common.MetadataXMLSerializer() fixture = { 'metadata': { 'key6': 'value6', 'key4': 'value4', }, } output = serializer.serialize(fixture, 'update_all') print output root = etree.XML(output) xmlutil.validate_schema(root, 'metadata') metadata_dict = fixture['metadata'] metadata_elems = root.findall('{0}meta'.format(NS)) self.assertEqual(len(metadata_elems), 2) for i, metadata_elem in enumerate(metadata_elems): (meta_key, meta_value) = metadata_dict.items()[i] self.assertEqual(str(metadata_elem.get('key')), str(meta_key)) self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
def test_get_version_2_detail_atom(self): req = webob.Request.blank('/v2/') req.accept = "application/atom+xml" res = req.get_response(fakes.wsgi_app()) self.assertEqual(res.status_int, 200) self.assertEqual("application/atom+xml", res.content_type) xmlutil.validate_schema(etree.XML(res.body), 'atom') f = feedparser.parse(res.body) self.assertEqual(f.feed.title, 'About This Version') self.assertEqual(f.feed.updated, '2011-01-21T11:33:21Z') self.assertEqual(f.feed.id, 'http://localhost/v2/') self.assertEqual(f.feed.author, 'Rackspace') self.assertEqual(f.feed.author_detail.href, 'http://www.rackspace.com/') self.assertEqual(f.feed.links[0]['href'], 'http://localhost/v2/') self.assertEqual(f.feed.links[0]['rel'], 'self') self.assertEqual(len(f.entries), 1) entry = f.entries[0] self.assertEqual(entry.id, 'http://localhost/v2/') self.assertEqual(entry.title, 'Version v2.0') self.assertEqual(entry.updated, '2011-01-21T11:33:21Z') self.assertEqual(len(entry.content), 1) self.assertEqual(entry.content[0].value, 'Version v2.0 CURRENT (2011-01-21T11:33:21Z)') self.assertEqual(len(entry.links), 3) self.assertEqual(entry.links[0]['href'], 'http://localhost/v2/') self.assertEqual(entry.links[0]['rel'], 'self') self.assertEqual(entry.links[1], { 'href': 'http://docs.rackspacecloud.com/servers/api/v1.1/'\ 'cs-devguide-20110125.pdf', 'type': 'application/pdf', 'rel': 'describedby'}) self.assertEqual(entry.links[2], { 'href': 'http://docs.rackspacecloud.com/servers/api/v1.1/'\ 'application.wadl', 'type': 'application/vnd.sun.wadl+xml', 'rel': 'describedby'})
def test_get_version_2_detail_xml(self): req = webob.Request.blank('/v2/') req.accept = "application/xml" res = req.get_response(fakes.wsgi_app()) self.assertEqual(res.status_int, 200) self.assertEqual(res.content_type, "application/xml") version = etree.XML(res.body) xmlutil.validate_schema(version, 'version') expected = VERSIONS['v2.0'] self.assertTrue(version.xpath('/ns:version', namespaces=NS)) media_types = version.xpath('ns:media-types/ns:media-type', namespaces=NS) self.assertTrue(common.compare_media_types(media_types, expected['media-types'])) for key in ['id', 'status', 'updated']: self.assertEqual(version.get(key), expected[key]) links = version.xpath('atom:link', namespaces=NS) self.assertTrue(common.compare_links(links, [{'rel': 'self', 'href': 'http://localhost/v2/'}] + expected['links']))
def test_get_extension_xml(self): app = v2.APIRouter() ext_midware = extensions.ExtensionMiddleware(app) ser_midware = wsgi.LazySerializationMiddleware(ext_midware) request = webob.Request.blank("/123/extensions/FOXNSOX") request.accept = "application/xml" response = request.get_response(ser_midware) self.assertEqual(200, response.status_int) xml = response.body print xml root = etree.XML(xml) self.assertEqual(root.tag.split('extension')[0], NS) self.assertEqual(root.get('alias'), 'FOXNSOX') self.assertEqual(root.get('name'), 'Fox In Socks') self.assertEqual(root.get('namespace'), 'http://www.fox.in.socks/api/ext/pie/v1.0') self.assertEqual(root.get('updated'), '2011-01-22T13:25:27-06:00') self.assertEqual(root.findtext('{0}description'.format(NS)), 'The Fox In Socks Extension') xmlutil.validate_schema(root, 'extension')
def test_versions_list_xml_serializer(self): versions_data = { 'versions': [ { "id": "2.7", "updated": "2011-07-18T11:30:00Z", "status": "DEPRECATED", "links": [ { "rel": "self", "href": "http://test/v2", }, ], }, ] } serializer = versions.VersionsTemplate() response = serializer.serialize(versions_data) root = etree.XML(response) xmlutil.validate_schema(root, 'versions') self.assertTrue(root.xpath('/ns:versions', namespaces=NS)) version_elems = root.xpath('ns:version', namespaces=NS) self.assertEqual(len(version_elems), 1) version = version_elems[0] self.assertEqual(version.get('id'), versions_data['versions'][0]['id']) self.assertEqual(version.get('status'), versions_data['versions'][0]['status']) (link, ) = version.xpath('atom:link', namespaces=NS) self.assertTrue( common.compare_links(link, [{ 'rel': 'self', 'href': 'http://test/v2', 'type': 'application/atom+xml' }]))
def test_get_version_list_xml(self): req = webob.Request.blank('/') req.accept = "application/xml" res = req.get_response(fakes.wsgi_app()) self.assertEqual(res.status_int, 200) self.assertEqual(res.content_type, "application/xml") root = etree.XML(res.body) print res.body xmlutil.validate_schema(root, 'versions') self.assertTrue(root.xpath('/ns:versions', namespaces=NS)) versions = root.xpath('ns:version', namespaces=NS) self.assertEqual(len(versions), 1) for i, v in enumerate(['v2.0']): version = versions[i] expected = VERSIONS[v] for key in ['id', 'status', 'updated']: self.assertEqual(version.get(key), expected[key]) (link,) = version.xpath('atom:link', namespaces=NS) self.assertTrue(common.compare_links(link, [{'rel': 'self', 'href': 'http://localhost/%s/' % v}]))
def test_get_version_2_detail_xml(self): req = webob.Request.blank('/v2/') req.accept = "application/xml" res = req.get_response(fakes.wsgi_app()) self.assertEqual(res.status_int, 200) self.assertEqual(res.content_type, "application/xml") version = etree.XML(res.body) xmlutil.validate_schema(version, 'version') expected = VERSIONS['v2.0'] self.assertTrue(version.xpath('/ns:version', namespaces=NS)) media_types = version.xpath('ns:media-types/ns:media-type', namespaces=NS) self.assertTrue( common.compare_media_types(media_types, expected['media-types'])) for key in ['id', 'status', 'updated']: self.assertEqual(version.get(key), expected[key]) links = version.xpath('atom:link', namespaces=NS) self.assertTrue( common.compare_links(links, [{ 'rel': 'self', 'href': 'http://localhost/v2/' }] + expected['links']))
def test_versions_list_xml_serializer(self): versions_data = { 'versions': [ { "id": "2.7", "updated": "2011-07-18T11:30:00Z", "status": "DEPRECATED", "links": [ { "rel": "self", "href": "http://test/v2", }, ], }, ] } serializer = versions.VersionsTemplate() response = serializer.serialize(versions_data) root = etree.XML(response) xmlutil.validate_schema(root, 'versions') self.assertTrue(root.xpath('/ns:versions', namespaces=NS)) version_elems = root.xpath('ns:version', namespaces=NS) self.assertEqual(len(version_elems), 1) version = version_elems[0] self.assertEqual(version.get('id'), versions_data['versions'][0]['id']) self.assertEqual(version.get('status'), versions_data['versions'][0]['status']) (link,) = version.xpath('atom:link', namespaces=NS) self.assertTrue(common.compare_links(link, [{ 'rel': 'self', 'href': 'http://test/v2', 'type': 'application/atom+xml'}]))
def test_index(self): serializer = flavors.MinimalFlavorsTemplate() fixture = { "flavors": [ { "id": "23", "name": "flavor 23", "ram": "512", "disk": "20", "rxtx_factor": "1", "swap": "", "vcpus": "", "links": [ { "rel": "self", "href": "http://localhost/v2/fake/flavors/23", }, { "rel": "bookmark", "href": "http://localhost/fake/flavors/23", }, ], }, { "id": "13", "name": "flavor 13", "ram": "256", "disk": "10", "rxtx_factor": "1", "swap": "", "vcpus": "", "links": [ { "rel": "self", "href": "http://localhost/v2/fake/flavors/13", }, { "rel": "bookmark", "href": "http://localhost/fake/flavors/13", }, ], }, ], } output = serializer.serialize(fixture) print output root = etree.XML(output) xmlutil.validate_schema(root, 'flavors_index') flavor_elems = root.findall('{0}flavor'.format(NS)) self.assertEqual(len(flavor_elems), 2) for i, flavor_elem in enumerate(flavor_elems): flavor_dict = fixture['flavors'][i] for key in ['name', 'id']: self.assertEqual(flavor_elem.get(key), str(flavor_dict[key])) link_nodes = flavor_elem.findall('{0}link'.format(ATOMNS)) self.assertEqual(len(link_nodes), 2) for i, link in enumerate(flavor_dict['links']): for key, value in link.items(): self.assertEqual(link_nodes[i].get(key), value)
def test_index(self): serializer = limits.LimitsTemplate() fixture = { "limits": { "rate": [{ "uri": "*", "regex": ".*", "limit": [{ "value": 10, "verb": "POST", "remaining": 2, "unit": "MINUTE", "next-available": "2011-12-15T22:42:45Z" }] }, { "uri": "*/servers", "regex": "^/servers", "limit": [{ "value": 50, "verb": "POST", "remaining": 10, "unit": "DAY", "next-available": "2011-12-15T22:42:45Z" }] }], "absolute": { "maxServerMeta": 1, "maxImageMeta": 1, "maxPersonality": 5, "maxPersonalitySize": 10240 } } } output = serializer.serialize(fixture) print output root = etree.XML(output) xmlutil.validate_schema(root, 'limits') #verify absolute limits absolutes = root.xpath('ns:absolute/ns:limit', namespaces=NS) self.assertEqual(len(absolutes), 4) for limit in absolutes: name = limit.get('name') value = limit.get('value') self.assertEqual(value, str(fixture['limits']['absolute'][name])) #verify rate limits rates = root.xpath('ns:rates/ns:rate', namespaces=NS) self.assertEqual(len(rates), 2) for i, rate in enumerate(rates): for key in ['uri', 'regex']: self.assertEqual(rate.get(key), str(fixture['limits']['rate'][i][key])) rate_limits = rate.xpath('ns:limit', namespaces=NS) self.assertEqual(len(rate_limits), 1) for j, limit in enumerate(rate_limits): for key in [ 'verb', 'value', 'remaining', 'unit', 'next-available' ]: self.assertEqual( limit.get(key), str(fixture['limits']['rate'][i]['limit'][j][key]))