Merge lp:~elachuni/piston-mini-client/failhandler into lp:piston-mini-client

[Anthony Lenton]

Overview
========
This branch adds fail handlers, to decouple the behaviour we provide when something goes wrong with the web service.

Details
=======
PistonAPI now uses a FailHandler class to process the response headers and body, before carrying on with deserialization. The FailHandler is instantiated with all the data from the request (so that it can do custom fail handling depending on the particular request, though none of the provided fail handlers does that atm), and must provide a single method handle(response, body) that can raise an exception, modify the body or return it as is.

Tests and docs included.

[lp:~elachuni/piston-mini-client/failhandler]

29. By Anthony Lenton on 2011-01-12

Couple of small typos in the docs.

30. By Anthony Lenton on 2011-01-12

Removed duplicate line from tests.

31. By Anthony Lenton on 2011-01-12

Updated copyright year.

32. By Anthony Lenton on 2011-01-18

Factored out a bit of repeated code.

[Łukasz Czyżykowski (lukasz-czyzykowski)]

Looks good

review: Approve

=== modified file 'doc/conf.py'
--- doc/conf.py	2010-12-09 21:02:11 +0000
+++ doc/conf.py	2011-01-18 14:47:27 +0000
@@ -41,7 +41,7 @@
 
 # General information about the project.
 project = u'piston_mini_client'
-copyright = u'2010, Anthony Lenton'
+copyright = u'2010-2011, Canonical Ltd.'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the

=== modified file 'doc/quickstart.rst'
--- doc/quickstart.rst	2010-12-09 21:02:11 +0000
+++ doc/quickstart.rst	2011-01-18 14:47:27 +0000
@@ -5,6 +5,7 @@
 your api provides.  Each method can specify what arguments it takes, what
 authentication method should be used, and how to process the response.
 
+=================
 One simple method
 =================
 
@@ -41,10 +42,12 @@
    level http calls via ``httplib2``.
 
 
+======================================
 Validating arguments to your API calls
 ======================================
 
