Merge lp:~facundo/magicicada-client/full-closed-venv into lp:magicicada-client

[Facundo Batista]

Went full venv.

[Natalia Bidart (nataliabidart)]

20:43 < nessita> revisé tu branch, todo ok, pero no entiendo cómo anda "from devtools import..." porque no veo que nadie meta contrib en el pythonpath
20:44 < nessita> (y de elegir, preferiría que los imports sean from contrib.devtools ...)
20:45 < Facu> nessita, hola! no sé, todo lo que puse en contrib se importó solo, así que ahí no toqué nada
20:46 < Facu>| digo, ese mecanismo ya estaba de antes
20:48 < nessita> Facu, lo puedo landear así pero me da cosa que no veo quien carajo lo mete en el pythonpath
21:02 < Facu> nessita, +1 a "sacar eso", pero se podría hacer después; en cualquier caso, tenemos cosas más "urgentes" para hacer, yo ni le pondría prioridad
21:03 < nessita> okis

review: Approve

=== modified file 'Makefile'
--- Makefile	2018-04-14 23:34:20 +0000
+++ Makefile	2018-06-03 23:09:20 +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/devtools'
=== added file 'contrib/devtools/__init__.py'
--- contrib/devtools/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/__init__.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,1 @@
+"""Testing utilities for Ubuntu One client code."""
 
=== added file 'contrib/devtools/compat.py'
--- contrib/devtools/compat.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/compat.py	2018-06-03 23:09:20 +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 'contrib/devtools/errors.py'
--- contrib/devtools/errors.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/errors.py	2018-06-03 23:09:20 +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 'contrib/devtools/handlers.py'
--- contrib/devtools/handlers.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/handlers.py	2018-06-03 23:09:20 +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 'contrib/devtools/reactors'
=== added file 'contrib/devtools/reactors/__init__.py'
--- contrib/devtools/reactors/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/reactors/__init__.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,1 @@
+"""Twisted reactors for testing."""
 
