Merge lp:~facundo/magicicada-client/all-venv into lp:magicicada-client

[Facundo Batista]

Full virtualenv.

Unmerged revisions

1445. By Facundo Batista on 2018-05-30

Full virtualenv.

=== modified file 'Makefile'
--- Makefile	2018-04-14 23:34:20 +0000
+++ Makefile	2018-05-30 21:37:37 +0000
@@ -43,7 +43,7 @@
 	cat dependencies-devel.txt | xargs apt-get install -y --no-install-recommends
 
 venv: 
-	virtualenv --system-site-packages $(ENV)
+	virtualenv $(ENV)
 	$(ENV)/bin/pip install -r requirements.txt -r requirements-devel.txt
 
 lint:
 
=== added directory 'contrib/dirspec'
=== added file 'contrib/dirspec/__init__.py'
--- contrib/dirspec/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/dirspec/__init__.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser 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 warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""dirspec package."""
 
=== added file 'contrib/dirspec/basedir.py'
--- contrib/dirspec/basedir.py	1970-01-01 00:00:00 +0000
+++ contrib/dirspec/basedir.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser 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 warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""XDG Base Directory paths."""
+
+from __future__ import unicode_literals, print_function
+
+import os
+
+from dirspec.utils import (default_cache_home,
+                           default_config_path, default_config_home,
+                           default_data_path, default_data_home,
+                           get_env_path, unicode_path)
+
+__all__ = ['xdg_cache_home',
+           'xdg_config_home',
+           'xdg_data_home',
+           'xdg_config_dirs',
+           'xdg_data_dirs',
+           'load_config_paths',
+           'load_data_paths',
+           'load_first_config',
+           'save_config_path',
+           'save_data_path',
+           ]
+
+
+def get_xdg_cache_home():
+    """Get the path for XDG cache directory in user's HOME."""
+    return get_env_path('XDG_CACHE_HOME', default_cache_home)
+
+
+def get_xdg_config_home():
+    """Get the path for XDG config directory in user's HOME."""
+    return get_env_path('XDG_CONFIG_HOME', default_config_home)
+
+
+def get_xdg_data_home():
+    """Get the path for XDG data directory in user's HOME."""
+    return get_env_path('XDG_DATA_HOME', default_data_home)
+
+
+def get_xdg_config_dirs():
+    """Get the paths for the XDG config directories."""
+    result = [get_xdg_config_home()]
+    result.extend([x.encode('utf-8') for x in get_env_path(
+        'XDG_CONFIG_DIRS',
+        default_config_path).decode('utf-8').split(os.pathsep)])
+    return result
+
+
+def get_xdg_data_dirs():
+    """Get the paths for the XDG data directories."""
+    result = [get_xdg_data_home()]
+    result.extend([x.encode('utf-8') for x in get_env_path(
+        'XDG_DATA_DIRS',
+        default_data_path).decode('utf-8').split(os.pathsep)])
+    return result
+
+
+def load_config_paths(*resource):
+    """Iterator of configuration paths.
+
+    Return an iterator which gives each directory named 'resource' in
+    the configuration search path. Information provided by earlier
+    directories should take precedence over later ones (ie, the user's
+    config dir comes first).
+    """
+    resource = os.path.join(*resource)
+    assert not resource.startswith('/')
+    for config_dir in get_xdg_config_dirs():
+        path = os.path.join(config_dir, resource.encode('utf-8'))
+        # access the file system always with unicode
+        # to properly behave in some operating systems
+        if os.path.exists(unicode_path(path)):
+            yield path
+
+
+def load_data_paths(*resource):
+    """Iterator of data paths.
+
+    Return an iterator which gives each directory named 'resource' in
+    the stored data search path. Information provided by earlier
+    directories should take precedence over later ones.
+    """
+    resource = os.path.join(*resource)
+    assert not resource.startswith('/')
+    for data_dir in get_xdg_data_dirs():
+        path = os.path.join(data_dir, resource.encode('utf-8'))
+        # access the file system always with unicode
+        # to properly behave in some operating systems
+        if os.path.exists(unicode_path(path)):
+            yield path
+
+
+def load_first_config(*resource):
+    """Returns the first result from load_config_paths, or None if nothing
+    is found to load.
+    """
+    for path in load_config_paths(*resource):
+        return path
+    return None
+
+
+def save_config_path(*resource):
+    """Path to save configuration.
+
+    Ensure $XDG_CONFIG_HOME/<resource>/ exists, and return its path.
+    'resource' should normally be the name of your application. Use this
+    when SAVING configuration settings. Use the xdg_config_dirs variable
+    for loading.
+    """
+    resource = os.path.join(*resource)
+    assert not resource.startswith('/')
+    path = os.path.join(get_xdg_config_home(), resource.encode('utf-8'))
+    # access the file system always with unicode
+    # to properly behave in some operating systems
+    if not os.path.isdir(unicode_path(path)):
+        os.makedirs(unicode_path(path), 0o700)
+    return path
+
+
+def save_data_path(*resource):
+    """Path to save data.
+
+    Ensure $XDG_DATA_HOME/<resource>/ exists, and return its path.
+    'resource' should normally be the name of your application. Use this
+    when STORING a resource. Use the xdg_data_dirs variable for loading.
+    """
+    resource = os.path.join(*resource)
+    assert not resource.startswith('/')
+    path = os.path.join(get_xdg_data_home(), resource.encode('utf-8'))
+    # access the file system always with unicode
+    # to properly behave in some operating systems
+    if not os.path.isdir(unicode_path(path)):
+        os.makedirs(unicode_path(path), 0o700)
+    return path
+
+
+# pylint: disable=C0103
+xdg_cache_home = get_xdg_cache_home()
+xdg_config_home = get_xdg_config_home()
+xdg_data_home = get_xdg_data_home()
+
+xdg_config_dirs = [x for x in get_xdg_config_dirs() if x]
+xdg_data_dirs = [x for x in get_xdg_data_dirs() if x]
+# pylint: disable=C0103
 
