Merge lp:~elopio/cloudspacesclient/cloudspacer into lp:cloudspacesclient

[Leo Arias]

Use cloudspacer as the client.

This branch ports the code to python3-only.
It requires a small fix in ssoclient to work with python3, so please don't merge it yet.

[lp:~elopio/cloudspacesclient/cloudspacer]

33. By Leo Arias on 2013-12-03

Fixed pep8.

Unmerged revisions

=== modified file 'src/cloudspacesclient/__init__.py'
--- src/cloudspacesclient/__init__.py	2013-11-20 05:06:14 +0000
+++ src/cloudspacesclient/__init__.py	2013-11-29 08:45:45 +0000
@@ -14,10 +14,3 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with cloudspacesclient.  If not, see <http://www.gnu.org/licenses/>.
-
-__all__ = [
-    'APIException',
-    'CloudspacesAPIClient'
-]
-
-from client import APIException, CloudspacesAPIClient

=== removed file 'src/cloudspacesclient/client.py'
--- src/cloudspacesclient/client.py	2013-11-28 11:37:30 +0000
+++ src/cloudspacesclient/client.py	1970-01-01 00:00:00 +0000
@@ -1,104 +0,0 @@
-# Copyright (C) 2013 Canonical Ltd.
-#
-# This file is part of cloudspacesclient.
-#
-# cloudspacesclient is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# cloudspacesclient is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY 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 cloudspacesclient.  If not, see <http://www.gnu.org/licenses/>.
-
-"""Cloudspaces API client library."""
-
-import json
-import urlparse
-import requests
-import json
-
-JSON_MIME_TYPE = 'application/json'
-
-
-class APIException(Exception):
-    """Exception raised when there is an error calling the Cloudspaces API."""
-
-
-class CloudspacesAPIClient(object):
-
-    content_type = JSON_MIME_TYPE
-
-    def __init__(self, service_root_url, auth):
-        super(CloudspacesAPIClient, self).__init__()
-        self.service_root_url = service_root_url
-        self.auth = auth
-
-    def get_user_representation(self):
-        """Return the representation of the currently authorized user."""
-        response = requests.get(
-            self.service_root_url, auth=self.auth, headers=self._get_headers())
-        if not response.ok:
-            raise APIException(
-                "{0}: {1}".format(response.status_code, response.reason))
-        return response.json()
-
-    def _get_headers(self):
-        return {
-            'Content-Type': self.content_type,
-            'Accept': self.content_type
-        }
-
-    def create_folder(self, folder_name, parent_node_id=""):
-        """Create a folder with the name folder_name
-        :parameter folder_name: the name of the folder to create
-        :parameter parent_node_id: the id of the parent folder
-        """
-        params = {'folder_name': folder_name, 'parent_node_id': parent_node_id}
-        # convert parameters to json string
-        json_params = json.dumps(params)
-        url = urlparse.urljoin(self.service_root_url, 'metadata/')
-        # send the post request
-        response = requests.post(
-            url, data=json_params, auth=self.auth, headers=self._get_headers())
-        if not response.ok:
-            raise APIException(
-                "{0}: {1}".format(response.status_code, response.reason))
-        return response.json()
-
-    def get_metadata(self, node_id):
-        """Return the metadata for a file or folder.
-
-        :parameter node_id: the id of a file or folder.
-
-        """
-        url = urlparse.urljoin(
-            self.service_root_url, 'metadata/{}'.format(node_id))
-        response = requests.get(
-            url, auth=self.auth, headers=self._get_headers())
-        if not response.ok:
-            raise APIException(
-                "{0}: {1}".format(response.status_code, response.reason))
-        return response.json()
-
-    def create_file(self, file_name, folder_node_id=''):
-        """Create a new file.
-
-        :parameter file_name: the name of the file to create.
-        :parameter folder_node_id: the id of the folder where the file will be
-            created. The default value creates the file on the root node.
-
-        """
-        url = urlparse.urljoin(
-            self.service_root_url, 'content/{}'.format(folder_node_id))
-        response = requests.post(
-            url, auth=self.auth, headers=self._get_headers(),
-            data=json.dumps({'file_name': file_name}))
-        if not response.ok:
-            raise APIException(
-                "{0}: {1}".format(response.status_code, response.reason))
-        return response.json()

