Merge lp:~facundo/magicicada-client/kill-qt4 into lp:magicicada-client

[Facundo Batista]

Removed everything PyQt related, including the HTTP(S) Proxy.

Removed everything PyQt related, including the HTTP(S) Proxy.

[Natalia Bidart (nataliabidart)]

Thanks!

review: Approve

=== removed file 'bin/ubuntuone-proxy-tunnel'
--- bin/ubuntuone-proxy-tunnel	2015-09-29 21:05:26 +0000
+++ bin/ubuntuone-proxy-tunnel	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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.
-"""Tunnel for proxy support."""
-
-import sys
-
-from ubuntuone.proxy.tunnel_server import main
-
-if __name__ == "__main__":
-    main(sys.argv)

=== removed file 'contrib/check-reactor-import'
--- contrib/check-reactor-import	2016-05-28 23:32:02 +0000
+++ contrib/check-reactor-import	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-#! /usr/bin/python
-#
-# Copyright (C) 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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 script that checks for unintended imports of twisted.internet.reactor."""
-
-# NOTE: the goal of this script is to avoid a bug that affects
-# ubuntuone-control-panel on windows and darwin. Those platforms use
-# the qt4reactor, and will break if the default reactor is installed
-# first. This can happen if a module used by control-panel imports reactor.
-# Only sub-modules that are not used by ubuntuone-control-panel can safely
-# import reactor at module-level.
-
-from __future__ import (unicode_literals, print_function)
-
-import __builtin__
-
-import os
-import sys
-import traceback
-
-sys.path.append(os.path.abspath(os.getcwd()))
-
-
-def fake_import(*args, **kwargs):
-    """A wrapper for __import__ that dies when importing reactor."""
-    imp_name_base = args[0]
-
-    if len(args) == 4 and args[3] is not None:
-        imp_names = ["{0}.{1}".format(imp_name_base, sm)
-                     for sm in args[3]]
-    else:
-        imp_names = [imp_name_base]
-
-    for imp_name in imp_names:
-        if 'twisted.internet.reactor' == imp_name:
-            print("ERROR: should not import reactor here:")
-            traceback.print_stack()
-            sys.exit(1)
-
-    r = real_import(*args, **kwargs)
-    return r
-
-
-if __name__ == '__main__':
-
-    real_import = __builtin__.__import__
-    __builtin__.__import__ = fake_import
-
-    subs = ["", ".tools", ".logger"]
-    for module in ["ubuntuone.platform" + p for p in subs]:
-        m = __import__(module)

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2016-09-17 01:06:23 +0000
+++ contrib/testing/testcase.py	2018-03-14 21:14:07 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2015 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2018 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
@@ -41,7 +41,7 @@
 from collections import defaultdict
 from functools import wraps
 
-from twisted.internet import defer, reactor
+from twisted.internet import defer
 from twisted.trial.unittest import TestCase as TwistedTestCase
 from ubuntuone.devtools.testcases import skipIfOS
 from zope.interface import implements
@@ -312,17 +312,6 @@
         return defer.succeed(True)
 
 
-class FakeTunnelRunner(object):
-    """A fake proxy.tunnel_client.TunnelRunner."""
-
-    def __init__(self, *args):
-        """Fake a proxy tunnel."""
-
-    def get_client(self):
-        """Always return the reactor."""
-        return defer.succeed(reactor)
-
-
 class BaseTwistedTestCase(TwistedTestCase):
     """Base TestCase with helper methods to handle temp dir.
 
@@ -332,7 +321,6 @@
         makedirs(path): support read-only shares
     """
     MAX_FILENAME = 32  # some platforms limit lengths of filenames
-    tunnel_runner_class = FakeTunnelRunner
 
     def mktemp(self, name='temp'):
         """ Customized mktemp that accepts an optional name argument. """
@@ -439,8 +427,6 @@
         self.log = logging.getLogger("ubuntuone.SyncDaemon.TEST")
         self.log.info("starting test %s.%s", self.__class__.__name__,
                       self._testMethodName)
-        self.patch(action_queue.tunnel_runner, "TunnelRunner",
-                   self.tunnel_runner_class)
 
 
 class FakeMainTestCase(BaseTwistedTestCase):

=== modified file 'dependencies.txt'
--- dependencies.txt	2017-01-07 18:51:07 +0000
+++ dependencies.txt	2018-03-14 21:14:07 +0000
@@ -6,6 +6,4 @@
 python-gi
 python-protobuf
 python-pyinotify
-python-qt4-dbus
-python-qt4reactor
 python-twisted

=== modified file 'run-tests'
--- run-tests	2016-05-29 20:16:26 +0000
+++ run-tests	2018-03-14 21:14:07 +0000
@@ -1,6 +1,7 @@
 #! /bin/bash
 #
 # Copyright 2012-2013 Canonical Ltd.
+# Copyright 2015-2018 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
@@ -27,8 +28,6 @@
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
 
-PROXY_TESTS_PATH="ubuntuone/proxy/tests"
-
 # Allow alternative python executable via environment variable.  This is
 # useful for virtualenv testing.
 PYTHON=${PYTHON:-'python'}
@@ -47,22 +46,16 @@
 if [ "$SYSNAME" == "Darwin" ]; then
     IGNORE_FILES="test_linux.py,test_windows.py"
     IGNORE_PATHS="ubuntuone/platform/tests/linux"
-    REACTOR=qt4
 else
     # Linux
     IGNORE_FILES="test_darwin.py,test_fsevents_daemon.py,test_windows.py"
     IGNORE_PATHS="ubuntuone/platform/tests/windows"
-    REACTOR=gi
 fi
 
 echo "*** Running test suite for ""$MODULE"" ***"
 export SSL_CERTIFICATES_DIR=/etc/ssl/certs
 $PYTHON ./setup.py build
-u1trial --reactor=$REACTOR -i "$IGNORE_FILES" -p "$IGNORE_PATHS,$PROXY_TESTS_PATH" "$MODULE"
-echo "*** Running tests for ubuntuone-client-proxy ***"
-u1trial --reactor=qt4 -i "$IGNORE_FILES" -p "$IGNORE_PATHS" "$PROXY_TESTS_PATH"
+u1trial -i "$IGNORE_FILES" -p "$IGNORE_PATHS" "$MODULE"
 $PYTHON ./setup.py clean
 rm -rf _trial_temp
 rm -rf build
-
-$PYTHON contrib/check-reactor-import

=== modified file 'run-tests.bat'
--- run-tests.bat	2013-06-10 19:27:21 +0000
+++ run-tests.bat	2018-03-14 21:14:07 +0000
@@ -87,8 +87,6 @@
 ECHO Performing style checks...
 "%LINTPATH%"
 
-"%PYTHONEXEPATH%" contrib\check-reactor-import
-
 :: if pep8 is not present, move to the end
 IF EXIST "%PEP8PATH%" (
     "%PEP8PATH%" --repeat ubuntuone

=== modified file 'setup.py'
--- setup.py	2016-08-06 20:02:14 +0000
+++ setup.py	2018-03-14 21:14:07 +0000
@@ -1,6 +1,7 @@
 #!/usr/bin/python
 #
 # Copyright 2013 Canonical Ltd.
+# Copyright 2015-2018 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
@@ -203,7 +204,6 @@
 ]
 
 libexec_scripts = [
-    'bin/ubuntuone-proxy-tunnel',
     'bin/ubuntuone-syncdaemon',
 ]
 

=== removed directory 'ubuntuone/proxy'
=== removed file 'ubuntuone/proxy/__init__.py'
--- ubuntuone/proxy/__init__.py	2016-05-29 00:50:05 +0000
+++ ubuntuone/proxy/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-# Copyright 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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.
-"""Proxy support."""

=== removed file 'ubuntuone/proxy/common.py'
--- ubuntuone/proxy/common.py	2012-04-09 20:08:42 +0000
+++ ubuntuone/proxy/common.py	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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.
-"""Common classes to the tunnel client and server."""
-
-from twisted.protocols import basic
-
-CRLF = "\r\n"
-TUNNEL_PORT_LABEL = "Tunnel port"
-TUNNEL_COOKIE_LABEL = "Tunnel cookie"
-TUNNEL_COOKIE_HEADER = "Proxy-Tunnel-Cookie"
-
-
-class BaseTunnelProtocol(basic.LineReceiver):
-    """CONNECT base protocol for tunnelling connections."""
-
-    delimiter = CRLF
-
-    def __init__(self):
-        """Initialize this protocol."""
-        self._first_line = True
-        self.received_headers = []
-
-    def header_line(self, line):
-        """Handle each header line received."""
-        key, value = line.split(":", 1)
-        value = value.strip()
-        self.received_headers.append((key, value))
-
-    def lineReceived(self, line):
-        """Process a line in the header."""
-        if self._first_line:
-            self._first_line = False
-            self.handle_first_line(line)
-        else:
-            if line:
-                self.header_line(line)
-            else:
-                self.setRawMode()
-                self.headers_done()
-
-    def remote_disconnected(self):
-        """The remote end closed the connection."""
-        self.transport.loseConnection()
-
-    def format_headers(self, headers):
-        """Format some headers as a few response lines."""
-        return "".join("%s: %s" % item + CRLF for item in headers.items())

=== removed file 'ubuntuone/proxy/logger.py'
--- ubuntuone/proxy/logger.py	2012-06-21 18:58:50 +0000
+++ ubuntuone/proxy/logger.py	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-# ubuntuone.syncdaemon.logger - logging utilities
-#
-# Copyright 2009-2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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.
-"""SyncDaemon logging utilities and config."""
-
-import logging
-import os
-
-from ubuntuone.logger import (
-    basic_formatter,
-    CustomRotatingFileHandler,
-)
-
-from ubuntuone.platform.logger import ubuntuone_log_dir
-
-
-LOGFILENAME = os.path.join(ubuntuone_log_dir, 'proxy.log')
-logger = logging.getLogger("ubuntuone.proxy")
-logger.setLevel(logging.DEBUG)
-handler = CustomRotatingFileHandler(filename=LOGFILENAME)
-handler.setFormatter(basic_formatter)
-handler.setLevel(logging.DEBUG)
-logger.addHandler(handler)

=== removed directory 'ubuntuone/proxy/tests'
=== removed file 'ubuntuone/proxy/tests/__init__.py'
--- ubuntuone/proxy/tests/__init__.py	2016-06-01 18:28:19 +0000
+++ ubuntuone/proxy/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,156 +0,0 @@
-# Copyright 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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 Magicicada proxy support."""
-
-from os import path
-from StringIO import StringIO
-
-from twisted.application import internet, service
-from twisted.internet import defer, ssl
-from twisted.web import http, resource, server
-
-SAMPLE_CONTENT = "hello world!"
-SIMPLERESOURCE = "simpleresource"
-DUMMY_KEY_FILENAME = "dummy.key"
-DUMMY_CERT_FILENAME = "dummy.cert"
-FAKE_COOKIE = "fa:ke:co:ok:ie"
-
-
-class SaveHTTPChannel(http.HTTPChannel):
-    """A save protocol to be used in tests."""
-
-    protocolInstance = None
-
-    def connectionMade(self):
-        """Keep track of the given protocol."""
-        SaveHTTPChannel.protocolInstance = self
-        http.HTTPChannel.connectionMade(self)
-
-
-class SaveSite(server.Site):
-    """A site that let us know when it's closed."""
-
-    protocol = SaveHTTPChannel
-
-    def __init__(self, *args, **kwargs):
-        """Create a new instance."""
-        server.Site.__init__(self, *args, **kwargs)
-        self.timeOut = None
-
-
-class BaseMockWebServer(object):
-    """A mock webserver for testing"""
-
-    def __init__(self):
-        """Start up this instance."""
-        self.root = self.get_root_resource()
-        self.site = SaveSite(self.root)
-        application = service.Application('web')
-        self.service_collection = service.IServiceCollection(application)
-        self.tcpserver = internet.TCPServer(0, self.site)
-        self.tcpserver.setServiceParent(self.service_collection)
-        self.sslserver = internet.SSLServer(0, self.site, self.get_context())
-        self.sslserver.setServiceParent(self.service_collection)
-        self.service_collection.startService()
-
-    def get_dummy_path(self, filename):
-        """Path pointing at the dummy certificate files."""
-        base_path = path.dirname(__file__)
-        return path.join(base_path, "ssl", filename)
-
-    def get_context(self):
-        """Return an ssl context."""
-        key_path = self.get_dummy_path(DUMMY_KEY_FILENAME)
-        cert_path = self.get_dummy_path(DUMMY_CERT_FILENAME)
-        return ssl.DefaultOpenSSLContextFactory(key_path, cert_path)
-
-    def get_root_resource(self):
-        """Get the root resource with all the children."""
-        raise NotImplementedError
-
-    def get_iri(self):
-        """Build the iri for this mock server."""
-        port_num = self.tcpserver._port.getHost().port
-        return u"http://0.0.0.0:%d/" % port_num
-
-    def get_ssl_iri(self):
-        """Build the iri for the ssl mock server."""
-        port_num = self.sslserver._port.getHost().port
-        return u"https://0.0.0.0:%d/" % port_num
-
-    def stop(self):
-        """Shut it down."""
-        if self.site.protocol.protocolInstance:
-            self.site.protocol.protocolInstance.timeoutConnection()
-        return self.service_collection.stopService()
-
-
-class SimpleResource(resource.Resource):
-    """A simple web resource."""
-
-    def __init__(self):
-        """Initialize this mock resource."""
-        resource.Resource.__init__(self)
-        self.rendered = defer.Deferred()
-
-    def render_GET(self, request):
-        """Make a bit of html out of the resource's content."""
-        if not self.rendered.called:
-            self.rendered.callback(None)
-        return SAMPLE_CONTENT
-
-
-class MockWebServer(BaseMockWebServer):
-    """A mock webserver."""
-
-    def __init__(self):
-        """Initialize this mock server."""
-        self.simple_resource = SimpleResource()
-        super(MockWebServer, self).__init__()
-
-    def get_root_resource(self):
-        """Get the root resource with all the children."""
-        root = resource.Resource()
-        root.putChild(SIMPLERESOURCE, self.simple_resource)
-        return root
-
-
-class FakeTransport(StringIO):
-    """A fake transport that stores everything written to it."""
-
-    connected = True
-    disconnecting = False
-    cookie = None
-
-    def loseConnection(self):
-        """Mark the connection as lost."""
-        self.connected = False
-        self.disconnecting = True
-
-    def getPeer(self):
-        """Return the peer IAddress."""
-        return None