=== added file 'contrib/devtools/reactors/gi.py'
--- contrib/devtools/reactors/gi.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/reactors/gi.py	2018-06-03 23:09:20 +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 'contrib/devtools/runners'
=== added file 'contrib/devtools/runners/__init__.py'
--- contrib/devtools/runners/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/runners/__init__.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,305 @@
+# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 devtools.errors import TestError, UsageError
+from devtools.testing.txcheck import TXCheckSuite
+from devtools.utils import OptionParser
+from 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 = '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 'contrib/devtools/runners/txrunner.py'
--- contrib/devtools/runners/txrunner.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/runners/txrunner.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,133 @@
+# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 devtools.errors import TestError
+from 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 = ('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 'contrib/devtools/services'
=== added file 'contrib/devtools/services/__init__.py'
--- contrib/devtools/services/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/services/__init__.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,66 @@
+# Copyright 2011-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 'contrib/devtools/services/dbus.py'
--- contrib/devtools/services/dbus.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/services/dbus.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,119 @@
+# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 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 'contrib/devtools/testcases'
=== added file 'contrib/devtools/testcases/__init__.py'
--- contrib/devtools/testcases/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/testcases/__init__.py	2018-06-03 23:09:20 +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 'contrib/devtools/testcases/dbus.py'
--- contrib/devtools/testcases/dbus.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/testcases/dbus.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 devtools.testcases import BaseTestCase, skipIf
+
+# DBusRunner for DBusTestCase using tests
+from 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 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 'contrib/devtools/testcases/txsocketserver.py'
--- contrib/devtools/testcases/txsocketserver.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/testcases/txsocketserver.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,358 @@
+# -*- coding: utf-8 -*-
+# Copyright 2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 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 'contrib/devtools/testing'
=== added file 'contrib/devtools/testing/__init__.py'
--- contrib/devtools/testing/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/testing/__init__.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,1 @@
+"""Testing helpers."""
 
=== added file 'contrib/devtools/testing/txcheck.py'
--- contrib/devtools/testing/txcheck.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/testing/txcheck.py	2018-06-03 23:09:20 +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 'contrib/devtools/testing/txwebserver.py'
--- contrib/devtools/testing/txwebserver.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/testing/txwebserver.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+# Copyright 2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 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 'contrib/devtools/utils.py'
--- contrib/devtools/utils.py	1970-01-01 00:00:00 +0000
+++ contrib/devtools/utils.py	2018-06-03 23:09:20 +0000
@@ -0,0 +1,181 @@
+# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 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)
 
=== 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-06-03 23:09:20 +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-06-03 23:09:20 +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-06-03 23:09:20 +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-06-03 23:09:20 +0000
@@ -0,0 +1,41 @@
+#! /usr/bin/python
+#
+# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# 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 devtools.runners import main
+
+
+if __name__ == '__main__':
+    main()
 
=== modified file 'dependencies-devel.txt'
--- dependencies-devel.txt	2018-03-18 11:59:08 +0000
+++ dependencies-devel.txt	2018-06-03 23:09:20 +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-06-03 23:09:20 +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 'magicicadaclient/platform/tests/filesystem_notifications/__init__.py'
--- magicicadaclient/platform/tests/filesystem_notifications/__init__.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/filesystem_notifications/__init__.py	2018-06-03 23:09:20 +0000
@@ -1,4 +1,5 @@
 # Copyright 2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -30,10 +31,10 @@
 
 from twisted.internet import defer, reactor
 
-from magicicadaclient.testing import testcase
-from ubuntuone.devtools.handlers import MementoHandler
+from devtools.handlers import MementoHandler
 from magicicadaclient.syncdaemon import event_queue, filesystem_manager
 from magicicadaclient.syncdaemon.tritcask import Tritcask
+from magicicadaclient.testing import testcase
 
 
 class BaseFSMonitorTestCase(testcase.BaseTwistedTestCase):
 
=== modified file 'magicicadaclient/platform/tests/filesystem_notifications/common.py'
--- magicicadaclient/platform/tests/filesystem_notifications/common.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/filesystem_notifications/common.py	2018-06-03 23:09:20 +0000
@@ -1,8 +1,5 @@
-#
-# Authors: Manuel de la Pena <[e-mail]>
-#          Alejandro J. Cura <[e-mail]>
-#
 # Copyright 2011-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -38,16 +35,18 @@
 import itertools
 
 from twisted.internet import defer
+
+from devtools.handlers import MementoHandler
 from magicicadaclient.testing.testcase import BaseTwistedTestCase
-from ubuntuone.devtools.handlers import MementoHandler
-from magicicadaclient.platform.filesystem_notifications.pyinotify_agnostic import (
-    EventsCodes,
-    ProcessEvent,
-    IN_CLOSE_WRITE,
-    IN_CREATE,
-    IN_DELETE,
-    IN_OPEN,
-)
+from magicicadaclient.platform.filesystem_notifications.pyinotify_agnostic \
+    import (
+        EventsCodes,
+        ProcessEvent,
+        IN_CLOSE_WRITE,
+        IN_CREATE,
+        IN_DELETE,
+        IN_OPEN,
+    )
 from magicicadaclient.platform.filesystem_notifications import notify_processor
 from magicicadaclient.platform.filesystem_notifications.monitor.common import (
     FilesystemMonitor,
 
=== modified file 'magicicadaclient/platform/tests/filesystem_notifications/test_darwin.py'
--- magicicadaclient/platform/tests/filesystem_notifications/test_darwin.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/filesystem_notifications/test_darwin.py	2018-06-03 23:09:20 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 *-*
 #
 # Copyright 2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -38,9 +39,8 @@
 
 import fsevents
 
+from devtools.handlers import MementoHandler
 from magicicadaclient.testing.testcase import BaseTwistedTestCase
-
-from ubuntuone.devtools.handlers import MementoHandler
 from magicicadaclient.platform.filesystem_notifications.monitor import (
     common,
 )
@@ -52,13 +52,14 @@
     Watch,
     WatchManager,
 )
-from magicicadaclient.platform.filesystem_notifications.pyinotify_agnostic import (
-    ProcessEvent,
-    IN_CLOSE_WRITE,
-    IN_CREATE,
-    IN_DELETE,
-    IN_OPEN,
-)
+from magicicadaclient.platform.filesystem_notifications.pyinotify_agnostic \
+    import (
+        ProcessEvent,
+        IN_CLOSE_WRITE,
+        IN_CREATE,
+        IN_DELETE,
+        IN_OPEN,
+    )
 from magicicadaclient.platform.tests.filesystem_notifications import (
     BaseFSMonitorTestCase,
     common as common_tests,
 
=== modified file 'magicicadaclient/platform/tests/filesystem_notifications/test_filesystem_notifications.py'
--- magicicadaclient/platform/tests/filesystem_notifications/test_filesystem_notifications.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/filesystem_notifications/test_filesystem_notifications.py	2018-06-03 23:09:20 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -33,8 +34,8 @@
 
 from twisted.internet import defer, reactor
 from twisted.trial import unittest
-from ubuntuone.devtools.handlers import MementoHandler
 
+from devtools.handlers import MementoHandler
 from magicicadaclient.testing.testcase import (
     BaseTwistedTestCase,
     FakeVolumeManager,
 
=== modified file 'magicicadaclient/platform/tests/filesystem_notifications/test_fsevents_daemon.py'
--- magicicadaclient/platform/tests/filesystem_notifications/test_fsevents_daemon.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/filesystem_notifications/test_fsevents_daemon.py	2018-06-03 23:09:20 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 *-*
 #
 # Copyright 2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -32,24 +33,20 @@
 
 from twisted.internet import defer, protocol
 
+from devtools.testcases.txsocketserver import TidyUnixServer
 from magicicadaclient.testing.testcase import BaseTwistedTestCase
 from magicicadaclient import fseventsd
-try:
-    from ubuntuone.devtools.testcases import skipIf
-    from ubuntuone.devtools.testcases.txsocketserver import TidyUnixServer
-except ImportError:
-    from ubuntuone.devtools.testcase import skipIf
-    TidyUnixServer = None
 from magicicadaclient.platform.filesystem_notifications.monitor.darwin import (
     fsevents_daemon,
 )
-from magicicadaclient.platform.filesystem_notifications.pyinotify_agnostic import (
-    IN_CREATE,
-    IN_DELETE,
-    IN_MODIFY,
-    IN_MOVED_FROM,
-    IN_MOVED_TO,
-)
+from magicicadaclient.platform.filesystem_notifications.pyinotify_agnostic \
+    import (
+        IN_CREATE,
+        IN_DELETE,
+        IN_MODIFY,
+        IN_MOVED_FROM,
+        IN_MOVED_TO,
+    )
 
 
 class FakeServerProtocol(protocol.Protocol):
@@ -469,8 +466,6 @@
         yield self.monitor.add_watch(dirpath)
         self.assertNotIn('add_path', self.protocol.called)
 
-    @skipIf(TidyUnixServer is None,
-            'Testcases from txsocketserver not availble.')
     @defer.inlineCallbacks
     def test_is_available_monitor_running(self):
         """Test the method when it is indeed running."""
 
=== modified file 'magicicadaclient/platform/tests/ipc/test_linux.py'
--- magicicadaclient/platform/tests/ipc/test_linux.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/ipc/test_linux.py	2018-06-03 23:09:20 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -33,11 +34,8 @@
 import dbus
 
 from twisted.internet import defer
-try:
-    from ubuntuone.devtools.testcases.dbus import DBusTestCase
-except ImportError:
-    from ubuntuone.devtools.testcase import DBusTestCase
 
+from devtools.testcases.dbus import DBusTestCase
 from magicicadaclient.testing.testcase import (
     FakeMainTestCase,
     FakedService,
 
=== modified file 'magicicadaclient/platform/tests/ipc/test_perspective_broker.py'
--- magicicadaclient/platform/tests/ipc/test_perspective_broker.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/ipc/test_perspective_broker.py	2018-06-03 23:09:20 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2011-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -41,14 +42,8 @@
 )
 from twisted.trial.unittest import TestCase
 
-from magicicadaclient.testing.testcase import (
-    FakedService,
-    FakeMainTestCase,
-)
-try:
-    from ubuntuone.devtools.testcases import skipIf, skipIfOS
-except ImportError:
-    from ubuntuone.devtools.testcase import skipIf, skipIfOS
+from devtools.testcases import skipIf, skipIfOS
+from magicicadaclient.testing.testcase import FakedService, FakeMainTestCase
 from magicicadaclient.platform.ipc import perspective_broker as ipc
 from magicicadaclient.platform.ipc.perspective_broker import (
     Config,
 
=== modified file 'magicicadaclient/platform/tests/os_helper/test_darwin.py'
--- magicicadaclient/platform/tests/os_helper/test_darwin.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/os_helper/test_darwin.py	2018-06-03 23:09:20 +0000
@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
-# tests.platform.os_helper - darwin platform tests
 #
 # Copyright 2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -33,13 +33,9 @@
 import os
 
 from twisted.internet import defer
-from ubuntuone.devtools.handlers import MementoHandler
 
-from magicicadaclient.platform import (
-    move_to_trash,
-    open_file,
-    stat_path,
-)
+from devtools.handlers import MementoHandler
+from magicicadaclient.platform import move_to_trash, open_file, stat_path
 from magicicadaclient.platform.os_helper import darwin
 from magicicadaclient.platform.tests.os_helper import test_os_helper
 
 
=== modified file 'magicicadaclient/platform/tests/os_helper/test_linux.py'
--- magicicadaclient/platform/tests/os_helper/test_linux.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/os_helper/test_linux.py	2018-06-03 23:09:20 +0000
@@ -1,4 +1,5 @@
 # Copyright 2010-2013 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -30,15 +31,11 @@
 import os
 
 from twisted.internet import defer
-from ubuntuone.devtools.handlers import MementoHandler
 
+from devtools.handlers import MementoHandler
+from magicicadaclient.platform import move_to_trash, open_file, stat_path
 from magicicadaclient.platform.tests.os_helper import test_os_helper
 from magicicadaclient.platform.os_helper import linux
-from magicicadaclient.platform import (
-    move_to_trash,
-    open_file,
-    stat_path,
-)
 
 
 class OSWrapperTests(test_os_helper.OSWrapperTests):
 
=== modified file 'magicicadaclient/platform/tests/session/test_common.py'
--- magicicadaclient/platform/tests/session/test_common.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/session/test_common.py	2018-06-03 23:09:20 +0000
@@ -1,5 +1,6 @@
 #
 # Copyright 2011-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -30,7 +31,7 @@
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
 
-from ubuntuone.devtools.testcases import skipIfOS
+from devtools.testcases import skipIfOS
 from magicicadaclient.platform.session import Inhibitor, INHIBIT_LOGOUT_SUSPEND
 
 
 
=== modified file 'magicicadaclient/platform/tests/session/test_linux.py'
--- magicicadaclient/platform/tests/session/test_linux.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/session/test_linux.py	2018-06-03 23:09:20 +0000
@@ -1,8 +1,5 @@
-# tests.platform.linux.test_session
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
 # Copyright 2011-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -30,15 +27,13 @@
 # files in the program, then also delete it here.
 """Tests for the session inhibition DBus client."""
 
+import operator
+
 import dbus
-import operator
-
 from dbus.mainloop.glib import DBusGMainLoop
 from twisted.internet.defer import inlineCallbacks
-try:
-    from ubuntuone.devtools.testcases.dbus import DBusTestCase
-except ImportError:
-    from ubuntuone.devtools.testcase import DBusTestCase
+
+from devtools.testcases.dbus import DBusTestCase
 from magicicadaclient.platform import session
 
 INHIBIT_ALL = (session.INHIBIT_LOGGING_OUT |
@@ -137,9 +132,8 @@
     def test_uninhibit_call(self):
         """Test the uninhibit call."""
         fakeinhibitor = self.register_fakeserver(
-                                             session.SESSION_MANAGER_BUSNAME,
-                                             session.SESSION_MANAGER_PATH,
-                                             FakeGnomeSessionManagerInhibitor)
+            session.SESSION_MANAGER_BUSNAME, session.SESSION_MANAGER_PATH,
+            FakeGnomeSessionManagerInhibitor)
         i = yield session.inhibit_logout_suspend("fake reason")
         yield i.cancel()
         result = fakeinhibitor.IsInhibited(session.INHIBIT_LOGGING_OUT)
 
=== modified file 'magicicadaclient/platform/tests/test_tools.py'
--- magicicadaclient/platform/tests/test_tools.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/platform/tests/test_tools.py	2018-06-03 23:09:20 +0000
@@ -30,15 +30,15 @@
 """Tests for the syncdaemon tools module."""
 
 import os
-
 from collections import defaultdict
 
 from twisted.internet import defer, reactor
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import skipTest, skipIfNotOS
 
+from devtools.handlers import MementoHandler
+from devtools.testcases import skipTest, skipIfNotOS
 from magicicadaclient.testing.testcase import FakeCommand
-
+from magicicadaclient.platform import tools
+from magicicadaclient.platform.tests import IPCTestCase
 from magicicadaclient.syncdaemon import (
     action_queue,
     event_queue,
@@ -46,8 +46,6 @@
     states,
     volume_manager,
 )
-from magicicadaclient.platform import tools
-from magicicadaclient.platform.tests import IPCTestCase
 
 
 SOME_ERROR = 'CRASH BOOM BANG'
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_action_queue.py'
--- magicicadaclient/syncdaemon/tests/test_action_queue.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_action_queue.py	2018-06-03 23:09:20 +0000
@@ -60,16 +60,8 @@
 from twisted.trial.unittest import TestCase as TwistedTestCase
 from zope.interface.verify import verifyObject, verifyClass
 
-from magicicadaclient.testing.testcase import (
-    BaseTwistedTestCase,
-    DummyClass,
-    FakeActionQueue,
-    FakeCommand,
-    FakeMain,
-    FakeUpload,
-)
-from ubuntuone.devtools import handlers
-from ubuntuone.devtools.testcases import skipTest
+from devtools import handlers
+from devtools.testcases import skipTest
 from magicicadaclient import logger, clientdefs
 from magicicadaclient.platform import open_file, platform, path_exists
 from magicicadaclient.syncdaemon import interfaces, config
@@ -88,6 +80,14 @@
 from magicicadaclient.syncdaemon import offload_queue
 from magicicadaclient.syncdaemon.marker import MDMarker
 from magicicadaclient.syncdaemon.volume_manager import ACCESS_LEVEL_RO
+from magicicadaclient.testing.testcase import (
+    BaseTwistedTestCase,
+    DummyClass,
+    FakeActionQueue,
+    FakeCommand,
+    FakeMain,
+    FakeUpload,
+)
 
 PATH = os.path.join(u'~', u'Documents', u'pdfs', u'moño', u'')
 NAME = u'UDF-me'
@@ -3352,7 +3352,7 @@
 
     def test_progress_hook(self):
         """Test the progress hook."""
-        self.command.deflated_size = 2*TRANSFER_PROGRESS_THRESHOLD
+        self.command.deflated_size = 2 * TRANSFER_PROGRESS_THRESHOLD
         self.command.n_bytes_written_last = 0
 
         self.command.n_bytes_written = 5
@@ -3368,8 +3368,8 @@
         self.command.n_bytes_written = TRANSFER_PROGRESS_THRESHOLD + 5
         self.command.progress_hook()
         kwargs = {'share_id': self.command.share_id, 'node_id': 'a_node_id',
-                  'deflated_size': 2*TRANSFER_PROGRESS_THRESHOLD,
-                  'n_bytes_written': 5+TRANSFER_PROGRESS_THRESHOLD}
+                  'deflated_size': 2 * TRANSFER_PROGRESS_THRESHOLD,
+                  'n_bytes_written': 5 + TRANSFER_PROGRESS_THRESHOLD}
         events = [('AQ_UPLOAD_FILE_PROGRESS', kwargs)]
         self.assertEqual(events, self.command.action_queue.event_queue.events)
         self.assertEqual(self.command.n_bytes_written_last,
@@ -4932,7 +4932,7 @@
 
     def test_repr(self):
         """A DeltaList has a short representation."""
-        a = DeltaList(["a"*1000])
+        a = DeltaList(["a" * 1000])
         self.assertTrue(len(repr(a)) < 100)
         self.assertTrue(len(str(a)) < 100)
 
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_eq_inotify.py'
--- magicicadaclient/syncdaemon/tests/test_eq_inotify.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_eq_inotify.py	2018-06-03 23:09:20 +0000
@@ -1,9 +1,5 @@
-# tests.syncdaemon.test_eq_inotify
-#
-# Authors: Facundo Batista <[e-mail]>
-#          Manuel de la Pena <[e-mail]>
-#
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -37,17 +33,9 @@
 import sys
 
 from twisted.internet import defer, reactor
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import skipIfOS, skipIfNotOS
 
-from magicicadaclient.testing.testcase import (
-    BaseTwistedTestCase,
-    FakeMain,
-    Listener,
-    skip_if_darwin_missing_fs_event,
-    skip_if_win32_missing_fs_event,
-)
-from magicicadaclient.syncdaemon.tests.test_eventqueue import BaseEQTestCase
+from devtools.handlers import MementoHandler
+from devtools.testcases import skipIfOS, skipIfNotOS
 from magicicadaclient.platform import (
     make_link,
     make_dir,
@@ -61,6 +49,14 @@
     set_dir_readwrite,
 )
 from magicicadaclient.syncdaemon import event_queue, volume_manager
+from magicicadaclient.syncdaemon.tests.test_eventqueue import BaseEQTestCase
+from magicicadaclient.testing.testcase import (
+    BaseTwistedTestCase,
+    FakeMain,
+    Listener,
+    skip_if_darwin_missing_fs_event,
+    skip_if_win32_missing_fs_event,
+)
 
 # our logging level
 TRACE = logging.getLevelName('TRACE')
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_eventqueue.py'
--- magicicadaclient/syncdaemon/tests/test_eventqueue.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_eventqueue.py	2018-06-03 23:09:20 +0000
@@ -1,9 +1,5 @@
-#
-# Author: Facundo Batista <[e-mail]>
-#
-# Author: Guillermo Gonzalez <[e-mail]>
-#
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -36,6 +32,7 @@
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
 
+from devtools.handlers import MementoHandler
 from magicicadaclient.testing.testcase import (
     BaseTwistedTestCase,
     FakeMonitor,
@@ -49,7 +46,6 @@
     filesystem_manager,
     tritcask,
 )
-from ubuntuone.devtools.handlers import MementoHandler
 
 
 class BaseEQTestCase(BaseTwistedTestCase):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_fileshelf.py'
--- magicicadaclient/syncdaemon/tests/test_fileshelf.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_fileshelf.py	2018-06-03 23:09:20 +0000
@@ -1,7 +1,5 @@
-#
-# Author: Guillermo Gonzalez <[e-mail]>
-#
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -37,19 +35,16 @@
 import unittest
 
 from twisted.internet import defer
-from ubuntuone.devtools.testcases import skipIfOS
 
-from magicicadaclient.testing.testcase import BaseTwistedTestCase
-from magicicadaclient.platform import (
-    open_file,
-    path_exists,
-)
+from devtools.testcases import skipIfOS
+from magicicadaclient.platform import open_file, path_exists
 from magicicadaclient.syncdaemon.file_shelf import (
     FileShelf,
     CachedFileShelf,
     LRUCache,
     CacheInconsistencyError,
 )
+from magicicadaclient.testing.testcase import BaseTwistedTestCase
 
 
 BROKEN_PICKLE = '\axb80\x02}q\x01(U\x01aU\x04testq\x02U\x01bU\x06brokenq\x03u.'
@@ -168,11 +163,11 @@
         """test that each time a metadata file is updated a .old is kept"""
         self.shelf['bad_file'] = {'value': 'old'}
         path = self.shelf.key_file('bad_file')
-        self.assertFalse(path_exists(path+'.old'))
+        self.assertFalse(path_exists(path + '.old'))
         self.assertEqual({'value': 'old'}, self.shelf['bad_file'])
         # force the creation of the .old file
         self.shelf['bad_file'] = {'value': 'new'}
-        self.assertTrue(path_exists(path+'.old'))
+        self.assertTrue(path_exists(path + '.old'))
         # check that the new value is there
         self.assertEqual({'value': 'new'}, self.shelf['bad_file'])
         # write the current md file fwith 0 bytes
@@ -183,11 +178,11 @@
         self.shelf['broken_pickle'] = {'value': 'old'}
         path = self.shelf.key_file('broken_pickle')
         # check that .old don't exist
-        self.assertFalse(path_exists(path+'.old'))
+        self.assertFalse(path_exists(path + '.old'))
         # force the creation of the .old file
         self.shelf['broken_pickle'] = {'value': 'new'}
         # check that .old exists
-        self.assertTrue(path_exists(path+'.old'))
+        self.assertTrue(path_exists(path + '.old'))
         # check that the new value is there
         self.assertEqual({'value': 'new'}, self.shelf['broken_pickle'])
         # write random bytes to the md file
@@ -200,10 +195,10 @@
         """test keys() with .old and .new files around"""
         self.shelf["foo"] = "bar"
         self.shelf["foo1"] = "bar1"
-        open_file(self.shelf.key_file('foo')+'.old', 'w').close()
-        open_file(self.shelf.key_file('foo1')+'.old', 'w').close()
-        open_file(self.shelf.key_file('foo')+'.new', 'w').close()
-        open_file(self.shelf.key_file('foo1')+'.new', 'w').close()
+        open_file(self.shelf.key_file('foo') + '.old', 'w').close()
+        open_file(self.shelf.key_file('foo1') + '.old', 'w').close()
+        open_file(self.shelf.key_file('foo') + '.new', 'w').close()
+        open_file(self.shelf.key_file('foo1') + '.new', 'w').close()
         self.assertEqual(set(['foo', 'foo1']), set(self.shelf.keys()))
 
     def test_corrupted_backup(self):
@@ -212,7 +207,7 @@
         # create the .old backup
         self.shelf["foo"] = "bar1"
         # write 0 bytes to both
-        open_file(self.shelf.key_file('foo')+'.old', 'w').close()
+        open_file(self.shelf.key_file('foo') + '.old', 'w').close()
         open_file(self.shelf.key_file('foo'), 'w').close()
         self.assertRaises(KeyError, self.shelf.__getitem__, 'foo')
 
@@ -233,12 +228,12 @@
         self.shelf["foo"] = "bar1"
         path = self.shelf.key_file('foo')
         # create a .new file (a hard reboot during the rename dance)
-        open_file(path+'.new', 'w').close()
+        open_file(path + '.new', 'w').close()
         # write 0 bytes to both
         del self.shelf['foo']
         self.assertFalse(path_exists(path))
-        self.assertFalse(path_exists(path+'.old'), 'there is a .old file!')
-        self.assertFalse(path_exists(path+'.new'), 'there is a .new file!')
+        self.assertFalse(path_exists(path + '.old'), 'there is a .old file!')
+        self.assertFalse(path_exists(path + '.new'), 'there is a .new file!')
 
     @skipIfOS('win32', 'Skipped because code is deprecated on Windows.')
     def test_custom_unpickle(self):
@@ -330,11 +325,11 @@
         """overrides parent test as we have the value in the cache."""
         self.shelf['bad_file'] = {'value': 'old'}
         path = self.shelf.key_file('bad_file')
-        self.assertFalse(path_exists(path+'.old'))
+        self.assertFalse(path_exists(path + '.old'))
         self.assertEqual({'value': 'old'}, self.shelf['bad_file'])
         # force the creation of the .old file
         self.shelf['bad_file'] = {'value': 'new'}
-        self.assertTrue(path_exists(path+'.old'))
+        self.assertTrue(path_exists(path + '.old'))
         # check that the new value is there
         self.assertEqual({'value': 'new'}, self.shelf['bad_file'])
         # write the current md file fwith 0 bytes
@@ -346,11 +341,11 @@
         self.shelf['broken_pickle'] = {'value': 'old'}
         path = self.shelf.key_file('broken_pickle')
         # check that .old don't exist
-        self.assertFalse(path_exists(path+'.old'))
+        self.assertFalse(path_exists(path + '.old'))
         # force the creation of the .old file
         self.shelf['broken_pickle'] = {'value': 'new'}
         # check that .old exists
-        self.assertTrue(path_exists(path+'.old'))
+        self.assertTrue(path_exists(path + '.old'))
         # check that the new value is there
         self.assertEqual({'value': 'new'}, self.shelf['broken_pickle'])
         # write random bytes to the md file
@@ -368,7 +363,7 @@
         """test __delitem__ method"""
         cache = LRUCache(100, 4)
         # set some data in the cache
-        values = [('key'+str(i), i) for i in range(100)]
+        values = [('key' + str(i), i) for i in range(100)]
         for i, j in values:
             cache[i] = j
         self.assertEqual(len(cache._queue), len(values))
@@ -378,7 +373,7 @@
         """test __delitem__ method"""
         cache = LRUCache(100, 4)
         # set some data in the cache
-        values = [('key'+str(i), i) for i in range(100)]
+        values = [('key' + str(i), i) for i in range(100)]
         for i, j in values:
             cache[i] = j
         self.assertEqual(len(cache._queue), len(values))
@@ -390,7 +385,7 @@
     def test_delitem(self):
         """test __delitem__ method"""
         cache = LRUCache(100, 4)
-        values = [('key'+str(i), i) for i in range(100)]
+        values = [('key' + str(i), i) for i in range(100)]
         for i, j in values:
             cache[i] = j
         self.assertEqual(len(cache._queue), len(values))
@@ -415,7 +410,7 @@
     def test_purge(self):
         """Test the queue compact and cache purge"""
         cache = LRUCache(100, 4)
-        values = [('key'+str(i), j) for i in range(50) for j in range(8)]
+        values = [('key' + str(i), j) for i in range(50) for j in range(8)]
         for i, j in values:
             cache[i] = j
         # we hit the limit
@@ -442,7 +437,7 @@
         """Tests if the cache correclty keeps track of misses and hits."""
         cache = LRUCache(100, 4)
         # set some data in the cache
-        values = [('key'+str(i), i) for i in range(10)]
+        values = [('key' + str(i), i) for i in range(10)]
         for i, j in values:
             cache[i] = j
         self.assertEqual(len(cache._queue), len(values))
@@ -454,7 +449,7 @@
         self.assertEqual(cache.hits, 4)
         # try to get items not present in the cache
         for i, j in values[5:10]:
-            self.assertRaises(KeyError, cache.__getitem__, i*10)
+            self.assertRaises(KeyError, cache.__getitem__, i * 10)
         self.assertEqual(cache.misses, 5)
 
     def test_inconsistency(self):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_fsm.py'
--- magicicadaclient/syncdaemon/tests/test_fsm.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_fsm.py	2018-06-03 23:09:20 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -47,7 +48,7 @@
     skip_if_win32_and_uses_readonly,
 )
 
-from ubuntuone.devtools.handlers import MementoHandler
+from devtools.handlers import MementoHandler
 from magicicadaclient.platform import (
     listdir,
     make_dir,
@@ -229,7 +230,7 @@
         self.assertEqual(mdobj.size, None)
         when = mdobj.info.created
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # set uuid using valid path, but not twice
         self.fsm.set_node_id(path, "uuid")
@@ -237,7 +238,7 @@
         mdobj = self.fsm.get_by_path(path)
         when = mdobj.info.node_id_assigned
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
     def test_with_node_id(self):
         """Test creation with node_id"""
@@ -255,14 +256,14 @@
         self.assertEqual(mdobj.size, None)
         when = mdobj.info.created
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # set uuid using valid path, but not twice
         self.assertRaises(ValueError, self.fsm.set_node_id, path, "whatever")
         mdobj = self.fsm.get_by_path(path)
         when = mdobj.info.node_id_assigned
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
     def test_invalid_args(self):
         """Test using invalid args in set_node_id."""
@@ -351,7 +352,7 @@
             old_fs[k] = v
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -417,7 +418,7 @@
             old_fs[k] = v
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -474,7 +475,7 @@
             old_fs[k] = v
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -530,7 +531,7 @@
             old_fs[k] = v
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -595,7 +596,7 @@
             old_mvlimbo[k] = v
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -654,7 +655,7 @@
             old_mvlimbo[k] = v
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -710,7 +711,7 @@
         remove_file(version_file)
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -757,7 +758,7 @@
             fh.write("1")
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -809,7 +810,7 @@
             os.fsync(f.fileno())
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -867,7 +868,7 @@
         remove_file(version_file)
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -928,7 +929,7 @@
             fh.write("1")
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -996,7 +997,7 @@
             os.fsync(f.fileno())
 
         # start up again, and check
-        db = Tritcask(self.tritcask_path+'.new')
+        db = Tritcask(self.tritcask_path + '.new')
         self.addCleanup(db.shutdown)
         newfsm = FileSystemManager(self.fsmdir, self.partials_dir,
                                    self.fsm.vm, db)
@@ -1548,7 +1549,7 @@
         """Test having similar paths (a/b, a/b1, a/b2)."""
         expected = [os.path.join('a', 'b', 'y.txt')]
         actual = sorted([d.path for d in self.fsm.get_mdobjs_in_dir(
-                                    os.path.join(self.share.path, 'a', 'b'))])
+            os.path.join(self.share.path, 'a', 'b'))])
         self.assertEqual(expected, actual)
 
     @defer.inlineCallbacks
@@ -1719,7 +1720,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         when = mdobj.info.last_partial_created
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # invalid uuid
         self.assertRaises(KeyError, self.fsm.create_partial, "foo", "share")
@@ -1756,7 +1757,7 @@
         self.assertEqual(mdobj.local_hash, 9876)
         when = mdobj.info.last_downloaded
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # invalid uuid
         self.assertRaises(
@@ -1796,7 +1797,7 @@
         self.assertFalse(mdobj.info.is_partial)
         when = mdobj.info.last_partial_removed
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # invalid uuid
         self.assertRaises(KeyError, self.fsm.remove_partial, "foo", "share")
@@ -1822,7 +1823,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         when = mdobj.info.last_partial_created
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # invalid uuid
         self.assertRaises(KeyError, self.fsm.create_partial, "foo", "share")
@@ -1847,7 +1848,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         when = mdobj.info.last_partial_created
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # invalid uuid
         self.assertRaises(KeyError, self.fsm.create_partial, "foo", "share")
@@ -1890,7 +1891,7 @@
         self.assertFalse(mdobj.info.is_partial)
         when = mdobj.info.last_partial_removed
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # invalid uuid
         self.assertRaises(KeyError, self.fsm.remove_partial, "foo", "share")
@@ -1948,7 +1949,7 @@
         # find a almost too long file
         repeat = 300
         while True:
-            testfile = os.path.join(self.share_path, "x"*repeat)
+            testfile = os.path.join(self.share_path, "x" * repeat)
             try:
                 fh = open_file(testfile, 'w')
             except IOError, e:
@@ -2071,7 +2072,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         when = mdobj.info.last_conflicted
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # move second time, start the .N serie
         with open_file(testfile, "w") as fh:
@@ -2145,7 +2146,7 @@
         self.assertEqual(mdobj.server_hash, 1234567890)
         when = mdobj.info.last_uploaded
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # invalid mdid
         self.assertRaises(KeyError, self.fsm.upload_finished,
@@ -2173,7 +2174,7 @@
         self.assertEqual(mdobj.info.last_moved_from, testfile)
         when = mdobj.info.last_moved_time
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # move again, to a directory
         from_path = to_path
@@ -2244,7 +2245,7 @@
         self.assertEqual(mdobj.info.last_moved_from, from_path)
         when = mdobj.info.last_moved_time
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # move again, to a directory
         from_path = to_path
@@ -2257,7 +2258,7 @@
         self.assertEqual(mdobj.info.last_moved_from, from_path)
         when = mdobj.info.last_moved_time
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
     def test_move_file_withfulldir(self):
         """Test that a dir is moved from even having a file inside."""
@@ -2288,7 +2289,7 @@
         self.assertEqual(mdobj.info.last_moved_from, from_path)
         when = mdobj.info.last_moved_time
         now = time.time()
-        self.assertTrue(now-3 <= when <= now)  # 3 seconds test range
+        self.assertTrue(now - 3 <= when <= now)  # 3 seconds test range
 
         # check that file inside is ok
         newfilepath = os.path.join(to_path, "file.txt")
@@ -4086,8 +4087,10 @@
     def setUp(self):
         """Set up."""
         yield super(OsIntegrationTests, self).setUp()
-        self.open_file = self.mocker.replace('magicicadaclient.platform.open_file')
-        self.normpath = self.mocker.replace('magicicadaclient.platform.normpath')
+        self.open_file = self.mocker.replace(
+            'magicicadaclient.platform.open_file')
+        self.normpath = self.mocker.replace(
+            'magicicadaclient.platform.normpath')
         self.listdir = self.mocker.replace('magicicadaclient.platform.listdir')
 
     def test_get_partial_for_writing(self):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_hashqueue.py'
--- magicicadaclient/syncdaemon/tests/test_hashqueue.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_hashqueue.py	2018-06-03 23:09:20 +0000
@@ -41,13 +41,13 @@
 from magicicadaprotocol.content_hash import content_hash_factory, crc32
 from twisted.trial.unittest import TestCase as TwistedTestCase
 from twisted.internet import defer, reactor
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import skipTest
 
-from magicicadaclient.testing.testcase import BaseTwistedTestCase
+from devtools.handlers import MementoHandler
+from devtools.testcases import skipTest
 from magicicadaclient.platform import open_file, stat_path
 from magicicadaclient.syncdaemon import hash_queue
 from magicicadaclient.syncdaemon.hash_queue import HASHQUEUE_DELAY
+from magicicadaclient.testing.testcase import BaseTwistedTestCase
 
 FAKE_TIMESTAMP = 1
 
@@ -244,11 +244,11 @@
         should_be = []
         for i in range(10):
             hasher = content_hash_factory()
-            text = "supercalifragilistico"+str(i)
+            text = "supercalifragilistico" + str(i)
             hasher.hash_object.update(text)
-            tfile = os.path.join(self.test_dir, "tfile"+str(i))
+            tfile = os.path.join(self.test_dir, "tfile" + str(i))
             with open_file(tfile, "wb") as fh:
-                fh.write("supercalifragilistico"+str(i))
+                fh.write("supercalifragilistico" + str(i))
             d = dict(path=tfile, hash=hasher.content_hash(),
                      crc32=crc32(text), size=len(text), stat=stat_path(tfile))
             should_be.append(("HQ_HASH_NEW", d))
@@ -262,7 +262,7 @@
 
         # send what to hash
         for i in range(10):
-            tfile = os.path.join(self.test_dir, "tfile"+str(i))
+            tfile = os.path.join(self.test_dir, "tfile" + str(i))
             item = ((tfile, "mdid"), FAKE_TIMESTAMP)
             queue.put(item)
 
@@ -554,11 +554,11 @@
         should_be = []
         for i in range(10):
             hasher = content_hash_factory()
-            text = "supercalifragilistico"+str(i)
+            text = "supercalifragilistico" + str(i)
             hasher.hash_object.update(text)
-            tfile = os.path.join(self.test_dir, "tfile"+str(i))
+            tfile = os.path.join(self.test_dir, "tfile" + str(i))
             with open_file(tfile, "wb") as fh:
-                fh.write("supercalifragilistico"+str(i))
+                fh.write("supercalifragilistico" + str(i))
             d = dict(path=tfile, hash=hasher.content_hash(),
                      crc32=crc32(text), size=len(text), stat=stat_path(tfile))
             should_be.append(("HQ_HASH_NEW", d))
@@ -569,7 +569,7 @@
 
         # send what to hash
         for i in range(10):
-            tfile = os.path.join(self.test_dir, "tfile"+str(i))
+            tfile = os.path.join(self.test_dir, "tfile" + str(i))
             hq.insert(tfile, "mdid")
 
         # release the processor and check
@@ -583,11 +583,11 @@
         should_be = []
         for i in range(10):
             hasher = content_hash_factory()
-            text = "supercalifragilistico"+str(i)
+            text = "supercalifragilistico" + str(i)
             hasher.hash_object.update(text)
-            tfile = os.path.join(self.test_dir, "tfile"+str(i))
+            tfile = os.path.join(self.test_dir, "tfile" + str(i))
             with open_file(tfile, "wb") as fh:
-                fh.write("supercalifragilistico"+str(i))
+                fh.write("supercalifragilistico" + str(i))
             d = dict(path=tfile, hash=hasher.content_hash(),
                      crc32=crc32(text), size=len(text), stat=stat_path(tfile))
             should_be.append(("HQ_HASH_NEW", d))
@@ -606,7 +606,7 @@
 
         # send to hash twice
         for i in range(10):
-            tfile = os.path.join(self.test_dir, "tfile"+str(i))
+            tfile = os.path.join(self.test_dir, "tfile" + str(i))
             hq.insert(tfile, "mdid")
             hq.insert(tfile, "mdid")
         # start the hasher
@@ -615,7 +615,7 @@
         # insert the last item to check the uniqueness in the queue while
         # the hasher is running
         for i in range(9, 10):
-            tfile = os.path.join(self.test_dir, "tfile"+str(i))
+            tfile = os.path.join(self.test_dir, "tfile" + str(i))
             hq.insert(tfile, "mdid")
 
         # release the processor and check
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_interaction_interfaces.py'
--- magicicadaclient/syncdaemon/tests/test_interaction_interfaces.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_interaction_interfaces.py	2018-06-03 23:09:20 +0000
@@ -34,27 +34,14 @@
 
 from magicicadaprotocol.protocol_pb2 import AccountInfo
 from twisted.internet import defer
-from ubuntuone.devtools.handlers import MementoHandler
 
-from magicicadaclient.testing.testcase import (
-    FAKED_CREDENTIALS,
-    FakeCommand,
-    FakeDownload,
-    FakeUpload,
-    FakedObject,
-    FakeMainTestCase,
-    skipIfOS,
-)
+from devtools.handlers import MementoHandler
 from magicicadaclient.networkstate.networkstates import ONLINE
 from magicicadaclient.platform import make_dir, make_link
 from magicicadaclient.platform.tests.ipc.test_perspective_broker import (
     FakeNetworkManagerState,
 )
-from magicicadaclient.syncdaemon import (
-    config,
-    interaction_interfaces,
-    states,
-)
+from magicicadaclient.syncdaemon import config, interaction_interfaces, states
 from magicicadaclient.syncdaemon.interaction_interfaces import (
     bool_str,
     get_share_dict,
@@ -82,6 +69,15 @@
     UDF,
     VolumeDoesNotExist,
 )
+from magicicadaclient.testing.testcase import (
+    FAKED_CREDENTIALS,
+    FakeCommand,
+    FakeDownload,
+    FakeUpload,
+    FakedObject,
+    FakeMainTestCase,
+    skipIfOS,
+)
 
 
 class CustomError(Exception):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_localrescan.py'
--- magicicadaclient/syncdaemon/tests/test_localrescan.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_localrescan.py	2018-06-03 23:09:20 +0000
@@ -37,14 +37,9 @@
 
 from magicicadaprotocol import content_hash as storage_hash, volumes
 from twisted.internet import defer, reactor
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import skipIfOS
 
-from magicicadaclient.testing.testcase import (
-    BaseTwistedTestCase,
-    FakeVolumeManager,
-    skip_if_win32_and_uses_readonly,
-)
+from devtools.handlers import MementoHandler
+from devtools.testcases import skipIfOS
 from magicicadaclient.platform import (
     make_dir,
     make_link,
@@ -68,6 +63,11 @@
     ACCESS_LEVEL_RO,
     ACCESS_LEVEL_RW,
 )
+from magicicadaclient.testing.testcase import (
+    BaseTwistedTestCase,
+    FakeVolumeManager,
+    skip_if_win32_and_uses_readonly,
+)
 
 # our logging level
 TRACE = logging.getLevelName('TRACE')
@@ -829,7 +829,7 @@
         """Lot of files in a dir, and lots of dirs."""
         # almost all known, to force the system to go deep
         dirs = "abcdefghijklmnopq" * 20
-        for i in range(1, len(dirs)+1):
+        for i in range(1, len(dirs) + 1):
             dirpath = os.path.join(*dirs[:i])
             self.create_node(dirpath, is_dir=True)
         basedir = os.path.join(*dirs)
@@ -840,11 +840,11 @@
         # some files in some dirs
         files = "rstuvwxyz"
         for f in files:
-            path = os.path.join(*dirs[:3]+f)
-            self.create_node(path, is_dir=False)
-            path = os.path.join(*dirs[:6]+f)
-            self.create_node(path, is_dir=False)
-        sh2 = os.path.join(self.share.path, *dirs[:6]+"q")
+            path = os.path.join(*dirs[:3] + f)
+            self.create_node(path, is_dir=False)
+            path = os.path.join(*dirs[:6] + f)
+            self.create_node(path, is_dir=False)
+        sh2 = os.path.join(self.share.path, *dirs[:6] + "q")
         open_file(sh2, "w").close()
 
         # scan!
@@ -1953,7 +1953,7 @@
         self.assertFalse(path_exists(partial_path))
         # logged in warning
         self.assertTrue(self.handler.check_warning(
-                                                "Found a directory in SERVER"))
+            "Found a directory in SERVER"))
 
     def test_check_stat_None(self):
         """Test check_stat with oldstat = None."""
@@ -2041,7 +2041,7 @@
         self.assertEqual(self.aq.unlinked, [(self.share.volume_id,
                                              "parent_id", "uuid", path, True)])
         self.assertTrue(self.handler.check_info(
-                         "generating Unlink from trash"))
+            "generating Unlink from trash"))
 
     @defer.inlineCallbacks
     def test_trash_two(self):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_logger.py'