=== added file 'contrib/dirspec/utils.py'
--- contrib/dirspec/utils.py	1970-01-01 00:00:00 +0000
+++ contrib/dirspec/utils.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser 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 warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Utilities for multiplatform support of XDG directory handling."""
+
+from __future__ import unicode_literals, print_function
+
+import errno
+import os
+import sys
+
+__all__ = ['user_home',
+           'default_cache_home',
+           'default_config_home',
+           'default_config_path',
+           'default_data_home',
+           'default_data_path',
+           'get_env_path',
+           'get_program_path',
+           'unicode_path',
+           ]
+
+
+def _get_exe_path_frozen_win32(exe_name):
+    """Get path to the helper .exe on packaged windows."""
+    # all the .exes are in the same place on windows:
+    cur_exec_path = os.path.abspath(sys.executable)
+    exe_dir = os.path.dirname(cur_exec_path)
+    return os.path.join(exe_dir, exe_name + ".exe")
+
+
+def _get_exe_path_frozen_darwin(exe_name, app_names):
+    """Get path to the sub-app executable on packaged darwin."""
+
+    sub_app_name = app_names[exe_name]
+    main_app_dir = "".join(__file__.partition(".app")[:-1])
+    main_app_resources_dir = os.path.join(main_app_dir,
+                                          "Contents",
+                                          "Resources")
+    exe_bin = os.path.join(main_app_resources_dir,
+                           sub_app_name,
+                           "Contents", "MacOS",
+                           exe_name)
+    return exe_bin
+
+
+def get_program_path(program_name, *args, **kwargs):
+    """Given a program name, returns the path to run that program.
+
+    Raises OSError if the program is not found.
+
+    :param program_name: The name of the program to find. For darwin and win32
+        platforms, the behavior is changed slightly, when sys.frozen is set,
+        to look in the packaged program locations for the program.
+    :param search_dirs: A list of directories to look for the program in. This
+        is only available as a keyword argument.
+    :param app_names: A dict of program names mapped to sub-app names. Used
+        for discovering paths in embedded .app bundles on the darwin platform.
+        This is only available as a keyword argument.
+    :return: The path to the discovered program.
+    """
+    search_dirs = kwargs.get('fallback_dirs', None)
+    app_names = kwargs.get('app_names', None)
+
+    if getattr(sys, "frozen", None) is not None:
+        if sys.platform == 'win32':
+            program_path = _get_exe_path_frozen_win32(program_name)
+        elif sys.platform == 'darwin':
+            program_path = _get_exe_path_frozen_darwin(program_name,
+                                                       app_names)
+        else:
+            raise Exception("Unsupported platform for frozen execution: %r" %
+                            sys.platform)
+    else:
+        if search_dirs is not None:
+            for dirname in search_dirs:
+                program_path = os.path.join(dirname, program_name)
+                if os.path.exists(program_path):
+                    return program_path
+        else:
+            # Check in normal system $PATH, if no fallback dirs specified
+            from distutils.spawn import find_executable
+            program_path = find_executable(program_name)
+
+    if program_path is None or not os.path.exists(program_path):
+        raise OSError(errno.ENOENT,
+                      "Could not find executable %r" % program_name)
+
+    return program_path
+
+
+def get_env_path(key, default):
+    """Get a UTF-8 encoded path from an environment variable."""
+    if key in os.environ:
+        # on windows, environment variables are mbcs bytes
+        # so we must turn them into utf-8 Syncdaemon paths
+        try:
+            path = os.environb.get(key.encode('utf-8'))
+        except AttributeError:
+            path = os.environ[key]
+        return path.decode(sys.getfilesystemencoding()).encode('utf-8')
+    else:
+        if not isinstance(default, bytes):
+            return default.encode('utf-8')
+        return default
+
+
+def unicode_path(utf8path):
+    """Turn an utf8 path into a unicode path."""
+    if isinstance(utf8path, bytes):
+        return utf8path.decode("utf-8")
+    return utf8path
+
+
+def get_special_folders():
+    """ Routine to grab all the Windows Special Folders locations.
+
+    If successful, returns dictionary
+    of shell folder locations indexed on Windows keyword for each;
+    otherwise, returns an empty dictionary.
+    """
+    # pylint: disable=W0621, F0401, E0611
+    special_folders = {}
+
+    if sys.platform == 'win32':
+        from win32com.shell import shell, shellcon
+        # CSIDL_LOCAL_APPDATA = C:\Users\<username>\AppData\Local
+        # CSIDL_PROFILE = C:\Users\<username>
+        # CSIDL_COMMON_APPDATA = C:\ProgramData
+        # More information on these constants at
+        # http://msdn.microsoft.com/en-us/library/bb762494
+
+        # per http://msdn.microsoft.com/en-us/library/windows/desktop/bb762181,
+        # SHGetFolderPath is deprecated, replaced by SHGetKnownFolderPath
+        # (http://msdn.microsoft.com/en-us/library/windows/desktop/bb762188)
+        def get_path(name):
+            return shell.SHGetFolderPath(0, getattr(shellcon, name),
+                                         None, 0).encode('utf8')
+        special_folders['Personal'] = get_path("CSIDL_PROFILE")
+        special_folders['Local AppData'] = get_path("CSIDL_LOCAL_APPDATA")
+        special_folders['AppData'] = os.path.dirname(
+            special_folders['Local AppData'])
+        special_folders['Common AppData'] = get_path("CSIDL_COMMON_APPDATA")
+
+    return special_folders
+
+
+# pylint: disable=C0103
+if sys.platform == 'win32':
+    special_folders = get_special_folders()
+    user_home = special_folders['Personal']
+    default_config_path = special_folders['Common AppData']
+    default_config_home = special_folders['Local AppData']
+    default_data_path = os.path.join(default_config_path, b'xdg')
+    default_data_home = os.path.join(default_config_home, b'xdg')
+    default_cache_home = os.path.join(default_data_home, b'cache')
+elif sys.platform == 'darwin':
+    user_home = os.path.expanduser(b'~')
+    default_cache_home = os.path.join(user_home, b'Library', b'Caches')
+    default_config_path = b'/Library/Preferences:/etc/xdg'
+    default_config_home = os.path.join(user_home, b'Library', b'Preferences')
+    default_data_path = b':'.join([b'/Library/Application Support',
+                                   b'/usr/local/share',
+                                   b'/usr/share'])
+    default_data_home = os.path.join(user_home, b'Library',
+                                     b'Application Support')
+else:
+    user_home = os.path.expanduser(b'~')
+    default_cache_home = os.path.join(user_home,
+                                      b'.cache')
+    default_config_path = b'/etc/xdg'
+    default_config_home = os.path.join(user_home,
+                                       b'.config')
+    default_data_path = b'/usr/local/share:/usr/share'
+    default_data_home = os.path.join(user_home,
+                                     b'.local', b'share')
 
=== added file 'contrib/u1trial'
--- contrib/u1trial	1970-01-01 00:00:00 +0000
+++ contrib/u1trial	2018-05-30 21:37:37 +0000
@@ -0,0 +1,40 @@
+#! /usr/bin/python
+#
+# 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.
+"""Test runner which works with special services and main loops."""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("."))
+
+from ubuntuone.devtools.runners import main  # noqa
+
+
+if __name__ == '__main__':
+    main()
 
=== added file 'data/dbus-session.conf.in'
--- data/dbus-session.conf.in	1970-01-01 00:00:00 +0000
+++ data/dbus-session.conf.in	2018-05-30 21:37:37 +0000
@@ -0,0 +1,63 @@
+<!-- This configuration file controls our test-only session bus -->
+
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+  <!-- We only use a session bus -->
+  <type>session</type>
+
+  <listen>@ADDRESS@</listen>
+
+  <!-- Load our own services.
+       To make other dbus service in this session bus, just add another servicedir entry. -->
+  <servicedir>dbus-session</servicedir>
+  <!-- Load the standard session services -->
+  <!--standard_session_servicedirs /-->
+
+  <policy context="default">
+    <!-- Allow everything to be sent -->
+    <allow send_destination="*" eavesdrop="true"/>
+    <!-- Allow everything to be received -->
+    <allow eavesdrop="true"/>
+    <!-- Allow anyone to own anything -->
+    <allow own="*"/>
+  </policy>
+
+  <!-- Config files are placed here that among other things, 
+       further restrict the above policy for specific services. -->
+  <includedir>/etc/dbus-1/session.d</includedir>
+
+  <!-- raise the service start timeout to 40 seconds as it can timeout
+       on the live cd on slow machines -->
+  <limit name="service_start_timeout">60000</limit>
+
+  <!-- This is included last so local configuration can override what's 
+       in this standard file -->
+  <include ignore_missing="yes">session-local.conf</include>
+
+  <include ignore_missing="yes" if_selinux_enabled="yes" selinux_root_relative="yes">contexts/dbus_contexts</include>
+
+  <!-- For the session bus, override the default relatively-low limits 
+       with essentially infinite limits, since the bus is just running 
+       as the user anyway, using up bus resources is not something we need 
+       to worry about. In some cases, we do set the limits lower than 
+       "all available memory" if exceeding the limit is almost certainly a bug, 
+       having the bus enforce a limit is nicer than a huge memory leak. But the 
+       intent is that these limits should never be hit. -->
+
+  <!-- the memory limits are 1G instead of say 4G because they can't exceed 32-bit signed int max -->
+  <limit name="max_incoming_bytes">1000000000</limit>
+  <limit name="max_outgoing_bytes">1000000000</limit>
+  <limit name="max_message_size">1000000000</limit>
+  <limit name="service_start_timeout">120000</limit>  
+  <limit name="auth_timeout">240000</limit>
+  <limit name="max_completed_connections">100000</limit>  
+  <limit name="max_incomplete_connections">10000</limit>
+  <limit name="max_connections_per_user">100000</limit>
+  <limit name="max_pending_service_starts">10000</limit>
+  <limit name="max_names_per_connection">50000</limit>
+  <limit name="max_match_rules_per_connection">50000</limit>
+  <limit name="max_replies_per_connection">50000</limit>
+  <limit name="reply_timeout">300000</limit>
+
+</busconfig>
 
=== modified file 'dependencies-devel.txt'
--- dependencies-devel.txt	2018-03-18 11:59:08 +0000
+++ dependencies-devel.txt	2018-05-30 21:37:37 +0000
@@ -1,5 +1,2 @@
 bzr
 make
-python-mocker
-ubuntuone-dev-tools
-virtualenv
 
=== modified file 'dependencies.txt'
--- dependencies.txt	2018-04-14 23:34:20 +0000
+++ dependencies.txt	2018-05-30 21:37:37 +0000
@@ -1,8 +1,5 @@
-gir1.2-soup-2.4
-python-configglue
-python-dirspec
-python-distutils-extra
-python-gi
-python-protobuf
-python-pyinotify
-python-twisted
+libgirepository1.0-dev
+libgtk2.0-dev
+pkg-config
+python-dev
+virtualenv
 
=== modified file 'requirements-devel.txt'
--- requirements-devel.txt	2018-03-18 15:03:09 +0000
+++ requirements-devel.txt	2018-05-30 21:37:37 +0000
@@ -1,1 +1,3 @@
+coverage==3.7.1
 flake8==3.5.0
+mocker==1.1.1
 
=== modified file 'requirements.txt'
--- requirements.txt	2018-04-14 23:34:20 +0000
+++ requirements.txt	2018-05-30 21:37:37 +0000
@@ -1,2 +1,7 @@
+configglue==1.1.3.post0
+dbus-python==1.2.8
+magicicadaprotocol==2.0
+PyGObject==3.28.2
+pyinotify==0.9.6
 Send2Trash==1.5.0
-magicicadaprotocol==2.0
+Twisted==18.4.0
 
=== modified file 'run-tests'
--- run-tests	2018-03-18 11:59:08 +0000
+++ run-tests	2018-05-30 21:37:37 +0000
@@ -49,5 +49,5 @@
 
 echo "*** Running test suite for ""$MODULE"" ***"
 export SSL_CERTIFICATES_DIR=/etc/ssl/certs
-.env/bin/python /usr/bin/u1trial -i "$IGNORE_FILES" -p "$IGNORE_PATHS" $MODULE
+.env/bin/python contrib/u1trial -i "$IGNORE_FILES" -p "$IGNORE_PATHS" $MODULE
 rm -rf _trial_temp
 
=== modified file 'setup.py'
--- setup.py	2018-04-23 02:21:03 +0000
+++ setup.py	2018-05-30 21:37:37 +0000
@@ -32,15 +32,9 @@
 import os
 import sys
 
-try:
-    from DistUtilsExtra.command import build_extra, build_i18n
-    import DistUtilsExtra.auto
-except ImportError:
-    print >> sys.stderr, 'To build this program you need '\
-                         'https://launchpad.net/python-distutils-extra'
-    raise
-assert DistUtilsExtra.auto.__version__ >= '2.18', \
-    'needs DistUtilsExtra.auto >= 2.18'
+from setuptools import setup
+from setuptools.command.install import install
+from distutils.command import build, clean
 
 
 PROJECT_NAME = 'magicicada-client'
@@ -83,7 +77,7 @@
                 out_file.write(content)
 
 
-class Install(DistUtilsExtra.auto.install_auto):
+class Install(install):
     """Class to install proper files."""
 
     def run(self):
@@ -110,7 +104,8 @@
         prefix = self.install_data.replace(
             self.root if self.root is not None else '', '')
         replace_variables(SERVICE_FILES, prefix)
-        DistUtilsExtra.auto.install_auto.run(self)
+        install.run(self)
+
         # Replace the CLIENTDEFS paths here, so that we can do it directly in
         # the installed copy, rather than the lcoal copy. This allows us to
         # have a semi-generated version for use in tests, and a full version
@@ -127,7 +122,7 @@
                 out_file.write(content)
 
 
-class Build(build_extra.build_extra):
+class Build(build.build):
     """Build PyQt (.ui) files and resources."""
 
     description = "build PyQt GUIs (.ui) and resources (.qrc)"
@@ -135,10 +130,10 @@
     def run(self):
         """Execute the command."""
         replace_variables(BUILD_FILES)
-        build_extra.build_extra.run(self)
-
-
-class Clean(DistUtilsExtra.auto.clean_build_tree):
+        build.build.run(self)
+
+
+class Clean(clean.clean):
     """Class to clean up after the build."""
 
     def run(self):
@@ -147,24 +142,7 @@
             if os.path.exists(built_file):
                 os.unlink(built_file)
 
-        DistUtilsExtra.auto.clean_build_tree.run(self)
-
-
-class BuildLocale(build_i18n.build_i18n):
-    """Work around a bug in DistUtilsExtra."""
-
-    def run(self):
-        """Magic."""
-        build_i18n.build_i18n.run(self)
-        i = 0
-        for df in self.distribution.data_files:
-            if df[0].startswith('etc/xdg/'):
-                if sys.platform not in ('darwin', 'win32'):
-                    new_df = (df[0].replace('etc/xdg/', '/etc/xdg/'), df[1])
-                    self.distribution.data_files[i] = new_df
-                else:
-                    self.distribution.data_files.pop(i)
-            i += 1
+        clean.clean.run(self)
 
 
 def set_py2exe_paths():
@@ -191,10 +169,9 @@
 
 
 cmdclass = {
-    'install': Install,
     'build': Build,
     'clean': Clean,
-    'build_i18n': BuildLocale,
+    'install': Install,
 }
 
 bin_scripts = [
@@ -236,7 +213,7 @@
     scripts.extend(bin_scripts)
     extra = {}
 
-DistUtilsExtra.auto.setup(
+setup(
     name=PROJECT_NAME,
     version=VERSION,
     license='GPL v3',
 
=== added directory 'ubuntuone/devtools'
=== added file 'ubuntuone/devtools/__init__.py'
--- ubuntuone/devtools/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/__init__.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,1 @@
+"""Testing utilities for Ubuntu One client code."""
 
=== added file 'ubuntuone/devtools/compat.py'
--- ubuntuone/devtools/compat.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/compat.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,49 @@
+# -*- 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.
+"""Python 2 and 3 compatibility."""
+
+from __future__ import unicode_literals
+
+# The following approach was outlined in Lennart Regebro's
+# "Porting to Python 3" book.
+# http://python3porting.com/noconv.html#more-bytes-strings-and-unicode
+
+import sys
+
+# Disable redefined builtin, invalid name warning
+# pylint: disable=W0622,C0103
+
+if sys.version_info < (3,):
+    text_type = unicode
+    binary_type = str
+    basestring = basestring
+else:
+    text_type = str
+    binary_type = bytes
+    basestring = str
 
=== added file 'ubuntuone/devtools/errors.py'
--- ubuntuone/devtools/errors.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/errors.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,35 @@
+# 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.
+"""Custom error types for Ubuntu One developer tools."""
+
+
+class TestError(Exception):
+    """An error occurred in attempting to load or start the tests."""
+
+
+class UsageError(Exception):
+    """An error occurred in parsing the command line arguments."""
 
=== added file 'ubuntuone/devtools/handlers.py'
--- ubuntuone/devtools/handlers.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/handlers.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+# Author: Guillermo Gonzalez <[e-mail]>
+# Author: Facundo Batista <[e-mail]>
+#
+# 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.
+"""Set of helpers handlers."""
+
+from __future__ import print_function
+
+import logging
+
+
+class MementoHandler(logging.Handler):
+    """ A handler class which store logging records in a list """
+
+    def __init__(self, *args, **kwargs):
+        """ Create the instance, and add a records attribute. """
+        logging.Handler.__init__(self, *args, **kwargs)
+        self.records = []
+        self.debug = False
+
+    def emit(self, record):
+        """ Just add the record to self.records. """
+        self.format(record)
+        self.records.append(record)
+
+    def dump_contents(self, msgs):
+        """Dumps the contents of the MementoHandler."""
+        if self.debug:
+            print("Expecting:")
+            for msg in msgs:
+                print("\t", msg)
+            print("MementoHandler contents:")
+            for rec in self.records:
+                print("\t", rec.exc_info)
+                print("\t", logging.getLevelName(rec.levelno))
+                print("\t\t", rec.message)
+                print("\t\t", rec.exc_text)
+
+    def check(self, level, *msgs):
+        """Verifies that the msgs are logged in the specified level"""
+        for rec in self.records:
+            if rec.levelno == level and all(m in rec.message for m in msgs):
+                return rec
+        self.dump_contents(msgs)
+        return False
+
+    def check_debug(self, *msgs):
+        """Shortcut for checking in DEBUG."""
+        return self.check(logging.DEBUG, *msgs)
+
+    def check_info(self, *msgs):
+        """Shortcut for checking in INFO."""
+        return self.check(logging.INFO, *msgs)
+
+    def check_warning(self, *msgs):
+        """Shortcut for checking in WARNING."""
+        return self.check(logging.WARNING, *msgs)
+
+    def check_error(self, *msgs):
+        """Shortcut for checking in ERROR."""
+        return self.check(logging.ERROR, *msgs)
+
+    def check_exception(self, exception_info, *msgs):
+        """Shortcut for checking exceptions."""
+        for rec in self.records:
+            if rec.levelno == logging.ERROR and \
+                    all(m in rec.exc_text + rec.message for m in msgs) and \
+                    exception_info in rec.exc_info:
+                return True
+        return False
 
=== added directory 'ubuntuone/devtools/reactors'
=== added file 'ubuntuone/devtools/reactors/__init__.py'
--- ubuntuone/devtools/reactors/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/reactors/__init__.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,1 @@
+"""Twisted reactors for testing."""
 
=== added file 'ubuntuone/devtools/reactors/gi.py'
--- ubuntuone/devtools/reactors/gi.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/reactors/gi.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,53 @@
+# 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.
+"""The introspection based main loop integration reactor for testing."""
+
+REACTOR_URL = 'http://twistedmatrix.com/trac/ticket/4558'
+
+
+def load_reactor(reactor_name=None):
+    """Load the reactor module and return it."""
+    return __import__(reactor_name, None, None, [''])
+
+
+def install(options=None):
+    """Install the reactor and parse any options we might need."""
+    reactor = None
+    if options is not None and options['gui']:
+        try:
+            reactor = load_reactor('twisted.internet.gtk3reactor')
+        except ImportError:
+            print('Falling back to gtk2reactor module.')
+            reactor = load_reactor('twisted.internet.gtk2reactor')
+    else:
+        try:
+            reactor = load_reactor('twisted.internet.gireactor')
+        except ImportError:
+            print('Falling back to glib2reactor module.')
+            reactor = load_reactor('twisted.internet.glib2reactor')
+
+    reactor.install()
 
=== added directory 'ubuntuone/devtools/runners'
=== added file 'ubuntuone/devtools/runners/__init__.py'
--- ubuntuone/devtools/runners/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/runners/__init__.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,304 @@
+# 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.
+"""The base test runner object."""
+
+from __future__ import print_function, unicode_literals
+
+import coverage
+import gc
+import inspect
+import os
+import re
+import sys
+import unittest
+
+from ubuntuone.devtools.errors import TestError, UsageError
+from ubuntuone.devtools.testing.txcheck import TXCheckSuite
+from ubuntuone.devtools.utils import OptionParser
+from ubuntuone.devtools.compat import text_type
+
+__all__ = ['BaseTestOptions', 'BaseTestRunner', 'main']
+
+
+def _is_in_ignored_path(testcase, paths):
+    """Return if the testcase is in one of the ignored paths."""
+    for ignored_path in paths:
+        if testcase.startswith(ignored_path):
+            return True
+    return False
+
+
+class BaseTestRunner(object):
+    """The base test runner type. Does not actually run tests."""
+
+    def __init__(self, options=None, *args, **kwargs):
+        super(BaseTestRunner, self).__init__(*args, **kwargs)
+
+        # set $HOME to the _trial_temp dir, to avoid breaking user files
+        trial_temp_dir = os.environ.get('TRIAL_TEMP_DIR', os.getcwd())
+        homedir = os.path.join(trial_temp_dir, options['temp-directory'])
+        os.environ['HOME'] = homedir
+
+        # setup $XDG_*_HOME variables and create the directories
+        xdg_cache = os.path.join(homedir, 'xdg_cache')
+        xdg_config = os.path.join(homedir, 'xdg_config')
+        xdg_data = os.path.join(homedir, 'xdg_data')
+        os.environ['XDG_CACHE_HOME'] = xdg_cache
+        os.environ['XDG_CONFIG_HOME'] = xdg_config
+        os.environ['XDG_DATA_HOME'] = xdg_data
+
+        if not os.path.exists(xdg_cache):
+            os.makedirs(xdg_cache)
+        if not os.path.exists(xdg_config):
+            os.makedirs(xdg_config)
+        if not os.path.exists(xdg_data):
+            os.makedirs(xdg_data)
+
+        # setup the ROOTDIR env var
+        os.environ['ROOTDIR'] = os.getcwd()
+
+        # Need an attribute for tempdir so we can use it later
+        self.tempdir = homedir
+        self.working_dir = os.path.join(self.tempdir, 'trial')
+
+        self.source_files = []
+        self.required_services = []
+
+    def _load_unittest(self, relpath):
+        """Load unit tests from a Python module with the given 'relpath'."""
+        assert relpath.endswith(".py"), (
+            "%s does not appear to be a Python module" % relpath)
+        if not os.path.basename(relpath).startswith('test_'):
+            return
+        modpath = relpath.replace(os.path.sep, ".")[:-3]
+        module = __import__(modpath, None, None, [""])
+
+        # If the module specifies required_services, make sure we get them
+        members = [x[1] for x in inspect.getmembers(module, inspect.isclass)]
+        for member_type in members:
+            if hasattr(member_type, 'required_services'):
+                member = member_type()
+                for service in member.required_services():
+                    if service not in self.required_services:
+                        self.required_services.append(service)
+                del member
+        gc.collect()
+
+        # If the module has a 'suite' or 'test_suite' function, use that
+        # to load the tests.
+        if hasattr(module, "suite"):
+            return module.suite()
+        elif hasattr(module, "test_suite"):
+            return module.test_suite()
+        else:
+            return unittest.defaultTestLoader.loadTestsFromModule(module)
+
+    def _collect_tests(self, path, test_pattern, ignored_modules,
+                       ignored_paths):
+        """Return the set of unittests."""
+        suite = TXCheckSuite()
+        if test_pattern:
+            pattern = re.compile('.*%s.*' % test_pattern)
+        else:
+            pattern = None
+
+        # Disable this lint warning as we need to access _tests in the
+        # test suites, to collect the tests
+        # pylint: disable=W0212
+        if path:
+            try:
+                module_suite = self._load_unittest(path)
+                if pattern:
+                    for inner_suite in module_suite._tests:
+                        for test in inner_suite._tests:
+                            if pattern.match(test.id()):
+                                suite.addTest(test)
+                else:
+                    suite.addTests(module_suite)
+                return suite
+            except AssertionError:
+                pass
+        else:
+            raise TestError('Path should be defined.')
+
+        # We don't use the dirs variable, so ignore the warning
+        # pylint: disable=W0612
+        for root, dirs, files in os.walk(path):
+            for test in files:
+                filepath = os.path.join(root, test)
+                if test.endswith(".py") and test not in ignored_modules and \
+                        not _is_in_ignored_path(filepath, ignored_paths):
+                    self.source_files.append(filepath)
+                    if test.startswith("test_"):
+                        module_suite = self._load_unittest(filepath)
+                        if pattern:
+                            for inner_suite in module_suite._tests:
+                                for test in inner_suite._tests:
+                                    if pattern.match(test.id()):
+                                        suite.addTest(test)
+                        else:
+                            suite.addTests(module_suite)
+        return suite
+
+    def get_suite(self, config):
+        """Get the test suite to use."""
+        suite = unittest.TestSuite()
+        for path in config['tests']:
+            suite.addTest(self._collect_tests(path, config['test'],
+                                              config['ignore-modules'],
+                                              config['ignore-paths']))
+        if config['loop']:
+            old_suite = suite
+            suite = unittest.TestSuite()
+            for _ in range(config['loop']):
+                suite.addTest(old_suite)
+
+        return suite
+
+    def run_tests(self, suite):
+        """Run the test suite."""
+        return False
+
+
+class BaseTestOptions(OptionParser):
+    """Base options for our test runner."""
+
+    optFlags = [['coverage', 'c', 'Generate a coverage report for the tests.'],
+                ['gui', None, 'Use the GUI mode of some runners.'],
+                ['help', 'h', ''],
+                ['help-runners', None, 'List information about test runners.'],
+                ]
+
+    optParameters = [['test', 't', None, None],
+                     ['loop', None, 1, None],
+                     ['ignore-modules', 'i', '', None],
+                     ['ignore-paths', 'p', '', None],
+                     ['runner', None, 'txrunner', None],
+                     ['temp-directory', None, b'_trial_temp', None],
+                     ]
+
+    def __init__(self, *args, **kwargs):
+        super(BaseTestOptions, self).__init__(*args, **kwargs)
+
+    def opt_help_runners(self):
+        """List the runners which are supported."""
+        sys.exit(0)
+
+    def opt_ignore_modules(self, option):
+        """Comma-separate list of test modules to ignore,
+           e.g: test_gtk.py, test_account.py
+           """
+        self['ignore-modules'] = list(map(text_type.strip, option.split(',')))
+
+    def opt_ignore_paths(self, option):
+        """Comma-separated list of relative paths to ignore,
+           e.g: tests/platform/windows, tests/platform/macosx
+           """
+        self['ignore-paths'] = list(map(text_type.strip, option.split(',')))
+
+    def opt_loop(self, option):
+        """Loop tests the specified number of times."""
+        try:
+            self['loop'] = int(option)
+        except ValueError:
+            raise UsageError('A positive integer value must be specified.')
+
+    def opt_temp_directory(self, option):
+        """Path to use as a working directory for tests.
+           [default: _trial_temp]
+           """
+        self['temp-directory'] = option
+
+    def opt_test(self, option):
+        """Run specific tests, e.g: className.methodName"""
+        self['test'] = option
+
+    # We use some camelcase names for trial compatibility here.
+    def parseArgs(self, *args):
+        """Handle the extra arguments."""
+        if isinstance(self.tests, set):
+            self['tests'].update(args)
+        elif isinstance(self.tests, list):
+            self['tests'].extend(args)
+
+
+def _get_runner_options(runner_name):
+    """Return the test runner module, and its options object."""
+    module_name = 'ubuntuone.devtools.runners.%s' % runner_name
+    runner = __import__(module_name, None, None, [''])
+    options = None
+    if getattr(runner, 'TestOptions', None) is not None:
+        options = runner.TestOptions()
+    if options is None:
+        options = BaseTestOptions()
+    return (runner, options)
+
+
+def main():
+    """Do the deed."""
+    if len(sys.argv) == 1:
+        sys.argv.append('--help')
+
+    try:
+        pos = sys.argv.index('--runner')
+        runner_name = sys.argv.pop(pos + 1)
+        sys.argv.pop(pos)
+    except ValueError:
+        runner_name = 'txrunner'
+    finally:
+        runner, options = _get_runner_options(runner_name)
+        options.parseOptions()
+
+    test_runner = runner.TestRunner(options=options)
+    suite = test_runner.get_suite(options)
+
+    if options['coverage']:
+        coverage.erase()
+        coverage.start()
+
+    running_services = []
+
+    succeeded = False
+    try:
+        # Start any required services
+        for service_obj in test_runner.required_services:
+            service = service_obj()
+            service.start_service(tempdir=test_runner.tempdir)
+            running_services.append(service)
+
+        succeeded = test_runner.run_tests(suite)
+    finally:
+        # Stop all the running services
+        for service in running_services:
+            service.stop_service()
+
+    if options['coverage']:
+        coverage.stop()
+        coverage.report(test_runner.source_files, ignore_errors=True,
+                        show_missing=False)
+
+    sys.exit(not succeeded)
 
=== added file 'ubuntuone/devtools/runners/txrunner.py'
--- ubuntuone/devtools/runners/txrunner.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/runners/txrunner.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,133 @@
+# 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.
+"""The twisted test runner and options."""
+
+from __future__ import print_function, unicode_literals
+
+import sys
+
+from twisted.scripts import trial
+from twisted.trial.runner import TrialRunner
+
+from ubuntuone.devtools.errors import TestError
+from ubuntuone.devtools.runners import BaseTestOptions, BaseTestRunner
+
+__all__ = ['TestRunner', 'TestOptions']
+
+
+class TestRunner(BaseTestRunner, TrialRunner):
+    """The twisted test runner implementation."""
+
+    def __init__(self, options=None):
+        # Handle running trial in debug or dry-run mode
+        self.config = options
+
+        try:
+            reactor_name = ('ubuntuone.devtools.reactors.%s' %
+                            self.config['reactor'])
+            reactor = __import__(reactor_name, None, None, [''])
+        except ImportError:
+            raise TestError('The specified reactor is not supported.')
+        else:
+            try:
+                reactor.install(options=self.config)
+            except ImportError:
+                raise TestError(
+                    'The Python package providing the requested reactor is '
+                    'not installed. You can find it here: %s' %
+                    reactor.REACTOR_URL)
+
+        mode = None
+        if self.config['debug']:
+            mode = TrialRunner.DEBUG
+        if self.config['dry-run']:
+            mode = TrialRunner.DRY_RUN
+
+        # Hook up to the parent test runner
+        super(TestRunner, self).__init__(
+            options=options,
+            reporterFactory=self.config['reporter'],
+            mode=mode,
+            profile=self.config['profile'],
+            logfile=self.config['logfile'],
+            tracebackFormat=self.config['tbformat'],
+            realTimeErrors=self.config['rterrors'],
+            uncleanWarnings=self.config['unclean-warnings'],
+            forceGarbageCollection=self.config['force-gc'])
+        # Named for trial compatibility.
+        # pylint: disable=C0103
+        self.workingDirectory = self.working_dir
+        # pylint: enable=C0103
+
+    def run_tests(self, suite):
+        """Run the twisted test suite."""
+        if self.config['until-failure']:
+            result = self.runUntilFailure(suite)
+        else:
+            result = self.run(suite)
+        return result.wasSuccessful()
+
+
+def _get_default_reactor():
+    """Return the platform-dependent default reactor to use."""
+    default_reactor = 'gi'
+    if sys.platform in ['darwin', 'win32']:
+        default_reactor = 'twisted'
+    return default_reactor
+
+
+class TestOptions(trial.Options, BaseTestOptions):
+    """Class for twisted options handling."""
+
+    optFlags = [["help-reactors", None],
+                ]
+
+    optParameters = [["reactor", "r", _get_default_reactor()],
+                     ]
+
+    def __init__(self, *args, **kwargs):
+        super(TestOptions, self).__init__(*args, **kwargs)
+        self['rterrors'] = True
+
+    def opt_coverage(self, option):
+        """Handle special flags."""
+        self['coverage'] = True
+    opt_c = opt_coverage
+
+    def opt_help_reactors(self):
+        """Help on available reactors for use with tests"""
+        synopsis = ('')
+        print(synopsis)
+        print('Need to get list of reactors and print them here.\n')
+        sys.exit(0)
+
+    def opt_reactor(self, option):
+        """Which reactor to use (see --help-reactors for a list
+           of possibilities)
+           """
+        self['reactor'] = option
+    opt_r = opt_reactor
 
=== added directory 'ubuntuone/devtools/services'
=== added file 'ubuntuone/devtools/services/__init__.py'
--- ubuntuone/devtools/services/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/services/__init__.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,66 @@
+#
+# Copyright 2011-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.
+"""Service runners for testing."""
+
+import os
+import socket
+
+from dirspec.basedir import load_data_paths
+
+
+def find_config_file(in_config_file):
+    """Find the first appropriate conf to use."""
+    # In case we're running from within the source tree
+    path = os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                        os.path.pardir, os.path.pardir,
+                                        os.path.pardir,
+                                        "data", in_config_file))
+    if not os.path.exists(path):
+        # Use the installed file in $pkgdatadir as source
+        for path in load_data_paths("ubuntuone-dev-tools", in_config_file):
+            if os.path.exists(path):
+                break
+
+    # Check to make sure we didn't just fall out of the loop
+    if not os.path.exists(path):
+        raise IOError('Could not locate suitable %s' % in_config_file)
+    return path
+
+
+def get_arbitrary_port():
+    """
+    Find an unused port, and return it.
+
+    There might be a small race condition here, but we aren't
+    worried about it.
+    """
+    sock = socket.socket()
+    sock.bind(('localhost', 0))
+    _, port = sock.getsockname()
+    sock.close()
+    return port
 
=== added file 'ubuntuone/devtools/services/dbus.py'
--- ubuntuone/devtools/services/dbus.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/services/dbus.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,121 @@
+#
+# Author: Guillermo Gonzalez <[e-mail]>
+#
+# 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.
+"""Utilities for finding and running a dbus session bus for testing."""
+
+from __future__ import unicode_literals
+
+import os
+import signal
+import subprocess
+
+from distutils.spawn import find_executable
+
+# pylint: disable=F0401,E0611
+try:
+    from urllib.parse import quote
+except ImportError:
+    from urllib import quote
+# pylint: enable=F0401,E0611
+
+from ubuntuone.devtools.services import find_config_file
+DBUS_CONFIG_FILE = 'dbus-session.conf.in'
+
+
+class DBusLaunchError(Exception):
+    """Error while launching dbus-daemon"""
+    pass
+
+
+class NotFoundError(Exception):
+    """Not found error"""
+    pass
+
+
+class DBusRunner(object):
+    """Class for running dbus-daemon with a private session."""
+
+    def __init__(self):
+        self.dbus_address = None
+        self.dbus_pid = None
+        self.running = False
+        self.config_file = None
+
+    def _generate_config_file(self, tempdir=None):
+        """Find the first appropriate dbus-session.conf to use."""
+        # load the config file
+        path = find_config_file(DBUS_CONFIG_FILE)
+        # replace config settings
+        self.config_file = os.path.join(tempdir, 'dbus-session.conf')
+        dbus_address = 'unix:tmpdir=%s' % quote(tempdir)
+        with open(path) as in_file:
+            content = in_file.read()
+            with open(self.config_file, 'w') as out_file:
+                out_file.write(content.replace('@ADDRESS@', dbus_address))
+
+    def start_service(self, tempdir=None):
+        """Start our own session bus daemon for testing."""
+        dbus = find_executable("dbus-daemon")
+        if not dbus:
+            raise NotFoundError("dbus-daemon was not found.")
+
+        self._generate_config_file(tempdir)
+
+        dbus_args = ["--fork",
+                     "--config-file=" + self.config_file,
+                     "--print-address=1",
+                     "--print-pid=2"]
+        sp = subprocess.Popen([dbus] + dbus_args,
+                              bufsize=4096, stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE)
+
+        # Call wait here as under the qt4 reactor we get an error about
+        # interrupted system call if we don't.
+        sp.wait()
+        self.dbus_address = b"".join(sp.stdout.readlines()).strip()
+        self.dbus_pid = int(b"".join(sp.stderr.readlines()).strip())
+
+        if self.dbus_address != "":
+            os.environ["DBUS_SESSION_BUS_ADDRESS"] = \
+                self.dbus_address.decode("utf8")
+        else:
+            os.kill(self.dbus_pid, signal.SIGKILL)
+            raise DBusLaunchError("There was a problem launching dbus-daemon.")
+        self.running = True
+
+    def stop_service(self):
+        """Stop our DBus session bus daemon."""
+        try:
+            del os.environ["DBUS_SESSION_BUS_ADDRESS"]
+        except KeyError:
+            pass
+        os.kill(self.dbus_pid, signal.SIGKILL)
+        self.running = False
+        os.unlink(self.config_file)
+        self.config_file = None
 
=== added directory 'ubuntuone/devtools/testcases'
=== added file 'ubuntuone/devtools/testcases/__init__.py'
--- ubuntuone/devtools/testcases/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testcases/__init__.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+#
+# 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.
+"""Base tests cases and test utilities."""
+
+from __future__ import with_statement
+
+import contextlib
+import os
+import shutil
+import sys
+
+from functools import wraps
+
+from twisted.trial.unittest import TestCase, SkipTest
+
+
[e-mail]
+def environ(env_var, new_value):
+    """context manager to replace/add an environ value"""
+    old_value = os.environ.get(env_var, None)
+    os.environ[env_var] = new_value
+    yield
+    if old_value is None:
+        os.environ.pop(env_var)
+    else:
+        os.environ[env_var] = old_value
+
+
+def _id(obj):
+    """Return the obj calling the funct."""
+    return obj
+
+
+# pylint: disable=C0103
+def skipTest(reason):
+    """Unconditionally skip a test."""
+
+    def decorator(test_item):
+        """Decorate the test so that it is skipped."""
+        if not (isinstance(test_item, type) and
+                issubclass(test_item, TestCase)):
+
+            @wraps(test_item)
+            def skip_wrapper(*args, **kwargs):
+                """Skip a test method raising an exception."""
+                raise SkipTest(reason)
+            test_item = skip_wrapper
+
+        # tell twisted.trial.unittest to skip the test, pylint will complain
+        # since it thinks we are redefining a name out of the scope
+        # pylint: disable=W0621,W0612
+        test_item.skip = reason
+        # pylint: enable=W0621,W0612
+        # because the item was skipped, we will make sure that no
+        # services are started for it
+        if hasattr(test_item, "required_services"):
+            # pylint: disable=W0612
+            test_item.required_services = lambda *args, **kwargs: []
+            # pylint: enable=W0612
+        return test_item
+    return decorator
+
+
+def skipIf(condition, reason):
+    """Skip a test if the condition is true."""
+    if condition:
+        return skipTest(reason)
+    return _id
+
+
+def skipIfOS(current_os, reason):
+    """Skip test for a particular os or lists of them."""
+    if os:
+        if sys.platform in current_os or sys.platform == current_os:
+            return skipTest(reason)
+        return _id
+    return _id
+
+
+def skipIfNotOS(current_os, reason):
+    """Skip test we are not in a particular os."""
+    if os:
+        if sys.platform not in current_os or \
+                sys.platform != current_os:
+            return skipTest(reason)
+        return _id
+    return _id
+
+
+def skipIfJenkins(current_os, reason):
+    """Skip test for a particular os or lists of them
+       when running on Jenkins."""
+    if os.getenv("JENKINS", False) and (sys.platform in current_os or
+                                        sys.platform == current_os):
+        return skipTest(reason)
+    return _id
+
+
+# pylint: enable=C0103
+
+
+class BaseTestCase(TestCase):
+    """Base TestCase with helper methods to handle temp dir.
+
+    This class provides:
+        mktemp(name): helper to create temporary dirs
+        rmtree(path): support read-only shares
+        makedirs(path): support read-only shares
+
+    """
+
+    def required_services(self):
+        """Return the list of required services for DBusTestCase."""
+        return []
+
+    def mktemp(self, name='temp'):
+        """Customized mktemp that accepts an optional name argument."""
+        tempdir = os.path.join(self.tmpdir, name)
+        if os.path.exists(tempdir):
+            self.rmtree(tempdir)
+        self.makedirs(tempdir)
+        return tempdir
+
+    @property
+    def tmpdir(self):
+        """Default tmpdir: module/class/test_method."""
+        # check if we already generated the root path
+        root_dir = getattr(self, '__root', None)
+        if root_dir:
+            return root_dir
+        max_filename = 32  # some platforms limit lengths of filenames
+        base = os.path.join(self.__class__.__module__[:max_filename],
+                            self.__class__.__name__[:max_filename],
+                            self._testMethodName[:max_filename])
+        # use _trial_temp dir, it should be os.gwtcwd()
+        # define the root temp dir of the testcase, pylint: disable=W0201
+        self.__root = os.path.join(os.getcwd(), base)
+        return self.__root
+
+    def rmtree(self, path):
+        """Custom rmtree that handle ro parent(s) and childs."""
+        if not os.path.exists(path):
+            return
+        # change perms to rw, so we can delete the temp dir
+        if path != getattr(self, '__root', None):
+            os.chmod(os.path.dirname(path), 0o755)
+        if not os.access(path, os.W_OK):
+            os.chmod(path, 0o755)
+        # pylint: disable=W0612
+        for dirpath, dirs, files in os.walk(path):
+            for dirname in dirs:
+                if not os.access(os.path.join(dirpath, dirname), os.W_OK):
+                    os.chmod(os.path.join(dirpath, dirname), 0o777)
+        shutil.rmtree(path)
+
+    def makedirs(self, path):
+        """Custom makedirs that handle ro parent."""
+        parent = os.path.dirname(path)
+        if os.path.exists(parent):
+            os.chmod(parent, 0o755)
+        os.makedirs(path)
 
=== added file 'ubuntuone/devtools/testcases/dbus.py'
--- ubuntuone/devtools/testcases/dbus.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testcases/dbus.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+#
+# 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.
+"""Base dbus tests cases and test utilities."""
+
+from __future__ import absolute_import, with_statement
+
+import os
+
+from twisted.internet import defer
+
+from ubuntuone.devtools.testcases import BaseTestCase, skipIf
+
+# DBusRunner for DBusTestCase using tests
+from ubuntuone.devtools.services.dbus import DBusRunner
+
+
+# pylint: disable=F0401,C0103,W0406,E0611
+try:
+    import dbus
+except ImportError as e:
+    dbus = None
+
+try:
+    import dbus.service as service
+except ImportError:
+    service = None
+
+try:
+    from dbus.mainloop.glib import DBusGMainLoop
+except ImportError:
+    DBusGMainLoop = None
+
+# pylint: enable=F0401,C0103,W0406,E0611
+
+
+class InvalidSessionBus(Exception):
+    """Error when we are connected to the wrong session bus in tests."""
+
+
+class FakeDBusInterface(object):
+    """A fake DBusInterface..."""
+
+    def shutdown(self, with_restart=False):
+        """...that only knows how to go away"""
+
+
+@skipIf(dbus is None or service is None or DBusGMainLoop is None,
+        "The test requires dbus.")
+class DBusTestCase(BaseTestCase):
+    """Test the DBus event handling."""
+
+    def required_services(self):
+        """Return the list of required services for DBusTestCase."""
+        services = super(DBusTestCase, self).required_services()
+        services.extend([DBusRunner])
+        return services
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup the infrastructure fo the test (dbus service)."""
+        # Class 'BaseTestCase' has no 'setUp' member
+        # pylint: disable=E1101
+        # dbus modules will be imported by the decorator
+        # pylint: disable=E0602
+        yield super(DBusTestCase, self).setUp()
+
+        # We need to ensure DBUS_SESSION_BUS_ADDRESS is private here
+        # pylint: disable=F0401,E0611
+        try:
+            from urllib.parse import unquote
+        except ImportError:
+            from urllib import unquote
+        # pylint: enable=F0401,E0611
+
+        bus_address = os.environ.get('DBUS_SESSION_BUS_ADDRESS', None)
+        if os.path.dirname(unquote(bus_address.split(',')[0].split('=')[1])) \
+                != os.path.dirname(os.getcwd()):
+            raise InvalidSessionBus('DBUS_SESSION_BUS_ADDRESS is wrong.')
+
+        # Set up the main loop and bus connection
+        self.loop = DBusGMainLoop(set_as_default=True)
+
+        # NOTE: The address_or_type value must remain explicitly as
+        # str instead of anything from ubuntuone.devtools.compat. dbus
+        # expects this to be str regardless of version.
+        self.bus = dbus.bus.BusConnection(address_or_type=str(bus_address),
+                                          mainloop=self.loop)
+
+        # Monkeypatch the dbus.SessionBus/SystemBus methods, to ensure we
+        # always point at our own private bus instance.
+        self.patch(dbus, 'SessionBus', lambda: self.bus)
+        self.patch(dbus, 'SystemBus', lambda: self.bus)
+
+        # Check that we are on the correct bus for real
+# Disable this for now, because our tests are extremely broken :(
+#        bus_names = self.bus.list_names()
+#        if len(bus_names) > 2:
+#            raise InvalidSessionBus('Too many bus connections: %s (%r)' %
+#                                    (len(bus_names), bus_names))
+
+        # monkeypatch busName.__del__ to avoid errors on gc
+        # we take care of releasing the name in shutdown
+        service.BusName.__del__ = lambda _: None
+        yield self.bus.set_exit_on_disconnect(False)
+        self.signal_receivers = set()
+
+    @defer.inlineCallbacks
+    def tearDown(self):
+        """Cleanup the test."""
+        yield self.bus.flush()
+        yield self.bus.close()
+        yield super(DBusTestCase, self).tearDown()
 