=== removed directory 'ubuntuone/proxy/tests/ssl'
=== removed file 'ubuntuone/proxy/tests/ssl/dummy.cert'
--- ubuntuone/proxy/tests/ssl/dummy.cert	2012-02-23 23:58:33 +0000
+++ ubuntuone/proxy/tests/ssl/dummy.cert	1970-01-01 00:00:00 +0000
@@ -1,19 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDEDCCAnmgAwIBAgIJAM/bIJ77awBCMA0GCSqGSIb3DQEBBQUAMIGgMQswCQYD
-VQQGEwJBUjETMBEGA1UECAwKRmFrZSBTdGF0ZTESMBAGA1UEBwwJRmFrZSBDaXR5
-MRUwEwYDVQQKDAxGYWtlIENvbXBhbnkxFjAUBgNVBAsMDUZha2UgRGl2aXNpb24x
-EjAQBgNVBAMMCUZha2UgTmFtZTElMCMGCSqGSIb3DQEJARYWZmFrZUBlbWFpbC5h
-ZGRyZXNzLm5vdDAeFw0xMjAyMjIxOTI0MjBaFw0yMjAyMjMxOTI0MjBaMIGgMQsw
-CQYDVQQGEwJBUjETMBEGA1UECAwKRmFrZSBTdGF0ZTESMBAGA1UEBwwJRmFrZSBD
-aXR5MRUwEwYDVQQKDAxGYWtlIENvbXBhbnkxFjAUBgNVBAsMDUZha2UgRGl2aXNp
-b24xEjAQBgNVBAMMCUZha2UgTmFtZTElMCMGCSqGSIb3DQEJARYWZmFrZUBlbWFp
-bC5hZGRyZXNzLm5vdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0hbliGty
-HwfZixU609UHBQdbfO+oObrPIrIawWX5FxD6KhX4ei23idmpyYEcXLK4ivNlT4dW
-27bvhtpf6/FBbu9e1YdwcdDNoXajr9Ia4NZJyANgo9b5UIsnyTc45NlnpZgRg5zc
-Oz7Vwwr4qf6r1ljK/I2mAO7rlpH5Ak9J+RkCAwEAAaNQME4wHQYDVR0OBBYEFLwr
-ps/JLNcfpSuuylMnkvImVvkgMB8GA1UdIwQYMBaAFLwrps/JLNcfpSuuylMnkvIm
-VvkgMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAWYDBAr0MgpnBxIne
-WRz8MX0/c7IqrEuZCYMSGnU7PoX3GdNk1Lkif1ufELKSoG8jY16CDgEl26GPxA1k
-Tho7MWSLikLbuQYJs2saF9by0Y/Mrau0auxEnpHZ7pkybeKFnrIqiNKvTVMnjo5T
-FMET5qEOKKvp9IOnezCYX1nYXyY=
------END CERTIFICATE-----

=== removed file 'ubuntuone/proxy/tests/ssl/dummy.key'
--- ubuntuone/proxy/tests/ssl/dummy.key	2012-02-23 23:58:33 +0000
+++ ubuntuone/proxy/tests/ssl/dummy.key	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBANIW5Yhrch8H2YsV
-OtPVBwUHW3zvqDm6zyKyGsFl+RcQ+ioV+Hott4nZqcmBHFyyuIrzZU+HVtu274ba
-X+vxQW7vXtWHcHHQzaF2o6/SGuDWScgDYKPW+VCLJ8k3OOTZZ6WYEYOc3Ds+1cMK
-+Kn+q9ZYyvyNpgDu65aR+QJPSfkZAgMBAAECgYBSxFh7TTExjmsjAyMg700LqyFc
-8CHLVJBkL9ygkqb2cmbMC8nPgJFNSqY8T5Q35OUVQNyJ31zVxJVLAF9H2c0Xy48K
-IkbS/hntyqlJYK1yfTbTHkDiweToE3Lm+55Do1TX04AyvBrwA1O/jNGi4xIlUEAy
-1Bs8MrJ1E/j/XDn9/QJBAOuhPTgG3F7bKuBrQzv98CvC5o2Txf3vLY8nL8V24b3l
-XgqzkDLhUxReBmmkGxZfKAju3+gXFvGGpbP7V8zShg8CQQDkQGs7kArFq/KR/GCh
-CAmJaDWy4LJkSqzDHoJbTrS7YuqN6X6mW1xPRnWpYSxae38fJsCpG3Vq8Mv1Zl32
-VPZXAkEAsAeE9JYri7GwFngLgoXzJr4z/xCmmU5VetyLk7l8a6Eu4E/FKj2rE0wq
-/kDa+5ubDRFntLuLKGSu5gafUST1gQJABhdmBTfp4a6eEaFPntyNDJq4XCa8/Ao2
-JBrrVa57Ckkwg0sI8z2a8A6sUzHhsiR7lwQ8vgaakpkMiGcL+Of5jwJAA/qX3PW+
-9JXbjWxpgh7FHnZJNRZ8xSe47REGA7qS/nIlV9iRuf/9M+k3A5VqitfFxrjPwSyI
-rvKTYkk13dL4hg==
------END PRIVATE KEY-----

