Merge lp:~facundo/magicicada-client/remove-web into lp:magicicada-client

[Facundo Batista]

Remove everything related to hitting server functionality through (web) API.

Remove everything related to hitting server functionality through (web) API.

This is not needed anymore after implementing public files through API and deprecating the old-days Share offering not-by-username.

[Natalia Bidart (nataliabidart)]

Looks good! Thanks

review: Approve

=== modified file 'dependencies.txt'
--- dependencies.txt	2016-09-17 01:06:23 +0000
+++ dependencies.txt	2017-01-13 11:56:59 +0000
@@ -4,7 +4,6 @@
 python-dirspec
 python-distutils-extra
 python-gi
-python-httplib2
 python-protobuf
 python-pyinotify
 python-qt4-dbus

=== modified file 'ubuntuone/proxy/tunnel_server.py'
--- ubuntuone/proxy/tunnel_server.py	2016-06-01 18:28:19 +0000
+++ ubuntuone/proxy/tunnel_server.py	2017-01-13 11:56:59 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2012-2013 Canonical Ltd.
+# Copyright 2015-2017 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # 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
@@ -60,7 +61,7 @@
 
 from ubuntuone.clientdefs import NAME
 from ubuntuone.keyring import Keyring
-from ubuntuone.utils.webclient import gsettings
+from ubuntuone.utils import gsettings
 from ubuntuone.proxy.common import (
     BaseTunnelProtocol,
     CRLF,

=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2016-11-07 01:13:32 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2017-01-13 11:56:59 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2015 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2017 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # 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
@@ -33,15 +33,12 @@
 import logging
 import os
 import random
-import re
 import tempfile
 import traceback
 import zlib
 
 from collections import deque, defaultdict
 from functools import partial
-from urllib import urlencode
-from urlparse import urlparse
 
 import OpenSSL.SSL
 
@@ -62,19 +59,14 @@
 from ubuntuone.storageprotocol.context import get_ssl_context
 from ubuntuone.syncdaemon.interfaces import IActionQueue, IMarker
 from ubuntuone.syncdaemon.logger import mklog, TRACE
-from ubuntuone.syncdaemon.volume_manager import ACCESS_LEVEL_RW
 from ubuntuone.syncdaemon import config, offload_queue
 from ubuntuone.syncdaemon import tunnel_runner
-from ubuntuone.utils.webclient import txweb
 
 logger = logging.getLogger("ubuntuone.SyncDaemon.ActionQueue")
 
 # I want something which repr() is "---" *without* the quotes :)
 UNKNOWN = type('', (), {'__repr__': lambda _: '---'})()
 
-# Regular expression to validate an e-mail address
-EREGEX = "^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$"
-
 # progress threshold to emit a download/upload progress event: 64Kb
 TRANSFER_PROGRESS_THRESHOLD = 64 * 1024
 
@@ -911,27 +903,6 @@
             return defer.succeed((self.host, self.port))
 
     @defer.inlineCallbacks
-    def webcall(self, iri, **kwargs):
-        """Perform a web call to the api servers."""
-        webclient = yield self.get_webclient(iri)
-        # FIXME: we need to review these requests after credentials change
-        response = yield webclient.request(
-            iri, auth_credentials=self.credentials, **kwargs)
-        defer.returnValue(response)
-
-    @defer.inlineCallbacks
-    def get_webclient(self, iri):
-        """Get the webclient, creating it if needed."""
-        uri = txweb.WebClient().iri_to_uri(iri)
-        host = urlparse(uri).netloc.split(":")[0]
-        ssl_context = get_ssl_context(self.disable_ssl_verify, host)
-        connector = yield self.tunnel_runner.get_client()
-        webclient = txweb.WebClient(
-            connector=connector, appname=clientdefs.NAME,
-            context_factory=ssl_context)
-        defer.returnValue(webclient)
-
-    @defer.inlineCallbacks
     def _make_connection(self, result):
         """Do the real connect call."""
         host, port = result
@@ -1892,7 +1863,7 @@
     """Offer a share to somebody."""
 
     __slots__ = ('node_id', 'share_to', 'name', 'access_level',
-                 'marker', 'use_http', 'path')
+                 'marker', 'path')
     possible_markers = 'node_id',
     logged_attrs = ActionQueueCommand.logged_attrs + __slots__
 
@@ -1904,47 +1875,18 @@
         self.name = name
         self.access_level = access_level
         self.marker = marker
-        self.use_http = False
         self.path = path
 
-        if share_to and re.match(EREGEX, share_to):
-            self.use_http = True
-
-    @defer.inlineCallbacks
-    def _create_share_http(self, node_id, user, name, read_only):
-        """Create a share using the HTTP Web API method."""
-
-        iri = u"https://one.ubuntu.com/files/api/offer_share/"
-        data = dict(offer_to_email=user,
-                    read_only=read_only,
-                    node_id=node_id,
-                    share_name=name)
-        pdata = urlencode(data)
-        yield self.action_queue.webcall(iri, method="POST", post_content=pdata)
-
     def _run(self):
         """Do the actual running."""
-        if self.use_http:
-            # External user, do the HTTP REST method
-            return self._create_share_http(
-                self.node_id, self.share_to, self.name,
-                self.access_level != ACCESS_LEVEL_RW)
-        else:
-            return self.action_queue.client.create_share(self.node_id,
-                                                         self.share_to,
-                                                         self.name,
-                                                         self.access_level)
+        return self.action_queue.client.create_share(
+            self.node_id, self.share_to, self.name, self.access_level)
 
     def handle_success(self, success):
         """It worked! Push the event."""
-        # We don't get a share_id back from the HTTP REST method
-        if not self.use_http:
-            self.action_queue.event_queue.push('AQ_CREATE_SHARE_OK',
-                                               share_id=success.share_id,
-                                               marker=self.marker)
-        else:
-            self.action_queue.event_queue.push('AQ_SHARE_INVITATION_SENT',
-                                               marker=self.marker)
+        self.action_queue.event_queue.push(
+            'AQ_CREATE_SHARE_OK', share_id=success.share_id,
+            marker=self.marker)
 
     def handle_failure(self, failure):
         """It didn't work! Push the event."""

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2015-09-19 23:15:50 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2017-01-13 11:56:59 +0000
@@ -1,9 +1,5 @@
-# ubuntuone.syncdaemon.event_queue - Event queuing
-#
-# Authors: Facundo Batista <[e-mail]>
-#          Manuel de la Pena <[e-mail]>
-#
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2016-2017 Chicharreros
 #
 # 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
@@ -79,7 +75,6 @@
     'AQ_UPLOAD_ERROR': ('share_id', 'node_id', 'error', 'hash'),
     'AQ_SHARES_LIST': ('shares_list',),
     'AQ_LIST_SHARES_ERROR': ('error',),
-    'AQ_SHARE_INVITATION_SENT': ('marker',),
     'AQ_CREATE_SHARE_OK': ('share_id', 'marker'),
     'AQ_CREATE_SHARE_ERROR': ('marker', 'error'),
     'AQ_DELETE_SHARE_OK': ('share_id',),

=== modified file 'ubuntuone/syncdaemon/tests/test_action_queue.py'
--- ubuntuone/syncdaemon/tests/test_action_queue.py	2016-12-06 02:00:29 +0000
+++ ubuntuone/syncdaemon/tests/test_action_queue.py	2017-01-13 11:56:59 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2015 Canonical Ltd.
-# Copyright 2016 Chicharreros
+# Copyright 2016-2017 Chicharreros
 #
 # 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
@@ -86,10 +86,7 @@
 from ubuntuone.syncdaemon.event_queue import EventQueue, EVENTS
 from ubuntuone.syncdaemon import offload_queue
 from ubuntuone.syncdaemon.marker import MDMarker
-from ubuntuone.syncdaemon.volume_manager import (
-    ACCESS_LEVEL_RO,
-    ACCESS_LEVEL_RW,
-)
+from ubuntuone.syncdaemon.volume_manager import ACCESS_LEVEL_RO
 
 PATH = os.path.join(u'~', u'Documents', u'pdfs', u'moño', u'')
 NAME = u'UDF-me'
@@ -435,56 +432,6 @@
                 self.assertEqual(defined_args[0], 'self')
                 self.assertEqual(set(defined_args[1:]), set(evtargs))
 
-    @defer.inlineCallbacks
-    def test_get_webclient_called_with_iri(self):
-        """The call to get_webclient includes the iri."""
-        called_args = []
-        real_get_webclient = action_queue.ActionQueue.get_webclient
-
-        def fake_get_webclient(aq, *args):
-            """A fake get_webclient."""
-            called_args.append(args)
-            return real_get_webclient(aq, *args)
-
-        self.patch(action_queue.ActionQueue, "get_webclient",
-                   fake_get_webclient)
-        self.patch(action_queue.txweb.WebClient, "request",
-                   lambda *args, **kwargs: defer.succeed(None))
-
-        yield self.action_queue.webcall(self.fake_iri)
-        self.assertEqual(called_args, [(self.fake_iri,)])
-
-    @defer.inlineCallbacks
-    def test_get_webclient(self):
-        """The webclient is created every time."""
-        webclient1 = yield self.action_queue.get_webclient(self.fake_iri)
-        webclient2 = yield self.action_queue.get_webclient(self.fake_iri)
-        self.assertNotEqual(webclient1, webclient2)
-
-    @defer.inlineCallbacks
-    def test_get_webclient_creates_context_with_host(self):
-        """The ssl context is created with the right host."""
-        used_host = []
-
-        def fake_get_ssl_context(disable_ssl_verify, host):
-            """The host is used to call get_ssl_context."""
-            used_host.append(host)
-
-        self.patch(action_queue, "get_ssl_context", fake_get_ssl_context)
-        yield self.action_queue.get_webclient(self.fake_iri)
-        self.assertEqual(used_host, [self.fake_host])
-
-    @defer.inlineCallbacks
-    def test_get_webclient_uses_just_created_context(self):
-        """The freshly created context is used to create the webclient."""
-        calls = []
-        fake_context = object()
-        self.patch(action_queue, "get_ssl_context", lambda *args: fake_context)
-        self.patch(action_queue.txweb.WebClient, "__init__",
-                   lambda *args, **kwargs: calls.append(kwargs))
-        yield self.action_queue.get_webclient(self.fake_iri)
-        self.assertEqual(calls[1]["context_factory"], fake_context)
-
 
 class TestLoggingStorageClient(TwistedTestCase):
     """Tests for ensuring magic hash dont show in logs."""