=== added file 'ubuntuone/devtools/testcases/txsocketserver.py'
--- ubuntuone/devtools/testcases/txsocketserver.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testcases/txsocketserver.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,357 @@
+# -*- 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.
+
+"""Base test case for twisted servers."""
+
+import os
+import shutil
+import tempfile
+
+from twisted.internet import defer, endpoints, protocol
+from twisted.spread import pb
+
+from ubuntuone.devtools.testcases import BaseTestCase
+
+# no init method + twisted common warnings
+# pylint: disable=W0232, C0103, E1101
+
+
+def server_protocol_factory(cls):
+    """Factory to create tidy protocols."""
+
+    if cls is None:
+        cls = protocol.Protocol
+
+    class ServerTidyProtocol(cls):
+        """A tidy protocol."""
+
+        def connectionLost(self, *args):
+            """Lost the connection."""
+            cls.connectionLost(self, *args)
+            # lets tell everyone
+            # pylint: disable=W0212
+            if (self.factory._disconnecting and
+                    self.factory.testserver_on_connection_lost is not None and
+                    not self.factory.testserver_on_connection_lost.called):
+                self.factory.testserver_on_connection_lost.callback(self)
+            # pylint: enable=W0212
+
+    return ServerTidyProtocol
+
+
+def server_factory_factory(cls):
+    """Factory that creates special types of factories for tests."""
+
+    if cls is None:
+        cls = protocol.ServerFactory
+
+    class TidyServerFactory(cls):
+        """A tidy factory."""
+
+        testserver_on_connection_lost = None
+
+        def buildProtocol(self, addr):
+            prot = cls.buildProtocol(self, addr)
+            self.testserver_on_connection_lost = defer.Deferred()
+            return prot
+
+    return TidyServerFactory
+
+
+def client_protocol_factory(cls):
+    """Factory to create tidy protocols."""
+
+    if cls is None:
+        cls = protocol.Protocol
+
+    class ClientTidyProtocol(cls):
+        """A tidy protocol."""
+
+        def connectionLost(self, *a):
+            """Connection list."""
+            cls.connectionLost(self, *a)
+            # pylint: disable=W0212
+            if (self.factory._disconnecting and
+                    self.factory.testserver_on_connection_lost is not None and
+                    not self.factory.testserver_on_connection_lost.called):
+                self.factory.testserver_on_connection_lost.callback(self)
+            # pylint: enable=W0212
+
+    return ClientTidyProtocol
+
+
+class TidySocketServer(object):
+    """Ensure that twisted servers are correctly managed in tests.
+
+    Closing a twisted server is a complicated matter. In order to do so you
+    have to ensure that three different deferreds are fired:
+
+        1. The server must stop listening.
+        2. The client connection must disconnect.
+        3. The server connection must disconnect.
+
+    This class allows to create a server and a client that will ensure that
+    the reactor is left clean by following the pattern described at
+    http://mumak.net/stuff/twisted-disconnect.html
+    """
+    def __init__(self):
+        """Create a new instance."""
+        self.listener = None
+        self.server_factory = None
+
+        self.connector = None
+        self.client_factory = None
+
+    def get_server_endpoint(self):
+        """Return the server endpoint description."""
+        raise NotImplementedError('To be implemented by child classes.')
+
+    def get_client_endpoint(self):
+        """Return the client endpoint description."""
+        raise NotImplementedError('To be implemented by child classes.')
+
+    @defer.inlineCallbacks
+    def listen_server(self, server_class, *args, **kwargs):
+        """Start a server in a random port."""
+        from twisted.internet import reactor
+        tidy_class = server_factory_factory(server_class)
+        self.server_factory = tidy_class(*args, **kwargs)
+        self.server_factory._disconnecting = False
+        self.server_factory.protocol = server_protocol_factory(
+            self.server_factory.protocol)
+        endpoint = endpoints.serverFromString(reactor,
+                                              self.get_server_endpoint())
+        self.listener = yield endpoint.listen(self.server_factory)
+        defer.returnValue(self.server_factory)
+
+    @defer.inlineCallbacks
+    def connect_client(self, client_class, *args, **kwargs):
+        """Conect a client to a given server."""
+        from twisted.internet import reactor
+
+        if self.server_factory is None:
+            raise ValueError('Server Factory was not provided.')
+        if self.listener is None:
+            raise ValueError('%s has not started listening.',
+                             self.server_factory)
+
+        self.client_factory = client_class(*args, **kwargs)
+        self.client_factory._disconnecting = False
+        self.client_factory.protocol = client_protocol_factory(
+            self.client_factory.protocol)
+        self.client_factory.testserver_on_connection_lost = defer.Deferred()
+        endpoint = endpoints.clientFromString(reactor,
+                                              self.get_client_endpoint())
+        self.connector = yield endpoint.connect(self.client_factory)
+        defer.returnValue(self.client_factory)
+
+    def clean_up(self):
+        """Action to be performed for clean up."""
+        if self.server_factory is None or self.listener is None:
+            # nothing to clean
+            return defer.succeed(None)
+
+        if self.listener and self.connector:
+            # clean client and server
+            self.server_factory._disconnecting = True
+            self.client_factory._disconnecting = True
+            d = defer.maybeDeferred(self.listener.stopListening)
+            self.connector.transport.loseConnection()
+            if self.server_factory.testserver_on_connection_lost:
+                return defer.gatherResults(
+                    [d,
+                     self.client_factory.testserver_on_connection_lost,
+                     self.server_factory.testserver_on_connection_lost])
+            else:
+                return defer.gatherResults(
+                    [d,
+                     self.client_factory.testserver_on_connection_lost])
+        if self.listener:
+            # just clean the server since there is no client
+            # pylint: disable=W0201
+            self.server_factory._disconnecting = True
+            return defer.maybeDeferred(self.listener.stopListening)
+            # pylint: enable=W0201
+
+
+class TidyTCPServer(TidySocketServer):
+    """A tidy tcp domain sockets server."""
+
+    client_endpoint_pattern = 'tcp:host=127.0.0.1:port=%s'
+    server_endpoint_pattern = 'tcp:0:interface=127.0.0.1'
+
+    def get_server_endpoint(self):
+        """Return the server endpoint description."""
+        return self.server_endpoint_pattern
+
+    def get_client_endpoint(self):
+        """Return the client endpoint description."""
+        if self.server_factory is None:
+            raise ValueError('Server Factory was not provided.')
+        if self.listener is None:
+            raise ValueError('%s has not started listening.',
+                             self.server_factory)
+        return self.client_endpoint_pattern % self.listener.getHost().port
+
+
+class TidyUnixServer(TidySocketServer):
+    """A tidy unix domain sockets server."""
+
+    client_endpoint_pattern = 'unix:path=%s'
+    server_endpoint_pattern = 'unix:%s'
+
+    def __init__(self):
+        """Create a new instance."""
+        super(TidyUnixServer, self).__init__()
+        self.temp_dir = tempfile.mkdtemp()
+        self.path = os.path.join(self.temp_dir, 'tidy_unix_server')
+
+    def get_server_endpoint(self):
+        """Return the server endpoint description."""
+        return self.server_endpoint_pattern % self.path
+
+    def get_client_endpoint(self):
+        """Return the client endpoint description."""
+        return self.client_endpoint_pattern % self.path
+
+    def clean_up(self):
+        """Action to be performed for clean up."""
+        result = super(TidyUnixServer, self).clean_up()
+        # remove the dir once we are disconnected
+        result.addCallback(lambda _: shutil.rmtree(self.temp_dir))
+        return result
+
+
+class ServerTestCase(BaseTestCase):
+    """Base test case for tidy servers."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the diff tests."""
+        yield super(ServerTestCase, self).setUp()
+
+        try:
+            self.server_runner = self.get_server()
+        except NotImplementedError:
+            self.server_runner = None
+
+        self.server_factory = None
+        self.client_factory = None
+        self.server_disconnected = None
+        self.client_connected = None
+        self.client_disconnected = None
+        self.listener = None
+        self.connector = None
+        self.addCleanup(self.tear_down_server_client)
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        raise NotImplementedError('To be implemented by child classes.')
+
+    @defer.inlineCallbacks
+    def listen_server(self, server_class, *args, **kwargs):
+        """Listen a server.
+
+        The method takes the server class and the arguments that should be
+        passed to the server constructor.
+        """
+        self.server_factory = yield self.server_runner.listen_server(
+            server_class, *args, **kwargs)
+        self.server_disconnected = \
+            self.server_factory.testserver_on_connection_lost
+        self.listener = self.server_runner.listener
+
+    @defer.inlineCallbacks
+    def connect_client(self, client_class, *args, **kwargs):
+        """Connect the client.
+
+        The method takes the client factory  class and the arguments that
+        should be passed to the client constructor.
+        """
+        self.client_factory = yield self.server_runner.connect_client(
+            client_class, *args, **kwargs)
+        self.client_disconnected = \
+            self.client_factory.testserver_on_connection_lost
+        self.connector = self.server_runner.connector
+
+    def tear_down_server_client(self):
+        """Clean the server and client."""
+        if self.server_runner:
+            return self.server_runner.clean_up()
+
+
+class TCPServerTestCase(ServerTestCase):
+    """Test that uses a single twisted server."""
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        return TidyTCPServer()
+
+
+class UnixServerTestCase(ServerTestCase):
+    """Test that uses a single twisted server."""
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        return TidyUnixServer()
+
+
+class PbServerTestCase(ServerTestCase):
+    """Test a pb server."""
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        raise NotImplementedError('To be implemented by child classes.')
+
+    @defer.inlineCallbacks
+    def listen_server(self, *args, **kwargs):
+        """Listen a pb server."""
+        yield super(PbServerTestCase, self).listen_server(pb.PBServerFactory,
+                                                          *args, **kwargs)
+
+    @defer.inlineCallbacks
+    def connect_client(self, *args, **kwargs):
+        """Connect a pb client."""
+        yield super(PbServerTestCase, self).connect_client(pb.PBClientFactory,
+                                                           *args, **kwargs)
+
+
+class TCPPbServerTestCase(PbServerTestCase):
+    """Test a pb server over TCP."""
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        return TidyTCPServer()
+
+
+class UnixPbServerTestCase(PbServerTestCase):
+    """Test a pb server over Unix domain sockets."""
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        return TidyUnixServer()
 