=== removed file 'ubuntuone/proxy/tests/test_tunnel_client.py'
--- ubuntuone/proxy/tests/test_tunnel_client.py	2016-06-01 18:28:19 +0000
+++ ubuntuone/proxy/tests/test_tunnel_client.py	1970-01-01 00:00:00 +0000
@@ -1,225 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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 tunnel."""
-
-from twisted.internet import defer, protocol, ssl
-from twisted.trial.unittest import TestCase
-from twisted.web import client
-
-from ubuntuone.devtools.testcases.squid import SquidTestCase
-
-from ubuntuone.proxy.tests import (
-    FakeTransport,
-    FAKE_COOKIE,
-    MockWebServer,
-    SAMPLE_CONTENT,
-    SIMPLERESOURCE,
-)
-from ubuntuone.proxy import tunnel_client
-from ubuntuone.proxy.tunnel_client import CRLF, TunnelClient
-from ubuntuone.proxy.tunnel_server import TunnelServer
-
-
-FAKE_HEADER = (
-    "HTTP/1.0 200 Connected!" + CRLF +
-    "Header1: value1" + CRLF +
-    "Header2: value2" + CRLF +
-    CRLF
-)
-
-
-class SavingProtocol(protocol.Protocol):
-    """A protocol that saves all that it receives."""
-
-    def __init__(self):
-        """Initialize this protocol."""
-        self.saved_data = None
-
-    def connectionMade(self):
-        """The connection was made, start saving."""
-        self.saved_data = []
-
-    def dataReceived(self, data):
-        """Save the data received."""
-        self.saved_data.append(data)
-
-    @property
-    def content(self):
-        """All the content so far."""
-        return "".join(self.saved_data)
-
-
-class TunnelClientProtocolTestCase(TestCase):
-    """Tests for the client side tunnel protocol."""
-
-    timeout = 3
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this testcase."""
-        yield super(TunnelClientProtocolTestCase, self).setUp()
-        self.host, self.port = "9.9.9.9", 8765
-        fake_addr = object()
-        self.cookie = FAKE_COOKIE
-        self.other_proto = SavingProtocol()
-        other_factory = protocol.ClientFactory()
-        other_factory.buildProtocol = lambda _addr: self.other_proto
-        tunnel_client_factory = tunnel_client.TunnelClientFactory(
-            self.host, self.port, other_factory, self.cookie)
-        tunnel_client_proto = tunnel_client_factory.buildProtocol(fake_addr)
-        tunnel_client_proto.transport = FakeTransport()
-        tunnel_client_proto.connectionMade()
-        self.tunnel_client_proto = tunnel_client_proto
-
-    def test_sends_connect_request(self):
-        """Sends the expected CONNECT request."""
-        expected = tunnel_client.METHOD_LINE % (self.host, self.port)
-        written = self.tunnel_client_proto.transport.getvalue()
-        first_line = written.split(CRLF)[0]
-        self.assertEqual(first_line + CRLF, expected)
-        self.assertTrue(written.endswith(CRLF * 2),
-                        "Ends with a double CRLF")
-
-    def test_sends_cookie_header(self):
-        """Sends the expected cookie header."""
-        expected = "%s: %s" % (tunnel_client.TUNNEL_COOKIE_HEADER, self.cookie)
-        written = self.tunnel_client_proto.transport.getvalue()
-        headers = written.split(CRLF)[1:]
-        self.assertIn(expected, headers)
-
-    def test_handles_successful_connection(self):
-        """A successful connection is handled."""
-        self.tunnel_client_proto.dataReceived(FAKE_HEADER)
-        self.assertEqual(self.tunnel_client_proto.status_code, "200")
-
-    def test_protocol_is_switched(self):
-        """The protocol is switched after the headers are received."""
-        expected = (SAMPLE_CONTENT + CRLF) * 2
-        self.tunnel_client_proto.dataReceived(FAKE_HEADER + SAMPLE_CONTENT)
-        self.other_proto.dataReceived(CRLF + SAMPLE_CONTENT + CRLF)
-        self.assertEqual(self.other_proto.content, expected)
-
-
-class FakeOtherFactory(object):
-    """A fake factory."""
-
-    def __init__(self):
-        """Initialize this fake."""
-        self.started_called = None
-        self.failed_called = None
-        self.lost_called = None
-
-    def startedConnecting(self, *args):
-        """Store the call."""
-        self.started_called = args
-
-    def clientConnectionFailed(self, *args):
-        """Store the call."""
-        self.failed_called = args
-
-    def clientConnectionLost(self, *args):
-        """Store the call."""
-        self.lost_called = args
-
-
-class TunnelClientFactoryTestCase(TestCase):
-    """Tests for the TunnelClientFactory."""
-
-    def test_forwards_started(self):
-        """The factory forwards the startedConnecting call."""
-        fake_other_factory = FakeOtherFactory()
-        tcf = tunnel_client.TunnelClientFactory(None, None, fake_other_factory,
-                                                FAKE_COOKIE)
-        fake_connector = object()
-        tcf.startedConnecting(fake_connector)
-        self.assertEqual(fake_other_factory.started_called, (fake_connector,))
-
-    def test_forwards_failed(self):
-        """The factory forwards the clientConnectionFailed call."""
-        fake_reason = object()
-        fake_other_factory = FakeOtherFactory()
-        tcf = tunnel_client.TunnelClientFactory(None, None, fake_other_factory,
-                                                FAKE_COOKIE)
-        fake_connector = object()
-        tcf.clientConnectionFailed(fake_connector, fake_reason)
-        self.assertEqual(fake_other_factory.failed_called,
-                         (fake_connector, fake_reason))
-
-    def test_forwards_lost(self):
-        """The factory forwards the clientConnectionLost call."""
-        fake_reason = object()
-        fake_other_factory = FakeOtherFactory()
-        tcf = tunnel_client.TunnelClientFactory(None, None, fake_other_factory,
-                                                FAKE_COOKIE)
-        fake_connector = object()
-        tcf.clientConnectionLost(fake_connector, fake_reason)
-        self.assertEqual(fake_other_factory.lost_called,
-                         (fake_connector, fake_reason))
-
-
-class TunnelClientTestCase(SquidTestCase):
-    """Test the client for the tunnel."""
-
-    timeout = 3
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this testcase."""
-        yield super(TunnelClientTestCase, self).setUp()
-        self.ws = MockWebServer()
-        self.addCleanup(self.ws.stop)
-        self.dest_url = self.ws.get_iri().encode("utf-8") + SIMPLERESOURCE
-        self.dest_ssl_url = (
-            self.ws.get_ssl_iri().encode("utf-8") + SIMPLERESOURCE)
-        self.cookie = FAKE_COOKIE
-        self.tunnel_server = TunnelServer(self.cookie)
-        self.addCleanup(self.tunnel_server.shutdown)
-
-    @defer.inlineCallbacks
-    def test_connects_right(self):
-        """Uses the CONNECT method on the tunnel."""
-        tunnel_client = TunnelClient("0.0.0.0", self.tunnel_server.port,
-                                     self.cookie)
-        factory = client.HTTPClientFactory(self.dest_url)
-        scheme, host, port, path = client._parse(self.dest_url)
-        tunnel_client.connectTCP(host, port, factory)
-        result = yield factory.deferred
-        self.assertEqual(result, SAMPLE_CONTENT)
-
-    @defer.inlineCallbacks
-    def test_starts_tls_connection(self):
-        """TLS is started after connecting; control passed to the client."""
-        tunnel_client = TunnelClient(
-            "0.0.0.0", self.tunnel_server.port, self.cookie)
-        factory = client.HTTPClientFactory(self.dest_ssl_url)
-        scheme, host, port, path = client._parse(self.dest_ssl_url)
-        context_factory = ssl.ClientContextFactory()
-        tunnel_client.connectSSL(host, port, factory, context_factory)
-        result = yield factory.deferred
-        self.assertEqual(result, SAMPLE_CONTENT)

=== removed file 'ubuntuone/proxy/tests/test_tunnel_server.py'
--- ubuntuone/proxy/tests/test_tunnel_server.py	2016-06-01 18:28:19 +0000
+++ ubuntuone/proxy/tests/test_tunnel_server.py	1970-01-01 00:00:00 +0000
@@ -1,743 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2012-2013 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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 tunnel."""
-
-from StringIO import StringIO
-from urlparse import urlparse
-
-from twisted.internet import defer, protocol, reactor
-from twisted.trial.unittest import TestCase
-from PyQt4.QtCore import QCoreApplication
-from PyQt4.QtNetwork import QAuthenticator
-from ubuntuone.devtools.testcases import skipIfOS
-from ubuntuone.devtools.testcases.squid import SquidTestCase
-
-from ubuntuone.proxy.tests import (
-    FakeTransport,
-    FAKE_COOKIE,
-    MockWebServer,
-    SAMPLE_CONTENT,
-    SIMPLERESOURCE,
-)
-from ubuntuone.proxy import tunnel_server
-from ubuntuone.proxy.tunnel_server import CRLF
-
-
-FAKE_SESSION_TEMPLATE = (
-    "CONNECT %s HTTP/1.0" + CRLF +
-    "Header1: value1" + CRLF +
-    "Header2: value2" + CRLF +
-    tunnel_server.TUNNEL_COOKIE_HEADER + ": %s" + CRLF +
-    CRLF +
-    "GET %s HTTP/1.0" + CRLF + CRLF
-)
-
-FAKE_SETTINGS = {
-    "http": {
-        "host": "myhost",
-        "port": 8888,
-    }
-}
-
-FAKE_AUTH_SETTINGS = {
-    "http": {
-        "host": "myhost",
-        "port": 8888,
-        "username": "fake_user",
-        "password": "fake_password",
-    }
-}
-
-SAMPLE_HOST = "samplehost.com"
-SAMPLE_PORT = 443
-
-FAKE_CREDS = {
-    "username": "rhea",
-    "password": "caracolcaracola",
-}
-
-
-class DisconnectingProtocol(protocol.Protocol):
-    """A protocol that just disconnects."""
-
-    def connectionMade(self):
-        """Upon connecting: just disconnect."""
-        self.transport.loseConnection()
-
-
-class DisconnectingClientFactory(protocol.ClientFactory):
-    """A factory that fires a deferred on connection."""
-
-    def __init__(self):
-        """Initialize this instance."""
-        self.connected = defer.Deferred()
-
-    def buildProtocol(self, addr):
-        """The connection was made."""
-        proto = DisconnectingProtocol()
-        if not self.connected.called:
-            self.connected.callback(proto)
-        return proto
-
-
-class FakeProtocol(protocol.Protocol):
-    """A protocol that forwards some data."""
-
-    def __init__(self, factory, data):
-        """Initialize this fake."""
-        self.factory = factory
-        self.data = data
-        self.received_data = []
-
-    def connectionMade(self):
-        """Upon connection: send the stored data."""
-        self.transport.write(self.data)
-
-    def dataReceived(self, data):
-        """Some data was received."""
-        self.received_data.append(data)
-
-    def connectionLost(self, reason):
-        """The connection was lost, return the response."""
-        response = "".join(self.received_data)
-        if not self.factory.response.called:
-            self.factory.response.callback(response)
-
-
-class FakeClientFactory(protocol.ClientFactory):
-    """A factory that forwards some data to the protocol."""
-
-    def __init__(self, data):
-        """Initialize this fake."""
-        self.data = data
-        self.response = defer.Deferred()
-
-    def buildProtocol(self, addr):
-        """The connection was made."""
-        return FakeProtocol(self, self.data)
-
-
-class TunnelIntegrationTestCase(SquidTestCase):
-    """Basic tunnel integration tests."""
-
-    timeout = 3
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this testcase."""
-        yield super(TunnelIntegrationTestCase, self).setUp()
-        self.ws = MockWebServer()
-        self.addCleanup(self.ws.stop)
-        self.dest_url = self.ws.get_iri().encode("utf-8") + SIMPLERESOURCE
-        self.cookie = FAKE_COOKIE
-        self.tunnel_server = tunnel_server.TunnelServer(self.cookie)
-        self.addCleanup(self.tunnel_server.shutdown)
-
-    def test_init(self):
-        """The tunnel is started."""
-        self.assertNotEqual(self.tunnel_server.port, 0)
-
-    @defer.inlineCallbacks
-    def test_accepts_connections(self):
-        """The tunnel accepts incoming connections."""
-        ncf = DisconnectingClientFactory()
-        reactor.connectTCP("0.0.0.0", self.tunnel_server.port, ncf)
-        yield ncf.connected
-
-    @defer.inlineCallbacks
-    def test_complete_connection(self):
-        """Test from the tunnel server down."""
-        url = urlparse(self.dest_url)
-        fake_session = FAKE_SESSION_TEMPLATE % (
-                                    url.netloc, self.cookie, url.path)
-        client = FakeClientFactory(fake_session)
-        reactor.connectTCP("0.0.0.0", self.tunnel_server.port, client)
-        response = yield client.response
-        self.assertIn(SAMPLE_CONTENT, response)
-
-
-class FakeClient(object):
-    """A fake destination client."""
-
-    protocol = None
-    connection_result = defer.succeed(True)
-    credentials = None
-    check_credentials = False
-    proxy_domain = None
-
-    def connect(self, hostport):
-        """Establish a connection with the other end."""
-        if (self.check_credentials and
-                self.protocol.proxy_credentials != FAKE_CREDS):
-            self.proxy_domain = "fake domain"
-            return defer.fail(tunnel_server.ProxyAuthenticationError())
-        return self.connection_result
-
-    def write(self, data):
-        """Write some data to the other end."""
-        if data == 'GET /simpleresource HTTP/1.0\r\n\r\n':
-            self.protocol.transport.write(SAMPLE_CONTENT)
-
-    def stop(self):
-        """Stop this fake client."""
-
-    def close(self):
-        """Reset this client."""
-
-
-class ServerTunnelProtocolTestCase(SquidTestCase):
-    """Tests for the ServerTunnelProtocol."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this test instance."""
-        yield super(ServerTunnelProtocolTestCase, self).setUp()
-        self.ws = MockWebServer()
-        self.addCleanup(self.ws.stop)
-        self.dest_url = self.ws.get_iri().encode("utf-8") + SIMPLERESOURCE
-        self.transport = FakeTransport()
-        self.transport.cookie = FAKE_COOKIE
-        self.fake_client = FakeClient()
-        self.proto = tunnel_server.ServerTunnelProtocol(
-                                                lambda _: self.fake_client)
-        self.fake_client.protocol = self.proto
-        self.proto.transport = self.transport
-        self.cookie_line = "%s: %s" % (tunnel_server.TUNNEL_COOKIE_HEADER,
-                                       FAKE_COOKIE)
-
-    def test_broken_request(self):
-        """Broken request."""
-        self.proto.dataReceived("Broken request." + CRLF)
-        self.assertTrue(self.transport.getvalue().startswith("HTTP/1.0 400 "),
-                        "A broken request must fail.")
-
-    def test_wrong_method(self):
-        """Wrong method."""
-        self.proto.dataReceived("GET http://slashdot.org HTTP/1.0" + CRLF)
-        self.assertTrue(self.transport.getvalue().startswith("HTTP/1.0 405 "),
-                        "Using a wrong method fails.")
-
-    def test_invalid_http_version(self):
-        """Invalid HTTP version."""
-        self.proto.dataReceived("CONNECT 127.0.0.1:9999 HTTP/1.1" + CRLF)
-        self.assertTrue(self.transport.getvalue().startswith("HTTP/1.0 505 "),
-                        "Invalid http version is not allowed.")
-
-    def test_connection_is_established(self):
-        """The response code is sent."""
-        expected = "HTTP/1.0 200 Proxy connection established" + CRLF
-        self.proto.dataReceived("CONNECT 127.0.0.1:9999 HTTP/1.0" + CRLF +
-                                self.cookie_line + CRLF * 2)
-        self.assertTrue(self.transport.getvalue().startswith(expected),
-                        "First line must be the response status")
-
-    def test_connection_fails(self):
-        """The connection to the other end fails, and it's handled."""
-        error = tunnel_server.ConnectionError()
-        self.patch(self.fake_client, "connection_result", defer.fail(error))
-        expected = "HTTP/1.0 500 Connection error" + CRLF
-        self.proto.dataReceived("CONNECT 127.0.0.1:9999 HTTP/1.0" + CRLF +
-                                self.cookie_line + CRLF * 2)
-        self.assertTrue(self.transport.getvalue().startswith(expected),
-                        "The connection should fail at this point.")
-
-    def test_headers_stored(self):
-        """The request headers are stored."""
-        expected = [
-            ("Header1", "value1"),
-            ("Header2", "value2"),
-        ]
-        self.proto.dataReceived("CONNECT 127.0.0.1:9999 HTTP/1.0" + CRLF +
-                                "Header1: value1" + CRLF +
-                                "Header2: value2" + CRLF + CRLF)
-        self.assertEqual(self.proto.received_headers, expected)
-
-    def test_cookie_header_present(self):
-        """The cookie header must be present."""
-        self.proto.received_headers = [
-            (tunnel_server.TUNNEL_COOKIE_HEADER, FAKE_COOKIE),
-        ]
-        self.proto.verify_cookie()
-
-    def test_cookie_header_absent(self):
-        """The tunnel should refuse connections without the cookie."""
-        self.proto.received_headers = []
-        exception = self.assertRaises(tunnel_server.ConnectionError,
-                                      self.proto.verify_cookie)
-        self.assertEqual(exception.code, 418)
-
-    def test_successful_connect(self):
-        """A successful connect thru the tunnel."""
-        url = urlparse(self.dest_url)
-        data = FAKE_SESSION_TEMPLATE % (url.netloc, self.transport.cookie,
-                                        url.path)
-        self.proto.dataReceived(data)
-        lines = self.transport.getvalue().split(CRLF)
-        self.assertEqual(lines[-1], SAMPLE_CONTENT)
-
-    def test_header_split(self):
-        """Test a header with many colons."""
-        self.proto.header_line("key: host:port")
-        self.assertIn("key", dict(self.proto.received_headers))
-
-    @defer.inlineCallbacks
-    def test_keyring_credentials_are_retried(self):
-        """Wrong credentials are retried with values from keyring."""
-        self.fake_client.check_credentials = True
-        self.patch(self.proto, "verify_cookie", lambda: None)
-        self.patch(self.proto, "error_response",
-                   lambda code, desc: self.fail(desc))
-        self.proto.proxy_domain = "xxx"
-        self.patch(tunnel_server.Keyring, "get_credentials",
-                   lambda _, domain: defer.succeed(FAKE_CREDS))
-        yield self.proto.headers_done()
-
-    def test_creds_are_not_logged(self):
-        """The proxy credentials are not logged."""
-        log = []
-        self.patch(tunnel_server.logger, "info",
-                   lambda text, *args: log.append(text % args))
-        proxy = tunnel_server.build_proxy(FAKE_AUTH_SETTINGS)
-        authenticator = QAuthenticator()
-        username = FAKE_AUTH_SETTINGS["http"]["username"]
-        password = FAKE_AUTH_SETTINGS["http"]["password"]
-        self.proto.proxy_credentials = {
-            "username": username,
-            "password": password,
-        }
-        self.proto.proxy_domain = proxy.hostName()
-
-        self.proto.proxy_auth_required(proxy, authenticator)
-
-        for line in log:
-            self.assertNotIn(username, line)
-            self.assertNotIn(password, line)
-
-
-class FakeServerTunnelProtocol(object):
-    """A fake ServerTunnelProtocol."""
-
-    def __init__(self):
-        """Initialize this fake tunnel."""
-        self.response_received = defer.Deferred()
-        self.proxy_credentials = None
-
-    def response_data_received(self, data):
-        """Fire the response deferred."""
-        if not self.response_received.called:
-            self.response_received.callback(data)
-
-    def remote_disconnected(self):
-        """The remote server disconnected."""
-
-    def proxy_auth_required(self, proxy, authenticator):
-        """Proxy credentials are needed."""
-        if self.proxy_credentials:
-            authenticator.setUser(self.proxy_credentials["username"])
-            authenticator.setPassword(self.proxy_credentials["password"])
-
-
-class BuildProxyTestCase(TestCase):
-    """Tests for the build_proxy function."""
-
-    def test_socks_is_preferred(self):
-        """Socks overrides all protocols."""
-        settings = {
-            "http": {"host": "httphost", "port": 3128},
-            "https": {"host": "httpshost", "port": 3129},
-            "socks": {"host": "sockshost", "port": 1080},
-        }
-        proxy = tunnel_server.build_proxy(settings)
-        self.assertEqual(proxy.type(), proxy.Socks5Proxy)
-        self.assertEqual(proxy.hostName(), "sockshost")
-        self.assertEqual(proxy.port(), 1080)
-
-    def test_https_beats_http(self):
-        """HTTPS wins over HTTP, since all of SD traffic is https."""
-        settings = {
-            "http": {"host": "httphost", "port": 3128},
-            "https": {"host": "httpshost", "port": 3129},
-        }
-        proxy = tunnel_server.build_proxy(settings)
-        self.assertEqual(proxy.type(), proxy.HttpProxy)
-        self.assertEqual(proxy.hostName(), "httpshost")
-        self.assertEqual(proxy.port(), 3129)
-
-    def test_http_if_no_other_choice(self):
-        """Finally, we use the host configured for HTTP."""
-        settings = {
-            "http": {"host": "httphost", "port": 3128},
-        }
-        proxy = tunnel_server.build_proxy(settings)
-        self.assertEqual(proxy.type(), proxy.HttpProxy)
-        self.assertEqual(proxy.hostName(), "httphost")
-        self.assertEqual(proxy.port(), 3128)
-
-    def test_use_noproxy_as_fallback(self):
-        """If nothing useful, revert to no proxy."""
-        settings = {}
-        proxy = tunnel_server.build_proxy(settings)
-        self.assertEqual(proxy.type(), proxy.DefaultProxy)
-
-
-class RemoteSocketTestCase(SquidTestCase):
-    """Tests for the client that connects to the other side."""
-
-    timeout = 3
-
-    def get_proxy_settings(self):
-        return {}
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this testcase."""
-        yield super(RemoteSocketTestCase, self).setUp()
-        self.ws = MockWebServer()
-        self.addCleanup(self.ws.stop)
-        self.dest_url = self.ws.get_iri().encode("utf-8") + SIMPLERESOURCE
-
-        self.addCleanup(tunnel_server.QNetworkProxy.setApplicationProxy,
-                        tunnel_server.QNetworkProxy.applicationProxy())
-        settings = {"http": self.get_proxy_settings()}
-        proxy = tunnel_server.build_proxy(settings)
-        tunnel_server.QNetworkProxy.setApplicationProxy(proxy)
-
-    def test_invalid_port(self):
-        """A request with an invalid port fails with a 400."""
-        protocol = tunnel_server.ServerTunnelProtocol(
-                                                    tunnel_server.RemoteSocket)
-        protocol.transport = FakeTransport()
-        protocol.dataReceived("CONNECT 127.0.0.1:wrong_port HTTP/1.0" +
-                              CRLF * 2)
-
-        status_line = protocol.transport.getvalue()
-        self.assertTrue(status_line.startswith("HTTP/1.0 400 "),
-                        "The port must be an integer.")
-
-    @defer.inlineCallbacks
-    def test_connection_is_finished_when_stopping(self):
-        """The client disconnects when requested."""
-        fake_protocol = FakeServerTunnelProtocol()
-        client = tunnel_server.RemoteSocket(fake_protocol)
-        url = urlparse(self.dest_url)
-        yield client.connect(url.netloc)
-        yield client.stop()
-
-    @defer.inlineCallbacks
-    def test_stop_but_never_connected(self):
-        """Stop but it was never connected."""
-        fake_protocol = FakeServerTunnelProtocol()
-        client = tunnel_server.RemoteSocket(fake_protocol)
-        yield client.stop()
-
-    @defer.inlineCallbacks
-    def test_client_write(self):
-        """Data written to the client is sent to the other side."""
-        fake_protocol = FakeServerTunnelProtocol()
-        client = tunnel_server.RemoteSocket(fake_protocol)
-        self.addCleanup(client.stop)
-        url = urlparse(self.dest_url)
-        yield client.connect(url.netloc)
-        client.write("GET /simpleresource HTTP/1.0" + CRLF * 2)
-        yield self.ws.simple_resource.rendered
-
-    @defer.inlineCallbacks
-    def test_client_read(self):
-        """Data received by the client is written into the transport."""
-        fake_protocol = FakeServerTunnelProtocol()
-        client = tunnel_server.RemoteSocket(fake_protocol)
-        self.addCleanup(client.stop)
-        url = urlparse(self.dest_url)
-        yield client.connect(url.netloc)
-        client.write("GET /simpleresource HTTP/1.0" + CRLF * 2)
-        yield self.ws.simple_resource.rendered
-        data = yield fake_protocol.response_received
-        _headers, content = str(data).split(CRLF * 2, 1)
-        self.assertEqual(content, SAMPLE_CONTENT)
-
-
-class AnonProxyRemoteSocketTestCase(RemoteSocketTestCase):
-    """Tests for the client going thru an anonymous proxy."""
-
-    get_proxy_settings = RemoteSocketTestCase.get_nonauth_proxy_settings
-
-    def parse_headers(self, raw_headers):
-        """Parse the headers."""
-        lines = raw_headers.split(CRLF)
-        header_lines = lines[1:]
-        headers_pairs = (l.split(":", 1) for l in header_lines)
-        return dict((k.lower(), v.strip()) for k, v in headers_pairs)
-
-    @defer.inlineCallbacks
-    def test_verify_client_uses_proxy(self):
-        """Verify that the client uses the proxy."""
-        fake_protocol = FakeServerTunnelProtocol()
-        client = tunnel_server.RemoteSocket(fake_protocol)
-        self.addCleanup(client.stop)
-        url = urlparse(self.dest_url)
-        yield client.connect(url.netloc)
-        client.write("GET /simpleresource HTTP/1.0" + CRLF * 2)
-        yield self.ws.simple_resource.rendered
-        data = yield fake_protocol.response_received
-        raw_headers, _content = str(data).split(CRLF * 2, 1)
-        self.parse_headers(raw_headers)
-
-
-@skipIfOS('linux2', 'LP: #1111880 - ncsa_auth crashing for auth proxy tests.')
-class AuthenticatedProxyRemoteSocketTestCase(AnonProxyRemoteSocketTestCase):
-    """Tests for the client going thru an authenticated proxy."""
-
-    get_proxy_settings = RemoteSocketTestCase.get_auth_proxy_settings
-
-    @defer.inlineCallbacks
-    def test_proxy_authentication_error(self):
-        """The proxy credentials were wrong on purpose."""
-        settings = {"http": self.get_proxy_settings()}
-        settings["http"]["password"] = "wrong password!!!"
-        proxy = tunnel_server.build_proxy(settings)
-        tunnel_server.QNetworkProxy.setApplicationProxy(proxy)
-        fake_protocol = FakeServerTunnelProtocol()
-        client = tunnel_server.RemoteSocket(fake_protocol)
-        self.addCleanup(client.stop)
-        url = urlparse(self.dest_url)
-        yield self.assertFailure(client.connect(url.netloc),
-                                 tunnel_server.ProxyAuthenticationError)
-
-    @defer.inlineCallbacks
-    def test_proxy_nobody_listens(self):
-        """The proxy settings point to a proxy that's unreachable."""
-        settings = dict(http={
-            "host": "127.0.0.1",
-            "port": 83,  # unused port according to /etc/services
-        })
-        proxy = tunnel_server.build_proxy(settings)
-        tunnel_server.QNetworkProxy.setApplicationProxy(proxy)
-        fake_protocol = FakeServerTunnelProtocol()
-        client = tunnel_server.RemoteSocket(fake_protocol)
-        self.addCleanup(client.stop)
-        url = urlparse(self.dest_url)
-        yield self.assertFailure(client.connect(url.netloc),
-                                 tunnel_server.ConnectionError)
-
-    def test_use_credentials(self):
-        """The credentials are used if present."""
-        fake_protocol = FakeServerTunnelProtocol()
-        client = tunnel_server.RemoteSocket(fake_protocol)
-        proxy = tunnel_server.build_proxy(FAKE_SETTINGS)
-        authenticator = QAuthenticator()
-
-        client.proxyAuthenticationRequired.emit(proxy, authenticator)
-        self.assertEqual(proxy.user(), "")
-        self.assertEqual(proxy.password(), "")
-        fake_protocol.proxy_credentials = FAKE_CREDS
-
-        client.proxyAuthenticationRequired.emit(proxy, authenticator)
-        self.assertEqual(authenticator.user(), FAKE_CREDS["username"])
-        self.assertEqual(authenticator.password(), FAKE_CREDS["password"])
-
-
-class FakeNetworkProxyFactoryClass(object):
-    """A fake QNetworkProxyFactory."""
-    last_query = None
-    use_system = False
-
-    def __init__(self, enabled):
-        """Initialize this fake instance."""
-        if enabled:
-            self.proxy_type = tunnel_server.QNetworkProxy.HttpProxy
-        else:
-            self.proxy_type = tunnel_server.QNetworkProxy.NoProxy
-
-    def type(self):
-        """Return the proxy type configured."""
-        return self.proxy_type
-
-    @classmethod
-    def setUseSystemConfiguration(cls, new_value):
-        """Save the system configuration requested."""
-        cls.use_system = new_value
-
-    @classmethod
-    def useSystemConfiguration(cls):
-        """Is the system configured for proxies?"""
-        return cls.use_system
-
-    def systemProxyForQuery(self, query):
-        """A list of proxies, but only type() will be called on the first."""
-        return [self]
-
-
-class CheckProxyEnabledTestCase(TestCase):
-    """Tests for the check_proxy_enabled function."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this testcase."""
-        yield super(CheckProxyEnabledTestCase, self).setUp()
-        self.app_proxy = []
-
-    def _assert_proxy_state(self, platform, state, assertion):
-        """Assert the proxy is in a given state."""
-        self.patch(tunnel_server.QNetworkProxy, "setApplicationProxy",
-                   lambda proxy: self.app_proxy.append(proxy))
-        self.patch(tunnel_server.sys, "platform", platform)
-        ret = tunnel_server.check_proxy_enabled(SAMPLE_HOST, str(SAMPLE_PORT))
-        self.assertTrue(ret == state, assertion)
-
-    def _assert_proxy_enabled(self, platform):
-        """Assert that the proxy is enabled."""
-        self._assert_proxy_state(platform, True, "Proxy is enabled.")
-
-    def _assert_proxy_disabled(self, platform):
-        """Assert that the proxy is disabled."""
-        self._assert_proxy_state(platform, False, "Proxy is disabled.")
-
-    def test_platform_linux_enabled(self):
-        """Tests for the linux platform with proxies enabled."""
-        self.patch(tunnel_server.gsettings, "get_proxy_settings",
-                   lambda: FAKE_SETTINGS)
-        self._assert_proxy_enabled("linux3")
-        self.assertEqual(len(self.app_proxy), 1)
-
-    def test_platform_linux_disabled(self):
-        """Tests for the linux platform with proxies disabled."""
-        self.patch(tunnel_server.gsettings, "get_proxy_settings", lambda: {})
-        self._assert_proxy_disabled("linux3")
-        self.assertEqual(len(self.app_proxy), 0)
-
-    def test_platform_other_enabled(self):
-        """Tests for any other platform with proxies enabled."""
-        fake_netproxfact = FakeNetworkProxyFactoryClass(True)
-        self.patch(tunnel_server, "QNetworkProxyFactory", fake_netproxfact)
-        self._assert_proxy_enabled("windows 1.0")
-        self.assertEqual(len(self.app_proxy), 0)
-        self.assertTrue(fake_netproxfact.useSystemConfiguration())
-
-    def test_platform_other_disabled(self):
-        """Tests for any other platform with proxies disabled."""
-        fake_netproxfact = FakeNetworkProxyFactoryClass(False)
-        self.patch(tunnel_server, "QNetworkProxyFactory", fake_netproxfact)
-        self._assert_proxy_disabled("windows 1.0")
-        self.assertEqual(len(self.app_proxy), 0)
-        self.assertTrue(fake_netproxfact.useSystemConfiguration())
-
-
-class FakeQCoreApp(object):
-    """A fake QCoreApplication."""
-
-    fake_instance = None
-
-    def __init__(self, argv):
-        """Initialize this fake."""
-        self.executed = False
-        self.argv = argv
-        FakeQCoreApp.fake_instance = self
-
-    def exec_(self):
-        """Fake the execution of this app."""
-        self.executed = True
-
-    @staticmethod
-    def instance():
-        """But return the real instance."""
-        return QCoreApplication.instance()
-
-
-class MainFunctionTestCase(TestCase):
-    """Tests for the main function of the tunnel server."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize these testcases."""
-        yield super(MainFunctionTestCase, self).setUp()
-        self.called = []
-        self.proxies_enabled = False
-
-        def fake_is_proxy_enabled(*args):
-            """Store the call, return false."""
-            self.called.append(args)
-            return self.proxies_enabled
-
-        self.patch(tunnel_server, "check_proxy_enabled", fake_is_proxy_enabled)
-        self.fake_stdout = StringIO()
-        self.patch(tunnel_server.sys, "stdout", self.fake_stdout)
-        self.patch(tunnel_server, "QCoreApplication", FakeQCoreApp)
-
-    def test_checks_proxies(self):
-        """Main checks that the proxies are enabled."""
-        tunnel_server.main([])
-        self.assertEqual(len(self.called), 1)
-
-    def test_on_proxies_enabled_prints_port_and_cookie(self):
-        """With proxies enabled print port to stdout and start the mainloop."""
-        self.patch(tunnel_server.uuid, "uuid4", lambda: FAKE_COOKIE)
-        self.proxies_enabled = True
-        port = 443
-        tunnel_server.main(["example.com", str(port)])
-        stdout = self.fake_stdout.getvalue()
-
-        self.assertIn(tunnel_server.TUNNEL_PORT_LABEL + ": ", stdout)
-        cookie_line = tunnel_server.TUNNEL_COOKIE_LABEL + ": " + FAKE_COOKIE
-        self.assertIn(cookie_line, stdout)
-
-    def test_on_proxies_disabled_exit(self):
-        """With proxies disabled, print a message and exit gracefully."""
-        self.proxies_enabled = False
-        tunnel_server.main(["example.com", "443"])
-        self.assertIn("Proxy not enabled.", self.fake_stdout.getvalue())
-        self.assertEqual(FakeQCoreApp.fake_instance, None)
-
-    def test_qtdbus_installed_on_linux(self):
-        """The QtDbus mainloop is installed."""
-        self.patch(tunnel_server.sys, "platform", "linux123")
-        installed = []
-        self.patch(
-            tunnel_server, "install_qt_dbus", lambda: installed.append(None))
-        self.proxies_enabled = True
-        tunnel_server.main(["example.com", "443"])
-        self.assertEqual(len(installed), 1)
-
-    def test_qtdbus_not_installed_on_windows(self):
-        """The QtDbus mainloop is installed."""
-        self.patch(tunnel_server.sys, "platform", "win98")
-        installed = []
-        self.patch(
-            tunnel_server, "install_qt_dbus", lambda: installed.append(None))
-        self.proxies_enabled = True
-        tunnel_server.main(["example.com", "443"])
-        self.assertEqual(len(installed), 0)
-
-    def test_fix_turkish_locale_called(self):
-        """The fix_turkish_locale function is called, always."""
-        called = []
-        self.patch(
-            tunnel_server, "fix_turkish_locale",
-            lambda *args, **kwargs: called.append((args, kwargs)))
-        tunnel_server.main(["localhost", "443"])
-        self.assertEqual(called, [((), {})])