@@ -3716,51 +3663,6 @@
         yield super(CreateShareTestCase, self).setUp()
         self.request_queue = RequestQueue(action_queue=self.action_queue)
 
-    @defer.inlineCallbacks
-    def test_access_level_modify_http(self):
-        """Test proper handling of the access level in the http case."""
-        # replace _create_share_http with a fake, just to check the args
-        d = defer.Deferred()
-
-        def check_create_http(self, node_id, user, name, read_only):
-            """Fire the deferred with the args."""
-            d.callback((node_id, user, name, read_only))
-
-        self.patch(CreateShare, "_create_share_http", check_create_http)
-        command = CreateShare(self.request_queue, 'node_id',
-                              '[e-mail]', 'share_name',
-                              ACCESS_LEVEL_RW, 'marker', 'path')
-        self.assertTrue(command.use_http, 'CreateShare should be in http mode')
-
-        command._run()
-        node_id, user, name, read_only = yield d
-        self.assertEqual('node_id', node_id)
-        self.assertEqual('[e-mail]', user)
-        self.assertEqual('share_name', name)
-        self.assertFalse(read_only)
-
-    @defer.inlineCallbacks
-    def test_access_level_view_http(self):
-        """Test proper handling of the access level in the http case."""
-        # replace _create_share_http with a fake, just to check the args
-        d = defer.Deferred()
-
-        def check_create_http(self, node_id, user, name, read_only):
-            """Fire the deferred with the args."""
-            d.callback((node_id, user, name, read_only))
-
-        self.patch(CreateShare, "_create_share_http", check_create_http)
-        command = CreateShare(self.request_queue, 'node_id',
-                              '[e-mail]', 'share_name',
-                              ACCESS_LEVEL_RO, 'marker', 'path')
-        self.assertTrue(command.use_http, 'CreateShare should be in http mode')
-        command._run()
-        node_id, user, name, read_only = yield d
-        self.assertEqual('node_id', node_id)
-        self.assertEqual('[e-mail]', user)
-        self.assertEqual('share_name', name)
-        self.assertTrue(read_only)
-
     def test_possible_markers(self):
         """Test that it returns the correct values."""
         cmd = CreateShare(self.request_queue, 'node_id', '[e-mail]',
@@ -3768,27 +3670,6 @@
         res = [getattr(cmd, x) for x in cmd.possible_markers]
         self.assertEqual(res, ['node_id'])
 
-    def test_handle_success_sends_invitation(self):
-        """The success handler sends the AQ_SHARE_INVITATION_SENT event."""
-        marker_id = "marker"
-        share_name = "share name"
-        share_to = "[e-mail]"
-
-        class MockResult(object):
-            """A mock result."""
-            share_id = SHARE
-
-        mock_success = MockResult()
-        cmd = CreateShare(self.request_queue, NODE, share_to,
-                          share_name, ACCESS_LEVEL_RO, marker_id, 'path')
-        cmd.log = cmd.make_logger()
-        cmd.use_http = True
-        cmd.handle_success(mock_success)
-
-        event_params = {'marker': marker_id}
-        events = [('AQ_SHARE_INVITATION_SENT', event_params)]
-        self.assertEqual(events, cmd.action_queue.event_queue.events)
-
     def test_path_locking(self):
         """Test that it acquires correctly the path lock."""
         t = []

=== renamed file 'ubuntuone/utils/webclient/gsettings.py' => 'ubuntuone/utils/gsettings.py'
=== modified file 'ubuntuone/utils/tests/test_common.py'
--- ubuntuone/utils/tests/test_common.py	2016-05-29 00:50:05 +0000
+++ ubuntuone/utils/tests/test_common.py	2017-01-13 11:56:59 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2017 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # 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
@@ -48,22 +48,6 @@
 NOT_DEFINED = object()
 
 
-class FakeWebclient(object):
-    """A fake webclient."""
-
-    def __init__(self):
-        self.called = []
-
-    def request(self, *args, **kwargs):
-        """Save a webclient request."""
-        self.called.append((args, kwargs))
-        response = utils.webclient.common.Response(content="response")
-        return response
-
-    def shutdown(self):
-        """Shutdown this fake webclient."""
-
-
 class FakedConstantsModule(object):
     """Fake the 'ubuntuone.controlpanel.constants' module."""
 

=== renamed file 'ubuntuone/utils/webclient/tests/test_gsettings.py' => 'ubuntuone/utils/tests/test_gsettings.py'
--- ubuntuone/utils/webclient/tests/test_gsettings.py	2016-05-29 00:50:05 +0000
+++ ubuntuone/utils/tests/test_gsettings.py	2017-01-13 11:56:59 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2017 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # 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
@@ -35,11 +35,41 @@
 from twisted.trial.unittest import TestCase
 from ubuntuone.devtools.handlers import MementoHandler
 
-from ubuntuone.utils.webclient import gsettings
-from ubuntuone.utils.webclient.tests import (
-    BASE_GSETTINGS_VALUES,
-    TEMPLATE_GSETTINGS_OUTPUT,
-)
+from ubuntuone.utils import gsettings
+
+TEMPLATE_GSETTINGS_OUTPUT = """\
+org.gnome.system.proxy autoconfig-url '{autoconfig_url}'
+org.gnome.system.proxy ignore-hosts {ignore_hosts:s}
+org.gnome.system.proxy mode '{mode}'
+org.gnome.system.proxy.ftp host '{ftp_host}'
+org.gnome.system.proxy.ftp port {ftp_port}
+org.gnome.system.proxy.http authentication-password '{auth_password}'
+org.gnome.system.proxy.http authentication-user '{auth_user}'
+org.gnome.system.proxy.http host '{http_host}'
+org.gnome.system.proxy.http port {http_port}
+org.gnome.system.proxy.http use-authentication {http_use_auth}
+org.gnome.system.proxy.https host '{https_host}'
+org.gnome.system.proxy.https port {https_port}
+org.gnome.system.proxy.socks host '{socks_host}'
+org.gnome.system.proxy.socks port {socks_port}
+"""
+
+BASE_GSETTINGS_VALUES = {
+    "autoconfig_url": "",
+    "ignore_hosts": ["localhost", "127.0.0.0/8"],
+    "mode": "none",
+    "ftp_host": "",
+    "ftp_port": 0,
+    "auth_password": "",
+    "auth_user": "",
+    "http_host": "",
+    "http_port": 0,
+    "http_use_auth": "false",
+    "https_host": "",
+    "https_port": 0,
+    "socks_host": "",
+    "socks_port": 0,
+}
 
 
 class ProxySettingsTestCase(TestCase):

=== removed directory 'ubuntuone/utils/webclient'
=== removed file 'ubuntuone/utils/webclient/__init__.py'
--- ubuntuone/utils/webclient/__init__.py	2016-06-04 21:14:35 +0000
+++ ubuntuone/utils/webclient/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""A common webclient that can use a QtNetwork or libsoup backend."""
-
-
-def webclient_module():
-    """Choose the module of the web client."""
-    if False:
-        from ubuntuone.utils.webclient import txweb
-        return txweb
-    else:
-        from ubuntuone.utils.webclient import libsoup
-        return libsoup
-
-
-def webclient_factory(*args, **kwargs):
-    """Choose the type of the web client dynamically."""
-    web_module = webclient_module()
-    return web_module.WebClient(*args, **kwargs)

=== removed file 'ubuntuone/utils/webclient/common.py'
--- ubuntuone/utils/webclient/common.py	2016-06-04 21:14:35 +0000
+++ ubuntuone/utils/webclient/common.py	1970-01-01 00:00:00 +0000
@@ -1,189 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2013 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""The common bits of a webclient."""
-
-import collections
-import logging
-
-from httplib2 import iri2uri
-from twisted.internet import defer
-
-from ubuntuone.utils.webclient.timestamp import TimestampChecker
-
-
-logger = logging.getLogger(__name__)
-
-
-class WebClientError(Exception):
-    """An http error happened while calling the webservice."""
-
-
-class UnauthorizedError(WebClientError):
-    """The request ended with bad_request, unauthorized or forbidden."""
-
-
-class ProxyUnauthorizedError(WebClientError):
-    """Failure raised when there is an issue with the proxy auth."""
-
-
-class Response(object):
-    """A response object."""
-
-    def __init__(self, content, headers=None):
-        """Initialize this instance."""
-        self.content = content
-        self.headers = headers
-
-
-class HeaderDict(collections.defaultdict):
-    """A case insensitive dict for headers."""
-
-    def __init__(self, *args, **kwargs):
-        """Handle case-insensitive keys."""
-        super(HeaderDict, self).__init__(list, *args, **kwargs)
-        for key, value in self.items():
-            super(HeaderDict, self).__delitem__(key)
-            self[key] = value
-
-    def __setitem__(self, key, value):
-        """Set the value with a case-insensitive key."""
-        super(HeaderDict, self).__setitem__(key.lower(), value)
-
-    def __getitem__(self, key):
-        """Get the value with a case-insensitive key."""
-        return super(HeaderDict, self).__getitem__(key.lower())
-
-    def __delitem__(self, key):
-        """Delete the item with the case-insensitive key."""
-        super(HeaderDict, self).__delitem__(key.lower())
-
-    def __contains__(self, key):
-        """Check the containment with a case-insensitive key."""
-        return super(HeaderDict, self).__contains__(key.lower())
-
-
-class BaseWebClient(object):
-    """The webclient base class, to be extended by backends."""
-
-    timestamp_checker = None
-
-    def __init__(self, appname='', username=None, password=None):
-        """Initialize this instance."""
-        self.appname = appname
-        self.username = username
-        self.password = password
-        self.proxy_username = None
-        self.proxy_password = None
-
-    def request(self, iri, method="GET", extra_headers=None,
-                post_content=None):
-        """Return a deferred that will be fired with a Response object."""
-        raise NotImplementedError
-
-    @classmethod
-    def get_timestamp_checker(cls):
-        """Get the timestamp checker for this class of webclient."""
-        if cls.timestamp_checker is None:
-            cls.timestamp_checker = TimestampChecker(cls)
-        return cls.timestamp_checker
-
-    def get_timestamp(self):
-        """Get a timestamp synchronized with the server."""
-        return self.get_timestamp_checker().get_faithful_time()
-
-    def force_use_proxy(self, settings):
-        """Setup this webclient to use the given proxy settings."""
-        raise NotImplementedError
-
-    def iri_to_uri(self, iri):
-        """Transform a unicode iri into a ascii uri."""
-        if not isinstance(iri, unicode):
-            raise TypeError('iri %r should be unicode.' % iri)
-        return bytes(iri2uri(iri))
-
-    def build_auth_request(self, method, uri, credentials, timestamp):
-        """Build an auth request given some credentials."""
-        # XXX: implement
-        return {'Authorization': 'Auth dummy'}
-
-    @defer.inlineCallbacks
-    def build_request_headers(self, uri, method="GET", extra_headers=None,
-                              auth_credentials=None):
-        """Build the headers for a request."""
-        if extra_headers:
-            headers = dict(extra_headers)
-        else:
-            headers = {}
-
-        if auth_credentials:
-            timestamp = yield self.get_timestamp()
-            signed_headers = self.build_auth_request(
-                method, uri, auth_credentials, timestamp)
-            headers.update(signed_headers)
-
-        defer.returnValue(headers)
-
-    @defer.inlineCallbacks
-    def build_signed_iri(self, iri, credentials, parameters=None):
-        """Build a new iri signing 'iri' with 'credentials'."""
-        uri = self.iri_to_uri(iri)
-        timestamp = yield self.get_timestamp()
-        url = self.build_auth_request(
-            method='GET', uri=uri, credentials=credentials,
-            timestamp=timestamp)
-        defer.returnValue(url)
-
-    def shutdown(self):
-        """Shut down all pending requests (if possible)."""
-
-    @defer.inlineCallbacks
-    def _load_proxy_creds_from_keyring(self, domain):
-        """Load the proxy creds from the keyring."""
-        from ubuntuone.keyring import Keyring
-        keyring = Keyring()
-        try:
-            creds = yield keyring.get_credentials(str(domain))
-            logger.debug('Got credentials from keyring.')
-        except Exception as e:
-            logger.error('Error when retrieving the creds.')
-            raise WebClientError('Error when retrieving the creds.', e)
-        if creds is not None:
-            # if we are loading the same creds it means that we got the wrong
-            # ones
-            if (self.proxy_username == creds['username'] and
-                    self.proxy_password == creds['password']):
-                defer.returnValue(False)
-            else:
-                self.proxy_username = creds['username']
-                self.proxy_password = creds['password']
-                defer.returnValue(True)
-        logger.debug('Proxy creds not in keyring.')
-        defer.returnValue(False)

=== removed file 'ubuntuone/utils/webclient/libsoup.py'
--- ubuntuone/utils/webclient/libsoup.py	2016-06-04 21:14:35 +0000
+++ ubuntuone/utils/webclient/libsoup.py	1970-01-01 00:00:00 +0000
@@ -1,137 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""A webclient backend that uses libsoup."""
-
-import httplib
-import logging
-
-from twisted.internet import defer
-
-from ubuntuone.utils.webclient.common import (
-    BaseWebClient,
-    HeaderDict,
-    Response,
-    ProxyUnauthorizedError,
-    UnauthorizedError,
-    WebClientError,
-)
-
-URI_ANONYMOUS_TEMPLATE = "http://{host}:{port}/"
-URI_USERNAME_TEMPLATE = "http://{username}:{password}@{host}:{port}/"
-
-logger = logging.getLogger(__name__)
-
-
-class WebClient(BaseWebClient):
-    """A webclient with a libsoup backend."""
-
-    def __init__(self, *args, **kwargs):
-        """Initialize this instance."""
-        super(WebClient, self).__init__(*args, **kwargs)
-        from gi.repository import Soup, SoupGNOME
-        self.soup = Soup
-        self.session = Soup.SessionAsync()
-        self.session.add_feature(SoupGNOME.ProxyResolverGNOME())
-        self.session.connect("authenticate", self._on_authenticate)
-
-    def _on_message(self, session, message, d):
-        """Handle the result of an http message."""
-        logger.debug('_on_message status code is %s', message.status_code)
-        if message.status_code == httplib.OK:
-            headers = HeaderDict()
-            response_headers = message.get_property("response-headers")
-            response_headers.foreach(
-                lambda key, value, _: headers[key].append(value), None)
-            content = message.response_body.flatten().get_data()
-            response = Response(content, headers)
-            d.callback(response)
-        elif message.status_code == httplib.UNAUTHORIZED:
-            e = UnauthorizedError(message.reason_phrase)
-            d.errback(e)
-        elif message.status_code == httplib.PROXY_AUTHENTICATION_REQUIRED:
-            e = ProxyUnauthorizedError(message.reason_phrase)
-            d.errback(e)
-        else:
-            e = WebClientError(message.reason_phrase)
-            d.errback(e)
-
-    @defer.inlineCallbacks
-    def _on_authenticate(self, session, message, auth, retrying, data=None):
-        """Handle the "authenticate" signal."""
-        self.session.pause_message(message)
-        try:
-            logger.debug('_on_authenticate: message status code is %s',
-                         message.status_code)
-            if not retrying and self.username and self.password:
-                auth.authenticate(self.username, self.password)
-        finally:
-            self.session.unpause_message(message)
-
-    @defer.inlineCallbacks
-    def request(self, iri, method="GET", extra_headers=None,
-                auth_credentials=None, post_content=None):
-        """Return a deferred that will be fired with a Response object."""
-        uri = self.iri_to_uri(iri)
-        headers = yield self.build_request_headers(uri, method, extra_headers,
-                                                   auth_credentials)
-        d = defer.Deferred()
-        message = self.soup.Message.new(method, uri)
-
-        for key, value in headers.items():
-            message.request_headers.append(key, value)
-
-        if post_content:
-            message.request_body.append(post_content)
-
-        self.session.queue_message(message, self._on_message, d)
-        response = yield d
-        defer.returnValue(response)
-
-    def force_use_proxy(self, settings):
-        """Setup this webclient to use the given proxy settings."""
-        proxy_uri = self.get_proxy_uri(settings)
-        self.session.set_property("proxy-uri", proxy_uri)
-
-    def get_proxy_uri(self, settings):
-        """Get a Soup.URI for the proxy, or None if disabled."""
-        if "host" in settings and "port" in settings:
-            template = URI_ANONYMOUS_TEMPLATE
-            if "username" in settings and "password" in settings:
-                template = URI_USERNAME_TEMPLATE
-            uri = template.format(**settings)
-            return self.soup.URI.new(uri)
-        else:
-            # If the proxy host is not set, use no proxy
-            return None
-
-    def shutdown(self):
-        """End the soup session for this webclient."""
-        self.session.abort()

=== removed file 'ubuntuone/utils/webclient/restful.py'
--- ubuntuone/utils/webclient/restful.py	2016-05-29 00:50:05 +0000
+++ ubuntuone/utils/webclient/restful.py	1970-01-01 00:00:00 +0000
@@ -1,94 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""A proxy-enabled restful client."""
-
-import json
-import logging
-
-try:
-    from urllib.parse import urlencode
-except ImportError:
-    from urllib import urlencode
-
-from twisted.internet import defer
-
-from ubuntuone.utils import webclient
-
-logger = logging.getLogger(__name__)
-
-POST_HEADERS = {
-    "content-type": "application/x-www-form-urlencoded",
-}
-
-
-class RestfulClient(object):
-    """A proxy-enabled restful client."""
-
-    def __init__(self, service_iri, username=None, password=None,
-                 auth_credentials=None):
-        """Initialize this instance."""
-        assert service_iri.endswith("/")
-        self.service_iri = service_iri
-        self.webclient = webclient.webclient_factory(username=username,
-                                                     password=password)
-        self.auth_credentials = auth_credentials
-
-    @defer.inlineCallbacks
-    def restcall(self, method, **kwargs):
-        """Make a restful call."""
-        assert isinstance(method, unicode)
-        params = {}
-        for key, value in kwargs.items():
-            if isinstance(value, basestring):
-                assert isinstance(value, unicode)
-            params[key] = json.dumps(value)
-        namespace, operation = method.split(".")
-        params["ws.op"] = operation
-        encoded_args = urlencode(params)
-        iri = self.service_iri + namespace
-        creds = self.auth_credentials
-        logger.debug('Performing REST call to %r.', iri)
-        result = yield self.webclient.request(iri, method="POST",
-                                              auth_credentials=creds,
-                                              post_content=encoded_args,
-                                              extra_headers=POST_HEADERS)
-        try:
-            response = json.loads(result.content)
-        except:
-            logger.exception('Can not load json from REST request response '
-                             '(content is %r).', result.content)
-            raise
-        else:
-            defer.returnValue(response)
-
-    def shutdown(self):
-        """Stop the webclient used by this class."""
-        self.webclient.shutdown()

=== removed directory 'ubuntuone/utils/webclient/tests'
=== removed file 'ubuntuone/utils/webclient/tests/__init__.py'
--- ubuntuone/utils/webclient/tests/__init__.py	2016-05-28 23:52:12 +0000
+++ ubuntuone/utils/webclient/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,65 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""Tests for the proxy-aware webclient."""
-
-TEMPLATE_GSETTINGS_OUTPUT = """\
-org.gnome.system.proxy autoconfig-url '{autoconfig_url}'
-org.gnome.system.proxy ignore-hosts {ignore_hosts:s}
-org.gnome.system.proxy mode '{mode}'
-org.gnome.system.proxy.ftp host '{ftp_host}'
-org.gnome.system.proxy.ftp port {ftp_port}
-org.gnome.system.proxy.http authentication-password '{auth_password}'
-org.gnome.system.proxy.http authentication-user '{auth_user}'
-org.gnome.system.proxy.http host '{http_host}'
-org.gnome.system.proxy.http port {http_port}
-org.gnome.system.proxy.http use-authentication {http_use_auth}
-org.gnome.system.proxy.https host '{https_host}'
-org.gnome.system.proxy.https port {https_port}
-org.gnome.system.proxy.socks host '{socks_host}'
-org.gnome.system.proxy.socks port {socks_port}
-"""
-
-BASE_GSETTINGS_VALUES = {
-    "autoconfig_url": "",
-    "ignore_hosts": ["localhost", "127.0.0.0/8"],
-    "mode": "none",
-    "ftp_host": "",
-    "ftp_port": 0,
-    "auth_password": "",
-    "auth_user": "",
-    "http_host": "",
-    "http_port": 0,
-    "http_use_auth": "false",
-    "https_host": "",
-    "https_port": 0,
-    "socks_host": "",
-    "socks_port": 0,
-}

=== removed file 'ubuntuone/utils/webclient/tests/test_restful.py'
--- ubuntuone/utils/webclient/tests/test_restful.py	2016-05-29 00:50:05 +0000
+++ ubuntuone/utils/webclient/tests/test_restful.py	1970-01-01 00:00:00 +0000
@@ -1,233 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""Tests for the proxy-enabled restful client."""
-
-import logging
-
-try:
-    from urllib.parse import urlparse, parse_qs, parse_qsl
-except ImportError:
-    from urlparse import urlparse, parse_qs, parse_qsl
-
-from twisted.internet import defer
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import TestCase
-
-from ubuntuone.utils.webclient import restful
-from ubuntuone.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_AUTH_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
-        self.running = True
-
-    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))
-
-    def shutdown(self):
-        """Stop this fake webclient."""
-        self.running = False
-
-
-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)
-        self.addCleanup(self.rc.shutdown)
-
-    def test_has_a_webclient(self):
-        """The RC has a webclient."""
-        self.assertEqual(self.rc.webclient, self.wc)
-
-    def test_shutsdown_the_webclient(self):
-        """Calling shutdown on the restful shuts down the webclient too."""
-        self.rc.shutdown()
-        self.assertFalse(self.rc.webclient.running, "The webclient is stopped")
-
-    @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 test_restful_namespace_added_to_url(self):
-        """The restful namespace is added to the url."""
-        yield self.rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
-        iri, _, _ = self.wc.called[0]
-        uri = iri.encode("ascii")
-        url = urlparse(uri)
-        self.assertTrue(url.path.endswith(SAMPLE_NAMESPACE),
-                        "The namespace is included in url")
-
-    @defer.inlineCallbacks
-    def test_restful_method_added_to_params(self):
-        """The restful method is added to the params."""
-        yield self.rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
-        _, _, webcall_kwargs = self.wc.called[0]
-        wc_params = parse_qs(webcall_kwargs["post_content"])
-        self.assertEqual(wc_params["ws.op"][0], SAMPLE_METHOD)
-
-    @defer.inlineCallbacks
-    def test_arguments_added_as_json_to_webcall(self):
-        """The keyword arguments are used as json in the webcall."""
-        yield self.rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
-        _, _, webcall_kwargs = self.wc.called[0]
-        params = parse_qsl(webcall_kwargs["post_content"])
-        result = {}
-        for key, value in params:
-            if key == "ws.op":
-                continue
-            result[key] = restful.json.loads(value)
-        self.assertEqual(result, SAMPLE_ARGS)
-
-    @defer.inlineCallbacks
-    def test_post_header_sent(self):
-        """A header is sent specifying the contents of the post."""
-        yield self.rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
-        _, _, webcall_kwargs = self.wc.called[0]
-        self.assertEqual(restful.POST_HEADERS,
-                         webcall_kwargs["extra_headers"])
-
-    @defer.inlineCallbacks
-    def test_post_method_set(self):
-        """The method of the webcall is set to POST."""
-        yield self.rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
-        _, _, webcall_kwargs = self.wc.called[0]
-        self.assertEqual("POST", webcall_kwargs["method"])
-
-    @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."""
-        params = dict(username=SAMPLE_USERNAME, password=SAMPLE_PASSWORD)
-        restful.RestfulClient(SAMPLE_SERVICE_IRI, **params)
-        expected = dict(params)
-        self.assertEqual(self.wc.init_kwargs, expected)
-
-    @defer.inlineCallbacks
-    def test_passes_auth_creds_to_request(self):
-        """The RestfulClient passes the credentials in each request."""
-        kwargs = dict(auth_credentials=SAMPLE_AUTH_CREDS)
-        rc = restful.RestfulClient(SAMPLE_SERVICE_IRI, **kwargs)
-        yield rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
-        _, _, kwargs = self.wc.called[0]
-        self.assertEqual(kwargs["auth_credentials"], SAMPLE_AUTH_CREDS)
-
-
-class LogginTestCase(BaseTestCase):
-    """Ensure that proper debug logging is done."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this testcase."""
-        yield super(LogginTestCase, self).setUp()
-        self.memento = MementoHandler()
-        restful.logger.addHandler(self.memento)
-        restful.logger.setLevel(logging.DEBUG)
-        self.addCleanup(restful.logger.removeHandler, self.memento)
-
-        self.rc = restful.RestfulClient(SAMPLE_SERVICE_IRI)
-        self.addCleanup(self.rc.shutdown)
-
-    @defer.inlineCallbacks
-    def test_log_rest_call(self):
-        """Check that proper DEBUG is made for every REST call."""
-        yield self.rc.restcall(SAMPLE_OPERATION, **SAMPLE_ARGS)
-
-        expected_msgs = (
-            SAMPLE_SERVICE_IRI + SAMPLE_NAMESPACE,
-        )
-        self.assertTrue(self.memento.check_debug(*expected_msgs))
-
-    @defer.inlineCallbacks
-    def test_log_json_loads_exception(self):
-        """Check that json load errors are properly logged."""
-        invalid_json = 'NOTAVALIDJSON'
-        self.patch(self.wc, 'return_value', invalid_json)
-        yield self.assertFailure(self.rc.restcall(SAMPLE_OPERATION),
-                                 ValueError)
-
-        self.memento.debug = True
-        expected_msgs = (
-            ValueError,
-            'Can not load json from REST request response',
-            invalid_json
-        )
-        self.assertTrue(self.memento.check_exception(*expected_msgs))