=== added directory 'ubuntuone/devtools/testing'
=== added file 'ubuntuone/devtools/testing/__init__.py'
--- ubuntuone/devtools/testing/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testing/__init__.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,1 @@
+"""Testing helpers."""
 
=== added file 'ubuntuone/devtools/testing/txcheck.py'
--- ubuntuone/devtools/testing/txcheck.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testing/txcheck.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,381 @@
+# -*- coding: utf-8 -*-
+
+# Author: Tim Cole <[e-mail]>
+#
+# Copyright 2011-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.
+"""Utilities for performing correctness checks."""
+
+import sys
+import ast
+from inspect import getsource
+from textwrap import dedent
+from itertools import takewhile
+from unittest import TestCase, TestSuite, TestResult
+
+from twisted.trial.unittest import TestCase as TwistedTestCase
+
+
+def type_to_name(type_obj):
+    """Return a name for a type."""
+    package_name = getattr(type_obj, '__module__', None)
+    if package_name:
+        return "%s.%s" % (package_name, type_obj.__name__)
+    else:
+        return type_obj.__name__
+
+
+class Problem(AssertionError):
+    """An object representing a problem in a method."""
+
+    def __init__(self, method, test_class, ancestor_class):
+        """Initialize an instance."""
+        super(Problem, self).__init__()
+        self.method = method
+        self.test_class = test_class
+        self.ancestor_class = ancestor_class
+
+    def __eq__(self, other):
+        """Test equality."""
+        return type(self) == type(other) and self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        """Test inequality."""
+        return not (self == other)
+
+    def __hash__(self):
+        """Return hash."""
+        member_hash = 0
+        for (key, value) in self.__dict__.items():
+            member_hash ^= hash(key) ^ hash(value)
+        return hash(type(self)) ^ member_hash
+
+    def __str__(self):
+        """Return a friendlier representation."""
+        if self.ancestor_class != self.test_class:
+            method_string = ("%s in ancestor method %s.%s" %
+                             (type_to_name(self.test_class),
+                              type_to_name(self.ancestor_class),
+                              self.method))
+        else:
+            method_string = ("%s.%s" %
+                             (type_to_name(self.test_class), self.method))
+        return ("%s for %s" % (type(self).__name__, method_string))
+
+    def __repr__(self):
+        """Return representation string."""
+        return "<%s %r>" % (type(self), self.__dict__)
+
+
+class MethodShadowed(Problem):
+    """Problem when trial's run method is shadowed."""
+
+
+class SuperResultDiscarded(Problem):
+    """Problem when callback chains are broken."""
+
+
+class SuperNotCalled(Problem):
+    """Problem when super isn't called."""
+
+
+class MissingInlineCallbacks(Problem):
+    """Problem when the inlineCallbacks decorator is missing."""
+
+
+class MissingReturnValue(Problem):
+    """Problem when there's no return value."""
+
+
+def match_type(expected_type):
+    """Return predicate matching nodes of given type."""
+    return lambda node: isinstance(node, expected_type)
+
+
+def match_equal(expected_value):
+    """Return predicate matching nodes equaling the given value."""
+    return lambda node: expected_value == node
+
+
+def match_in(expected_values):
+    """Return predicate matching node if in collection of expected values."""
+    return lambda node: node in expected_values
+
+
+def match_not_none():
+    """Returns a predicate matching nodes which are not None."""
+    return lambda node: node is not None
+
+
+def match_any(*subtests):
+    """Return short-circuiting predicate matching any given subpredicate."""
+    if len(subtests) == 1:
+        return subtests[0]
+    else:
+
+        def test(node):
+            """Try each subtest until we find one that passes."""
+            for subtest in subtests:
+                if subtest(node):
+                    return True
+            return False
+
+        return test
+
+
+def match_all(*subtests):
+    """Return short-circuiting predicate matching all given subpredicates."""
+    if len(subtests) == 1:
+        return subtests[0]
+    else:
+
+        def test(node):
+            """Try each subtest until we find one that fails."""
+            for subtest in subtests:
+                if not subtest(node):
+                    return False
+            return True
+
+        return test
+
+
+def match_attr(attr_name, *tests):
+    """Return predicate matching subpredicates against an attribute value."""
+    return lambda node: match_all(*tests)(getattr(node, attr_name))
+
+
+def match_path(initial_test, *components):
+    """Return predicate which recurses into the tree via given attributes."""
+    components = list(components)
+    components.reverse()
+
+    def test(node):
+        return True
+
+    for component in components:
+        attr_name = component[0]
+        subtests = component[1:]
+        test = match_attr(attr_name, match_all(match_all(*subtests), test))
+    return match_all(initial_test, test)
+
+
+def match_child(*tests):
+    """Return predicate which tests any child."""
+    subtest = match_all(*tests)
+
+    def test(node):
+        """Try each child until we find one that matches."""
+        for child in ast.iter_child_nodes(node):
+            if subtest(child):
+                return True
+        return False
+
+    return test
+
+
+def match_descendant(subtest, prune):
+    """Return predicate which tests a node and any descendants."""
+
+    def test(node):
+        """Recursively (breadth-first) search for a matching node."""
+        for child in ast.iter_child_nodes(node):
+            if prune(child):
+                continue
+            if subtest(child) or test(child):
+                return True
+        return False
+
+    return test
+
+
+def matches(node, *tests):
+    """Convenience function to try predicates on a node."""
+    return match_all(*tests)(node)
+
+
+def any_matches(nodes, *tests):
+    """Convenience function to try predicates on any of a sequence of nodes."""
+    test = match_all(*tests)
+    for node in nodes:
+        if test(node):
+            return True
+    return False
+
+
+def iter_matching_child_nodes(node, *tests):
+    """Yields every matching child node."""
+    test = match_all(*tests)
+    for child in ast.iter_child_nodes(node):
+        if test(child):
+            yield child
+
+
+SETUP_FUNCTION_NAMES = ('setUp', 'tearDown')
+SETUP_FUNCTION = match_path(match_type(ast.FunctionDef),
+                            ('name', match_in(SETUP_FUNCTION_NAMES)))
+
+SUPER = match_path(match_type(ast.Call),
+                   ('func', match_type(ast.Attribute)),
+                   ('value', match_type(ast.Call)),
+                   ('func', match_type(ast.Name)),
+                   ('id', match_equal("super")))
+
+BARE_SUPER = match_path(match_type(ast.Expr),
+                        ('value', SUPER))
+
+YIELD = match_type(ast.Yield)
+
+INLINE_CALLBACKS_DECORATOR = \
+    match_any(match_path(match_type(ast.Attribute),
+                         ('attr', match_equal('inlineCallbacks'))),
+              match_path(match_type(ast.Name),
+                         ('id', match_equal('inlineCallbacks'))))
+
+RETURN_VALUE = \
+    match_path(match_type(ast.Return),
+               ('value', match_not_none()))
+
+DEFS = match_any(match_type(ast.ClassDef),
+                 match_type(ast.FunctionDef))
+
+
+def find_problems(class_to_check):
+    """Check twisted test setup in a given test class."""
+    mro = class_to_check.__mro__
+    if TwistedTestCase not in mro:
+        return set()
+
+    problems = set()
+
+    ancestry = takewhile(lambda c: c != TwistedTestCase, mro)
+    for ancestor_class in ancestry:
+        if 'run' in ancestor_class.__dict__:
+            problem = MethodShadowed(method='run',
+                                     test_class=class_to_check,
+                                     ancestor_class=ancestor_class)
+            problems.add(problem)
+
+        source = dedent(getsource(ancestor_class))
+        tree = ast.parse(source)
+        # the top level of the tree is a Module
+        class_node = tree.body[0]
+
+        # Check setUp/tearDown
+        for def_node in iter_matching_child_nodes(class_node, SETUP_FUNCTION):
+            if matches(def_node, match_child(BARE_SUPER)):
+                # Superclass method called, but its result wasn't used
+                problem = SuperResultDiscarded(method=def_node.name,
+                                               test_class=class_to_check,
+                                               ancestor_class=ancestor_class)
+                problems.add(problem)
+            if not matches(def_node, match_descendant(SUPER, DEFS)):
+                # The call to the overridden superclass method is missing
+                problem = SuperNotCalled(method=def_node.name,
+                                         test_class=class_to_check,
+                                         ancestor_class=ancestor_class)
+                problems.add(problem)
+
+            decorators = def_node.decorator_list
+
+            if matches(def_node, match_descendant(YIELD, DEFS)):
+                # Yield was used, making this a generator
+                if not any_matches(decorators, INLINE_CALLBACKS_DECORATOR):
+                    # ...but the inlineCallbacks decorator is missing
+                    problem = MissingInlineCallbacks(
+                        method=def_node.name,
+                        test_class=class_to_check,
+                        ancestor_class=ancestor_class)
+                    problems.add(problem)
+            else:
+                if not matches(def_node, match_descendant(RETURN_VALUE, DEFS)):
+                    # The function fails to return a deferred
+                    problem = MissingReturnValue(
+                        method=def_node.name,
+                        test_class=class_to_check,
+                        ancestor_class=ancestor_class)
+                    problems.add(problem)
+
+    return problems
+
+
+def get_test_classes(suite):
+    """Return all the unique test classes involved in a suite."""
+    classes = set()
+
+    def find_classes(suite_or_test):
+        """Recursively find all the test classes."""
+        if isinstance(suite_or_test, TestSuite):
+            for subtest in suite_or_test:
+                find_classes(subtest)
+        else:
+            classes.add(type(suite_or_test))
+
+    find_classes(suite)
+
+    return classes
+
+
+def make_check_testcase(tests):
+    """Make TestCase which checks the given twisted tests."""
+
+    class TXCheckTest(TestCase):
+        """Test case which checks the test classes for problems."""
+
+        def runTest(self):  # pylint: disable=C0103
+            """Do nothing."""
+
+        def run(self, result=None):
+            """Check all the test classes for problems."""
+            if result is None:
+                result = TestResult()
+
+            test_classes = set()
+
+            for test_object in tests:
+                test_classes |= get_test_classes(test_object)
+
+            for test_class in test_classes:
+                problems = find_problems(test_class)
+                for problem in problems:
+                    try:
+                        raise problem
+                    except Problem:
+                        result.addFailure(self, sys.exc_info())
+
+    return TXCheckTest()
+
+
+class TXCheckSuite(TestSuite):
+    """Test suite which checks twisted tests."""
+
+    def __init__(self, tests=()):
+        """Initialize with the given tests, and add a special test."""
+
+        tests = list(tests)
+        tests.insert(0, make_check_testcase(self))
+
+        super(TXCheckSuite, self).__init__(tests)
 