-If your ``urls.py`` specifies placeholders for resource arguments, as in::
+If your server's ``urls.py`` specifies placeholders for resource arguments, as
+in::
 
     urlpatterns = patterns('',
         url(r'^foo/(?P<language>[^/]+)/(?P<foobar_id>\d+)/frobble$',
@@ -92,6 +95,7 @@
 
 Then again, if we use this we'd need to then ensure that ``foobar_id >= 0``.
 
+==============================================
 Getting back light-weight objects from the API
 ==============================================
 
@@ -140,3 +144,45 @@
 and specified ``@returns(PistonResponse)`` but it might be nice to be able to
 print one of these responses and get a meaningful output, or we might want
 to attach some other method to ``FooBarResponse``.
+
+================
+Handling Failure
+================
+
+A common issue is what to do if the webservice returns an error.  One possible
+solution (and the default for ``piston-mini-client``) is to raise an
+exception.
+
+This might not be the best solution for everybody, so piston-mini-client
+allows you to customize the way in which such failures are handled.
+
+You can do this by defining a ``FailHandler`` class.  This class needs to
+provide a single method (``handle``), that receives the response headers and
+body, and decides what to do with it all.  It can raise an exception, or
+modify the body in any way.
+
+If it returns a string this will be assumed to be the (possibly
+fixed) body of the response and will be deserialized by any decorators the
+method has.
+
+To use a different fail handler in your ``PistonAPI`` set the ``fail_handler``
+class attribute .  For example, to use the
+``NoneFailHandler`` instead of the default ``ExceptionFailHandler``,
+you can use::
+
+    class MyAPI(PistonAPI):
+        fail_handler = NoneFailHandler
+        # ... rest of the client definition...
+
+``piston-mini-client`` provides four fail handlers out of the box:
+
+ * ``ExceptionFailHandler``: The default fail handler, raises ``APIError`` if
+   anything goes wrong
+ * ``NoneFailHandler``: Returns None if anything goes wrong.  This will
+   provide no information about *what* went wrong, so only use it if you don't
+   really care.
+ * ``DictFailHandler``: If anything goes wrong it returns a dict with all the
+   headers and body for you to debug.
+ * ``MultiExceptionFailHandler``: Raises a different exception according to
+   what went wrong.
+

=== modified file 'piston_mini_client/__init__.py'
--- piston_mini_client/__init__.py	2010-12-22 20:49:37 +0000
+++ piston_mini_client/__init__.py	2011-01-18 14:47:27 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
 # GNU Lesser General Public License version 3 (see the file LICENSE).
 
 import httplib2
@@ -7,17 +7,14 @@
 import urllib
 from functools import wraps
 
-class APIError(Exception):
-    def __init__(self, msg, body=None):
-        self.msg = msg
-        self.body = body
-    def __str__(self):
-        return self.msg
+from failhandlers import ExceptionFailHandler, APIError
 
 def returns_json(func):
     @wraps(func)
     def wrapper(*args, **kwargs):
-        response, body = func(*args, **kwargs)
+        body = func(*args, **kwargs)
+        if not isinstance(body, basestring):
+            return body
         return simplejson.loads(body)
     return wrapper
 
@@ -35,8 +32,10 @@
     def decorator(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
-            response, body = func(self, *args, **kwargs)
-            return cls.from_response(response, body, none_allowed)
+            body = func(self, *args, **kwargs)
+            if not isinstance(body, basestring):
+                return body
+            return cls.from_response(body, none_allowed)
         return wrapper
     return decorator
 
@@ -49,7 +48,9 @@
     def decorator(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
-            response, body = func(self, *args, **kwargs)
+            body = func(self, *args, **kwargs)
+            if not isinstance(body, basestring):
+                return body
             data = simplejson.loads(body)
             items = []
             for datum in data:
@@ -63,7 +64,7 @@
     """Base class for objects that are returned from api calls.
     """
     @classmethod
-    def from_response(cls, response, body, none_allowed=False):
+    def from_response(cls, body, none_allowed=False):
         data = simplejson.loads(body)
         if none_allowed and data is None:
             return data
@@ -113,6 +114,8 @@
 
     default_content_type = 'application/json'
 
+    fail_handler = ExceptionFailHandler
+
     def __init__(self, service_root=None, cachedir=None, auth=None):
         if service_root is None:
             service_root = self.default_service_root
@@ -182,9 +185,9 @@
                 raise APIError('Unable to connect to %s' % self._service_root)
             else:
                 raise
-        if response['status'] not in ['200', '201', '304']:
-            raise APIError('%s: %s' % (response['status'],response), body)
-        return response, body
+        handler = self.fail_handler(url, method, body, headers)
+        body = handler.handle(response, body)
+        return body
 
     def _path2url(self, path):
         return self._service_root.rstrip('/') + '/' + path.lstrip('/')

=== modified file 'piston_mini_client/auth.py'
--- piston_mini_client/auth.py	2010-12-09 17:06:20 +0000
+++ piston_mini_client/auth.py	2011-01-18 14:47:27 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
 # GNU Lesser General Public License version 3 (see the file LICENSE).
 
 from functools import wraps

=== added file 'piston_mini_client/failhandlers.py'
--- piston_mini_client/failhandlers.py	1970-01-01 00:00:00 +0000
+++ piston_mini_client/failhandlers.py	2011-01-18 14:47:27 +0000
@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
+# GNU Lesser General Public License version 3 (see the file LICENSE).
+
+"""A fail handler is passed the raw httplib2 response and body, and has a
+chance to raise an exception, modify the body or return it unaltered, or
+even return a completely different object.  It's up to the client (and
+possibly decorators) to know what to do with these returned objects.
+"""
+
+class APIError(Exception):
+    def __init__(self, msg, body=None):
+        self.msg = msg
+        self.body = body
+    def __str__(self):
+        return self.msg
+
+
+class BaseFailHandler(object):
+    """A base class for fail handlers.
+
+    Child classes should at least define handle()
+    """
+    success_status_codes = ['200', '201', '304']
+    
+    def __init__(self, url, method, body, headers):
+        """Don't store any of the provided information as we don't need it"""
+        pass
+
+    def handle(self, response, body):
+        raise NotImplementedError()
+
+    def was_error(self, response):
+        """Returns True if 'response' is a failure"""
+        return response.get('status') not in self.success_status_codes
+
+class ExceptionFailHandler(BaseFailHandler):
+    """A fail handler that will raise APIErrors if anything goes wrong"""
+
+    def handle(self, response, body):
+        """Raise APIError if a strange status code is found"""
+        if 'status' not in response:
+            raise APIError('No status code in response')
+        if self.was_error(response):
+            raise APIError('%s: %s' % (response['status'], response), body)
+        return body
+
+
+class NoneFailHandler(BaseFailHandler):
+    """A fail handler that returns None if anything goes wrong.
+
+    You probably only want to use this if you really don't care about what
+    went wrong.
+    """
+    def handle(self, response, body):
+        """Raise APIError if a strange status code is found"""
+        if self.was_error(response):
+            return None
+        return body
+
+
+class DictFailHandler(BaseFailHandler):
+    """A fail handler that returns error information in a dict"""
+
+    def handle(self, response, body):
+        if self.was_error(response):
+            return {'response': response, 'body': body}
+        return body
+
+
+class BadRequestError(APIError):
+    """A 400 Bad Request response was received"""
+
+
+class UnauthorizedError(APIError):
+    """A 401 Bad Request response was received"""
+
+
+class NotFoundError(APIError):
+    """A 404 Not Found response was received"""
+
+
+class InternalServerErrorError(APIError):
+    """A 500 Internal Server Error response was received"""
+
+
+class MultiExceptionFailHandler(BaseFailHandler):
+    """A fail handler that raises an exception according to what goes wrong"""
+    exceptions = {
+        '400': BadRequestError,
+        '401': UnauthorizedError,
+        '404': NotFoundError,
+        '500': InternalServerErrorError,
+    }
+
+    def handle(self, response, body):
+        if self.was_error(response):
+            status = response.get('status')
+            exception_class = self.exceptions.get(status, APIError)
+            raise exception_class('%s: %s' % (status, response), body)
+        return body
+

=== modified file 'piston_mini_client/serializers.py'
--- piston_mini_client/serializers.py	2010-12-09 21:02:11 +0000
+++ piston_mini_client/serializers.py	2011-01-18 14:47:27 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
 # GNU Lesser General Public License version 3 (see the file LICENSE).
 
 import simplejson

=== modified file 'piston_mini_client/test/test_auth.py'
--- piston_mini_client/test/test_auth.py	2010-12-09 21:02:11 +0000
+++ piston_mini_client/test/test_auth.py	2011-01-18 14:47:27 +0000
@@ -1,3 +1,7 @@
+# -*- coding: utf-8 -*-
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
+# GNU Lesser General Public License version 3 (see the file LICENSE).
+
 from piston_mini_client.auth import OAuthAuthorizer, BasicAuthorizer
 from unittest import TestCase
 

=== added file 'piston_mini_client/test/test_failhandlers.py'
--- piston_mini_client/test/test_failhandlers.py	1970-01-01 00:00:00 +0000
+++ piston_mini_client/test/test_failhandlers.py	2011-01-18 14:47:27 +0000
@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
+# GNU Lesser General Public License version 3 (see the file LICENSE).
+
+from mock import patch
+from unittest import TestCase
+from piston_mini_client import (
+    PistonAPI,
+    PistonResponseObject,
+    returns,
+    returns_json,
+    returns_list_of,
+)
+from piston_mini_client.failhandlers import (
+    APIError,
+    BadRequestError,
+    DictFailHandler,
+    ExceptionFailHandler,
+    InternalServerErrorError,
+    MultiExceptionFailHandler,
+    NoneFailHandler,
+    NotFoundError,
+    UnauthorizedError,
+)
+
+class GardeningAPI(PistonAPI):
+    """Just a dummy API so we can play around with"""
+    fail_handler = NoneFailHandler
+    default_service_root = 'http://localhost:12345'
+
+    @returns_json
+    def grow(self):
+        return self._post('/grow', {'plants': 'all'})
+
+    @returns(PistonResponseObject)
+    def get_plant(self):
+        return self._get('/plant')
+
+    @returns_list_of(PistonResponseObject)
+    def get_plants(self):
+        return self._get('/plant')
+
+
+class ExceptionFailHandlerTestCase(TestCase):
+    """As this is the default fail handler, we can skip most tests"""
+    def test_no_status(self):
+        """Check that an exception is raised if no status in response"""
+        handler = ExceptionFailHandler('/foo', 'GET', '', {})
+        self.assertRaises(APIError, handler.handle, {}, '')
+
+    def test_bad_status_codes(self):
+        """Check that APIError is raised if bad status codes are returned"""
+        bad_status = ['404', '500', '401']
+        handler = ExceptionFailHandler('/foo', 'GET', '', {})
+        for status in bad_status:
+            self.assertRaises(APIError, handler.handle,
+                {'status': status}, '')
+
+
+class NoneFailHandlerTestCase(TestCase):
+    def test_no_status(self):
+        handler = NoneFailHandler('/foo', 'GET', '', {})
+        self.assertEqual(None, handler.handle({}, 'not None'))
+
+    def test_bad_status_codes(self):
+        """Check that None is returned if bad status codes are returned"""
+        bad_status = ['404', '500', '401']
+        handler = NoneFailHandler('/foo', 'GET', '', {})
+        for status in bad_status:
+            self.assertEqual(None, handler.handle({'status': status}, ''))
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_json_on_fail(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns_json"""
+        mock_request.return_value = {'status': '500'}, 'invalid json'
+        api = GardeningAPI()
+
+        self.assertEqual(None, api.grow())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_on_fail(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns"""
+        mock_request.return_value = {'status': '500'}, 'invalid json'
+        api = GardeningAPI()
+
+        self.assertEqual(None, api.get_plant())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_list_of_on_fail(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns_list_of"""
+        mock_request.return_value = {'status': '500'}, 'invalid json'
+        api = GardeningAPI()
+
+        self.assertEqual(None, api.get_plants())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_json(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns_json"""
+        mock_request.return_value = {'status': '200'}, '{"foo": "bar"}'
+        api = GardeningAPI()
+
+        self.assertEqual({'foo': 'bar'}, api.grow())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns"""
+        mock_request.return_value = {'status': '200'}, '{"foo": "bar"}'
+        api = GardeningAPI()
+
+        self.assertTrue(isinstance(api.get_plant(), PistonResponseObject))
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_list_of(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns_list_of"""
+        mock_request.return_value = {'status': '200'}, '[]'
+        api = GardeningAPI()
+
+        self.assertEqual([], api.get_plants())
+
+
+class DictFailHandlerTestCase(TestCase):
+    def setUp(self):
+        self.response = {'status': '500'}
+        self.body = 'invalid json'
+        self.expected = {'response': self.response, 'body': self.body}
+        self.api = GardeningAPI()
+        self.api.fail_handler = DictFailHandler
+        
+    def test_no_status(self):
+        handler = DictFailHandler('/foo', 'GET', '', {})
+        del self.response['status']
+
+        self.assertEqual(self.expected, handler.handle({}, self.body))
+
+    def test_bad_status_codes(self):
+        bad_status = ['404', '500', '401']
+        handler = DictFailHandler('/foo', 'GET', '', {})
+        for status in bad_status:
+            self.response['status'] = status
+            self.assertEqual(self.expected, handler.handle(**self.expected))
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_json_on_fail(self, mock_request):
+        """Check that DictFailHandler interacts well with returns_json"""
+        mock_request.return_value = self.response, self.body
+
+        self.assertEqual(self.expected, self.api.grow())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_on_fail(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns"""
+        mock_request.return_value = self.response, self.body
+
+        self.assertEqual(self.expected, self.api.get_plant())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_list_of_on_fail(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns_list_of"""
+        mock_request.return_value = self.response, self.body
+
+        self.assertEqual(self.expected, self.api.get_plants())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_json(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns_json"""
+        mock_request.return_value = {'status': '200'}, '{"foo": "bar"}'
+
+        self.assertEqual({'foo': 'bar'}, self.api.grow())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns"""
+        mock_request.return_value = {'status': '200'}, '{"foo": "bar"}'
+
+        self.assertTrue(isinstance(self.api.get_plant(),
+            PistonResponseObject))
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_list_of(self, mock_request):
+        """Check that NoneFailHandler interacts well with returns_list_of"""
+        mock_request.return_value = {'status': '200'}, '[]'
+
+        self.assertEqual([], self.api.get_plants())
+
+
+class MultiExceptionFailHandlerTestCase(TestCase):
+    def setUp(self):
+        self.api = GardeningAPI()
+        self.api.fail_handler = MultiExceptionFailHandler
+        
+    def test_no_status(self):
+        handler = MultiExceptionFailHandler('/foo', 'GET', '', {})
+
+        self.assertRaises(APIError, handler.handle, {}, '')
+
+    def test_bad_status_codes(self):
+        bad_status = {
+            '400': BadRequestError,
+            '401': UnauthorizedError,
+            '404': NotFoundError,
+            '500': InternalServerErrorError,
+        }
+        handler = MultiExceptionFailHandler('/foo', 'GET', '', {})
+        for status, exception in bad_status.items():
+            self.assertRaises(exception, handler.handle, {'status': status},
+                '')
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_json_on_fail(self, mock_request):
+        """ Check that MultiExceptionFailHandler interacts well with
+            returns_json"""
+        mock_request.return_value = {'status': '401'}, ''
+
+        self.assertRaises(UnauthorizedError, self.api.grow)
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_on_fail(self, mock_request):
+        """Check that MultiExceptionFailHandler interacts well with returns"""
+        mock_request.return_value = {'status': '404'}, ''
+
+        self.assertRaises(NotFoundError, self.api.get_plant)
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_list_of_on_fail(self, mock_request):
+        """ Check that MultiExceptionFailHandler interacts well with
+            returns_list_of"""
+        mock_request.return_value = {'status': '500'}, ''
+
+        self.assertRaises(InternalServerErrorError, self.api.get_plants)
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_json(self, mock_request):
+        """ Check that MultiExceptionFailHandler interacts well with
+            returns_json"""
+        mock_request.return_value = {'status': '200'}, '{"foo": "bar"}'
+
+        self.assertEqual({'foo': 'bar'}, self.api.grow())
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns(self, mock_request):
+        """Check that MultiExceptionFailHandler interacts well with returns"""
+        mock_request.return_value = {'status': '200'}, '{"foo": "bar"}'
+
+        self.assertTrue(isinstance(self.api.get_plant(),
+            PistonResponseObject))
+
+    @patch('httplib2.Http.request')
+    def test_interacts_well_with_returns_list_of(self, mock_request):
+        """ Check that MultiExceptionFailHandler interacts well with
+            returns_list_of"""
+        mock_request.return_value = {'status': '200'}, '[]'
+
+        self.assertEqual([], self.api.get_plants())
+

=== modified file 'piston_mini_client/test/test_resource.py'
--- piston_mini_client/test/test_resource.py	2010-12-21 13:47:11 +0000
+++ piston_mini_client/test/test_resource.py	2011-01-18 14:47:27 +0000
@@ -1,3 +1,7 @@
+# -*- coding: utf-8 -*-
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
+# GNU Lesser General Public License version 3 (see the file LICENSE).
+
 from mock import patch
 from unittest import TestCase
 from wsgi_intercept import add_wsgi_intercept, remove_wsgi_intercept
@@ -79,12 +83,12 @@
     @patch('httplib2.Http.request')
     def test_valid_status_codes_dont_raise_exception(self, mock_request):
         for status in ['200', '201', '304']:
-            expected_response = {'status': status}
+            response = {'status': status}
             expected_body = '"hello world!"'
-            mock_request.return_value = (expected_response, expected_body)
+            mock_request.return_value = (response, expected_body)
             api = self.CoffeeAPI()
-            response, body = api._get('/simmer')
-            self.assertEqual(expected_response, response)
+            body = api._get('/simmer')
+            self.assertEqual(expected_body, body)
 
     def test_get_with_extra_args(self):
         api = self.CoffeeAPI()
@@ -107,7 +111,7 @@
 
 class PistonResponseObjectTestCase(TestCase):
     def test_from_response(self):
-        obj = PistonResponseObject.from_response({}, '{"foo": "bar"}')
+        obj = PistonResponseObject.from_response('{"foo": "bar"}')
         self.assertEqual('bar', obj.foo)
 
     def test_from_dict(self):
@@ -121,7 +125,7 @@
             default_service_root = 'foo'
             @returns_json
             def func(self):
-                return {}, '{"foo": "bar", "baz": 42}'
+                return '{"foo": "bar", "baz": 42}'
 
         result = MyAPI().func()
         self.assertEqual({"foo": "bar", "baz": 42}, result)
@@ -133,7 +137,7 @@
             default_service_root = 'foo'
             @returns(PistonResponseObject)
             def func(self):
-                return {}, '{"foo": "bar", "baz": 42}'
+                return '{"foo": "bar", "baz": 42}'
 
         result = MyAPI().func()
         self.assertTrue(isinstance(result, PistonResponseObject))
@@ -143,7 +147,7 @@
             default_service_root = 'foo'
             @returns(PistonResponseObject, none_allowed=True)
             def func(self):
-                return {}, 'null'
+                return 'null'
 
         result = MyAPI().func()
         self.assertEqual(result, None)
@@ -153,7 +157,7 @@
             default_service_root = 'foo'
             @returns(PistonResponseObject, none_allowed=True)
             def func(self):
-                return {}, '{"foo": "bar", "baz": 42}'
+                return '{"foo": "bar", "baz": 42}'
 
         result = MyAPI().func()
         self.assertTrue(isinstance(result, PistonResponseObject))
@@ -165,7 +169,7 @@
             default_service_root = 'foo'
             @returns_list_of(PistonResponseObject)
             def func(self):
-                return {}, '[{"foo": "bar"}, {"baz": 42}]'
+                return '[{"foo": "bar"}, {"baz": 42}]'
 
         result = MyAPI().func()
         self.assertEqual(2, len(result))

=== modified file 'piston_mini_client/test/test_serializers.py'
--- piston_mini_client/test/test_serializers.py	2010-12-09 21:02:11 +0000
+++ piston_mini_client/test/test_serializers.py	2011-01-18 14:47:27 +0000
@@ -1,3 +1,7 @@
+# -*- coding: utf-8 -*-
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
+# GNU Lesser General Public License version 3 (see the file LICENSE).
+
 from unittest import TestCase
 
 from piston_mini_client.serializers import JSONSerializer, FormSerializer

=== modified file 'piston_mini_client/test/test_validators.py'
--- piston_mini_client/test/test_validators.py	2010-12-09 21:02:11 +0000
+++ piston_mini_client/test/test_validators.py	2011-01-18 14:47:27 +0000
@@ -1,4 +1,7 @@
-# nosetests --with-coverage --cover-html --cover-package=piston_mini_client
+# -*- coding: utf-8 -*-
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
+# GNU Lesser General Public License version 3 (see the file LICENSE).
+
 from piston_mini_client.validators import (validate_pattern, validate,
     validate_integer, oauth_protected, basic_protected, ValidationException)
 from piston_mini_client.auth import OAuthAuthorizer, BasicAuthorizer

=== modified file 'piston_mini_client/validators.py'
--- piston_mini_client/validators.py	2010-12-09 17:06:20 +0000
+++ piston_mini_client/validators.py	2011-01-18 14:47:27 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
 # GNU Lesser General Public License version 3 (see the file LICENSE).
 
 """ This module implements a bunch of decorators """