=== removed file 'ubuntuone/proxy/tunnel_client.py'
--- ubuntuone/proxy/tunnel_client.py	2016-05-29 00:50:05 +0000
+++ ubuntuone/proxy/tunnel_client.py	1970-01-01 00:00:00 +0000
@@ -1,202 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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.
-"""Client for the tunnel protocol."""
-
-import logging
-
-from twisted.internet import protocol, reactor
-
-from ubuntuone.clientdefs import NAME
-from ubuntuone.proxy.common import (
-    BaseTunnelProtocol,
-    CRLF,
-    TUNNEL_COOKIE_LABEL,
-    TUNNEL_COOKIE_HEADER,
-    TUNNEL_PORT_LABEL,
-)
-
-METHOD_LINE = "CONNECT %s:%d HTTP/1.0" + CRLF
-LOCALHOST = "127.0.0.1"
-
-logger = logging.getLogger("ubuntuone.SyncDaemon.TunnelClient")
-
-
-class TunnelClientProtocol(BaseTunnelProtocol):
-    """Client protocol for the handshake part of the tunnel."""
-
-    def connectionMade(self):
-        """The connection to the tunnel was made so send request."""
-        method_line = METHOD_LINE % (self.factory.tunnel_host,
-                                     self.factory.tunnel_port)
-        headers = {
-            "User-Agent": "%s tunnel client" % NAME,
-            TUNNEL_COOKIE_HEADER: self.factory.cookie,
-        }
-        self.transport.write(method_line +
-                             self.format_headers(headers) +
-                             CRLF)
-
-    def handle_first_line(self, line):
-        """The first line received is the status line."""
-        try:
-            proto_version, self.status_code, description = line.split(" ", 2)
-        except ValueError:
-            self.transport.loseConnection()
-
-    def headers_done(self):
-        """All the headers have arrived. Time to switch protocols."""
-        remaining_data = self.clearLineBuffer()
-        if self.status_code != "200":
-            self.transport.loseConnection()
-            return
-        addr = self.transport.getPeer()
-        other_protocol = self.factory.other_factory.buildProtocol(addr)
-        self.transport.protocol = other_protocol
-        other_protocol.transport = self.transport
-        self.transport = None
-        if self.factory.context_factory:
-            other_protocol.transport.startTLS(self.factory.context_factory)
-        other_protocol.connectionMade()
-        if remaining_data:
-            other_protocol.dataReceived(remaining_data)
-
-
-class TunnelClientFactory(protocol.ClientFactory):
-    """A factory for Tunnel Client Protocols."""
-
-    protocol = TunnelClientProtocol
-
-    def __init__(self, tunnel_host, tunnel_port, other_factory, cookie,
-                 context_factory=None):
-        """Initialize this factory."""
-        self.tunnel_host = tunnel_host
-        self.tunnel_port = tunnel_port
-        self.other_factory = other_factory
-        self.context_factory = context_factory
-        self.cookie = cookie
-
-    def startedConnecting(self, connector):
-        """Forward this call to the other factory."""
-        self.other_factory.startedConnecting(connector)
-
-    def clientConnectionFailed(self, connector, reason):
-        """Forward this call to the other factory."""
-        self.other_factory.clientConnectionFailed(connector, reason)
-
-    def clientConnectionLost(self, connector, reason):
-        """Forward this call to the other factory."""
-        self.other_factory.clientConnectionLost(connector, reason)
-
-
-class TunnelClient(object):
-    """A client for the proxy tunnel."""
-
-    def __init__(self, tunnel_host, tunnel_port, cookie):
-        """Initialize this client."""
-        self.tunnel_host = tunnel_host
-        self.tunnel_port = tunnel_port
-        self.cookie = cookie
-
-    def connectTCP(self, host, port, factory, *args, **kwargs):
-        """A connectTCP going thru the tunnel."""
-        logger.info("Connecting (TCP) to %r:%r via tunnel at %r:%r",
-                    host, port, self.tunnel_host, self.tunnel_port)
-        tunnel_factory = TunnelClientFactory(host, port, factory, self.cookie)
-        return reactor.connectTCP(self.tunnel_host, self.tunnel_port,
-                                  tunnel_factory, *args, **kwargs)
-
-    def connectSSL(self, host, port, factory,
-                   contextFactory, *args, **kwargs):
-        """A connectSSL going thru the tunnel."""
-        logger.info("Connecting (SSL) to %r:%r via tunnel at %r:%r",
-                    host, port, self.tunnel_host, self.tunnel_port)
-        tunnel_factory = TunnelClientFactory(
-            host, port, factory, self.cookie, contextFactory)
-        return reactor.connectTCP(self.tunnel_host, self.tunnel_port,
-                                  tunnel_factory, *args, **kwargs)
-
-
-class TunnelProcessProtocol(protocol.ProcessProtocol):
-    """The dialog thru stdout with the tunnel server."""
-
-    timeout = 30
-
-    def __init__(self, client_d):
-        """Initialize this protocol."""
-        self.client_d = client_d
-        self.timer = None
-        self.port = None
-        self.cookie = None
-
-    def connectionMade(self):
-        """The process has started, start a timer."""
-        logger.info("Tunnel process started.")
-        self.timer = reactor.callLater(self.timeout, self.process_timeouted)
-
-    def process_timeouted(self):
-        """The process took too long to reply."""
-        if not self.client_d.called:
-            logger.info("Timeout while waiting for tunnel process.")
-            self.client_d.callback(reactor)
-
-    def finish_timeout(self):
-        """Stop the timer from firing."""
-        if self.timer and self.timer.active():
-            logger.debug("canceling timer before connection timeout")
-            self.timer.cancel()
-
-    def processExited(self, status):
-        """The tunnel process has exited with some error code."""
-        self.finish_timeout()
-        logger.info("Tunnel process exit status %r.", status)
-        if not self.client_d.called:
-            logger.debug("Tunnel process exited before TunnelClient created. "
-                         "Falling back to reactor")
-            self.client_d.callback(reactor)
-
-    def outReceived(self, data):
-        """Receive the port number."""
-        if self.client_d.called:
-            return
-
-        for line in data.split("\n"):
-            if line.startswith(TUNNEL_PORT_LABEL):
-                _header, port = line.split(":", 1)
-                self.port = int(port.strip())
-            if line.startswith(TUNNEL_COOKIE_LABEL):
-                _header, cookie = line.split(":", 1)
-                self.cookie = cookie.strip()
-
-        if self.port and self.cookie:
-            logger.info("Tunnel process listening on port %r.", self.port)
-            client = TunnelClient(LOCALHOST, self.port, self.cookie)
-            self.client_d.callback(client)
-
-    def errReceived(self, data):
-        logger.debug("Got stderr from tunnel process: %r", data)

