XML de/serialization (bug 928058)

Middleware rewrites incoming XML requests as JSON, and outgoing JSON as
XML, per Accept and Content-Type headers.

Tests assert that core API methods support WADL/XSD specs, and cover
JSON content as well.

Change-Id: I6897971dd745766cbc472fd6e5346b1b34d933b0

1 files changed, 578 insertions, 0 deletions

diff --git a/tests/test_content_types.py b/tests/test_content_types.py
new file mode 100644
index 00000000..016ffa9a
--- /dev/null
+++ b/tests/test_content_types.py
@@ -0,0 +1,578 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+import httplib
+import json
+
+from lxml import etree
+import nose.exc
+
+from keystone import test
+from keystone.common import serializer
+
+import default_fixtures
+
+
+class RestfulTestCase(test.TestCase):
+    """Performs restful tests against the WSGI app over HTTP.
+
+    This class launches public & admin WSGI servers for every test, which can
+    be accessed by calling ``public_request()`` or ``admin_request()``,
+    respectfully.
+
+    ``restful_request()`` and ``request()`` methods are also exposed if you
+    need to bypass restful conventions or access HTTP details in your test
+    implementation.
+
+    Two new asserts are provided:
+
+    * ``assertResponseSuccessful``: called automatically for every request
+        unless an ``expected_status`` is provided
+    * ``assertResponseStatus``: called instead of ``assertResponseSuccessful``,
+        if an ``expected_status`` is provided
+
+    Requests are automatically serialized according to the defined
+    ``content_type``. Responses are automatically deserialized as well, and
+    available in the ``response.body`` attribute. The original body content is
+    available in the ``response.raw`` attribute.
+
+    """
+
+    # default content type to test
+    content_type = 'json'
+
+    def setUp(self):
+        super(RestfulTestCase, self).setUp()
+
+        self.load_backends()
+        self.load_fixtures(default_fixtures)
+
+        self.public_server = self.serveapp('keystone', name='main')
+        self.admin_server = self.serveapp('keystone', name='admin')
+
+        # TODO(termie): is_admin is being deprecated once the policy stuff
+        #               is all working
+        # TODO(termie): add an admin user to the fixtures and use that user
+        # override the fixtures, for now
+        self.metadata_foobar = self.identity_api.update_metadata(
+                self.user_foo['id'],
+                self.tenant_bar['id'],
+                dict(roles=['keystone_admin'], is_admin='1'))
+
+    def tearDown(self):
+        """Kill running servers and release references to avoid leaks."""
+        self.public_server.kill()
+        self.admin_server.kill()
+        self.public_server = None
+        self.admin_server = None
+        super(RestfulTestCase, self).tearDown()
+
+    def request(self, host='0.0.0.0', port=80, method='GET', path='/',
+                headers=None, body=None, expected_status=None):
+        """Perform request and fetch httplib.HTTPResponse from the server."""
+
+        # Initialize headers dictionary
+        headers = {} if not headers else headers
+
+        connection = httplib.HTTPConnection(host, port, timeout=10)
+
+        # Perform the request
+        connection.request(method, path, body, headers)
+
+        # Retrieve the response so we can close the connection
+        response = connection.getresponse()
+
+        response.body = response.read()
+
+        # Close the connection
+        connection.close()
+
+        # Automatically assert HTTP status code
+        if expected_status:
+            self.assertResponseStatus(response, expected_status)
+        else:
+            self.assertResponseSuccessful(response)
+
+        # Contains the response headers, body, etc
+        return response
+
+    def assertResponseSuccessful(self, response):
+        """Asserts that a status code lies inside the 2xx range.
+
+        :param response: :py:class:`httplib.HTTPResponse` to be
+          verified to have a status code between 200 and 299.
+
+        example::
+
+            >>> self.assertResponseSuccessful(response, 203)
+        """
+        self.assertTrue(response.status >= 200 and response.status <= 299,
+            'Status code %d is outside of the expected range (2xx)\n\n%s' %
+            (response.status, response.body))
+
+    def assertResponseStatus(self, response, expected_status):
+        """Asserts a specific status code on the response.
+
+        :param response: :py:class:`httplib.HTTPResponse`
+        :param assert_status: The specific ``status`` result expected
+
+        example::
+
+            >>> self.assertResponseStatus(response, 203)
+        """
+        self.assertEqual(response.status, expected_status,
+            'Status code %s is not %s, as expected)\n\n%s' %
+            (response.status, expected_status, response.body))
+
+    def _to_content_type(self, body, headers, content_type=None):
+        """Attempt to encode JSON and XML automatically."""
+        content_type = content_type or self.content_type
+
+        if content_type == 'json':
+            headers['Accept'] = 'application/json'
+            if body:
+                headers['Content-Type'] = 'application/json'
+                return json.dumps(body)
+        elif content_type == 'xml':
+            headers['Accept'] = 'application/xml'
+            if body:
+                headers['Content-Type'] = 'application/xml'
+                return serializer.to_xml(body)
+
+    def _from_content_type(self, response, content_type=None):
+        """Attempt to decode JSON and XML automatically, if detected."""
+        content_type = content_type or self.content_type
+
+        # make the original response body available, for convenience
+        response.raw = response.body
+
+        if response.body is not None and response.body.strip():
+            # if a body is provided, a Content-Type is also expected
+            header = response.getheader('Content-Type', None)
+            self.assertIn(self.content_type, header)
+
+            if self.content_type == 'json':
+                response.body = json.loads(response.body)
+            elif self.content_type == 'xml':
+                response.body = etree.fromstring(response.body)
+
+    def restful_request(self, headers=None, body=None, token=None, **kwargs):
+        """Serializes/deserializes json/xml as request/response body.
+
+        .. WARNING::
+
+            * Existing Accept header will be overwritten.
+            * Existing Content-Type header will be overwritten.
+
+        """
+        # Initialize headers dictionary
+        headers = {} if not headers else headers
+
+        if token is not None:
+            headers['X-Auth-Token'] = token
+
+        body = self._to_content_type(body, headers)
+
+        # Perform the HTTP request/response
+        response = self.request(headers=headers, body=body, **kwargs)
+
+        self._from_content_type(response)
+
+        # we can save some code & improve coverage by always doing this
+        if response.status >= 400:
+            self.assertValidErrorResponse(response)
+
+        # Contains the decoded response.body
+        return response
+
+    def _get_port(self, server):
+        return server.socket_info['socket'][1]
+
+    def _public_port(self):
+        return self._get_port(self.public_server)
+
+    def _admin_port(self):
+        return self._get_port(self.admin_server)
+
+    def public_request(self, port=None, **kwargs):
+        kwargs['port'] = port or self._public_port()
+        return self.restful_request(**kwargs)
+
+    def admin_request(self, port=None, **kwargs):
+        kwargs['port'] = port or self._admin_port()
+        return self.restful_request(**kwargs)
+
+    def get_scoped_token(self):
+        """Convenience method so that we can test authenticated requests."""
+        r = self.public_request(method='POST', path='/v2.0/tokens', body={
+                'auth': {
+                    'passwordCredentials': {
+                        'username': self.user_foo['name'],
+                        'password': self.user_foo['password'],
+                    },
+                    'tenantId': self.tenant_bar['id'],
+                },
+            })
+        return self._get_token_id(r)
+
+    def _get_token_id(self, r):
+        """Helper method to return a token ID from a response.
+
+        This needs to be overridden by child classes for on their content type.
+
+        """
+        raise NotImplementedError()
+
+
+class CoreApiTests(object):
+    def assertValidError(self, error):
+        """Applicable to XML and JSON."""
+        try:
+            print error.attrib
+        except:
+            pass
+        self.assertIsNotNone(error.get('code'))
+        self.assertIsNotNone(error.get('title'))
+        self.assertIsNotNone(error.get('message'))
+
+    def assertValidTenant(self, tenant):
+        """Applicable to XML and JSON."""
+        self.assertIsNotNone(tenant.get('id'))
+        self.assertIsNotNone(tenant.get('name'))
+
+    def assertValidUser(self, user):
+        """Applicable to XML and JSON."""
+        self.assertIsNotNone(user.get('id'))
+        self.assertIsNotNone(user.get('name'))
+
+    def assertValidRole(self, tenant):
+        """Applicable to XML and JSON."""
+        self.assertIsNotNone(tenant.get('id'))
+        self.assertIsNotNone(tenant.get('name'))
+
+    def test_public_multiple_choice(self):
+        r = self.public_request(path='/', expected_status=300)
+        self.assertValidMultipleChoiceResponse(r)
+
+    def test_admin_multiple_choice(self):
+        r = self.admin_request(path='/', expected_status=300)
+        self.assertValidMultipleChoiceResponse(r)
+
+    def test_public_version(self):
+        raise nose.exc.SkipTest('Blocked by bug 925548')
+
+        r = self.public_request(path='/v2.0/')
+        self.assertValidVersionResponse(r)
+
+    def test_admin_version(self):
+        raise nose.exc.SkipTest('Blocked by bug 925548')
+
+        r = self.admin_request(path='/v2.0/')
+        self.assertValidVersionResponse(r)
+
+    def test_public_extensions(self):
+        raise nose.exc.SkipTest('Blocked by bug 928054')
+
+        self.public_request(path='/v2.0/extensions',)
+
+    def test_admin_extensions(self):
+        raise nose.exc.SkipTest('Blocked by bug 928054')
+
+        self.admin_request(path='/v2.0/extensions',)
+
+    def test_authenticate(self):
+        r = self.public_request(method='POST', path='/v2.0/tokens', body={
+                'auth': {
+                    'passwordCredentials': {
+                        'username': self.user_foo['name'],
+                        'password': self.user_foo['password'],
+                    },
+                    'tenantId': self.tenant_bar['id'],
+                },
+            },
+            # TODO(dolph): creating a token should result in a 201 Created
+            expected_status=200)
+        self.assertValidAuthenticationResponse(r)
+
+    def test_get_tenants_for_token(self):
+        r = self.public_request(path='/v2.0/tenants',
+            token=self.get_scoped_token())
+        self.assertValidTenantListResponse(r)
+
+    def test_validate_token(self):
+        token = self.get_scoped_token()
+        r = self.admin_request(path='/v2.0/tokens/%(token_id)s' % {
+                'token_id': token,
+            },
+            token=token)
+        self.assertValidAuthenticationResponse(r)
+
+    def test_validate_token_head(self):
+        """The same call as above, except using HEAD.
+
+        There's no response to validate here, but this is included for the
+        sake of completely covering the core API.
+
+        """
+        raise nose.exc.SkipTest('Blocked by bug 933587')
+
+        token = self.get_scoped_token()
+        self.admin_request(method='HEAD', path='/v2.0/tokens/%(token_id)s' % {
+                'token_id': token,
+            },
+            token=token)
+
+    def test_endpoints(self):
+        raise nose.exc.SkipTest('Blocked by bug 933555')
+
+        token = self.get_scoped_token()
+        r = self.admin_request(path='/v2.0/tokens/%(token_id)s/endpoints' % {
+                'token_id': token,
+            },
+            token=token)
+        self.assertValidTokenCatalogResponse(r)
+
+    def test_get_tenant(self):
+        token = self.get_scoped_token()
+        r = self.admin_request(path='/v2.0/tenants/%(tenant_id)s' % {
+                'tenant_id': self.tenant_bar['id'],
+            },
+            token=token)
+        self.assertValidTenantResponse(r)
+
+    def test_get_user_roles(self):
+        raise nose.exc.SkipTest('Blocked by bug 933565')
+
+        token = self.get_scoped_token()
+        r = self.admin_request(path='/v2.0/users/%(user_id)s/roles' % {
+                'user_id': self.user_foo['id'],
+            },
+            token=token)
+        self.assertValidRoleListResponse(r)
+
+    def test_get_user_roles_with_tenant(self):
+        token = self.get_scoped_token()
+        r = self.admin_request(
+            path='/v2.0/tenants/%(tenant_id)s/users/%(user_id)s/roles' % {
+                'tenant_id': self.tenant_bar['id'],
+                'user_id': self.user_foo['id'],
+            },
+            token=token)
+        self.assertValidRoleListResponse(r)
+
+    def test_get_user(self):
+        token = self.get_scoped_token()
+        r = self.admin_request(path='/v2.0/users/%(user_id)s' % {
+                'user_id': self.user_foo['id'],
+            },
+            token=token)
+        self.assertValidUserResponse(r)
+
+    def test_error_response(self):
+        """This triggers assertValidErrorResponse by convention."""
+        self.public_request(path='/v2.0/tenants', expected_status=401)
+
+
+class JsonTestCase(RestfulTestCase, CoreApiTests):
+    content_type = 'json'
+
+    def _get_token_id(self, r):
+        """Applicable only to JSON."""
+        return r.body['access']['token']['id']
+
+    def assertValidErrorResponse(self, r):
+        self.assertIsNotNone(r.body.get('error'))
+        self.assertValidError(r.body['error'])
+        self.assertEqual(r.body['error']['code'], r.status)
+
+    def assertValidAuthenticationResponse(self, r):
+        self.assertIsNotNone(r.body.get('access'))
+        self.assertIsNotNone(r.body['access'].get('token'))
+        self.assertIsNotNone(r.body['access'].get('user'))
+
+        # validate token
+        self.assertIsNotNone(r.body['access']['token'].get('id'))
+        self.assertIsNotNone(r.body['access']['token'].get('expires'))
+        tenant = r.body['access']['token'].get('tenant')
+        if tenant is not None:
+            # validate tenant
+            self.assertIsNotNone(tenant.get('id'))
+            self.assertIsNotNone(tenant.get('name'))
+
+        # validate user
+        self.assertIsNotNone(r.body['access']['user'].get('id'))
+        self.assertIsNotNone(r.body['access']['user'].get('name'))
+
+        # validate service catalog
+        if r.body['access'].get('serviceCatalog') is not None:
+            self.assertTrue(len(r.body['access']['serviceCatalog']))
+            for service in r.body['access']['serviceCatalog']:
+                # validate service
+                self.assertIsNotNone(service.get('name'))
+                self.assertIsNotNone(service.get('type'))
+
+                # services contain at least one endpoint
+                self.assertIsNotNone(service.get('endpoints'))
+                self.assertTrue(len(service['endpoints']))
+                for endpoint in service['endpoints']:
+                    # validate service endpoint
+                    self.assertIsNotNone(endpoint.get('publicURL'))
+
+    def assertValidTenantListResponse(self, r):
+        self.assertIsNotNone(r.body.get('tenants'))
+        self.assertTrue(len(r.body['tenants']))
+        for tenant in r.body['tenants']:
+            self.assertValidTenant(tenant)
+            self.assertIsNotNone(tenant.get('enabled'))
+            self.assertIn(tenant.get('enabled'), [True, False])
+
+    def assertValidUserResponse(self, r):
+        self.assertIsNotNone(r.body.get('user'))
+        self.assertValidUser(r.body['user'])
+
+    def assertValidTenantResponse(self, r):
+        self.assertIsNotNone(r.body.get('tenant'))
+        self.assertValidTenant(r.body['tenant'])
+
+    def assertValidRoleListResponse(self, r):
+        self.assertIsNotNone(r.body.get('roles'))
+        self.assertTrue(len(r.body['roles']))
+        for role in r.body['roles']:
+            self.assertValidRole(role)
+
+    def assertValidMultipleChoiceResponse(self, r):
+        self.assertIsNotNone(r.body.get('versions'))
+        self.assertIsNotNone(r.body['versions'].get('values'))
+        self.assertTrue(len(r.body['versions']['values']))
+        for version in r.body['versions']['values']:
+            self.assertIsNotNone(version.get('id'))
+            self.assertIsNotNone(version.get('status'))
+            self.assertIsNotNone(version.get('updated'))
+            self.assertIsNotNone(version.get('links'))
+            self.assertTrue(len(version.get('links')))
+            for link in version.get('links'):
+                self.assertIsNotNone(link.get('rel'))
+                self.assertIsNotNone(link.get('href'))
+            self.assertIsNotNone(version.get('media-types'))
+            self.assertTrue(len(version.get('media-types')))
+            for media in version.get('media-types'):
+                self.assertIsNotNone(media.get('base'))
+                self.assertIsNotNone(media.get('type'))
+
+    def assertValidVersionResponse(self, r):
+        raise NotImplementedError()
+
+
+class XmlTestCase(RestfulTestCase, CoreApiTests):
+    xmlns = 'http://docs.openstack.org/identity/api/v2.0'
+    content_type = 'xml'
+
+    def _get_token_id(self, r):
+        return r.body.find(self._tag('token')).get('id')
+
+    def _tag(self, tag_name, xmlns=None):
+        """Helper method to build an namespaced element name."""
+        return '{%(ns)s}%(tag)s' % {'ns': xmlns or self.xmlns, 'tag': tag_name}
+
+    def assertValidErrorResponse(self, r):
+        xml = r.body
+        self.assertEqual(xml.tag, self._tag('error'))
+
+        self.assertValidError(xml)
+        self.assertEqual(xml.get('code'), str(r.status))
+
+    def assertValidMultipleChoiceResponse(self, r):
+        xml = r.body
+        self.assertEqual(xml.tag, self._tag('versions'))
+
+        self.assertTrue(len(xml.findall(self._tag('version'))))
+        for version in xml.findall(self._tag('version')):
+            # validate service endpoint
+            self.assertIsNotNone(version.get('id'))
+            self.assertIsNotNone(version.get('status'))
+            self.assertIsNotNone(version.get('updated'))
+
+            self.assertTrue(len(version.findall(self._tag('link'))))
+            for link in version.findall(self._tag('link')):
+                self.assertIsNotNone(link.get('rel'))
+                self.assertIsNotNone(link.get('href'))
+
+            media_types = version.find(self._tag('media-types'))
+            self.assertIsNotNone(media_types)
+            self.assertTrue(len(media_types.findall(self._tag('media-type'))))
+            for media in media_types.findall(self._tag('media-type')):
+                self.assertIsNotNone(media.get('base'))
+                self.assertIsNotNone(media.get('type'))
+
+    def assertValidVersionResponse(self, r):
+        raise NotImplementedError()
+
+    def assertValidTokenCatalogResponse(self, r):
+        xml = r.body
+        self.assertEqual(xml.tag, self._tag('endpoints'))
+
+        self.assertTrue(len(xml.findall(self._tag('endpoint'))))
+        for endpoint in xml.findall(self._tag('endpoint')):
+            self.assertIsNotNone(endpoint.get('publicUrl'))
+
+    def assertValidTenantResponse(self, r):
+        xml = r.body
+        self.assertEqual(xml.tag, self._tag('tenant'))
+
+        self.assertValidTenant(xml)
+
+    def assertValidUserResponse(self, r):
+        xml = r.body
+        self.assertEqual(xml.tag, self._tag('user'))
+
+        self.assertValidUser(xml)
+
+    def assertValidRoleListResponse(self, r):
+        xml = r.body
+        self.assertEqual(xml.tag, self._tag('roles'))
+
+        self.assertTrue(len(r.body.findall(self._tag('role'))))
+        for role in r.body.findall(self._tag('role')):
+            self.assertValidRole(role)
+
+    def assertValidAuthenticationResponse(self, r):
+        xml = r.body
+        self.assertEqual(xml.tag, self._tag('access'))
+
+        # validate token
+        token = xml.find(self._tag('token'))
+        self.assertIsNotNone(token)
+        self.assertIsNotNone(token.get('id'))
+        self.assertIsNotNone(token.get('expires'))
+        tenant = token.find(self._tag('tenant'))
+        if tenant is not None:
+            # validate tenant
+            self.assertValidTenant(tenant)
+            self.assertIn(tenant.get('enabled'), ['true', 'false'])
+
+        user = xml.find(self._tag('user'))
+        self.assertIsNotNone(user)
+        self.assertIsNotNone(user.get('id'))
+        self.assertIsNotNone(user.get('name'))
+
+        serviceCatalog = xml.find(self._tag('serviceCatalog'))
+        if serviceCatalog is not None:
+            self.assertTrue(len(serviceCatalog.findall(self._tag('service'))))
+            for service in serviceCatalog.findall(self._tag('service')):
+                # validate service
+                self.assertIsNotNone(service.get('name'))
+                self.assertIsNotNone(service.get('type'))
+
+                # services contain at least one endpoint
+                self.assertTrue(len(service))
+                for endpoint in service.findall(self._tag('endpoint')):
+                    # validate service endpoint
+                    self.assertIsNotNone(endpoint.get('publicURL'))
+
+    def assertValidTenantListResponse(self, r):
+        xml = r.body
+        self.assertEqual(xml.tag, self._tag('tenants'))
+
+        self.assertTrue(len(r.body))
+        for tenant in r.body.findall(self._tag('tenant')):
+            self.assertValidTenant(tenant)
+            self.assertIn(tenant.get('enabled'), ['true', 'false'])