=== removed file 'ubuntuone/utils/webclient/tests/test_timestamp.py'
--- ubuntuone/utils/webclient/tests/test_timestamp.py	2016-06-04 21:14:35 +0000
+++ ubuntuone/utils/webclient/tests/test_timestamp.py	1970-01-01 00:00:00 +0000
@@ -1,141 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""Tests for the timestamp sync classes."""
-
-from twisted.internet import defer
-from twisted.trial.unittest import TestCase
-from twisted.web import resource
-
-from ubuntuone.devtools.testing.txwebserver import HTTPWebServer
-
-from ubuntuone.utils.webclient import timestamp, webclient_module
-
-
-class FakedError(Exception):
-    """Stub to replace Request.error."""
-
-
-class RootResource(resource.Resource):
-    """A root resource that logs the number of calls."""
-
-    isLeaf = True
-
-    def __init__(self, *args, **kwargs):
-        """Initialize this fake instance."""
-        resource.Resource.__init__(self, *args, **kwargs)
-        self.count = 0
-        self.request_headers = []
-
-    def render_HEAD(self, request):
-        """Increase the counter on each render."""
-        self.request_headers.append(request.requestHeaders)
-        self.count += 1
-        return ""
-
-
-class MockWebServer(HTTPWebServer):
-    """A mock webserver for testing."""
-
-    def __init__(self):
-        """Create a new server."""
-        super(MockWebServer, self).__init__(RootResource())
-
-
-class TimestampCheckerTestCase(TestCase):
-    """Tests for the timestamp checker."""
-
-    timeout = 5
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(TimestampCheckerTestCase, self).setUp()
-        self.ws = MockWebServer()
-        self.ws.start()
-        self.addCleanup(self.ws.stop)
-        self.webclient_class = webclient_module().WebClient
-        self.patch(timestamp.TimestampChecker, "SERVER_IRI", self.ws.get_iri())
-
-    @defer.inlineCallbacks
-    def test_returned_value_is_int(self):
-        """The returned value is an integer."""
-        checker = timestamp.TimestampChecker(self.webclient_class)
-        result = yield checker.get_faithful_time()
-        self.assertEqual(type(result), int)
-
-    @defer.inlineCallbacks
-    def test_first_call_does_head(self):
-        """The first call gets the clock from our web."""
-        checker = timestamp.TimestampChecker(self.webclient_class)
-        yield checker.get_faithful_time()
-        self.assertEqual(self.ws.root.count, 1)
-
-    @defer.inlineCallbacks
-    def test_second_call_is_cached(self):
-        """For the second call, the time is cached."""
-        checker = timestamp.TimestampChecker(self.webclient_class)
-        yield checker.get_faithful_time()
-        yield checker.get_faithful_time()
-        self.assertEqual(self.ws.root.count, 1)
-
-    @defer.inlineCallbacks
-    def test_after_timeout_cache_expires(self):
-        """After some time, the cache expires."""
-        fake_timestamp = 1
-        self.patch(timestamp.time, "time", lambda: fake_timestamp)
-        checker = timestamp.TimestampChecker(self.webclient_class)
-        yield checker.get_faithful_time()
-        fake_timestamp += timestamp.TimestampChecker.CHECKING_INTERVAL
-        yield checker.get_faithful_time()
-        self.assertEqual(self.ws.root.count, 2)
-
-    @defer.inlineCallbacks
-    def test_server_error_means_skew_not_updated(self):
-        """When server can't be reached, the skew is not updated."""
-        fake_timestamp = 1
-        self.patch(timestamp.time, "time", lambda: fake_timestamp)
-        checker = timestamp.TimestampChecker(self.webclient_class)
-        self.patch(
-            checker, "get_server_time", lambda _: defer.fail(FakedError()))
-        yield checker.get_faithful_time()
-        self.assertEqual(checker.skew, 0)
-        self.assertEqual(
-            checker.next_check,
-            fake_timestamp + timestamp.TimestampChecker.ERROR_INTERVAL)
-
-    @defer.inlineCallbacks
-    def test_server_date_sends_nocache_headers(self):
-        """Getting the server date sends the no-cache headers."""
-        checker = timestamp.TimestampChecker(self.webclient_class)
-        yield checker.get_server_date_header(self.ws.get_iri())
-        self.assertEqual(len(self.ws.root.request_headers), 1)
-        headers = self.ws.root.request_headers[0]
-        result = headers.getRawHeaders("Cache-Control")
-        self.assertEqual(result, ["no-cache"])