=== removed file 'ubuntuone/proxy/tunnel_server.py'
--- ubuntuone/proxy/tunnel_server.py	2017-01-07 18:51:07 +0000
+++ ubuntuone/proxy/tunnel_server.py	1970-01-01 00:00:00 +0000
@@ -1,405 +0,0 @@
-# -*- 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
-# 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 tunnel through proxies.
-
-The layers in a tunneled proxied connection:
-
-↓ tunnelclient - initiates tcp to tunnelserver, request outward connection
-↕ client protocol - started after the tunneclient gets connected
----process boundary---
-↕ tunnelserver - creates a tunnel instance per incoming connection
-↕ tunnel - hold a qtcpsocket to tunnelclient, and srvtunnelproto to the remote
-↕ servertunnelprotocol - gets CONNECT from tunnelclient, creates a remotesocket
-↕ remotesocket - connects to the destination server via a proxy
-↕ proxy server - goes thru firewalls
-↑ server - dialogues with the client protocol
-
-"""
-
-import sys
-import uuid
-
-from PyQt4.QtCore import QCoreApplication, QTimer
-from PyQt4.QtNetwork import (
-    QAbstractSocket,
-    QHostAddress,
-    QNetworkProxy,
-    QNetworkProxyQuery,
-    QNetworkProxyFactory,
-    QTcpServer,
-    QTcpSocket,
-)
-from twisted.internet import defer, interfaces
-from zope.interface import implements
-
-from ubuntuone.clientdefs import NAME
-from ubuntuone.keyring import Keyring
-from ubuntuone.utils import gsettings
-from ubuntuone.proxy.common import (
-    BaseTunnelProtocol,
-    CRLF,
-    TUNNEL_COOKIE_HEADER,
-    TUNNEL_COOKIE_LABEL,
-    TUNNEL_PORT_LABEL,
-)
-from ubuntuone.proxy.logger import logger
-try:
-    from ubuntuone.utils.locale import fix_turkish_locale
-except ImportError:
-    def fix_turkish_locale():
-        return None
-
-
-DEFAULT_CODE = 500
-DEFAULT_DESCRIPTION = "Connection error"
-
-
-class ConnectionError(Exception):
-    """The client failed connecting to the destination."""
-
-    def __init__(self, code=DEFAULT_CODE, description=DEFAULT_DESCRIPTION):
-        self.code = code
-        self.description = description
-
-
-class ProxyAuthenticationError(ConnectionError):
-    """Credentials mismatch going thru a proxy."""
-
-
-def build_proxy(settings_groups):
-    """Create a QNetworkProxy from these settings."""
-    proxy_groups = [
-        ("socks", QNetworkProxy.Socks5Proxy),
-        ("https", QNetworkProxy.HttpProxy),
-        ("http", QNetworkProxy.HttpProxy),
-    ]
-    for group, proxy_type in proxy_groups:
-        if group not in settings_groups:
-            continue
-        settings = settings_groups[group]
-        if "host" in settings and "port" in settings:
-            return QNetworkProxy(proxy_type,
-                                 hostName=settings.get("host", ""),
-                                 port=settings.get("port", 0),
-                                 user=settings.get("username", ""),
-                                 password=settings.get("password", ""))
-    logger.error("No proxy correctly configured.")
-    return QNetworkProxy(QNetworkProxy.DefaultProxy)
-
-
-class RemoteSocket(QTcpSocket):
-    """A dumb connection through a proxy to a destination hostport."""
-
-    def __init__(self, tunnel_protocol):
-        """Initialize this object."""
-        super(RemoteSocket, self).__init__()
-        self.protocol = tunnel_protocol
-        self.connected_d = defer.Deferred()
-        self.connected.connect(self.handle_connected)
-        self.proxyAuthenticationRequired.connect(self.handle_auth_required)
-        self.buffered_data = []
-
-    def handle_connected(self):
-        """When connected, send all pending data."""
-        self.disconnected.connect(self.handle_disconnected)
-        self.connected_d.callback(None)
-        for d in self.buffered_data:
-            logger.debug("writing remote: %d bytes", len(d))
-            super(RemoteSocket, self).write(d)
-        self.buffered_data = []
-
-    def handle_disconnected(self):
-        """Do something with disconnections."""
-        logger.debug("Remote socket disconnected")
-        self.protocol.remote_disconnected()
-
-    def write(self, data):
-        """Write data to the remote end, buffering if not connected."""
-        if self.state() == QAbstractSocket.ConnectedState:
-            logger.debug("writing remote: %d bytes", len(data))
-            super(RemoteSocket, self).write(data)
-        else:
-            self.buffered_data.append(data)
-
-    def connect(self, hostport):
-        """Try to establish the connection to the remote end."""
-        host, port = hostport.split(":")
-
-        try:
-            port = int(port)
-        except ValueError:
-            raise ConnectionError(400, "Destination port must be an integer.")
-
-        self.readyRead.connect(self.handle_ready_read)
-        self.error.connect(self.handle_error)
-        self.connectToHost(host, port)
-
-        return self.connected_d
-
-    def handle_auth_required(self, proxy, authenticator):
-        """Handle the proxyAuthenticationRequired signal."""
-        self.protocol.proxy_auth_required(proxy, authenticator)
-
-    def handle_error(self, socket_error):
-        """Some error happened while connecting."""
-        error_description = "%s (%d)" % (self.errorString(), socket_error)
-        logger.error("connection error: %s", error_description)
-        if self.connected_d.called:
-            return
-
-        if socket_error == self.ProxyAuthenticationRequiredError:
-            error = ProxyAuthenticationError(407, error_description)
-        else:
-            error = ConnectionError(500, error_description)
-
-        self.connected_d.errback(error)
-
-    def handle_ready_read(self):
-        """Forward data from the remote end to the parent protocol."""
-        data = self.readAll()
-        self.protocol.response_data_received(data)
-
-    @defer.inlineCallbacks
-    def stop(self):
-        """Finish and cleanup."""
-        self.disconnectFromHost()
-        while self.state() != self.UnconnectedState:
-            d = defer.Deferred()
-            QTimer.singleShot(100, lambda: d.callback(None))
-            yield d
-
-
-class ServerTunnelProtocol(BaseTunnelProtocol):
-    """CONNECT sever protocol for tunnelling connections."""
-
-    def __init__(self, client_class):
-        """Initialize this protocol."""
-        BaseTunnelProtocol.__init__(self)
-        self.hostport = ""
-        self.client = None
-        self.client_class = client_class
-        self.proxy_credentials = None
-        self.proxy_domain = None
-
-    def error_response(self, code, description):
-        """Write a response with an error, and disconnect."""
-        self.write_transport("HTTP/1.0 %d %s" % (code, description) + CRLF * 2)
-        self.transport.loseConnection()
-        if self.client:
-            self.client.stop()
-        self.clearLineBuffer()
-
-    def write_transport(self, data):
-        """Write a response in the transport."""
-        self.transport.write(data)
-
-    def proxy_auth_required(self, proxy, authenticator):
-        """Proxy authentication is required."""
-        logger.info("auth_required %r, %r",
-                    proxy.hostName(), self.proxy_domain)
-        if self.proxy_credentials and proxy.hostName() == self.proxy_domain:
-            logger.info("Credentials added to authenticator.")
-            authenticator.setUser(self.proxy_credentials["username"])
-            authenticator.setPassword(self.proxy_credentials["password"])
-        else:
-            logger.info("Credentials needed, but none available.")
-            self.proxy_domain = proxy.hostName()
-
-    def handle_first_line(self, line):
-        """Special handling for the first line received."""
-        try:
-            method, hostport, proto_version = line.split(" ", 2)
-            if proto_version != "HTTP/1.0":
-                self.error_response(505, "HTTP Version Not Supported")
-                return
-            if method != "CONNECT":
-                self.error_response(405, "Only the CONNECT method is allowed")
-                return
-            self.hostport = hostport
-        except ValueError:
-            self.error_response(400, "Bad request")
-
-    def verify_cookie(self):
-        """Fail if the cookie is wrong or missing."""
-        cookie_received = dict(self.received_headers).get(TUNNEL_COOKIE_HEADER)
-        if cookie_received != self.transport.cookie:
-            raise ConnectionError(418, "Please see RFC 2324")
-
-    @defer.inlineCallbacks
-    def headers_done(self):
-        """An empty line was received, start connecting and switch mode."""
-        try:
-            self.verify_cookie()
-            try:
-                logger.info("Connecting once")
-                self.client = self.client_class(self)
-                yield self.client.connect(self.hostport)
-            except ProxyAuthenticationError:
-                if not self.proxy_domain:
-                    logger.info("No proxy domain defined")
-                    raise
-
-                credentials = yield Keyring().get_credentials(
-                    str(self.proxy_domain))
-                if "username" in credentials:
-                    self.proxy_credentials = credentials
-                logger.info("Connecting again with keyring credentials")
-                self.client = self.client_class(self)
-                yield self.client.connect(self.hostport)
-                logger.info("Connected with keyring credentials")
-
-            response_headers = {
-                "Server": "%s proxy tunnel" % NAME,
-            }
-            self.write_transport("HTTP/1.0 200 Proxy connection established" +
-                                 CRLF + self.format_headers(response_headers) +
-                                 CRLF)
-        except ConnectionError as e:
-            logger.exception("Connection error")
-            self.error_response(e.code, e.description)
-        except Exception:
-            logger.exception("Unhandled problem while connecting")
-
-    def rawDataReceived(self, data):
-        """Tunnel all raw data straight to the other side."""
-        self.client.write(data)
-
-    def response_data_received(self, data):
-        """Return data coming from the other side."""
-        self.write_transport(data)
-
-
-class Tunnel(object):
-    """An instance of a running tunnel."""
-
-    implements(interfaces.ITransport)
-
-    def __init__(self, local_socket, cookie):
-        """Initialize this Tunnel instance."""
-        self.cookie = cookie
-        self.disconnecting = False
-        self.local_socket = local_socket
-        self.protocol = ServerTunnelProtocol(RemoteSocket)
-        self.protocol.transport = self
-        local_socket.readyRead.connect(self.server_ready_read)
-        local_socket.disconnected.connect(self.local_disconnected)
-
-    def server_ready_read(self):
-        """Data available on the local end. Move it forward."""
-        data = bytes(self.local_socket.readAll())
-        self.protocol.dataReceived(data)
-
-    def write(self, data):
-        """Data available on the remote end. Bring it back."""
-        logger.debug("writing local: %d bytes", len(data))
-        self.local_socket.write(data)
-
-    def loseConnection(self):
-        """The remote end disconnected."""
-        logger.debug("disconnecting local end.")
-        self.local_socket.close()
-
-    def local_disconnected(self):
-        """The local end disconnected."""
-        logger.debug("The local socket got disconnected.")
-        # TODO: handle this case in an upcoming branch
-
-
-class TunnelServer(object):
-    """A server for tunnel instances."""
-
-    def __init__(self, cookie):
-        """Initialize this tunnel instance."""
-        self.tunnels = []
-        self.cookie = cookie
-        self.server = QTcpServer(QCoreApplication.instance())
-        self.server.newConnection.connect(self.new_connection)
-        self.server.listen(QHostAddress.LocalHost, 0)
-        logger.info("Starting tunnel server at port %d", self.port)
-
-    def new_connection(self):
-        """On a new connection create a new tunnel instance."""
-        logger.info("New connection made")
-        local_socket = self.server.nextPendingConnection()
-        tunnel = Tunnel(local_socket, self.cookie)
-        self.tunnels.append(tunnel)
-
-    def shutdown(self):
-        """Terminate every connection."""
-        # TODO: handle this gracefully in an upcoming branch
-
-    @property
-    def port(self):
-        """The port where this server listens."""
-        return self.server.serverPort()
-
-
-def check_proxy_enabled(host, port):
-    """Check if the proxy is enabled."""
-    port = int(port)
-    if sys.platform.startswith("linux"):
-        settings = gsettings.get_proxy_settings()
-        enabled = len(settings) > 0
-        if enabled:
-            proxy = build_proxy(settings)
-            QNetworkProxy.setApplicationProxy(proxy)
-        else:
-            logger.info("Proxy is disabled.")
-        return enabled
-    else:
-        QNetworkProxyFactory.setUseSystemConfiguration(True)
-        query = QNetworkProxyQuery(host, port)
-        proxies = QNetworkProxyFactory.systemProxyForQuery(query)
-        return len(proxies) and proxies[0].type() != QNetworkProxy.NoProxy
-
-
-def install_qt_dbus():
-    """Import and install the qt+dbus integration."""
-    from dbus.mainloop.qt import DBusQtMainLoop
-    DBusQtMainLoop(set_as_default=True)
-
-
-def main(argv):
-    """The main function for the tunnel server."""
-    fix_turkish_locale()
-    if not check_proxy_enabled(*argv[1:]):
-        sys.stdout.write("Proxy not enabled.")
-        sys.stdout.flush()
-    else:
-        if sys.platform.startswith("linux"):
-            install_qt_dbus()
-
-        app = QCoreApplication(argv)
-        cookie = str(uuid.uuid4())
-        tunnel_server = TunnelServer(cookie)
-        sys.stdout.write("%s: %d\n" % (TUNNEL_PORT_LABEL, tunnel_server.port) +
-                         "%s: %s\n" % (TUNNEL_COOKIE_LABEL, cookie))
-        sys.stdout.flush()
-        app.exec_()

=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2017-02-10 01:15:07 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2018-03-14 21:14:07 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2015 Canonical Ltd.
-# Copyright 2015-2017 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2018 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
@@ -59,7 +59,6 @@
 from ubuntuone.syncdaemon.interfaces import IActionQueue, IMarker
 from ubuntuone.syncdaemon.logger import mklog, TRACE
 from ubuntuone.syncdaemon import config, offload_queue
-from ubuntuone.syncdaemon import tunnel_runner
 
 logger = logging.getLogger("ubuntuone.SyncDaemon.ActionQueue")
 
@@ -856,27 +855,20 @@
         self.event_queue.push('SV_VOLUME_NEW_GENERATION',
                               volume_id=volume_id, generation=generation)
 
-    def _get_tunnel_runner(self, host, port):
-        """Build the tunnel runner."""
-        return tunnel_runner.TunnelRunner(host, port)
-
-    @defer.inlineCallbacks
     def _make_connection(self):
         """Do the real connect call."""
         connection_info = self.connection_info.next()
         logger.info("Attempting connection to %s", connection_info)
         host = connection_info['host']
         port = connection_info['port']
-        tunnelrunner = self._get_tunnel_runner(host, port)
-        client = yield tunnelrunner.get_client()
         if connection_info['use_ssl']:
             ssl_context = get_ssl_context(
                 connection_info['disable_ssl_verify'], host)
-            self.connector = client.connectSSL(
+            self.connector = reactor.connectSSL(
                 host, port, factory=self, contextFactory=ssl_context,
                 timeout=self.connection_timeout)
         else:
-            self.connector = client.connectTCP(
+            self.connector = reactor.connectTCP(
                 host, port, self, timeout=self.connection_timeout)
 
     def connect(self):

=== modified file 'ubuntuone/syncdaemon/tests/test_action_queue.py'
--- ubuntuone/syncdaemon/tests/test_action_queue.py	2018-03-08 19:39:13 +0000
+++ ubuntuone/syncdaemon/tests/test_action_queue.py	2018-03-14 21:14:07 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2015 Canonical Ltd.
-# Copyright 2016-2017 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2018 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
@@ -1384,9 +1384,13 @@
         self.assertTrue(self.handler.check_info("Connection started",
                                                 "host 1.2.3.4", "port 4321"))
 
-    @defer.inlineCallbacks
     def test_connection_info_rotation(self):
         """It tries to connect to different servers."""
+        # store how connectTCP is called
+        called = []
+        self.patch(
+            reactor, 'connectTCP',
+            lambda host, port, *a, **k: called.append((host, port)))
 
         multiple_conn = [
             {'host': 'host1', 'port': 'port1', 'use_ssl': False},
@@ -1394,61 +1398,14 @@
         ]
         self.action_queue.connection_info = itertools.cycle(multiple_conn)
 
-        self.tunnel_runner = None
-
-        def mitm(*args):
-            tunnel_runner = SavingConnectionTunnelRunner(*args)
-            self.tunnel_runner = tunnel_runner
-            return tunnel_runner
-
-        self.action_queue._get_tunnel_runner = mitm
-
-        yield self.action_queue._make_connection()
-        self.assertEqual(self.tunnel_runner.host, 'host1')
-        self.assertEqual(self.tunnel_runner.port, 'port1')
-
-        yield self.action_queue._make_connection()
-        self.assertEqual(self.tunnel_runner.host, 'host2')
-        self.assertEqual(self.tunnel_runner.port, 'port2')
-
-        yield self.action_queue._make_connection()
-        self.assertEqual(self.tunnel_runner.host, 'host1')
-        self.assertEqual(self.tunnel_runner.port, 'port1')
-
-
-class TunnelRunnerTestCase(FactoryBaseTestCase):
-    """Tests for the tunnel runner."""
-
-    tunnel_runner_class = SavingConnectionTunnelRunner
-
-    def setUp(self):
-        result = super(TunnelRunnerTestCase, self).setUp()
-        self.tunnel_runner = None
-        orig_get_tunnel_runner = self.action_queue._get_tunnel_runner
-
-        def mitm(*args):
-            tunnel_runner = orig_get_tunnel_runner(*args)
-            self.tunnel_runner = tunnel_runner
-            return tunnel_runner
-
-        self.action_queue._get_tunnel_runner = mitm
-        return result
-
-    @defer.inlineCallbacks
-    def test_make_connection_uses_tunnelrunner_non_ssl(self):
-        """Check that _make_connection uses TunnelRunner."""
-        self._patch_connection_info(use_ssl=False)
-        yield self.action_queue._make_connection()
-        self.assertTrue(self.tunnel_runner.client.tcp_connected,
-                        "connectTCP is called on the client.")
-
-    @defer.inlineCallbacks
-    def test_make_connection_uses_tunnelrunner_ssl(self):
-        """Check that _make_connection uses TunnelRunner."""
-        self._patch_connection_info(use_ssl=True, disable_ssl_verify=False)
-        yield self.action_queue._make_connection()
-        self.assertTrue(self.tunnel_runner.client.ssl_connected,
-                        "connectSSL is called on the client.")
+        self.action_queue._make_connection()
+        self.assertEqual(called[-1], ('host1', 'port1'))
+
+        self.action_queue._make_connection()
+        self.assertEqual(called[-1], ('host2', 'port2'))
+
+        self.action_queue._make_connection()
+        self.assertEqual(called[-1], ('host1', 'port1'))
 
 
 class ContextRequestedWithHost(FactoryBaseTestCase):
@@ -1459,6 +1416,9 @@
     @defer.inlineCallbacks
     def test_context_request_passes_host(self):
         """The context is requested passing the host."""
+        # avoid a real connection
+        self.patch(reactor, 'connectSSL', lambda *a, **k: None)
+
         fake_host = "fake_host"
         fake_disable_ssl_verify = False
 

=== removed file 'ubuntuone/syncdaemon/tests/test_tunnel_runner.py'
--- ubuntuone/syncdaemon/tests/test_tunnel_runner.py	2016-06-04 21:14:35 +0000
+++ ubuntuone/syncdaemon/tests/test_tunnel_runner.py	1970-01-01 00:00:00 +0000
@@ -1,185 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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 tunnel runner."""
-
-from twisted.internet import defer, error, reactor, task
-from twisted.trial.unittest import TestCase
-
-from ubuntuone.proxy.tests import FAKE_COOKIE
-from ubuntuone.proxy import tunnel_client
-from ubuntuone.syncdaemon import tunnel_runner
-
-FAKE_HOST = "fs-1.two.ubuntu.com"
-FAKE_PORT = 443
-
-
-class TunnelRunnerConstructorTestCase(TestCase):
-    """Test the tunnel runner constructor."""
-
-    timeout = 3
-
-    def raise_import_error(self, *args):
-        """Raise an import error."""
-        raise ImportError
-
-    @defer.inlineCallbacks
-    def test_proxy_support_not_installed(self):
-        """The proxy support binary package is not installed."""
-        self.patch(tunnel_runner.TunnelRunner, "start_process",
-                   self.raise_import_error)
-        tr = tunnel_runner.TunnelRunner(FAKE_HOST, FAKE_PORT)
-        client = yield tr.get_client()
-        self.assertEqual(client, reactor)
-
-    @defer.inlineCallbacks
-    def test_executable_not_found(self):
-        """The executable is not found anywhere."""
-        self.patch(tunnel_runner, "get_tunnel_bin_cmd",
-                   lambda *args, **kwargs: ["this_does_not_exist"])
-        tr = tunnel_runner.TunnelRunner(FAKE_HOST, FAKE_PORT)
-        client = yield tr.get_client()
-        self.assertEqual(client, reactor)
-
-
-class FakeProcessTransport(object):
-    """A fake ProcessTransport."""
-
-    pid = 0
-
-    def __init__(self):
-        """Initialize this fake."""
-        self._signals_sent = []
-
-    def signalProcess(self, signalID):
-        """Send a signal to the process."""
-        self._signals_sent.append(signalID)
-
-
-class TunnelRunnerTestCase(TestCase):
-    """Tests for the TunnelRunner."""
-
-    timeout = 3
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this testcase."""
-        yield super(TunnelRunnerTestCase, self).setUp()
-        self.spawned = []
-        self.triggers = []
-        self.fake_process_transport = FakeProcessTransport()
-
-        def fake_spawn_process(*args, **kwargs):
-            """A fake spawnProcess."""
-            self.spawned.append((args, kwargs))
-            return self.fake_process_transport
-
-        self.patch(tunnel_client.reactor, "spawnProcess", fake_spawn_process)
-
-        def fake_add_system_event_trigger(*args, **kwargs):
-            """A fake addSystemEventTrigger."""
-            self.triggers.append((args, kwargs))
-
-        self.patch(tunnel_client.reactor, "addSystemEventTrigger",
-                   fake_add_system_event_trigger)
-        self.process_protocol = None
-        self.process_protocol_class = tunnel_client.TunnelProcessProtocol
-        self.patch(tunnel_client, "TunnelProcessProtocol",
-                   self.storing_process_protocol_factory)
-        self.tr = tunnel_runner.TunnelRunner("fs-1.one.ubuntu.com", 443)
-
-    def storing_process_protocol_factory(self, *args, **kwargs):
-        """Store the process protocol just created."""
-        self.process_protocol = self.process_protocol_class(*args, **kwargs)
-        return self.process_protocol
-
-    def test_tunnel_process_is_started(self):
-        """The tunnel process is started."""
-        self.assertEqual(
-            len(self.spawned), 1, "The tunnel process is started.")
-
-    def test_system_event_finished(self):
-        """An event is added to stop the process with the reactor."""
-        expected = [(("before", "shutdown", self.tr.stop), {})]
-        self.assertEqual(self.triggers, expected)
-
-    def test_stop_process(self):
-        """The process is stopped if still running."""
-        self.tr.process_transport.pid = 1234
-        self.tr.stop()
-        self.assertEqual(self.fake_process_transport._signals_sent, ["KILL"])
-
-    def test_not_stopped_if_already_finished(self):
-        """Do not stop the tunnel process if it's already finished."""
-        self.tr.process_transport.pid = None
-        self.tr.stop()
-        self.assertEqual(self.fake_process_transport._signals_sent, [])
-
-    @defer.inlineCallbacks
-    def test_tunnel_process_get_client_yielded_twice(self):
-        """The get_client method can be yielded twice."""
-        self.process_protocol.processExited(error.ProcessTerminated(1))
-        client = yield self.tr.get_client()
-        client = yield self.tr.get_client()
-        self.assertNotEqual(client, None)
-
-    @defer.inlineCallbacks
-    def test_tunnel_process_exits_with_error(self):
-        """The tunnel process exits with an error."""
-        self.process_protocol.processExited(error.ProcessTerminated(1))
-        client = yield self.tr.get_client()
-        self.assertEqual(client, reactor)
-
-    @defer.inlineCallbacks
-    def test_tunnel_process_exits_gracefully(self):
-        """The tunnel process exits gracefully."""
-        self.process_protocol.processExited(error.ProcessDone(0))
-        client = yield self.tr.get_client()
-        self.assertEqual(client, reactor)
-
-    @defer.inlineCallbacks
-    def test_tunnel_process_prints_random_garbage_and_timeouts(self):
-        """The tunnel process prints garbage and timeouts."""
-        clock = task.Clock()
-        self.patch(tunnel_client, "reactor", clock)
-        self.process_protocol.connectionMade()
-        self.process_protocol.outReceived("Random garbage")
-        clock.advance(self.process_protocol.timeout)
-        client = yield self.tr.get_client()
-        self.assertEqual(client, clock)
-
-    @defer.inlineCallbacks
-    def test_tunnel_process_prints_port_number_and_cookie(self):
-        """The tunnel process prints the port number."""
-        received = "%s: %d\n%s: %s\n" % (
-                                tunnel_client.TUNNEL_PORT_LABEL, FAKE_PORT,
-                                tunnel_client.TUNNEL_COOKIE_LABEL, FAKE_COOKIE)
-        self.process_protocol.outReceived(received)
-        client = yield self.tr.get_client()
-        self.assertEqual(client.tunnel_port, FAKE_PORT)
-        self.assertEqual(client.cookie, FAKE_COOKIE)

