Merge lp:~alecu/ubuntu-sso-client/restful-client into lp:ubuntu-sso-client

[Alejandro J. Cura]

An async, proxy-enabled replacement for lazr.restfulclient

An async, proxy-enabled replacement for lazr.restfulclient
An upcoming branch will use this module to remove the threads that use lazr

NOTE! This branch also depends on lp:~alecu/ubuntu-sso-client/proxy-integration-tests

[lp:~alecu/ubuntu-sso-client/restful-client]

847. By Alejandro J. Cura on 2012-01-11

merged with trunk

[Diego Sarmentero (diegosarmentero)]

== Python Lint Notices ==

ubuntu_sso/utils/webclient/tests/test_webclient.py:
    343: [E0102, BasicProxyTestCase] class already defined line 305
    347: [E1003, BasicProxyTestCase.setUp] Bad first argument 'BasicProxyTestCase' given to super class

review: Needs Fixing

[lp:~alecu/ubuntu-sso-client/restful-client]

848. By Alejandro J. Cura on 2012-01-12

remove duplicated testcase

[Natalia Bidart (nataliabidart)]

Could you please put the value of reply.readAll() in a variable and use that in the 3 lines that uses it?

Shall you also assert on RestfulClient.__init__ that the iri is unicode?

Rest looks good! I will mark as approved but please change the readAll() thingy.

review: Approve

[lp:~alecu/ubuntu-sso-client/restful-client]

849. By Alejandro J. Cura on 2012-01-12

refactor requested by nessita

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

=== modified file 'ubuntu_sso/utils/webclient/common.py'
--- ubuntu_sso/utils/webclient/common.py	2012-01-04 21:26:27 +0000
+++ ubuntu_sso/utils/webclient/common.py	2012-01-12 17:51:24 +0000
@@ -56,7 +56,8 @@
         """Get a timestamp synchronized with the server."""
         # pylint: disable=W0511
         # TODO: get the synchronized timestamp
-        return defer.succeed(time.time())
+        timestamp = time.time()
+        return defer.succeed(int(timestamp))
 
     def force_use_proxy(self, settings):
         """Setup this webclient to use the given proxy settings."""
 
=== modified file 'ubuntu_sso/utils/webclient/qtnetwork.py'
--- ubuntu_sso/utils/webclient/qtnetwork.py	2012-01-04 21:26:27 +0000
+++ ubuntu_sso/utils/webclient/qtnetwork.py	2012-01-12 17:51:24 +0000
@@ -102,17 +102,19 @@
         assert reply in self.replies
         d = self.replies.pop(reply)
         error = reply.error()
+        content = reply.readAll()
         if not error:
             headers = defaultdict(list)
             for key, value in reply.rawHeaderPairs():
                 headers[str(key)].append(str(value))
-            response = Response(reply.readAll(), headers)
+            response = Response(bytes(content), headers)
             d.callback(response)
         else:
+            error_string = reply.errorString()
             if error == QNetworkReply.AuthenticationRequiredError:
-                exception = UnauthorizedError(reply.errorString())
+                exception = UnauthorizedError(error_string, content)
             else:
-                exception = WebClientError(reply.errorString())
+                exception = WebClientError(error_string, content)
             d.errback(exception)
 
     def force_use_proxy(self, settings):
 