=== removed file 'ubuntuone/utils/webclient/tests/test_webclient.py'
--- ubuntuone/utils/webclient/tests/test_webclient.py	2016-06-04 21:14:35 +0000
+++ ubuntuone/utils/webclient/tests/test_webclient.py	1970-01-01 00:00:00 +0000
@@ -1,753 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2013 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""Integration tests for the proxy-enabled webclient."""
-
-import logging
-import os
-import shutil
-
-try:
-    from urllib.parse import urlencode
-except ImportError:
-    from urllib import urlencode
-
-from OpenSSL import crypto
-from socket import gethostname
-from twisted.cred import checkers, portal
-from twisted.internet import defer
-from twisted.web import guard, http, resource
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import TestCase, skipIfOS
-from ubuntuone.devtools.testcases.squid import SquidTestCase
-from ubuntuone.devtools.testing.txwebserver import (
-    HTTPWebServer,
-    HTTPSWebServer,
-)
-
-from ubuntuone.utils import webclient
-from ubuntuone.utils.webclient import gsettings, txweb
-from ubuntuone.utils.webclient.common import (
-    HeaderDict,
-    UnauthorizedError,
-    WebClientError,
-)
-
-ANY_VALUE = object()
-SAMPLE_KEY = "result"
-SAMPLE_VALUE = "sample result"
-SAMPLE_RESOURCE = '{"%s": "%s"}' % (SAMPLE_KEY, SAMPLE_VALUE)
-SAMPLE_USERNAME = "peddro"
-SAMPLE_PASSWORD = "cantropus"
-SAMPLE_CREDENTIALS = dict(username="username", password="password")
-SAMPLE_HEADERS = {SAMPLE_KEY: SAMPLE_VALUE}
-SAMPLE_POST_PARAMS = {"param1": "value1", "param2": "value2"}
-SAMPLE_JPEG_HEADER = '\xff\xd8\xff\xe0\x00\x10JFIF'
-
-SIMPLERESOURCE = "simpleresource"
-BYTEZERORESOURCE = "bytezeroresource"
-POSTABLERESOURCE = "postableresource"
-THROWERROR = "throwerror"
-UNAUTHORIZED = "unauthorized"
-HEADONLY = "headonly"
-VERIFYHEADERS = "verifyheaders"
-VERIFYPOSTPARAMS = "verifypostparams"
-GUARDED = "guarded"
-AUTHRESOURCE = "authresource"
-
-WEBCLIENT_MODULE_NAME = webclient.webclient_module().__name__
-
-
-def sample_get_credentials():
-    """Will return the sample credentials right now."""
-    return defer.succeed(SAMPLE_CREDENTIALS)
-
-
-class SimpleResource(resource.Resource):
-    """A simple web resource."""
-
-    def render_GET(self, request):
-        """Make a bit of html out of these resource's content."""
-        return SAMPLE_RESOURCE
-
-
-class ByteZeroResource(resource.Resource):
-    """A resource that has a nul byte in the middle of it."""
-
-    def render_GET(self, request):
-        """Return the content of this resource."""
-        return SAMPLE_JPEG_HEADER
-
-
-class PostableResource(resource.Resource):
-    """A resource that only answers to POST requests."""
-
-    def render_POST(self, request):
-        """Make a bit of html out of these resource's content."""
-        return SAMPLE_RESOURCE
-
-
-class HeadOnlyResource(resource.Resource):
-    """A resource that fails if called with a method other than HEAD."""
-
-    def render_HEAD(self, request):
-        """Return a bit of html."""
-        return "OK"
-
-
-class VerifyHeadersResource(resource.Resource):
-    """A resource that verifies the headers received."""
-
-    def render_GET(self, request):
-        """Make a bit of html out of these resource's content."""
-        headers = request.requestHeaders.getRawHeaders(SAMPLE_KEY)
-        if headers != [SAMPLE_VALUE]:
-            request.setResponseCode(http.BAD_REQUEST)
-            return "ERROR: Expected header not present."
-        request.setHeader(SAMPLE_KEY, SAMPLE_VALUE)
-        return SAMPLE_RESOURCE
-
-
-class VerifyPostParameters(resource.Resource):
-    """A resource that answers to POST requests with some parameters."""
-
-    def fetch_post_args_only(self, request):
-        """Fetch only the POST arguments, not the args in the url."""
-        request.process = lambda: None
-        request.requestReceived(request.method, request.path,
-                                request.clientproto)
-        return request.args
-
-    def render_POST(self, request):
-        """Verify the parameters that we've been called with."""
-        post_params = self.fetch_post_args_only(request)
-        expected = dict(
-            (key, [val]) for key, val in SAMPLE_POST_PARAMS.items())
-        if post_params != expected:
-            request.setResponseCode(http.BAD_REQUEST)
-            return "ERROR: Expected arguments not present, %r != %r" % (
-                post_params, expected)
-        return SAMPLE_RESOURCE
-
-
-class SimpleRealm(object):
-    """The same simple resource for all users."""
-
-    def requestAvatar(self, avatarId, mind, *interfaces):
-        """The avatar for this user."""
-        if resource.IResource in interfaces:
-            return (resource.IResource, SimpleResource(), lambda: None)
-        raise NotImplementedError()
-
-
-class AuthCheckerResource(resource.Resource):
-    """A resource that verifies the request was auth signed."""
-
-    def render_GET(self, request):
-        """Make a bit of html out of these resource's content."""
-        header = request.requestHeaders.getRawHeaders("Authorization")[0]
-        if header.startswith("Auth "):
-            return SAMPLE_RESOURCE
-        request.setResponseCode(http.BAD_REQUEST)
-        return "ERROR: Expected Auth header not present."
-
-
-def get_root_resource():
-    """Get the root resource with all the children."""
-    root = resource.Resource()
-    root.putChild(SIMPLERESOURCE, SimpleResource())
-    root.putChild(BYTEZERORESOURCE, ByteZeroResource())
-    root.putChild(POSTABLERESOURCE, PostableResource())
-
-    root.putChild(THROWERROR, resource.NoResource())
-
-    unauthorized_resource = resource.ErrorPage(http.UNAUTHORIZED,
-                                               "Unauthorized", "Unauthorized")
-    root.putChild(UNAUTHORIZED, unauthorized_resource)
-    root.putChild(HEADONLY, HeadOnlyResource())
-    root.putChild(VERIFYHEADERS, VerifyHeadersResource())
-    root.putChild(VERIFYPOSTPARAMS, VerifyPostParameters())
-    root.putChild(AUTHRESOURCE, AuthCheckerResource())
-
-    db = checkers.InMemoryUsernamePasswordDatabaseDontUse()
-    db.addUser(SAMPLE_USERNAME, SAMPLE_PASSWORD)
-    test_portal = portal.Portal(SimpleRealm(), [db])
-    cred_factory = guard.BasicCredentialFactory("example.org")
-    guarded_resource = guard.HTTPAuthSessionWrapper(
-        test_portal, [cred_factory])
-    root.putChild(GUARDED, guarded_resource)
-    return root
-
-
-class HTTPMockWebServer(HTTPWebServer):
-    """A mock webserver for the webclient tests."""
-
-    def __init__(self):
-        """Create a new instance."""
-        root = get_root_resource()
-        super(HTTPMockWebServer, self).__init__(root)
-
-
-class HTTPSMockWebServer(HTTPSWebServer):
-    """A mock webserver for the webclient tests."""
-
-    def __init__(self, ssl_settings):
-        """Create a new instance."""
-        root = get_root_resource()
-        super(HTTPSMockWebServer, self).__init__(root, ssl_settings)
-
-
-class ModuleSelectionTestCase(TestCase):
-    """Test the functions to choose the txweb or libsoup backend."""
-
-    def assert_module_name(self, module, expected_name):
-        """Check the name of a given module."""
-        module_filename = os.path.basename(module.__file__)
-        module_name = os.path.splitext(module_filename)[0]
-        self.assertEqual(module_name, expected_name)
-
-    def test_webclient_module_libsoup(self):
-        """Test the module name for the libsoup case."""
-        module = webclient.webclient_module()
-        self.assert_module_name(module, "libsoup")
-
-
-class WebClientTestCase(TestCase):
-    """Test for the webclient."""
-
-    timeout = 1
-    webclient_factory = webclient.webclient_factory
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(WebClientTestCase, self).setUp()
-        self.wc = self.webclient_factory()
-        self.addCleanup(self.wc.shutdown)
-        self.ws = HTTPMockWebServer()
-        self.ws.start()
-        self.addCleanup(self.ws.stop)
-        self.base_iri = self.ws.get_iri()
-
-    @defer.inlineCallbacks
-    def test_request_takes_an_iri(self):
-        """Passing a non-unicode iri fails."""
-        d = self.wc.request(bytes(self.base_iri + SIMPLERESOURCE))
-        yield self.assertFailure(d, TypeError)
-
-    @defer.inlineCallbacks
-    def test_get_iri(self):
-        """Passing in a unicode iri works fine."""
-        result = yield self.wc.request(self.base_iri + SIMPLERESOURCE)
-        self.assertEqual(SAMPLE_RESOURCE, result.content)
-
-    @defer.inlineCallbacks
-    def test_get_iri_error(self):
-        """The errback is called when there's some error."""
-        yield self.assertFailure(self.wc.request(self.base_iri + THROWERROR),
-                                 WebClientError)
-
-    @defer.inlineCallbacks
-    def test_zero_byte_in_content(self):
-        """Test a reply with a nul byte in the middle of it."""
-        result = yield self.wc.request(self.base_iri + BYTEZERORESOURCE)
-        self.assertEqual(SAMPLE_JPEG_HEADER, result.content)
-
-    @defer.inlineCallbacks
-    def test_post(self):
-        """Test a post request."""
-        result = yield self.wc.request(self.base_iri + POSTABLERESOURCE,
-                                       method="POST")
-        self.assertEqual(SAMPLE_RESOURCE, result.content)
-
-    @defer.inlineCallbacks
-    def test_post_with_args(self):
-        """Test a post request with arguments."""
-        args = urlencode(SAMPLE_POST_PARAMS)
-        iri = self.base_iri + VERIFYPOSTPARAMS + "?" + args
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        }
-        result = yield self.wc.request(
-            iri, method="POST", extra_headers=headers, post_content=args)
-        self.assertEqual(SAMPLE_RESOURCE, result.content)
-
-    @defer.inlineCallbacks
-    def test_unauthorized(self):
-        """Detect when a request failed with the UNAUTHORIZED http code."""
-        yield self.assertFailure(self.wc.request(self.base_iri + UNAUTHORIZED),
-                                 UnauthorizedError)
-
-    @defer.inlineCallbacks
-    def test_method_head(self):
-        """The HTTP method is used."""
-        result = yield self.wc.request(self.base_iri + HEADONLY, method="HEAD")
-        self.assertEqual("", result.content)
-
-    @defer.inlineCallbacks
-    def test_send_extra_headers(self):
-        """The extra_headers are sent to the server."""
-        result = yield self.wc.request(self.base_iri + VERIFYHEADERS,
-                                       extra_headers=SAMPLE_HEADERS)
-        self.assertIn(SAMPLE_KEY, result.headers)
-        self.assertEqual(result.headers[SAMPLE_KEY], [SAMPLE_VALUE])
-
-    @defer.inlineCallbacks
-    def test_send_basic_auth(self):
-        """The basic authentication headers are sent."""
-        other_wc = self.webclient_factory(username=SAMPLE_USERNAME,
-                                          password=SAMPLE_PASSWORD)
-        self.addCleanup(other_wc.shutdown)
-        result = yield other_wc.request(self.base_iri + GUARDED)
-        self.assertEqual(SAMPLE_RESOURCE, result.content)
-
-    @defer.inlineCallbacks
-    def test_send_basic_auth_wrong_credentials(self):
-        """Wrong credentials returns a webclient error."""
-        other_wc = self.webclient_factory(username=SAMPLE_USERNAME,
-                                          password="wrong password!")
-        self.addCleanup(other_wc.shutdown)
-        yield self.assertFailure(other_wc.request(self.base_iri + GUARDED),
-                                 UnauthorizedError)
-
-    @defer.inlineCallbacks
-    def test_request_is_auth_signed(self):
-        """The request is auth signed."""
-        tsc = self.wc.get_timestamp_checker()
-        self.patch(tsc, "get_faithful_time", lambda: defer.succeed('1'))
-        result = yield self.wc.request(self.base_iri + AUTHRESOURCE,
-                                       auth_credentials=SAMPLE_CREDENTIALS)
-        self.assertEqual(SAMPLE_RESOURCE, result.content)
-
-    @defer.inlineCallbacks
-    def test_auth_signing_uses_timestamp(self):
-        """Auth signing uses the timestamp."""
-        called = []
-
-        def fake_get_faithful_time():
-            """A fake get_timestamp"""
-            called.append(True)
-            return defer.succeed('1')
-
-        tsc = self.wc.get_timestamp_checker()
-        self.patch(tsc, "get_faithful_time", fake_get_faithful_time)
-        yield self.wc.request(self.base_iri + AUTHRESOURCE,
-                              auth_credentials=SAMPLE_CREDENTIALS)
-        self.assertTrue(called, "The timestamp must be retrieved.")
-
-    @defer.inlineCallbacks
-    def test_returned_content_are_bytes(self):
-        """The returned content are bytes."""
-        tsc = self.wc.get_timestamp_checker()
-        self.patch(tsc, "get_faithful_time", lambda: defer.succeed('1'))
-        result = yield self.wc.request(self.base_iri + AUTHRESOURCE,
-                                       auth_credentials=SAMPLE_CREDENTIALS)
-        self.assertTrue(isinstance(result.content, bytes),
-                        "The type of %r must be bytes" % result.content)
-
-    @defer.inlineCallbacks
-    def test_webclienterror_not_string(self):
-        """The returned exception contains unicode data."""
-        deferred = self.wc.request(self.base_iri + THROWERROR)
-        failure = yield self.assertFailure(deferred, WebClientError)
-        for error in failure.args:
-            self.assertTrue(isinstance(error, basestring))
-
-
-class FakeSavingReactor(object):
-    """A fake reactor that saves connection attempts."""
-
-    def __init__(self):
-        """Initialize this fake instance."""
-        self.connections = []
-
-    def connectTCP(self, host, port, factory, *args):
-        """Fake the connection."""
-        self.connections.append((host, port, args))
-        factory.response_headers = {}
-        factory.deferred = defer.succeed("response content")
-
-    def connectSSL(self, host, port, factory, *args):
-        """Fake the connection."""
-        self.connections.append((host, port, args))
-        factory.response_headers = {}
-        factory.deferred = defer.succeed("response content")
-
-
-class TxWebClientTestCase(WebClientTestCase):
-    """Test case for txweb."""
-
-    webclient_factory = txweb.WebClient
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the diff tests."""
-        # delay import, otherwise a default reactor gets installed
-        from twisted.web import client
-        self.factory = client.HTTPClientFactory
-        # set the factory to be used
-        # Hook the server's buildProtocol to make the protocol instance
-        # accessible to tests and ensure that the reactor is clean!
-        build_protocol = self.factory.buildProtocol
-        self.serverProtocol = None
-
-        def remember_protocol_instance(my_self, addr):
-            """Remember the protocol used in the test."""
-            protocol = build_protocol(my_self, addr)
-            self.serverProtocol = protocol
-            on_connection_lost = defer.Deferred()
-            connection_lost = protocol.connectionLost
-
-            def defer_connection_lost(protocol, *a):
-                """Lost connection."""
-                if not on_connection_lost.called:
-                    on_connection_lost.callback(None)
-                connection_lost(protocol, *a)
-
-            self.patch(protocol, 'connectionLost', defer_connection_lost)
-
-            def cleanup():
-                """Clean the connection."""
-                if self.serverProtocol.transport is not None:
-                    self.serverProtocol.transport.loseConnection()
-                return on_connection_lost
-
-            self.addCleanup(cleanup)
-            return protocol
-
-        self.factory.buildProtocol = remember_protocol_instance
-        self.addCleanup(self.set_build_protocol, build_protocol)
-        txweb.WebClient.client_factory = self.factory
-
-        yield super(TxWebClientTestCase, self).setUp()
-
-    def set_build_protocol(self, method):
-        """Set the method back."""
-        self.factory.buildProtocol = method
-
-
-class TxWebClientReactorReplaceableTestCase(TestCase):
-    """In the txweb client the reactor is replaceable."""
-
-    timeout = 3
-    FAKE_HOST = u"fake"
-    FAKE_IRI_TEMPLATE = u"%%s://%s/fake_page" % FAKE_HOST
-
-    @defer.inlineCallbacks
-    def _test_replaceable_reactor(self, iri):
-        """The reactor can be replaced with the tunnel client."""
-        fake_reactor = FakeSavingReactor()
-        wc = txweb.WebClient(fake_reactor)
-        _response = yield wc.request(iri)
-        assert(_response)
-        host, _port, _args = fake_reactor.connections[0]
-        self.assertEqual(host, self.FAKE_HOST)
-
-    def test_replaceable_reactor_http(self):
-        """Test the replaceable reactor with an http iri."""
-        return self._test_replaceable_reactor(self.FAKE_IRI_TEMPLATE % "http")
-
-    def test_replaceable_reactor_https(self):
-        """Test the replaceable reactor with an https iri."""
-        return self._test_replaceable_reactor(self.FAKE_IRI_TEMPLATE % "https")
-
-
-class TimestampCheckerTestCase(TestCase):
-    """Tests for the timestampchecker classmethod."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this testcase."""
-        yield super(TimestampCheckerTestCase, self).setUp()
-        self.wc = webclient.webclient_factory()
-        self.patch(self.wc.__class__, "timestamp_checker", None)
-
-    def test_timestamp_checker_has_the_same_class_as_the_creator(self):
-        """The TimestampChecker has the same class."""
-        tsc = self.wc.get_timestamp_checker()
-        self.assertEqual(tsc.webclient_class, self.wc.__class__)
-
-    def test_timestamp_checker_is_the_same_for_all_webclients(self):
-        """The TimestampChecker is the same for all webclients."""
-        tsc1 = self.wc.get_timestamp_checker()
-        wc2 = webclient.webclient_factory()
-        tsc2 = wc2.get_timestamp_checker()
-        self.assertIs(tsc1, tsc2)
-
-
-class BasicProxyTestCase(SquidTestCase):
-    """Test that the proxy works at all."""
-
-    timeout = 3
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(BasicProxyTestCase, self).setUp()
-        self.ws = HTTPMockWebServer()
-        self.ws.start()
-        self.addCleanup(self.ws.stop)
-        self.base_iri = self.ws.get_iri()
-        self.wc = webclient.webclient_factory()
-        self.addCleanup(self.wc.shutdown)
-
-    def assert_header_contains(self, headers, expected):
-        """One of the headers matching key must contain a given value."""
-        self.assertTrue(any(expected in value for value in headers))
-
-    @defer.inlineCallbacks
-    def test_anonymous_proxy_is_used(self):
-        """The anonymous proxy is used by the webclient."""
-        settings = self.get_nonauth_proxy_settings()
-        self.wc.force_use_proxy(settings)
-        result = yield self.wc.request(self.base_iri + SIMPLERESOURCE)
-        self.assert_header_contains(result.headers["Via"], "squid")
-
-    @skipIfOS('linux2',
-              'LP: #1111880 - ncsa_auth crashing for auth proxy tests.')
-    @defer.inlineCallbacks
-    def test_authenticated_proxy_is_used(self):
-        """The authenticated proxy is used by the webclient."""
-        settings = self.get_auth_proxy_settings()
-        self.wc.force_use_proxy(settings)
-        result = yield self.wc.request(self.base_iri + SIMPLERESOURCE)
-        self.assert_header_contains(result.headers["Via"], "squid")
-
-    if WEBCLIENT_MODULE_NAME.endswith(".txweb"):
-        reason = "txweb does not support proxies."
-        test_anonymous_proxy_is_used.skip = reason
-        test_authenticated_proxy_is_used.kip = reason
-
-
-class HeaderDictTestCase(TestCase):
-    """Tests for the case insensitive header dictionary."""
-
-    def test_constructor_handles_keys(self):
-        """The constructor handles case-insensitive keys."""
-        hd = HeaderDict({"ClAvE": "value"})
-        self.assertIn("clave", hd)
-
-    def test_can_set_get_items(self):
-        """The item is set/getted."""
-        hd = HeaderDict()
-        hd["key"] = "value"
-        hd["KEY"] = "value2"
-        self.assertEqual(hd["key"], "value2")
-
-    def test_can_test_presence(self):
-        """The presence of an item is found."""
-        hd = HeaderDict()
-        self.assertNotIn("cLaVe", hd)
-        hd["CLAVE"] = "value1"
-        self.assertIn("cLaVe", hd)
-        del(hd["cLAVe"])
-        self.assertNotIn("cLaVe", hd)
-
-
-class FakeKeyring(object):
-    """A fake keyring."""
-
-    def __init__(self, creds):
-        """A fake keyring."""
-        self.creds = creds
-
-    def __call__(self):
-        """Fake instance callable."""
-        return self
-
-    def get_credentials(self, domain):
-        """A fake get_credentials."""
-        if isinstance(self.creds, Exception):
-            return defer.fail(self.creds)
-        return defer.succeed(self.creds)
-
-
-class BaseSSLTestCase(SquidTestCase):
-    """Base test that allows to use ssl connections."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the diff tests."""
-        yield super(BaseSSLTestCase, self).setUp()
-        self.cert_dir = os.path.join(self.tmpdir, 'cert')
-        self.cert_details = dict(organization='Canonical',
-                                 common_name=gethostname(),
-                                 locality_name='London',
-                                 unit='Ubuntu One',
-                                 country_name='UK',
-                                 state_name='London',)
-        self.ssl_settings = self._generate_self_signed_certificate(
-            self.cert_dir,
-            self.cert_details)
-        self.addCleanup(self._clean_ssl_certificate_files)
-
-        self.ws = HTTPSMockWebServer(self.ssl_settings)
-        self.ws.start()
-        self.addCleanup(self.ws.stop)
-        self.base_iri = self.ws.get_iri()
-
-    def _clean_ssl_certificate_files(self):
-        """Remove the certificate files."""
-        if os.path.exists(self.cert_dir):
-            shutil.rmtree(self.cert_dir)
-
-    def _generate_self_signed_certificate(self, cert_dir, cert_details):
-        """Generate the required SSL certificates."""
-        if not os.path.exists(cert_dir):
-            os.makedirs(cert_dir)
-        cert_path = os.path.join(cert_dir, 'cert.crt')
-        key_path = os.path.join(cert_dir, 'cert.key')
-
-        if os.path.exists(cert_path):
-            os.unlink(cert_path)
-        if os.path.exists(key_path):
-            os.unlink(key_path)
-
-        # create a key pair
-        key = crypto.PKey()
-        key.generate_key(crypto.TYPE_RSA, 1024)
-
-        # create a self-signed cert
-        cert = crypto.X509()
-        cert.get_subject().C = cert_details['country_name']
-        cert.get_subject().ST = cert_details['state_name']
-        cert.get_subject().L = cert_details['locality_name']
-        cert.get_subject().O = cert_details['organization']
-        cert.get_subject().OU = cert_details['unit']
-        cert.get_subject().CN = cert_details['common_name']
-        cert.set_serial_number(1000)
-        cert.gmtime_adj_notBefore(0)
-        cert.gmtime_adj_notAfter(10 * 365 * 24 * 60 * 60)
-        cert.set_issuer(cert.get_subject())
-        cert.set_pubkey(key)
-        cert.sign(key, 'sha1')
-
-        with open(cert_path, 'wt') as fd:
-            fd.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
-
-        with open(key_path, 'wt') as fd:
-            fd.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, key))
-
-        return dict(key=key_path, cert=cert_path)
-
-
-class CorrectProxyTestCase(BaseSSLTestCase):
-    """Test the interaction with a SSL enabled proxy."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the tests."""
-        yield super(CorrectProxyTestCase, self).setUp()
-
-        # fake the gsettings to have diff settings for https and http
-        http_settings = self.get_auth_proxy_settings()
-        https_settings = self.get_nonauth_proxy_settings()
-
-        proxy_settings = dict(http=http_settings, https=https_settings)
-        self.patch(gsettings, "get_proxy_settings", lambda: proxy_settings)
-
-        self.wc = webclient.webclient_factory()
-        self.addCleanup(self.wc.shutdown)
-
-        self.called = []
-
-    def assert_header_contains(self, headers, expected):
-        """One of the headers matching key must contain a given value."""
-        self.assertTrue(any(expected in value for value in headers))
-
-    @defer.inlineCallbacks
-    def test_https_request(self):
-        """Test using the correct proxy for the ssl request.
-
-        In order to assert that the correct proxy is used we expect not to call
-        the auth dialog since we set the https proxy not to use the auth proxy
-        and to fail because we are reaching a https page with bad self-signed
-        certs.
-        """
-        # we fail due to the fake ssl cert
-        yield self.failUnlessFailure(self.wc.request(
-                                     self.base_iri + SIMPLERESOURCE),
-                                     WebClientError)
-        # https requests do not use the auth proxy therefore called should be
-        # empty. This asserts that we are using the correct settings for the
-        # request.
-        self.assertEqual([], self.called)
-
-    @defer.inlineCallbacks
-    def test_http_request(self):
-        """Test using the correct proxy for the plain request.
-
-        This tests does the opposite to the https tests. We did set the auth
-        proxy for the http request therefore we expect the proxy dialog to be
-        used and not to get an error since we are not visiting a https with bad
-        self-signed certs.
-        """
-        # we do not fail since we are not going to the https page
-        result = yield self.wc.request(self.base_iri + SIMPLERESOURCE)
-        self.assert_header_contains(result.headers["Via"], "squid")
-
-    if WEBCLIENT_MODULE_NAME.endswith(".txweb"):
-        reason = 'Multiple proxy settings is not supported.'
-        test_https_request.skip = reason
-        test_http_request.skip = reason
-
-    if WEBCLIENT_MODULE_NAME.endswith(".libsoup"):
-        reason = 'Hard to test since we need to fully mock gsettings.'
-        test_https_request.skip = reason
-        test_http_request.skip = reason
-
-
-class SSLTestCase(BaseSSLTestCase):
-    """Test error handling when dealing with ssl."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the diff tests."""
-        yield super(SSLTestCase, self).setUp()
-
-        self.memento = MementoHandler()
-        self.memento.setLevel(logging.DEBUG)
-        logger = webclient.webclient_module().logger
-        logger.addHandler(self.memento)
-        self.addCleanup(logger.removeHandler, self.memento)
-
-        self.wc = webclient.webclient_factory()
-        self.addCleanup(self.wc.shutdown)
-
-        self.called = []
-
-    def test_ssl_fail(self):
-        """Test showing the dialog and rejecting."""
-        self.failUnlessFailure(self.wc.request(
-                self.base_iri + SIMPLERESOURCE), WebClientError)
-        self.assertNotEqual(None, self.memento.check_error('SSL errors'))
-
-    if (WEBCLIENT_MODULE_NAME.endswith(".txweb") or
-            WEBCLIENT_MODULE_NAME.endswith(".libsoup")):
-        reason = 'SSL support has not yet been implemented.'
-        test_ssl_fail.skip = reason