=== removed file 'ubuntuone/syncdaemon/tunnel_runner.py'
--- ubuntuone/syncdaemon/tunnel_runner.py	2012-11-28 08:08:10 +0000
+++ ubuntuone/syncdaemon/tunnel_runner.py	1970-01-01 00:00:00 +0000
@@ -1,86 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2012 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# 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.
-"""Run the tunnel process and start a client, with a reactor as a fallback."""
-
-import logging
-
-from twisted.internet import defer, reactor
-
-from ubuntuone.clientdefs import LIBEXECDIR
-from ubuntuone.syncdaemon.utils import get_tunnel_bin_cmd
-
-logger = logging.getLogger("ubuntuone.SyncDaemon.TunnelRunner")
-
-
-class TunnelRunner(object):
-    """Run a tunnel process."""
-
-    def __init__(self, host, port):
-        """Start this runner instance."""
-        self.client_d = defer.Deferred()
-        self.process_transport = None
-        try:
-            self.start_process(host, port)
-        except ImportError:
-            logger.info("Proxy support not installed.")
-            self.client_d.callback(reactor)
-        except Exception:
-            logger.exception("Error while starting tunnel process:")
-            self.client_d.callback(reactor)
-
-    def start_process(self, host, port):
-        """Start the tunnel process."""
-        from ubuntuone.proxy.tunnel_client import TunnelProcessProtocol
-        protocol = TunnelProcessProtocol(self.client_d)
-        tunnel_cmd = get_tunnel_bin_cmd(extra_fallbacks=[LIBEXECDIR])
-
-        args = tunnel_cmd + [host, str(port)]
-
-        self.process_transport = reactor.spawnProcess(protocol, args[0],
-                                                      env=None, args=args)
-        reactor.addSystemEventTrigger("before", "shutdown", self.stop)
-
-    def stop(self):
-        """Stop the tunnel process if still running."""
-        logger.info("Stopping process %r", self.process_transport.pid)
-        if self.process_transport.pid is not None:
-            self.process_transport.signalProcess("KILL")
-
-    def get_client(self):
-        """A deferred with the reactor or a tunnel client."""
-
-        def client_selected(result, d):
-            """The tunnel_client or the reactor were selected."""
-            d.callback(result)
-            # make sure the result is available for next callback
-            return result
-
-        d = defer.Deferred()
-        self.client_d.addCallback(client_selected, d)
-        return d