=== added file 'ubuntuone/devtools/testing/txwebserver.py'
--- ubuntuone/devtools/testing/txwebserver.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testing/txwebserver.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,124 @@
+# -*- 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.
+
+"""A tx based web server."""
+
+from __future__ import unicode_literals
+
+from twisted.internet import defer, reactor, ssl
+from twisted.protocols.policies import WrappingFactory
+from twisted.web import server
+
+from ubuntuone.devtools.testcases.txsocketserver import server_protocol_factory
+
+# no init method +  twisted common warnings
+# pylint: disable=W0232, C0103, E1101
+
+
+class BaseWebServer(object):
+    """Webserver used to perform requests in tests."""
+
+    def __init__(self, root_resource, scheme):
+        """Create and start the instance.
+
+        The ssl_settings parameter contains a dictionary with the key and cert
+        that will be used to perform ssl connections. The root_resource
+        contains the resource with all its childre.
+        """
+        self.root = root_resource
+        self.scheme = scheme
+        self.port = None
+        # use an http.HTTPFactory that was modified to ensure that we have
+        # clean close connections
+        self.site = server.Site(self.root, timeout=None)
+        self.wrapper = WrappingFactory(self.site)
+        self.wrapper.testserver_on_connection_lost = defer.Deferred()
+        self.wrapper.protocol = server_protocol_factory(self.wrapper.protocol)
+        self.wrapper._disconnecting = False
+
+    def listen(self, site):
+        """Listen a port to allow the tests."""
+        raise NotImplementedError('Base abstract class.')
+
+    def get_iri(self):
+        """Build the iri for this mock server."""
+        return "{scheme}://127.0.0.1:{port}/".format(scheme=self.scheme,
+                                                     port=self.get_port())
+
+    def get_port(self):
+        """Return the port where we are listening."""
+        return self.port.getHost().port
+
+    def start(self):
+        """Start the service."""
+        self.port = self.listen(self.wrapper)
+
+    def stop(self):
+        """Shut it down."""
+        if self.port:
+            self.wrapper._disconnecting = True
+            connected = self.wrapper.protocols.keys()
+            if connected:
+                for con in connected:
+                    con.transport.loseConnection()
+            else:
+                self.wrapper.testserver_on_connection_lost = \
+                    defer.succeed(None)
+            d = defer.maybeDeferred(self.port.stopListening)
+            return defer.gatherResults(
+                [d,
+                 self.wrapper.testserver_on_connection_lost])
+        return defer.succeed(None)
+
+
+class HTTPWebServer(BaseWebServer):
+    """A Webserver that listens to http connections."""
+
+    def __init__(self, root_resource):
+        """Create  a new instance."""
+        super(HTTPWebServer, self).__init__(root_resource, 'http')
+
+    def listen(self, site):
+        """Listen a port to allow the tests."""
+        return reactor.listenTCP(0, site)
+
+
+class HTTPSWebServer(BaseWebServer):
+    """A WebServer that listens to https connections."""
+
+    def __init__(self, root_resource, ssl_settings=None):
+        """Create  a new instance."""
+        super(HTTPSWebServer, self).__init__(root_resource, 'https')
+        self.ssl_settings = ssl_settings
+
+    def listen(self, site):
+        """Listen a port to allow the tests."""
+        ssl_context = ssl.DefaultOpenSSLContextFactory(
+            self.ssl_settings['key'], self.ssl_settings['cert'])
+
+        return reactor.listenSSL(0, site, ssl_context)
 