=== removed file 'ubuntuone/utils/webclient/timestamp.py'
--- ubuntuone/utils/webclient/timestamp.py	2016-06-04 21:14:35 +0000
+++ ubuntuone/utils/webclient/timestamp.py	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2013 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""Timestamp synchronization with the server."""
-
-import logging
-import time
-
-from twisted.internet import defer
-
-
-logger = logging.getLogger(__name__)
-NOCACHE_HEADERS = {"Cache-Control": "no-cache"}
-
-
-class TimestampChecker(object):
-    """A timestamp that's regularly checked with a server."""
-
-    CHECKING_INTERVAL = 60 * 60  # in seconds
-    ERROR_INTERVAL = 30  # in seconds
-    SERVER_IRI = 'http://google.com'
-
-    def __init__(self, webclient_class):
-        """Initialize this instance."""
-        self.next_check = time.time()
-        self.skew = 0
-        self.webclient_class = webclient_class
-
-    @defer.inlineCallbacks
-    def get_server_date_header(self, server_iri):
-        """Get the server date using twisted webclient."""
-        webclient = self.webclient_class()
-        try:
-            response = yield webclient.request(server_iri, method="HEAD",
-                                               extra_headers=NOCACHE_HEADERS)
-            defer.returnValue(response.headers["Date"][0])
-        finally:
-            webclient.shutdown()
-
-    @defer.inlineCallbacks
-    def get_server_time(self):
-        """Get the time at the server."""
-        date_string = yield self.get_server_date_header(self.SERVER_IRI)
-        # delay import, otherwise a default reactor gets installed
-        from twisted.web import http
-        timestamp = http.stringToDatetime(date_string)
-        defer.returnValue(timestamp)
-
-    @defer.inlineCallbacks
-    def get_faithful_time(self):
-        """Get an accurate timestamp."""
-        local_time = time.time()
-        if local_time >= self.next_check:
-            try:
-                server_time = yield self.get_server_time()
-                self.next_check = local_time + self.CHECKING_INTERVAL
-                self.skew = server_time - local_time
-                logger.debug("Calculated server time skew: %r", self.skew)
-            except Exception as e:
-                logger.debug("Error while verifying server time skew: %r", e)
-                self.next_check = local_time + self.ERROR_INTERVAL
-        # delay import, otherwise a default reactor gets installed
-        from twisted.web import http
-        logger.debug("Using corrected timestamp: %r",
-                     http.datetimeToString(local_time + self.skew))
-        defer.returnValue(int(local_time + self.skew))