=== modified file 'src/cloudspacesclient/tests/conformance/test_cloudspaces_api.py'
--- src/cloudspacesclient/tests/conformance/test_cloudspaces_api.py	2013-11-28 11:37:30 +0000
+++ src/cloudspacesclient/tests/conformance/test_cloudspaces_api.py	2013-11-29 08:45:45 +0000
@@ -19,13 +19,14 @@
 
 import os
 import unittest
-import urlparse
+import urllib.parse
 from datetime import datetime
 
 import validictory
+import cloudspacer.cooked
 from dateutil import parser, tz
 
-from cloudspacesclient import client, config, schemas, ubuntuone
+from cloudspacesclient import config, schemas, ubuntuone
 
 
 class CloudspacesAPITestCase(unittest.TestCase):
@@ -42,13 +43,13 @@
         self.test_user = self.test_server.create_test_user()
         self.addCleanup(self.test_server.delete_test_user, self.test_user)
 
-        auth = self.test_server.get_auth_credentials(self.test_user)
-        self.service_root = urlparse.urljoin(
+        auth_session = self.test_server.get_auth_session(self.test_user)
+        self.service_root = urllib.parse.urljoin(
             self.cloudspaces_server_url, 'api/cloudspaces/')
         # TODO the client class should be defined in a config file, to make
         # it easy to test different Cloudspaces clients.
-        self.cloudspaces_api_client = client.CloudspacesAPIClient(
-            self.service_root, auth)
+        self.cloudspaces_api_client = cloudspacer.cooked.CloudSpacer(
+            self.service_root, auth_session)
 
     def _get_now_datetime(self):
         now = datetime.now(tz.tzutc())
@@ -92,7 +93,7 @@
             self._assert_resource_path(node_id, resource_path)
 
     def _assert_resource_path(self, node_id, resource_path):
-        path = urlparse.urlparse(self.service_root).path
+        path = urllib.parse.urlparse(self.service_root).path
         self.assertEqual(
             resource_path, '{0}metadata/{1}'.format(path, node_id))
 
@@ -105,96 +106,23 @@
         validictory.validate(
             metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
 
+        expected = dict(
+            is_deleted=False, is_folder=True, is_root=True, filename=filename,
+            node_id=node_id, path=self.test_server.get_root_path())
+        self._assert_json_object_values(expected, metadata)
+
         self._assert_normal_folder_keys_not_in_root(metadata)
         self._assert_content_path(node_id, metadata.get('content_path'))
+        self._assert_resource_path(node_id, metadata.get('resource_path'))
         # TODO Check that the contents are not present because the folder is
         # empty. --elopio - 2013-11-25
-        self.assertTrue(metadata.get('is_folder'))
-        self.assertFalse(metadata.get('is_deleted'))
-        self.assertTrue(metadata.get('is_root'))
         # TODO The spec doesn't include it in the filename in the examples.
         # --elopio - 2013-11-25
-        self.assertEqual(metadata.get('filename'), filename)
-        self.assertEqual(metadata.get('node_id'), node_id)
         # TODO The spec says the path shouldn't be returned on the root
         # metadata, but I think it's useful. Should we change the spec?
         # --elopio - 2013-11-25
-        self.assertEqual(
-            metadata.get('path'), self.test_server.get_root_path())
-        self._assert_resource_path(node_id, metadata.get('resource_path'))
         # TODO Check the volume_id field. --elopio - 2013-11-25
 
-    def test_create_folder_in_root(self):
-        # get the root node id and root folder name
-        root_node_id, root_name = self._get_root_info()
-        # create the folder
-        folder_name = 'root_folder_1'
-        metadata = self.cloudspaces_api_client.create_folder(
-            folder_name, root_node_id)
-        # validate the folder properties from response
-        validictory.validate(
-            metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
-        self.assertTrue(metadata.get('is_folder'))
-        self.assertFalse(metadata.get('is_deleted'))
-        self.assertFalse(metadata.get('is_root'))
-        self.assertEqual(metadata.get('path'), root_name)
-        self.assertEqual(metadata.get('filename'), folder_name)
-        self.assertEqual(metadata.get('parent_node_id'), root_node_id)
-        self.assertEqual(metadata.get('version'), 1)
-
-    def test_create_folder_no_parent_id(self):
-        # get the root node id and root folder name
-        root_node_id, root_name = self._get_root_info()
-        # create the folder without specifying the parent folder id
-        # this should add folder to root level by default
-        folder_name = 'folder_no_parent_id'
-        metadata = self.cloudspaces_api_client.create_folder(folder_name)
-        # validate the folder properties from response
-        validictory.validate(
-            metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
-        self.assertTrue(metadata.get('is_folder'))
-        self.assertFalse(metadata.get('is_deleted'))
-        self.assertFalse(metadata.get('is_root'))
-        self.assertEqual(metadata.get('path'), root_name)
-        self.assertEqual(metadata.get('filename'), folder_name)
-        self.assertEqual(metadata.get('parent_node_id'), root_node_id)
-        self.assertEqual(metadata.get('version'), 1)
-
-    def test_create_child_folder(self):
-        # get the root node id and root folder name
-        root_node_id, root_name = self._get_root_info()
-        parent_folder_name = 'parent_folder_1'
-        # create the parent folder
-        metadata = self.cloudspaces_api_client.create_folder(
-            parent_folder_name, root_node_id)
-        # validate the parent folder properties from response
-        validictory.validate(
-            metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
-        self.assertTrue(metadata.get('is_folder'))
-        self.assertFalse(metadata.get('is_deleted'))
-        self.assertFalse(metadata.get('is_root'))
-        self.assertEqual(metadata.get('path'), root_name)
-        self.assertEqual(metadata.get('filename'), parent_folder_name)
-        self.assertEqual(metadata.get('parent_node_id'), root_node_id)
-        self.assertEqual(metadata.get('version'), 1)
-
-        # Now create a sub folder under the parent folder
-        child_folder_name = 'child_folder_1'
-        parent_node_id = metadata.get('node_id')
-        metadata = self.cloudspaces_api_client.create_folder(
-            child_folder_name, parent_node_id)
-        # validate the sub-folder properties from response
-        validictory.validate(
-            metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
-        self.assertTrue(metadata.get('is_folder'))
-        self.assertFalse(metadata.get('is_deleted'))
-        self.assertFalse(metadata.get('is_root'))
-        self.assertEqual(metadata.get('path'), '{0}/{1}'.format(
-            root_name, parent_folder_name))
-        self.assertEqual(metadata.get('filename'), child_folder_name)
-        self.assertEqual(metadata.get('parent_node_id'), parent_node_id)
-        self.assertEqual(metadata.get('version'), 2)
-
     def _get_root_info(self):
         user_rep = self.cloudspaces_api_client.get_user_representation()
         root_volume = self._get_root_volume(user_rep.get('volumes'))
@@ -206,6 +134,21 @@
         # FIXME The first volume returned is not necessarily the root.
         # --elopio - 2013-11-23
         return volumes[0]
+        
+    def _assert_json_object_values(self, expected, actual):
+        """Assert the values of the returned json object.
+
+        It checks that all the items in ``expected`` are in ``actual`` with
+        the same value. It doesn't check that ``actual`` has no extra values.
+
+        """
+        for key, expected_value in expected.items():
+            actual_value = actual.get(key)
+            self.assertEqual(
+                expected_value, actual_value,
+                'Wrong value returned on the field {0}. '
+                'Expected: {1}. Received: {2}'.format(
+                    key, expected_value, actual_value))
 
     def _assert_normal_folder_keys_not_in_root(self, response_json):
         normal_folder_keys_not_in_root = [
@@ -218,38 +161,94 @@
                 "The root folder shouldn't include the {} key".format(key))
 
     def _assert_content_path(self, node_id, content_path):
-        path = urlparse.urlparse(self.service_root).path
+        path = urllib.parse.urlparse(self.service_root).path
         self.assertEqual(
             content_path, '{0}content/{1}'.format(path, node_id))
 
+    def test_create_folder_in_root(self):
+        # get the root node id and root folder name
+        root_node_id, root_name = self._get_root_info()
+        # create the folder
+        folder_name = 'root_folder_1'
+
+        metadata = self.cloudspaces_api_client.make_folder(
+            root_node_id, folder_name)
+        # validate the folder properties from response
+        validictory.validate(
+            metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
+
+        expected = dict(
+            is_folder=True, is_deleted=False, is_root=False, path=root_name,
+            filename=folder_name, parent_node_id=root_node_id, version=1)
+        self._assert_json_object_values(expected, metadata)
+
+    def test_create_folder_no_parent_id(self):
+        # get the root node id and root folder name
+        root_node_id, root_name = self._get_root_info()
+        # create the folder without specifying the parent folder id
+        # this should add folder to root level by default
+        folder_name = 'folder_no_parent_id'
+
+        metadata = self.cloudspaces_api_client.make_folder("", folder_name)
+        # validate the folder properties from response
+        validictory.validate(
+            metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
+
+        expected = dict(
+            is_folder=True, is_deleted=False, is_root=False, path=root_name,
+            filename=folder_name, parent_node_id=root_node_id, version=1)
+        self._assert_json_object_values(expected, metadata)
+
+    def test_create_child_folder(self):
+        # get the root node id and root folder name
+        root_node_id, root_name = self._get_root_info()
+        parent_folder_name = 'parent_folder_1'
+        # create the parent folder
+        parent_metadata = self.cloudspaces_api_client.make_folder(
+            root_node_id, parent_folder_name)
+        # Now create a sub folder under the parent folder
+        child_folder_name = 'child_folder_1'
+        parent_node_id = parent_metadata.get('node_id')
+        child_folder_path = '{0}/{1}'.format(root_name, parent_folder_name)
+
+        metadata = self.cloudspaces_api_client.make_folder(
+            parent_node_id, child_folder_name)
+        # validate the sub-folder properties from response
+        validictory.validate(
+            metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
+
+        expected = dict(
+            is_folder=True, is_deleted=False, is_root=False,
+            path=child_folder_path, filename=child_folder_name, version=2)
+        self._assert_json_object_values(expected, metadata)
+
     def test_create_new_file(self):
-        root_node_id, path = self._get_root_info()
-
-        metadata = self.cloudspaces_api_client.create_file(
-            'test.txt', root_node_id)
+        root_node_id, root_path = self._get_root_info()
+        test_file_name = 'test.txt'
+        test_file_mimetype = 'text/plain'
+
+        metadata = self.cloudspaces_api_client.make_file(
+            root_node_id, test_file_name)
+
+        validictory.validate(
+            metadata, schemas.GET_FILE_METADATA_RESPONSE_SCHEMA)
+
+        expected = dict(
+            hash=None, filename=test_file_name, is_deleted=False,
+            is_folder=False, mimetype=test_file_mimetype,
+            parent_node_id=root_node_id, path=root_path, size=0, version=1)
+        self._assert_json_object_values(expected, metadata)
+
         file_node_id = metadata.get('node_id')
-
-        validictory.validate(
-            metadata, schemas.GET_FILE_METADATA_RESPONSE_SCHEMA)
-
         self._assert_content_path(file_node_id, metadata.get('content_path'))
-        # TODO update the spec because it says checksum instead of hash.
-        # --elopio - 2013-11-27
-        self.assertEqual(metadata.get('hash'), None)
-        # TODO The spec doesn't include it in the filename in the examples.
-        # --elopio - 2013-11-25
-        self.assertEqual(metadata.get('filename'), 'test.txt')
-        self.assertFalse(metadata.get('is_deleted'))
-        self.assertFalse(metadata.get('is_folder'))
-        self.assertEqual(metadata.get('mimetype'), 'text/plain')
-        self.assertEqual(metadata.get('parent_node_id'), root_node_id)
-        self.assertEqual(metadata.get('path'), path)
         self._assert_resource_path(file_node_id, metadata.get('resource_path'))
-        self.assertEqual(metadata.get('size'), 0)
         # Assert that the file has just been created.
         self._assert_datetime_limits(
             parser.parse(metadata.get('server_modified')), self.start_datetime,
             self._get_now_datetime())
-        self.assertEqual(metadata.get('version'), 1)
+        # TODO update the spec because it says checksum instead of hash.
+        # --elopio - 2013-11-27
+        # TODO The spec doesn't include it in the filename in the examples.
+        # --elopio - 2013-11-25
         # TODO check the user_id. --elopio - 2013-11-27
         # TODO Check the volume_id field. --elopio - 2013-11-27

=== removed file 'src/cloudspacesclient/tests/unit/test_client.py'
--- src/cloudspacesclient/tests/unit/test_client.py	2013-11-27 06:14:16 +0000
+++ src/cloudspacesclient/tests/unit/test_client.py	1970-01-01 00:00:00 +0000
@@ -1,124 +0,0 @@
-# Copyright (C) 2013 Canonical Ltd.
-#
-# This file is part of cloudspacesclient.
-#
-# cloudspacesclient is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# cloudspacesclient is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY 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 cloudspacesclient.  If not, see <http://www.gnu.org/licenses/>.
-
-"""Unit tests for the Cloudspaces API client."""
-
-import json
-import unittest
-
-import mock
-
-import cloudspacesclient
-from cloudspacesclient.tests.unit import utils
-
-import testscenarios
-
-
-# List of API Methods, each item is a tuple with the method name, the request
-# type and the list of required arguments.
-_API_METHODS = [
-    ('get_user_representation', 'get', []),
-    ('get_metadata', 'get', ['dummynodeid']),
-    ('create_file', 'post', ['dummyfilename'])
-]
-
-
-class CloudspacesAPIClientResponseTestCase(
-        testscenarios.TestWithScenarios):
-
-    def setUp(self):
-        super(CloudspacesAPIClientResponseTestCase, self).setUp()
-        self.api_client = cloudspacesclient.CloudspacesAPIClient(
-            'dummy url', 'dummy auth')
-
-    scenarios = [
-        (api_method, dict(
-            api_method=api_method, request_type=request_type, args=args))
-        for (api_method, request_type, args) in _API_METHODS
-    ]
-
-    def test_call_api_method_should_return_json(self):
-        with mock.patch('requests.' + self.request_type) as request_mock:
-            request_mock.return_value = utils.RequestResponseMock(
-                ok=True, content=json.dumps("{'test': 'content'}"))
-            response = getattr(self.api_client, self.api_method)(*self.args)
-
-        self.assertEqual(response, "{'test': 'content'}")
-
-    def test_call_api_method_failure_should_raise_exception(self):
-        with mock.patch('requests.' + self.request_type) as request_mock:
-            request_mock.return_value = utils.RequestResponseMock(
-                ok=False, status_code='test error code', reason='test reason')
-            with self.assertRaises(cloudspacesclient.APIException) as e:
-                getattr(self.api_client, self.api_method)(*self.args)
-
-        self.assertEqual(str(e.exception), 'test error code: test reason')
-
-
-class CloudspacesAPIClientTestCase(unittest.TestCase):
-
-    def setUp(self):
-        super(CloudspacesAPIClientTestCase, self).setUp()
-        self.api_client = cloudspacesclient.CloudspacesAPIClient(
-            'http://example.com/cloudspaces/', 'test auth')
-        self.request_headers = {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json'
-        }
-
-    def test_get_user_representation_request(self):
-        with mock.patch('requests.get') as get_mock:
-            get_mock.return_value = utils.RequestResponseMock(
-                ok=True, content=json.dumps("{'test': 'content'}"))
-            self.api_client.get_user_representation()
-
-        get_mock.assert_called_once_with(
-            'http://example.com/cloudspaces/', auth='test auth',
-            headers=self.request_headers)
-
-    def test_get_metadata_request(self):
-        with mock.patch('requests.get') as get_mock:
-            get_mock.return_value = utils.RequestResponseMock(
-                ok=True, content=json.dumps("{'test': 'content'}"))
-            self.api_client.get_metadata('testnodeid')
-
-        get_mock.assert_called_once_with(
-            'http://example.com/cloudspaces/metadata/testnodeid',
-            auth='test auth', headers=self.request_headers)
-
-    def test_create_file_with_folder_id(self):
-        with mock.patch('requests.post') as post_mock:
-            post_mock.return_value = utils.RequestResponseMock(
-                ok=True, content=json.dumps("{'test': 'content'}"))
-            self.api_client.create_file(
-                'test file.txt', folder_node_id='testfoldernodeid')
-
-        post_mock.assert_called_once_with(
-            'http://example.com/cloudspaces/content/testfoldernodeid',
-            auth='test auth', headers=self.request_headers,
-            data=json.dumps({'file_name': 'test file.txt'}))
-
-    def test_create_file_without_folder_id(self):
-        with mock.patch('requests.post') as post_mock:
-            post_mock.return_value = utils.RequestResponseMock(
-                ok=True, content=json.dumps("{'test': 'content'}"))
-            self.api_client.create_file('test file.txt')
-
-        post_mock.assert_called_once_with(
-            'http://example.com/cloudspaces/content/',
-            auth='test auth', headers=self.request_headers,
-            data=json.dumps({'file_name': 'test file.txt'}))

=== modified file 'src/cloudspacesclient/tests/unit/test_schemas.py'
--- src/cloudspacesclient/tests/unit/test_schemas.py	2013-11-27 15:47:59 +0000
+++ src/cloudspacesclient/tests/unit/test_schemas.py	2013-11-29 08:45:45 +0000
@@ -22,6 +22,7 @@
 
 import testscenarios
 import validictory
+from validictory import validator
 
 from cloudspacesclient import schemas
 
@@ -183,12 +184,14 @@
 
 class ResponseSchemaTestCase(unittest.TestCase):
 
-    def assert_raises_validation_error(self, json, schema):
+    def assert_raises_validation_error(
+            self, json, schema, validator_cls=validator.SchemaValidator):
         self.assertRaises(
             validictory.ValidationError,
             validictory.validate,
             json,
-            schema
+            schema,
+            validator_cls=validator_cls
         )
 
 
@@ -258,6 +261,12 @@
     return wrong_types
 
 
+class _SchemaValidatorWithoutFormatValidation(validator.SchemaValidator):
+
+    def register_format_validator(self, format_name, format_validator_fun):
+        pass
+
+
 class WrongPropertiesValuesTestCase(
         testscenarios.TestWithScenarios, ResponseSchemaTestCase):
 
@@ -270,7 +279,7 @@
              value=wrong_value))
         for object_ in _OBJECTS
         for property_, types in (
-            object_.get('required_properties').items() +
+            object_.get('required_properties').items() |
             object_.get('optional_properties').items()
         )
         for wrong_type, wrong_value in _get_wrong_types(types).items()
@@ -282,7 +291,14 @@
 
     def test_json_with_wrong_property_value(self):
         self.json[self.property_] = self.value
-        self.assert_raises_validation_error(self.json, self.schema)
+        # XXX We use a validator without format validation because sometimes
+        # python will change the order of the schema and validictory will check
+        # the format before the type, raising the wrong error.
+        # Bug reported: https://github.com/sunlightlabs/validictory/issues/64
+        # We should change to the default validator once the bug is fixed.
+        # --elopio - 2013-11-29
+        self.assert_raises_validation_error(
+            self.json, self.schema, _SchemaValidatorWithoutFormatValidation)
 
 
 class ObjectExtraPropertiesTestCase(

=== modified file 'src/cloudspacesclient/tests/unit/test_ubuntuone.py'
--- src/cloudspacesclient/tests/unit/test_ubuntuone.py	2013-11-20 05:06:14 +0000
+++ src/cloudspacesclient/tests/unit/test_ubuntuone.py	2013-11-29 08:45:45 +0000
@@ -17,7 +17,6 @@
 
 """Unit tests for the Ubuntu One server adapter for Cloudspaces tests."""
 
-import contextlib
 import unittest
 
 import mock
@@ -119,7 +118,7 @@
             'Failed to register SSO user. ' + str(sso_exception))
         self.assertFalse(self.server.create_u1_user_mock.called)
 
-    def test_get_auth_credentials_should_return_oauth1(self):
+    def test_get_auth_session_should_return_oauth1session(self):
         self.server.sso_login_mock.return_value = {
             'consumer_key': 'test consumer key',
             'consumer_secret': 'test consumer secret',
@@ -128,7 +127,7 @@
         }
         user = ubuntuone.User.make_unique(unique_id='id')
 
-        auth = self.server.get_auth_credentials(user)
+        session = self.server.get_auth_session(user)
 
         self.server.sso_login_mock.assert_called_once_with(
             {
@@ -137,26 +136,28 @@
                 'token_name': 'Cloudspaces API test',
             }
         )
-        self.assertIsInstance(auth, requests_oauthlib.OAuth1)
-        self.assertEqual(auth.client.client_key, 'test consumer key')
-        self.assertEqual(auth.client.client_secret, 'test consumer secret')
-        self.assertEqual(auth.client.resource_owner_key, 'test token key')
-        self.assertEqual(
-            auth.client.resource_owner_secret, 'test token secret')
+        self.assertIsInstance(session, requests_oauthlib.OAuth1Session)
+        self.assertEqual(
+            session._client.client.client_key, 'test consumer key')
+        self.assertEqual(
+            session._client.client.client_secret, 'test consumer secret')
+        self.assertEqual(
+            session._client.client.resource_owner_key, 'test token key')
+        self.assertEqual(
+            session._client.client.resource_owner_secret, 'test token secret')
 
     def test_get_u1_api_client(self):
-        with contextlib.nested(
-            mock.patch('cloudspacesclient.config.get'),
-            mock.patch.object(self.server, 'get_auth_credentials')
-        ) as (config_mock, credentials_mock):
-            config_mock.return_value = 'http://example.com'
-            credentials_mock.return_value = 'test credentials'
-            client = self.server._get_u1_api_client('dummy user')
+        with mock.patch('cloudspacesclient.config.get') as config_mock:
+            with mock.patch.object(
+                    self.server, 'get_auth_session') as session_mock:
+                config_mock.return_value = 'http://example.com'
+                session_mock.return_value = 'test session'
+                client = self.server._get_u1_api_client('dummy user')
 
         self.assertIsInstance(client, ubuntuone.UbuntuOneAPIClient)
         self.assertEqual(
             client.service_root_url, 'http://example.com/api/')
-        self.assertEqual(client.auth, 'test credentials')
+        self.assertEqual(client.session, 'test session')
 
     def test_create_test_user_should_create_user_in_u1(self):
         self.server.create_test_user()
@@ -178,25 +179,28 @@
 
     def setUp(self):
         super(UbuntuOneAPITestCase, self).setUp()
+        self.session_mock = mock.Mock()
         self.api_client = ubuntuone.UbuntuOneAPIClient(
-            'dummy url', 'dummy auth')
+            'dummy url', self.session_mock)
 
     def test_get_account_info_should_return_request(self):
-        with mock.patch('requests.get') as get_mock:
-            get_mock.return_value = utils.RequestResponseMock(
-                ok=True, status_code=200, content='test content')
-            response = self.api_client.get_account_info()
+        mock_attributes = {'get.return_value': utils.RequestResponseMock(
+            ok=True, status_code=200, content='test content')
+        }
+        self.session_mock.configure_mock(**mock_attributes)
+        response = self.api_client.get_account_info()
 
         self.assertTrue(response.ok)
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.content, 'test content')
 
     def test_get_account_info_failure(self):
-        with mock.patch('requests.get') as get_mock:
-            get_mock.return_value = utils.RequestResponseMock(
-                ok=False, status_code='test error code', reason='test reason')
-            with self.assertRaises(ubuntuone.APIException) as e:
-                self.api_client.get_account_info()
+        mock_attributes = {'get.return_value': utils.RequestResponseMock(
+            ok=False, status_code='test error code', reason='test reason')
+        }
+        self.session_mock.configure_mock(**mock_attributes)
+        with self.assertRaises(ubuntuone.APIException) as e:
+            self.api_client.get_account_info()
 
         self.assertEqual(str(e.exception), 'test error code: test reason')
 

=== modified file 'src/cloudspacesclient/ubuntuone.py'
--- src/cloudspacesclient/ubuntuone.py	2013-11-26 16:13:41 +0000
+++ src/cloudspacesclient/ubuntuone.py	2013-11-29 08:45:45 +0000
@@ -17,10 +17,9 @@
 
 """Ubuntu One server adapter for Cloudspaces tests."""
 
-import urlparse
+import urllib.parse
 import uuid
 
-import requests
 import requests_oauthlib
 import ssoclient.v2
 
@@ -89,7 +88,7 @@
 
     def _get_sso_api_client(self):
         return ssoclient.v2.V2ApiClient(
-            urlparse.urljoin(self._get_sso_server_url(), 'api/v2'))
+            urllib.parse.urljoin(self._get_sso_server_url(), 'api/v2'))
 
     def _get_sso_server_url(self):
         return config.get('ubuntuone', 'sso_server_url')
@@ -102,9 +101,9 @@
                 'Failed to create U1 user. ' + str(e))
 
     def _get_u1_api_client(self, user):
-        url = urlparse.urljoin(self._get_ubuntuone_server_url(), 'api/')
-        auth = self.get_auth_credentials(user)
-        return UbuntuOneAPIClient(url, auth)
+        url = urllib.parse.urljoin(self._get_ubuntuone_server_url(), 'api/')
+        auth_session = self.get_auth_session(user)
+        return UbuntuOneAPIClient(url, auth_session)
 
     def _get_ubuntuone_server_url(self):
         return config.get('ubuntuone', 'ubuntuone_server_url')
@@ -113,8 +112,8 @@
         # Currently we can't delete users from U1 and SSO.
         pass
 
-    def get_auth_credentials(self, user):
-        """Return the auth credentials to sign the Cloudspaces API requests.
+    def get_auth_session(self, user):
+        """Return the auth session to sign the Cloudspaces API requests.
 
         :parameter user: An object with the user information.
 
@@ -124,7 +123,7 @@
             password=user.password,
             token_name='Cloudspaces API test')
         response = self._get_sso_api_client().login(data)
-        return requests_oauthlib.OAuth1(
+        return requests_oauthlib.OAuth1Session(
             response.get('consumer_key'), response.get('consumer_secret'),
             response.get('token_key'), response.get('token_secret'))
 
@@ -141,10 +140,10 @@
 
     content_type = JSON_MIME_TYPE
 
-    def __init__(self, service_root_url, auth):
+    def __init__(self, service_root_url, session):
         super(UbuntuOneAPIClient, self).__init__()
         self.service_root_url = service_root_url
-        self.auth = auth
+        self.session = session
 
     def create_user(self):
         """Create the authenticated user in Ubuntu One, if it doesn't exist."""
@@ -153,9 +152,8 @@
 
     def get_account_info(self):
         """Get the account information of the authenticated user."""
-        url = urlparse.urljoin(self.service_root_url, 'account/')
-        response = requests.get(
-            url, auth=self.auth, headers=self._get_headers())
+        url = urllib.parse.urljoin(self.service_root_url, 'account/')
+        response = self.session.get(url, headers=self._get_headers())
         if not response.ok:
             raise APIException(
                 "{0}: {1}".format(response.status_code, response.reason))