=== added file 'ubuntuone/devtools/utils.py'
--- ubuntuone/devtools/utils.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/utils.py	2018-05-30 21:37:37 +0000
@@ -0,0 +1,180 @@
+# 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.
+"""Utilities for Ubuntu One developer tools."""
+
+from __future__ import print_function, unicode_literals
+
+import getopt
+import sys
+
+from ubuntuone.devtools.errors import UsageError
+__all__ = ['OptionParser']
+
+
+def accumulate_list_attr(class_obj, attr, list_obj, base_class=None):
+    """Get all of the list attributes of attr from the class hierarchy,
+       and return a list of the lists."""
+    for base in class_obj.__bases__:
+        accumulate_list_attr(base, attr, list_obj)
+    if base_class is None or base_class in class_obj.__bases__:
+        list_obj.extend(class_obj.__dict__.get(attr, []))
+
+
+def unpack_padded(length, sequence, default=None):
+    """Pads a sequence to length with value of default.
+
+    Returns a list containing the original and padded values.
+    """
+    newlist = [default] * length
+    newlist[:len(sequence)] = list(sequence)
+    return newlist
+
+
+class OptionParser(dict):
+    """Base options for our test runner."""
+
+    def __init__(self, *args, **kwargs):
+        super(OptionParser, self).__init__(*args, **kwargs)
+
+        # Store info about the options and defaults
+        self.long_opts = []
+        self.short_opts = ''
+        self.docs = {}
+        self.defaults = {}
+        self.synonyms = {}
+        self.dispatch = {}
+
+        # Get the options and defaults
+        for _get in [self._get_flags, self._get_params]:
+            # We don't use variable 'syns' here. It's just to pad the result.
+            # pylint: disable=W0612
+            (long_opts, short_opts, docs, defaults, syns, dispatch) = _get()
+            # pylint: enable=W0612
+            self.long_opts.extend(long_opts)
+            self.short_opts = self.short_opts + short_opts
+            self.docs.update(docs)
+            self.update(defaults)
+            self.defaults.update(defaults)
+            self.synonyms.update(syns)
+            self.dispatch.update(dispatch)
+
+    # We use some camelcase names for trial compatibility here.
+    # pylint: disable=C0103
+    def parseOptions(self, options=None):
+        """Parse the options."""
+        if options is None:
+            options = sys.argv[1:]
+
+        try:
+            opts, args = getopt.getopt(options,
+                                       self.short_opts, self.long_opts)
+        except getopt.error as e:
+            raise UsageError(e)
+
+        for opt, arg in opts:
+            if opt[1] == '-':
+                opt = opt[2:]
+            else:
+                opt = opt[1:]
+
+            if (opt not in self.synonyms.keys()):
+                raise UsageError('No such options: "%s"' % opt)
+
+            opt = self.synonyms[opt]
+            if self.defaults[opt] is False:
+                self[opt] = True
+            else:
+                self.dispatch[opt](arg)
+
+        try:
+            self.parseArgs(*args)
+        except TypeError:
+            raise UsageError('Wrong number of arguments.')
+
+        self.postOptions()
+
+    def postOptions(self):
+        """Called after options are parsed."""
+
+    def parseArgs(self, *args):
+        """Override to handle extra arguments specially."""
+    # pylint: enable=C0103
+
+    def _parse_arguments(self, arg_type=None, has_default=False):
+        """Parse the arguments as either flags or parameters."""
+        long_opts, short_opts = [], ''
+        docs, defaults, syns, dispatch = {}, {}, {}, {}
+
+        _args = []
+        accumulate_list_attr(self.__class__, arg_type, _args)
+
+        for _arg in _args:
+            try:
+                if has_default:
+                    l_opt, s_opt, default, doc, _ = unpack_padded(5, _arg)
+                else:
+                    default = False
+                    l_opt, s_opt, doc, _ = unpack_padded(4, _arg)
+            except ValueError:
+                raise ValueError('Failed to parse argument: %s' % _arg)
+            if not l_opt:
+                raise ValueError('An option must have a long name.')
+
+            opt_m_name = 'opt_' + l_opt.replace('-', '_')
+            opt_method = getattr(self, opt_m_name, None)
+            if opt_method is not None:
+                docs[l_opt] = getattr(opt_method, '__doc__', None)
+                dispatch[l_opt] = opt_method
+                if docs[l_opt] is None:
+                    docs[l_opt] = doc
+            else:
+                docs[l_opt] = doc
+                dispatch[l_opt] = lambda arg: True
+
+            defaults[l_opt] = default
+            if has_default:
+                long_opts.append(l_opt + '=')
+            else:
+                long_opts.append(l_opt)
+
+            syns[l_opt] = l_opt
+            if s_opt is not None:
+                short_opts = short_opts + s_opt
+                if has_default:
+                    short_opts = short_opts + ':'
+                syns[s_opt] = l_opt
+
+        return long_opts, short_opts, docs, defaults, syns, dispatch
+
+    def _get_flags(self):
+        """Get the flag options."""
+        return self._parse_arguments(arg_type='optFlags', has_default=False)
+
+    def _get_params(self):
+        """Get the parameters options."""
+        return self._parse_arguments(arg_type='optParameters',
+                                     has_default=True)