=== removed file 'ubuntuone/utils/webclient/txweb.py'
--- ubuntuone/utils/webclient/txweb.py	2016-06-04 21:14:35 +0000
+++ ubuntuone/utils/webclient/txweb.py	1970-01-01 00:00:00 +0000
@@ -1,175 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
-#
-# 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""A webclient backend that uses twisted.web.client."""
-
-import base64
-import logging
-
-try:
-    from urllib.parse import urlparse
-except ImportError:
-    from urlparse import urlparse
-
-from twisted.internet import defer
-
-from ubuntuone.utils.webclient.common import (
-    BaseWebClient,
-    HeaderDict,
-    Response,
-    UnauthorizedError,
-    WebClientError,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class RawResponse(object):
-    """A raw response from the webcall."""
-
-    def __init__(self, headers, content, code=200, phrase="OK"):
-        """Initialize this response."""
-        self.headers = headers
-        self.content = content
-        self.code = code
-        self.phrase = phrase
-
-
-class WebClient(BaseWebClient):
-    """A simple web client that does not support proxies, yet."""
-
-    client_factory = None
-
-    def __init__(self, connector=None, context_factory=None, **kwargs):
-        """Initialize this webclient."""
-        # delay import, otherwise a default reactor gets installed
-        from twisted.web import client
-
-        super(WebClient, self).__init__(**kwargs)
-
-        if connector is None:
-            from twisted.internet import reactor
-            self.connector = reactor
-        else:
-            self.connector = connector
-
-        if context_factory is None:
-            from twisted.internet import ssl
-            self.context_factory = ssl.ClientContextFactory()
-        else:
-            self.context_factory = context_factory
-
-        # decide which client factory to use
-        if WebClient.client_factory is None:
-            self.client_factory = client.HTTPClientFactory
-        else:
-            self.client_factory = WebClient.client_factory
-
-    @defer.inlineCallbacks
-    def raw_request(self, method, uri, headers, postdata):
-        """Make a raw http request."""
-        # Twisted wants headers as bytes, but because of other libs, they might
-        # be unicodes.  Assume utf-8 and revert the encodings.
-        bytes_headers = {}
-        for key, value in headers.items():
-            if isinstance(key, unicode):
-                key = key.encode('utf-8')
-            if isinstance(value, unicode):
-                value = value.encode('utf-8')
-            bytes_headers[key] = value
-        headers = bytes_headers
-
-        # delay import, otherwise a default reactor gets installed
-        from twisted.web import error
-
-        parsed_url = urlparse(uri)
-
-        https = parsed_url.scheme == "https"
-        host = parsed_url.netloc.split(":")[0]
-        if parsed_url.port is None:
-            port = 443 if https else 80
-        else:
-            port = parsed_url.port
-
-        factory = self.client_factory(
-            uri, method=method, postdata=postdata, headers=headers,
-            followRedirect=False)
-        if https:
-            self.connector.connectSSL(host, port, factory,
-                                      self.context_factory)
-        else:
-            self.connector.connectTCP(host, port, factory)
-
-        try:
-            content = yield factory.deferred
-            response = RawResponse(factory.response_headers, content)
-        except error.Error as e:
-            response = RawResponse(factory.response_headers, e.response,
-                                   int(e.status), e.message)
-        defer.returnValue(response)
-
-    @defer.inlineCallbacks
-    def request(self, iri, method="GET", extra_headers=None,
-                auth_credentials=None, post_content=None):
-        """Get the page, or fail trying."""
-        # delay import, otherwise a default reactor gets installed
-        from twisted.web import http
-
-        uri = self.iri_to_uri(iri)
-        headers = yield self.build_request_headers(uri, method, extra_headers,
-                                                   auth_credentials)
-
-        if self.username and self.password:
-            auth = base64.b64encode(self.username + ":" + self.password)
-            headers["Authorization"] = "Basic " + auth
-
-        try:
-            raw_response = yield self.raw_request(method, uri,
-                                                  headers=headers,
-                                                  postdata=post_content)
-            response_headers = HeaderDict(raw_response.headers)
-            if method.lower() != "head":
-                response_content = raw_response.content
-            else:
-                response_content = ""
-            if raw_response.code == http.OK:
-                defer.returnValue(Response(response_content, response_headers))
-            if raw_response.code == http.UNAUTHORIZED:
-                raise UnauthorizedError(raw_response.phrase,
-                                        response_content)
-            raise WebClientError(raw_response.phrase, response_content)
-        except WebClientError:
-            raise
-        except Exception as e:
-            raise WebClientError(e.message, e)
-
-    def force_use_proxy(self, settings):
-        """Setup this webclient to use the given proxy settings."""
-        # No direct proxy support in twisted.web.client