--- magicicadaclient/syncdaemon/tests/test_logger.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_logger.py	2018-06-03 23:09:20 +0000
@@ -1,8 +1,7 @@
 # -*- coding: utf-8 -*-
 #
-# Author: Guillermo Gonzalez <[e-mail]>
-#
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -37,9 +36,8 @@
 from twisted.internet import defer
 from twisted.trial import unittest
 
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import skipIfOS
-
+from devtools.handlers import MementoHandler
+from devtools.testcases import skipIfOS
 from magicicadaclient.syncdaemon.logger import (
     DebugCapture,
     NOTE,
@@ -302,7 +300,7 @@
         self.handler.addFilter(MultiFilter([self.__class__.__name__]))
         self.logger.debug('this msg should be logged')
         self.assertEqual(1, len(self.handler.records))
-        other_logger = logging.getLogger("NO_LOG."+self.__class__.__name__)
+        other_logger = logging.getLogger("NO_LOG." + self.__class__.__name__)
         other_logger.debug('this msg shouldn\'t be logged')
         self.assertEqual(1, len(self.handler.records))
 
@@ -311,7 +309,7 @@
         self.handler.addFilter(
             MultiFilter([self.__class__.__name__,
                          self.__class__.__name__ + ".child"]))
-        no_logger = logging.getLogger("NO_LOG."+self.__class__.__name__)
+        no_logger = logging.getLogger("NO_LOG." + self.__class__.__name__)
         yes_logger = logging.getLogger(self.__class__.__name__ + '.child')
         self.logger.debug('this msg should be logged')
         self.assertEqual(1, len(self.handler.records))
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_main.py'
--- magicicadaclient/syncdaemon/tests/test_main.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_main.py	2018-06-03 23:09:20 +0000
@@ -33,15 +33,12 @@
 import os
 
 from twisted.internet import defer, reactor
-from ubuntuone.devtools.handlers import MementoHandler
-from magicicadaclient.platform import expand_user
 
-from magicicadaclient.testing.testcase import (
-    BaseTwistedTestCase, FAKED_CREDENTIALS, FakeMonitor
-)
+from devtools.handlers import MementoHandler
 from magicicadaclient.clientdefs import VERSION
 from magicicadaclient.logger import NOTE
 from magicicadaclient.platform import (
+    expand_user,
     is_link,
     make_dir,
     make_link,
@@ -49,6 +46,9 @@
     remove_dir,
 )
 from magicicadaclient.syncdaemon import main as main_mod
+from magicicadaclient.testing.testcase import (
+    BaseTwistedTestCase, FAKED_CREDENTIALS, FakeMonitor
+)
 
 
 class FakeListener(object):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_offloadqueue.py'
--- magicicadaclient/syncdaemon/tests/test_offloadqueue.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_offloadqueue.py	2018-06-03 23:09:20 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -36,10 +37,10 @@
 
 from twisted.trial.unittest import TestCase as TwistedTestCase
 
-from ubuntuone.devtools.handlers import MementoHandler
-from magicicadaclient.syncdaemon.offload_queue import OffloadQueue, STRUCT_SIZE
+from devtools.handlers import MementoHandler
 from magicicadaclient.syncdaemon.interfaces import IMarker
 from magicicadaclient.syncdaemon.marker import MDMarker
+from magicicadaclient.syncdaemon.offload_queue import OffloadQueue, STRUCT_SIZE
 
 
 class OffloadQueueTestCase(TwistedTestCase):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_pathlockingtree.py'
--- magicicadaclient/syncdaemon/tests/test_pathlockingtree.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_pathlockingtree.py	2018-06-03 23:09:20 +0000
@@ -1,8 +1,5 @@
-# ubuntuone.syncdaemon.tests.test_pathlockingtree - PathLockingTree tests
-#
-# Author: Facundo Batista <[e-mail]>
-#
 # Copyright 2011-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -35,7 +32,7 @@
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase as TwistedTestCase
 
-from ubuntuone.devtools.handlers import MementoHandler
+from devtools.handlers import MementoHandler
 from magicicadaclient.syncdaemon.action_queue import PathLockingTree
 
 
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_sync.py'
--- magicicadaclient/syncdaemon/tests/test_sync.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_sync.py	2018-06-03 23:09:20 +0000
@@ -43,15 +43,9 @@
 from magicicadaprotocol.request import ROOT
 from twisted.internet import defer
 from twisted.python.failure import Failure
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import skipIfOS
 
-from magicicadaclient.testing.testcase import (
-    FakeMain,
-    FakeVolumeManager,
-    BaseTwistedTestCase,
-    Listener,
-)
+from devtools.handlers import MementoHandler
+from devtools.testcases import skipIfOS
 from magicicadaclient.platform import (
     make_dir,
     open_file,
@@ -61,10 +55,20 @@
 from magicicadaclient.syncdaemon.filesystem_manager import FileSystemManager
 from magicicadaclient.syncdaemon.tritcask import Tritcask
 from magicicadaclient.syncdaemon.fsm import fsm as fsm_module
-from magicicadaclient.syncdaemon.sync import FSKey, Sync, SyncStateMachineRunner
+from magicicadaclient.syncdaemon.sync import (
+    FSKey,
+    Sync,
+    SyncStateMachineRunner,
+)
 from magicicadaclient.syncdaemon.volume_manager import Share
 from magicicadaclient.syncdaemon.event_queue import EventQueue, EVENTS
 from magicicadaclient.syncdaemon.marker import MDMarker
+from magicicadaclient.testing.testcase import (
+    FakeMain,
+    FakeVolumeManager,
+    BaseTwistedTestCase,
+    Listener,
+)
 
 
 class TestSyncClassAPI(unittest.TestCase):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_tritcask.py'
--- magicicadaclient/syncdaemon/tests/test_tritcask.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_tritcask.py	2018-06-03 23:09:20 +0000
@@ -1,8 +1,5 @@
-# tests.syncdaemon.test_tritcask - tritcask tests
-#
-# Author: Guillermo Gonzalez <[e-mail]>
-#
 # Copyright 2010-2012 Canonical Ltd.
+# Copyright 2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -42,8 +39,8 @@
 from operator import attrgetter
 from twisted.internet import defer
 
+from devtools.handlers import MementoHandler
 from magicicadaclient.testing.testcase import BaseTwistedTestCase
-from ubuntuone.devtools.handlers import MementoHandler
 from magicicadaclient.syncdaemon import tritcask
 from magicicadaclient.syncdaemon.tritcask import (
     TOMBSTONE,
@@ -343,7 +340,7 @@
             fd.read(crc32_size + 4)
             fd.truncate()
             # write a different value -> random bytes
-            fd.write(os.urandom(header_size/2))
+            fd.write(os.urandom(header_size / 2))
             fd.flush()
             fmap = mmap.mmap(fd.fileno(), 0, access=mmap.ACCESS_READ)
             with contextlib.closing(fmap):
@@ -1377,7 +1374,7 @@
         # check that the TOMBSTONE is there for these keys
         with open(self.db.live_file.filename, 'r+b') as f:
             raw_data_len = len(key) + len(TOMBSTONE) + crc32_size + header_size
-            f.seek(-1*raw_data_len, os.SEEK_END)
+            f.seek(-1 * raw_data_len, os.SEEK_END)
             raw_data = f.read(raw_data_len)
             self.assertEqual(TOMBSTONE,
                              raw_data[crc32_size + header_size + len(key):])
@@ -1743,9 +1740,10 @@
         for i in range(20):
             keydir[(0, str(uuid.uuid4()))] = KeydirEntry(
                 file_id_1, timestamp(), len(str(uuid.uuid4())), i + 10)
-        entry_size = len(str(uuid.uuid4()))*2 + header_size + crc32_size
-        self.assertEqual(entry_size*10, keydir._stats[file_id]['live_bytes'])
-        self.assertEqual(entry_size*20, keydir._stats[file_id_1]['live_bytes'])
+        entry_size = len(str(uuid.uuid4())) * 2 + header_size + crc32_size
+        self.assertEqual(entry_size * 10, keydir._stats[file_id]['live_bytes'])
+        self.assertEqual(
+            entry_size * 20, keydir._stats[file_id_1]['live_bytes'])
 
     def test_update_entry(self):
         """Test that __setitem__ updates the stats for an entry."""
@@ -1796,10 +1794,10 @@
                                            len(str(uuid.uuid4())), i + 10)
             if i % 2:
                 keydir.remove((0, key))
-        entry_size = len(str(uuid.uuid4()))*2 + header_size + crc32_size
-        self.assertEqual(entry_size*(10/2),
+        entry_size = len(str(uuid.uuid4())) * 2 + header_size + crc32_size
+        self.assertEqual(entry_size * (10 / 2),
                          keydir._stats[file_id]['live_bytes'])
-        self.assertEqual(entry_size*(20/2),
+        self.assertEqual(entry_size * (20 / 2),
                          keydir._stats[file_id_1]['live_bytes'])
 
     def test_remove_missing_key(self):
 
=== modified file 'magicicadaclient/syncdaemon/tests/test_vm.py'
--- magicicadaclient/syncdaemon/tests/test_vm.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/syncdaemon/tests/test_vm.py	2018-06-03 23:09:20 +0000
@@ -45,15 +45,16 @@
 
 from mocker import Mocker, MATCH
 from twisted.internet import defer, reactor
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import skipIfOS
 
-from magicicadaclient.testing.testcase import (
-    BaseTwistedTestCase,
-    FakeMain,
-)
+from devtools.handlers import MementoHandler
+from devtools.testcases import skipIfOS
 from magicicadaclient import platform
-from magicicadaclient.syncdaemon import config, event_queue, tritcask, volume_manager
+from magicicadaclient.syncdaemon import (
+    config,
+    event_queue,
+    tritcask,
+    volume_manager,
+)
 from magicicadaclient.syncdaemon.volume_manager import (
     ACCESS_LEVEL_RO,
     ACCESS_LEVEL_RW,
@@ -83,6 +84,7 @@
     set_dir_readonly,
     set_dir_readwrite,
 )
+from magicicadaclient.testing.testcase import BaseTwistedTestCase, FakeMain
 
 # grab the metadata version before tests fiddle with it
 CURRENT_METADATA_VERSION = VolumeManager.METADATA_VERSION
@@ -2760,7 +2762,7 @@
         root_volume = volumes.RootVolume(uuid.uuid4(), None, 10)
         d = defer.Deferred()
         self.vm._got_root = lambda node_id, free_bytes: d.callback(
-                                                        (node_id, free_bytes))
+            (node_id, free_bytes))
         self.main.event_q.push('AQ_LIST_VOLUMES', volumes=[root_volume])
         root_node_id, free_bytes = yield d
         self.assertEqual(str(root_volume.node_id), root_node_id)
@@ -4172,7 +4174,7 @@
         self.patch(VolumeManager, "METADATA_VERSION", self.fake_version)
         self.temp_dir = os.path.join(self.mktemp(), u"Ñandú")
         self.version_file = os.path.join(self.temp_dir, ".version").encode(
-                                                 sys.getfilesystemencoding())
+            sys.getfilesystemencoding())
         self.md_upgrader = MetadataUpgrader(self.temp_dir.encode("utf-8"),
                                             "", "", "", "", "", "", None)
 
 
=== modified file 'magicicadaclient/testing/testcase.py'
--- magicicadaclient/testing/testcase.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/testing/testcase.py	2018-06-03 23:09:20 +0000
@@ -43,10 +43,10 @@
 
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase as TwistedTestCase
-from ubuntuone.devtools.testcases import skipIfOS
 from zope.interface import implements
 from zope.interface.verify import verifyObject
 
+from devtools.testcases import skipIfOS
 from magicicadaclient.syncdaemon import (
     config,
     action_queue,
 
=== modified file 'magicicadaclient/utils/__init__.py'
--- magicicadaclient/utils/__init__.py	2016-06-04 21:14:35 +0000
+++ magicicadaclient/utils/__init__.py	2018-06-03 23:09:20 +0000
@@ -73,8 +73,8 @@
 
     # otherwise, try to load 'dir_constant' from installation path
     try:
-        __import__('ubuntuone.clientdefs', None, None, [''])
-        module = sys.modules.get('ubuntuone.clientdefs')
+        __import__('magicicadaclient.clientdefs', None, None, [''])
+        module = sys.modules.get('magicicadaclient.clientdefs')
         return getattr(module, dir_constant)
     except (ImportError, AttributeError):
         msg = '_get_dir: can not build a valid path. Giving up. ' \
@@ -135,8 +135,7 @@
 
     if getattr(sys, "frozen", None) is not None:
         if sys.platform == "win32":
-            ssl_cert_location = list(load_config_paths(
-                    "ubuntuone"))[1]
+            ssl_cert_location = list(load_config_paths("ubuntuone"))[1]
         elif sys.platform == "darwin":
                 main_app_dir = "".join(__file__.partition(".app")[:-1])
                 main_app_resources_dir = os.path.join(main_app_dir,
 
=== modified file 'magicicadaclient/utils/tests/test_common.py'
--- magicicadaclient/utils/tests/test_common.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/utils/tests/test_common.py	2018-06-03 23:09:20 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2017 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -38,13 +38,13 @@
 
 from twisted.internet import defer
 from twisted.web import resource
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testing.txwebserver import HTTPWebServer
 
+from devtools.handlers import MementoHandler
+from devtools.testing.txwebserver import HTTPWebServer
 from magicicadaclient import utils
 from magicicadaclient.tests import TestCase
 
-CONSTANTS_MODULE = 'ubuntuone.clientdefs'
+CONSTANTS_MODULE = 'magicicadaclient.clientdefs'
 NOT_DEFINED = object()
 
 
 
=== modified file 'magicicadaclient/utils/tests/test_ipc.py'
--- magicicadaclient/utils/tests/test_ipc.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/utils/tests/test_ipc.py	2018-06-03 23:09:20 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -39,13 +39,13 @@
     DeadReferenceError,
     NoSuchMethod,
 )
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases import skipIfOS
-from ubuntuone.devtools.testcases.txsocketserver import (
+
+from devtools.handlers import MementoHandler
+from devtools.testcases import skipIfOS
+from devtools.testcases.txsocketserver import (
     TidyUnixServer,
     TCPPbServerTestCase,
 )
-
 from magicicadaclient.tests import TestCase
 from magicicadaclient.utils import ipc
 
 
=== modified file 'magicicadaclient/utils/tests/test_tcpactivation.py'
--- magicicadaclient/utils/tests/test_tcpactivation.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/utils/tests/test_tcpactivation.py	2018-06-03 23:09:20 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2011-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -36,11 +36,8 @@
 from twisted.internet import defer, protocol, task
 from twisted.trial.unittest import TestCase
 
-from ubuntuone.devtools.testcases.txsocketserver import (
-    ServerTestCase,
-    TidyTCPServer,
-)
 
+from devtools.testcases.txsocketserver import ServerTestCase, TidyTCPServer
 from magicicadaclient.utils import tcpactivation
 from magicicadaclient.utils.tcpactivation import (
     ActivationClient,
 
=== modified file 'magicicadaclient/utils/tests/test_translation.py'
--- magicicadaclient/utils/tests/test_translation.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/utils/tests/test_translation.py	2018-06-03 23:09:20 +0000
@@ -34,8 +34,8 @@
 import sys
 
 from twisted.internet import defer
-from ubuntuone.devtools.testcases import TestCase, skipIfNotOS
 
+from devtools.testcases import TestCase, skipIfNotOS
 from magicicadaclient.utils import translation
 
 TEST_DOMAIN = 'test-domain'
 
=== modified file 'magicicadaclient/utils/tests/test_txsecrets.py'
--- magicicadaclient/utils/tests/test_txsecrets.py	2018-05-19 20:44:54 +0000
+++ magicicadaclient/utils/tests/test_txsecrets.py	2018-06-03 23:09:20 +0000
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2010-2012 Canonical Ltd.
-# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -36,8 +36,8 @@
 import dbus.service
 
 from twisted.internet.defer import inlineCallbacks, returnValue
-from ubuntuone.devtools.testcases.dbus import DBusTestCase
 
+from devtools.testcases.dbus import DBusTestCase
 from magicicadaclient.utils import txsecrets
 
 KEY_TYPE_ATTR = {"key-type": "Foo credentials"}
 
=== modified file 'requirements-devel.txt'
--- requirements-devel.txt	2018-03-18 15:03:09 +0000
+++ requirements-devel.txt	2018-06-03 23:09:20 +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-06-03 23:09:20 +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-05-19 20:44:54 +0000
+++ run-tests	2018-06-03 23:09:20 +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-05-31 16:29:41 +0000
+++ setup.py	2018-06-03 23:09:20 +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',