=== modified file 'ubuntuone/syncdaemon/utils.py'
--- ubuntuone/syncdaemon/utils.py	2015-09-20 00:03:47 +0000
+++ ubuntuone/syncdaemon/utils.py	2018-03-14 21:14:07 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2012 Canonical Ltd.
+# Copyright 2015-2018 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
@@ -42,10 +43,8 @@
 
 
 SYNCDAEMON_EXECUTABLE = 'ubuntuone-syncdaemon'
-TUNNEL_EXECUTABLE = 'ubuntuone-proxy-tunnel'
 
-DARWIN_APP_NAMES = {SYNCDAEMON_EXECUTABLE: 'UbuntuOne Syncdaemon.app',
-                    TUNNEL_EXECUTABLE: 'UbuntuOne Proxy Tunnel.app'}
+DARWIN_APP_NAMES = {SYNCDAEMON_EXECUTABLE: 'UbuntuOne Syncdaemon.app'}
 
 
 def _get_bin_cmd(exe_name, extra_fallbacks=[]):
@@ -73,9 +72,3 @@
 def get_sd_bin_cmd():
     """Get cmd + args to launch syncdaemon executable."""
     return _get_bin_cmd(SYNCDAEMON_EXECUTABLE)
-
-
-def get_tunnel_bin_cmd(extra_fallbacks):
-    """Get cmd + args to launch proxy tunnel."""
-    return _get_bin_cmd(TUNNEL_EXECUTABLE,
-                        extra_fallbacks=extra_fallbacks)