=== added file 'ubuntu_sso/utils/webclient/restful.py'
--- ubuntu_sso/utils/webclient/restful.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/restful.py	2012-01-12 17:51:24 +0000
@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""A proxy-enabled restful client."""
+
+import json
+import urllib
+
+from twisted.internet import defer
+
+from ubuntu_sso.utils import webclient
+
+
+class RestfulClient(object):
+    """A proxy-enabled restful client."""
+
+    def __init__(self, service_iri, username=None, password=None,
+                 oauth_credentials=None):
+        """Initialize this instance."""
+        assert service_iri.endswith("/")
+        self.service_iri = service_iri
+        self.webclient = webclient.webclient_factory(username=username,
+                                                     password=password)
+        self.oauth_credentials = oauth_credentials
+
+    @defer.inlineCallbacks
+    def restcall(self, method, **kwargs):
+        """Make a restful call."""
+        assert isinstance(method, unicode)
+        for key, value in kwargs.items():
+            if isinstance(value, basestring):
+                assert isinstance(value, unicode)
+                kwargs[key] = value.encode("utf-8")
+        namespace, operation = method.split(".")
+        kwargs["ws.op"] = operation
+        encoded_args = urllib.urlencode(kwargs)
+        iri = self.service_iri + namespace + "?" + encoded_args
+        creds = self.oauth_credentials
+        result = yield self.webclient.request(iri, oauth_credentials=creds)
+        defer.returnValue(json.loads(result.content))
 
=== added file 'ubuntu_sso/utils/webclient/tests/test_restful.py'
--- ubuntu_sso/utils/webclient/tests/test_restful.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/tests/test_restful.py	2012-01-12 17:51:24 +0000
@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT AN WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the proxy-enabled restful client."""
+
+import urlparse
+
+from twisted.internet import defer
+from ubuntuone.devtools.testcases import TestCase
+
+from ubuntu_sso.utils.webclient import restful
+from ubuntu_sso.utils.webclient.common import Response
+
+
+SAMPLE_SERVICE_IRI = u"http://localhost/"
+SAMPLE_NAMESPACE = u"sample_namespace"
+SAMPLE_METHOD = u"sample_method"
+SAMPLE_OPERATION = SAMPLE_NAMESPACE + u"." + SAMPLE_METHOD
+SAMPLE_ARGS = dict(uno=1, dos=u"2", tres=u"ñandú")
+SAMPLE_RESPONSE = restful.json.dumps(SAMPLE_ARGS)
+SAMPLE_USERNAME = "[e-mail]"
+SAMPLE_PASSWORD = "clavesecreta"
+SAMPLE_OAUTH_CREDS = dict(token="1234", etc="456")
+
+
+class FakeWebClient(object):
+    """A fake web client."""
+
+    def __init__(self, **kwargs):
+        """Initialize this faker."""
+        self.return_value = SAMPLE_RESPONSE
+        self.called = []
+        self.init_kwargs = kwargs
+
+    def request(self, iri, *args, **kwargs):
+        """Return a deferred that will be fired with a Response object."""
+        self.called.append((iri, args, kwargs))
+        return defer.succeed(Response(self.return_value))
+
+
+class BaseTestCase(TestCase):
+    """The base for the Restful Client testcases."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Initialize this test case."""
+        yield super(BaseTestCase, self).setUp()
+        self.wc = None
+        self.patch(restful.webclient, "webclient_factory",
+                   self.webclient_factory)
+
+    def webclient_factory(self, **kwargs):
+        """A factory that saves the webclient created."""
+        self.wc = FakeWebClient(**kwargs)
+        return self.wc
+
+
+class RestfulClientTestCase(BaseTestCase):
+    """Tests for the proxy-enabled Restful Client."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Initialize this testcase."""
+        yield super(RestfulClientTestCase, self).setUp()
+        self.rc = restful.RestfulClient(SAMPLE_SERVICE_IRI)
+
+    def test_has_a_webclient(self):
+        """The RC has a webclient."""
+        self.assertEqual(self.rc.webclient, self.wc)
+
+    @defer.inlineCallbacks
+    def test_can_make_calls(self):
+        """The RC can make webcalls."""
+        yield self.rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
+        self.assertEqual(len(self.wc.called), 1)
+
+    @defer.inlineCallbacks
+    def get_parsed_url(self):
+        """Call the sample operation, and return the url used."""
+        yield self.rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
+        iri, _, _ = self.wc.called[0]
+        uri = iri.encode("ascii")
+        defer.returnValue(urlparse.urlparse(uri))
+
+    @defer.inlineCallbacks
+    def test_restful_namespace_added_to_url(self):
+        """The restful namespace is added to the url."""
+        url = yield self.get_parsed_url()
+        self.assertTrue(url.path.endswith(SAMPLE_NAMESPACE),
+                        "The namespace is included in url")
+
+    @defer.inlineCallbacks
+    def test_restful_method_added_to_url(self):
+        """The restful method is added to the url."""
+        url = yield self.get_parsed_url()
+        url_query = urlparse.parse_qs(url.query)
+        self.assertEqual(url_query["ws.op"][0], SAMPLE_METHOD)
+
+    @defer.inlineCallbacks
+    def test_arguments_added_to_call(self):
+        """The keyword arguments are used in the called url."""
+        url = yield self.get_parsed_url()
+        url_query = dict(urlparse.parse_qsl(url.query))
+        del(url_query["ws.op"])
+        expected = {}
+        for key, value in SAMPLE_ARGS.items():
+            if isinstance(value, unicode):
+                expected[key] = value.encode("utf-8")
+            else:
+                expected[key] = str(value)
+        self.assertEqual(url_query, expected)
+
+    @defer.inlineCallbacks
+    def test_return_value_json_parsed(self):
+        """The result is json parsed before being returned."""
+        result = yield self.rc.restcall(SAMPLE_OPERATION)
+        self.assertEqual(result, SAMPLE_ARGS)
+
+
+class AuthenticationOptionsTestCase(BaseTestCase):
+    """Tests for the authentication options."""
+
+    def test_passes_userpass_to_webclient_init(self):
+        """The RestfulClient passes the user and pass to the webclient."""
+        expected = dict(username=SAMPLE_USERNAME, password=SAMPLE_PASSWORD)
+        restful.RestfulClient(SAMPLE_SERVICE_IRI, **expected)
+        self.assertEqual(self.wc.init_kwargs, expected)
+
+    @defer.inlineCallbacks
+    def test_passes_oauth_creds_to_request(self):
+        """The RestfulClient passes the credentials in each request."""
+        kwargs = dict(oauth_credentials=SAMPLE_OAUTH_CREDS)
+        rc = restful.RestfulClient(SAMPLE_SERVICE_IRI, **kwargs)
+        yield rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
+        _, _, kwargs = self.wc.called[0]
+        self.assertEqual(kwargs["oauth_credentials"], SAMPLE_OAUTH_CREDS)
 
=== modified file 'ubuntu_sso/utils/webclient/tests/test_webclient.py'
--- ubuntu_sso/utils/webclient/tests/test_webclient.py	2012-01-11 04:37:08 +0000
+++ ubuntu_sso/utils/webclient/tests/test_webclient.py	2012-01-12 17:51:24 +0000
@@ -293,6 +293,14 @@
                                        oauth_credentials=SAMPLE_CREDENTIALS)
         self.assertEqual(SAMPLE_RESOURCE, result.content)
 
+    @defer.inlineCallbacks
+    def test_returned_content_are_bytes(self):
+        """The returned content are bytes."""
+        result = yield self.wc.request(self.base_iri + OAUTHRESOURCE,
+                                       oauth_credentials=SAMPLE_CREDENTIALS)
+        self.assertTrue(isinstance(result.content, bytes),
+                        "The type of %r must be bytes" % result.content)
+
 
 class BasicProxyTestCase(SquidTestCase):
     """Test that the proxy works at all."""