=== removed file 'ubuntuone/utils/gsettings.py'
--- ubuntuone/utils/gsettings.py	2017-01-07 18:51:07 +0000
+++ ubuntuone/utils/gsettings.py	1970-01-01 00:00:00 +0000
@@ -1,114 +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.
-
-"""Retrieve the proxy configuration from Gnome."""
-
-import logging
-import subprocess
-
-
-logger = logging.getLogger(__name__)
-GSETTINGS_CMDLINE = "gsettings list-recursively org.gnome.system.proxy"
-CANNOT_PARSE_WARNING = "Cannot parse gsettings value: %r"
-
-
-def parse_proxy_host(hostname):
-    """Parse the host to get username and password."""
-    username = None
-    password = None
-    if "@" in hostname:
-        username, hostname = hostname.rsplit("@", 1)
-        if ":" in username:
-            username, password = username.split(":", 1)
-    return hostname, username, password
-
-
-def parse_manual_proxy_settings(scheme, gsettings):
-    """Parse the settings for a given scheme."""
-    host, username, pwd = parse_proxy_host(gsettings[scheme + ".host"])
-    # if the user did not set a proxy for a type (http/https/ftp) we should
-    # return None to ensure that it is not used
-    if host == '':
-        return None
-
-    settings = {
-        "host": host,
-        "port": gsettings[scheme + ".port"],
-    }
-    if scheme == "http" and gsettings["http.use-authentication"]:
-        username = gsettings["http.authentication-user"]
-        pwd = gsettings["http.authentication-password"]
-    if username is not None and pwd is not None:
-        settings.update({
-            "username": username,
-            "password": pwd,
-        })
-    return settings
-
-
-def get_proxy_settings():
-    """Parse the proxy settings as returned by the gsettings executable."""
-    output = subprocess.check_output(GSETTINGS_CMDLINE.split())
-    gsettings = {}
-    base_len = len("org.gnome.system.proxy.")
-
-    for line in output.split("\n"):
-        try:
-            path, key, value = line.split(" ", 2)
-        except ValueError:
-            continue
-        if value.startswith("'"):
-            parsed_value = value[1:-1]
-        elif value.startswith(('[', '@')):
-            parsed_value = value
-        elif value in ('true', 'false'):
-            parsed_value = (value == 'true')
-        elif value.isdigit():
-            parsed_value = int(value)
-        else:
-            logger.warning(CANNOT_PARSE_WARNING, value)
-            parsed_value = value
-        relative_key = (path + "." + key)[base_len:]
-        gsettings[relative_key] = parsed_value
-    mode = gsettings["mode"]
-    if mode == "none":
-        settings = {}
-    elif mode == "manual":
-        settings = {}
-        for scheme in ["http", "https"]:
-            scheme_settings = parse_manual_proxy_settings(scheme, gsettings)
-            if scheme_settings is not None:
-                settings[scheme] = scheme_settings
-    else:
-        # If mode is automatic the PAC javascript should be interpreted
-        # on each request. That is out of scope so it's ignored for now
-        settings = {}
-
-    return settings

=== removed file 'ubuntuone/utils/tests/test_gsettings.py'
--- ubuntuone/utils/tests/test_gsettings.py	2017-01-07 18:51:07 +0000
+++ ubuntuone/utils/tests/test_gsettings.py	1970-01-01 00:00:00 +0000
@@ -1,322 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 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
-# 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.
-
-"""Test the gsettings parser."""
-
-import logging
-
-from twisted.trial.unittest import TestCase
-from ubuntuone.devtools.handlers import MementoHandler
-
-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):
-    """Test the getting of the proxy settings."""
-
-    def test_gsettings_cmdline_correct(self):
-        """The command line used to get the proxy settings is the right one."""
-        expected = "gsettings list-recursively org.gnome.system.proxy".split()
-        called = []
-
-        def append_output(args):
-            """Append the output and return some settings."""
-            called.append(args)
-            return TEMPLATE_GSETTINGS_OUTPUT.format(**BASE_GSETTINGS_VALUES)
-
-        self.patch(gsettings.subprocess, "check_output", append_output)
-        gsettings.get_proxy_settings()
-        self.assertEqual(called[0], expected)
-
-    def test_gsettings_parser_none(self):
-        """Test a parser of gsettings."""
-        expected = {}
-        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**BASE_GSETTINGS_VALUES)
-        self.patch(gsettings.subprocess, "check_output",
-                   lambda _: fake_output)
-        ps = gsettings.get_proxy_settings()
-        self.assertEqual(ps, expected)
-
-    def _assert_parser_anonymous(self, scheme):
-        """Assert the parsing of anonymous settings."""
-        template_values = dict(BASE_GSETTINGS_VALUES)
-        expected_host = "expected_host"
-        expected_port = 54321
-        expected = {
-            "host": expected_host,
-            "port": expected_port,
-        }
-        template_values.update({
-            "mode": "manual",
-            scheme + "_host": expected_host,
-            scheme + "_port": expected_port,
-        })
-        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**template_values)
-        self.patch(gsettings.subprocess, "check_output",
-                   lambda _: fake_output)
-        ps = gsettings.get_proxy_settings()
-        self.assertEqual(ps[scheme], expected)
-
-    def test_gsettings_parser_http_anonymous(self):
-        """Test a parser of gsettings."""
-        self._assert_parser_anonymous('http')
-
-    def test_gsettings_parser_https_anonymus(self):
-        """Test a parser of gsettings."""
-        self._assert_parser_anonymous('https')
-
-    def test_gsettings_empty_ignore_hosts(self):
-        """Missing values in the ignore hosts."""
-        troublesome_value = "@as []"
-        template_values = dict(BASE_GSETTINGS_VALUES)
-        template_values["ignore_hosts"] = troublesome_value
-        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**template_values)
-        self.patch(gsettings.subprocess, "check_output",
-                   lambda _: fake_output)
-        ps = gsettings.get_proxy_settings()
-        self.assertEqual(ps, {})
-
-    def test_gsettings_cannot_parse(self):
-        """Some weird setting that cannot be parsed is logged with warning."""
-        memento = MementoHandler()
-        memento.setLevel(logging.DEBUG)
-        gsettings.logger.addHandler(memento)
-        self.addCleanup(gsettings.logger.removeHandler, memento)
-
-        troublesome_value = "#bang"
-        template_values = dict(BASE_GSETTINGS_VALUES)
-        template_values["ignore_hosts"] = troublesome_value
-        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**template_values)
-        self.patch(gsettings.subprocess, "check_output",
-                   lambda _: fake_output)
-        ps = gsettings.get_proxy_settings()
-        self.assertTrue(memento.check_warning(gsettings.CANNOT_PARSE_WARNING %
-                                              troublesome_value))
-        self.assertEqual(ps, {})
-
-    def test_gsettings_parser_http_authenticated(self):
-        """Test a parser of gsettings."""
-        template_values = dict(BASE_GSETTINGS_VALUES)
-        expected_host = "expected_host"
-        expected_port = 54321
-        expected_user = "carlitos"
-        expected_password = "very secret password"
-        expected = {
-            "host": expected_host,
-            "port": expected_port,
-            "username": expected_user,
-            "password": expected_password,
-        }
-        template_values.update({
-            "mode": "manual",
-            "http_host": expected_host,
-            "http_port": expected_port,
-            "auth_user": expected_user,
-            "auth_password": expected_password,
-            "http_use_auth": "true",
-        })
-        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**template_values)
-        self.patch(gsettings.subprocess, "check_output",
-                   lambda _: fake_output)
-        ps = gsettings.get_proxy_settings()
-        self.assertEqual(ps["http"], expected)
-
-    def _assert_parser_authenticated_url(self, scheme):
-        """Test a parser of gsettings with creds in the url."""
-        template_values = dict(BASE_GSETTINGS_VALUES)
-        expected_host = "expected_host"
-        expected_port = 54321
-        expected_user = "carlitos"
-        expected_password = "very secret password"
-        composed_url = '%s:%s@%s' % (expected_user, expected_password,
-                                     expected_host)
-        expected = {
-            "host": expected_host,
-            "port": expected_port,
-            "username": expected_user,
-            "password": expected_password,
-        }
-        template_values.update({
-            "mode": "manual",
-            scheme + "_host": composed_url,
-            scheme + "_port": expected_port,
-            "http_use_auth": "false",
-        })
-        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**template_values)
-        self.patch(gsettings.subprocess, "check_output",
-                   lambda _: fake_output)
-        ps = gsettings.get_proxy_settings()
-        self.assertEqual(ps[scheme], expected)
-
-    def test_gsettings_parser_http_authenticated_url(self):
-        """Test a parser of gsettings with creds in the url."""
-        self._assert_parser_authenticated_url('http')
-
-    def test_gsettings_parser_https_authenticated_url(self):
-        """Test a parser of gsettings with creds in the url."""
-        self._assert_parser_authenticated_url('https')
-
-    def test_gsettings_auth_over_url(self):
-        """Test that the settings are more important that the url."""
-        template_values = dict(BASE_GSETTINGS_VALUES)
-        expected_host = "expected_host"
-        expected_port = 54321
-        expected_user = "carlitos"
-        expected_password = "very secret password"
-        composed_url = '%s:%s@%s' % ('user', 'random',
-                                     expected_host)
-        http_expected = {
-            "host": expected_host,
-            "port": expected_port,
-            "username": expected_user,
-            "password": expected_password,
-        }
-        template_values.update({
-            "mode": "manual",
-            "http_host": composed_url,
-            "http_port": expected_port,
-            "auth_user": expected_user,
-            "auth_password": expected_password,
-            "http_use_auth": "true",
-        })
-        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**template_values)
-        self.patch(gsettings.subprocess, "check_output",
-                   lambda _: fake_output)
-        ps = gsettings.get_proxy_settings()
-        self.assertEqual(ps["http"], http_expected)
-
-    def _assert_parser_empty_url(self, scheme):
-        """Assert the parsing of an empty url."""
-        template_values = dict(BASE_GSETTINGS_VALUES)
-        template_values.update({
-            "mode": "manual",
-            scheme + "_host": '',
-            scheme + "_port": 0,
-            "http_use_auth": "false",
-        })
-        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**template_values)
-        self.patch(gsettings.subprocess, "check_output",
-                   lambda _: fake_output)
-        ps = gsettings.get_proxy_settings()
-        self.assertNotIn(scheme, ps)
-
-    def test_gsettings_parser_empty_http_url(self):
-        """Test when there is no http proxy set."""
-        self._assert_parser_empty_url('http')
-
-    def test_gsettings_parser_empty_https_url(self):
-        """Test when there is no https proxy set."""
-        self._assert_parser_empty_url('https')
-
-
-class ParseProxyHostTestCase(TestCase):
-    """Test the parsing of the domain."""
-
-    def test_onlyhost(self):
-        """Parse a host with no username or password."""
-        sample = "hostname"
-        hostname, username, password = gsettings.parse_proxy_host(sample)
-        self.assertEqual(username, None)
-        self.assertEqual(password, None)
-        self.assertEqual(hostname, "hostname")
-
-    def test_user_and_host(self):
-        """Parse host just with the username."""
-        sample = "username@hostname"
-        hostname, username, password = gsettings.parse_proxy_host(sample)
-        self.assertEqual(username, "username")
-        self.assertEqual(password, None)
-        self.assertEqual(hostname, "hostname")
-
-    def test_user_pass_and_host(self):
-        """Test parsing a host with a username and password."""
-        sample = "username:password@hostname"
-        hostname, username, password = gsettings.parse_proxy_host(sample)
-        self.assertEqual(username, "username")
-        self.assertEqual(password, "password")
-        self.assertEqual(hostname, "hostname")
-
-    def test_username_with_at(self):
-        """Test parsing the host with a username with @."""
-        sample = "[e-mail]:password@hostname"
-        hostname, username, password = gsettings.parse_proxy_host(sample)
-        self.assertEqual(username, "[e-mail]")
-        self.assertEqual(password, "password")
-        self.assertEqual(hostname, "hostname")
-
-    def test_username_with_at_nopass(self):
-        """Test parsing the host without a password."""
-        sample = "[e-mail]@hostname"
-        hostname, username, password = gsettings.parse_proxy_host(sample)
-        self.assertEqual(username, "[e-mail]")
-        self.assertEqual(password, None)
-        self.assertEqual(hostname, "hostname")
-
-    def test_user_pass_with_colon_and_host(self):
-        """Test parsing the host with a password that contains :."""
-        sample = "username:pass:word@hostname"
-        hostname, username, password = gsettings.parse_proxy_host(sample)
-        self.assertEqual(username, "username")
-        self.assertEqual(password, "pass:word")
-        self.assertEqual(hostname, "hostname")