Merge lp:~dobey/ubuntuone-dev-tools/runner-refactor into lp:ubuntuone-dev-tools

[dobey]

Refactor u1trial to allow multiple different test running back-ends
Implement Option handling API that is compatible with twisted trial
Remove logic from u1trial script
Fix a typo in the dbus test case
Ignore .pc directory for pep8 in run-tests

[Roberto Alsina (ralsina)]

review: Approve

[Alejandro J. Cura (alecu)]

_get_flags and _get_params are too much alike, I think the common code should be merged.

There are no tests for the new code. Please create a new bug for that.

The code looks fine otherwise.

review: Needs Fixing

[lp:~dobey/ubuntuone-dev-tools/runner-refactor]

82. By dobey on 2012-08-02

Consolidate the _get_flags and _get_params code into a single function

[dobey (dobey)]

Have merged the flag/params parsers into a single function which the other two call now.

As for testing, I haven't filed a bug yet, as I had just realized something about the testing and wanted to discuss first. We can probably add more tests, but as this code is required to work for u1trial to run, and we're running the dev-tools tests with the u1trial which is in the branch itself, the code has at least 90% coverage, if not 100%, simply by running the tests already. I suppose we could make it >100% by adding a bunch of fake objects and options lists, and ensuring somehow that the parsed output is what we'd expect, but also not sure how useful that is right now.

[dobey (dobey)]

Bug about needing more tests is now filed as bug #1032336.

[Alejandro J. Cura (alecu)]

Refactored code looks good.|

review: Approve

=== modified file 'bin/u1trial'
--- bin/u1trial	2012-06-05 21:33:33 +0000
+++ bin/u1trial	2012-08-02 15:49:22 +0000
@@ -26,315 +26,14 @@
 # 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 that uses a private dbus session and glib main loop."""
+"""Test runner which works with special services and main loops."""
 
-import coverage
-import gc
-import inspect
 import os
-import re
 import sys
-import unittest
-
-from twisted.python.usage import UsageError
-from twisted.scripts import trial
-from twisted.trial.runner import TrialRunner
 
 sys.path.insert(0, os.path.abspath("."))
 
-from ubuntuone.devtools.testing.txcheck import TXCheckSuite
-
-
-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 TestRunner(TrialRunner):
-    """The test runner implementation."""
-
-    def __init__(self, config=None):
-        # 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, config['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
-        working_dir = os.path.join(self.tempdir, 'trial')
-
-        # Handle running trial in debug or dry-run mode
-        mode = None
-        if config['debug']:
-            mode = TrialRunner.DEBUG
-        if config['dry-run']:
-            mode = TrialRunner.DRY_RUN
-
-        # Hook up to the parent test runner
-        super(TestRunner, self).__init__(
-            reporterFactory=config['reporter'],
-            mode=mode,
-            profile=config['profile'],
-            logfile=config['logfile'],
-            tracebackFormat=config['tbformat'],
-            realTimeErrors=config['rterrors'],
-            uncleanWarnings=config['unclean-warnings'],
-            workingDirectory=working_dir,
-            forceGarbageCollection=config['force-gc'])
-
-        self.required_services = []
-        self.source_files = []
-
-    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:
-            print 'Path should be defined.'
-            exit(1)
-
-        # 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 xrange(config['loop']):
-                suite.addTest(old_suite)
-
-        return suite
-
-    # pylint: disable=C0103
-    def _runWithoutDecoration(self, test):
-        """run the tests."""
-        result = None
-        running_services = []
-
-        try:
-            # Start any required services
-            for service in self.required_services:
-                runner = service()
-                runner.start_service(tempdir=self.tempdir)
-                running_services.append(runner)
-
-            result = super(TestRunner, self)._runWithoutDecoration(test)
-        finally:
-            # Stop all the running services
-            for runner in running_services:
-                runner.stop_service()
-
-        return result
-
-
-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 Options(trial.Options):
-    """Class for options handling."""
-
-    optFlags = [["coverage", "c"],
-                ["gui", None],
-                ["help-reactors", None],
-                ]
-
-    optParameters = [["test", "t", None],
-                     ["loop", None, 1],
-                     ["ignore-modules", "i", ""],
-                     ["ignore-paths", "p", ""],
-                     ["reactor", "r", _get_default_reactor()],
-                     ]
-
-    def __init__(self):
-        self['tests'] = set()
-        super(Options, self).__init__()
-        self['rterrors'] = True
-
-    def opt_coverage(self):
-        """Generate a coverage report for the run tests"""
-        self['coverage'] = True
-
-    def opt_gui(self):
-        """Use the GUI mode of some reactors"""
-        self['gui'] = True
-
-    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.'
-        print
-        sys.exit(0)
-
-    def opt_test(self, option):
-        """Run specific tests, e.g: className.methodName"""
-        self['test'] = option
-
-    def opt_loop(self, option):
-        """Loop tests the specified number of times."""
-        try:
-            self['loop'] = long(option)
-        except ValueError:
-            raise UsageError('A positive integer value must be specified.')
-
-    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'] = map(str.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'] = map(str.strip, option.split(','))
-
-    def opt_reactor(self, option):
-        """Which reactor to use (see --help-reactors for a list
-           of possibilities)
-           """
-        self['reactor'] = option
-    opt_r = opt_reactor
-
-
-def main():
-    """Do the deed."""
-    if len(sys.argv) == 1:
-        sys.argv.append('--help')
-
-    config = Options()
-    config.parseOptions()
-
-    try:
-        reactor_name = 'ubuntuone.devtools.reactors.%s' % config['reactor']
-        reactor = __import__(reactor_name, None, None, [''])
-    except ImportError:
-        print 'The specified reactor is not supported.'
-        sys.exit(1)
-    else:
-        try:
-            reactor.install(options=config)
-        except ImportError:
-            print('The Python package providing the requested reactor is not '
-                  'installed. You can find it here: %s' % reactor.REACTOR_URL)
-            raise
-
-    trial_runner = TestRunner(config=config)
-    suite = trial_runner.get_suite(config)
-
-    if config['coverage']:
-        coverage.erase()
-        coverage.start()
-
-    if config['until-failure']:
-        result = trial_runner.runUntilFailure(suite)
-    else:
-        result = trial_runner.run(suite)
-
-    if config['coverage']:
-        coverage.stop()
-        coverage.report(trial_runner.source_files, ignore_errors=True,
-                        show_missing=False)
-
-    sys.exit(not result.wasSuccessful())
+from ubuntuone.devtools.runners import main
 
 
 if __name__ == '__main__':
 
=== modified file 'run-tests'
--- run-tests	2012-06-06 13:26:02 +0000
+++ run-tests	2012-08-02 15:49:22 +0000
@@ -21,6 +21,6 @@
 $PYTHON bin/u1trial --reactor=twisted -i "test_squid_windows.py" ubuntuone
 echo "Running style checks..."
 $PYTHON bin/u1lint
-pep8 --repeat . bin/* --exclude=*.bat
+pep8 --repeat . bin/* --exclude=*.bat,.pc
 rm -rf _trial_temp
 rm -rf .coverage
 
=== modified file 'setup.py'
--- setup.py	2012-06-05 21:28:52 +0000
+++ setup.py	2012-08-02 15:49:22 +0000
@@ -89,6 +89,7 @@
       packages=['ubuntuone',
                 'ubuntuone.devtools',
                 'ubuntuone.devtools.reactors',
+                'ubuntuone.devtools.runners',
                 'ubuntuone.devtools.services',
                 'ubuntuone.devtools.testing',
                 'ubuntuone.devtools.testcases'],
 
=== added file 'ubuntuone/devtools/errors.py'
--- ubuntuone/devtools/errors.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/errors.py	2012-08-02 15:49:22 +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 directory 'ubuntuone/devtools/runners'
=== added file 'ubuntuone/devtools/runners/__init__.py'
--- ubuntuone/devtools/runners/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/runners/__init__.py	2012-08-02 15:49:22 +0000
@@ -0,0 +1,286 @@
+# Copyright 2009-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""The base test runner object."""
+
+import coverage
+import gc
+import inspect
+import os
+import re
+import sys
+import unittest
+
+from ubuntuone.devtools.errors import TestError, UsageError
+from ubuntuone.devtools.testing.txcheck import TXCheckSuite
+from ubuntuone.devtools.utils import OptionParser
+
+__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 xrange(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],
+                     ]
+
+    def __init__(self, *args, **kwargs):
+        self['tests'] = set()
+        super(BaseTestOptions, self).__init__(*args, **kwargs)
+
+    def opt_help_runners(self):
+        """List the runners which are supported."""
+
+    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'] = map(str.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'] = map(str.strip, option.split(','))
+
+    def opt_loop(self, option):
+        """Loop tests the specified number of times."""
+        try:
+            self['loop'] = long(option)
+        except ValueError:
+            raise UsageError('A positive integer value must be specified.')
+
+    def opt_test(self, option):
+        """Run specific tests, e.g: className.methodName"""
+        self['test'] = option
+
+
+def _get_runner_options(runner_name):
+    """Return the test runner module, and its options object."""
+    module_name = 'ubuntuone.devtools.runners.%s' % runner_name
+    runner = __import__(module_name, None, None, [''])
+    options = None
+    if getattr(runner, 'TestOptions', None) is not None:
+        options = runner.TestOptions()
+    if options is None:
+        options = BaseTestOptions()
+    return (runner, options)
+
+
+def main():
+    """Do the deed."""
+    if len(sys.argv) == 1:
+        sys.argv.append('--help')
+
+    try:
+        pos = sys.argv.index('--runner')
+        runner_name = sys.argv.pop(pos + 1)
+        sys.argv.pop(pos)
+    except ValueError:
+        runner_name = 'txrunner'
+    finally:
+        runner, options = _get_runner_options(runner_name)
+        options.parseOptions()
+
+    test_runner = runner.TestRunner(options=options)
+    suite = test_runner.get_suite(options)
+
+    if options['coverage']:
+        coverage.erase()
+        coverage.start()
+
+    running_services = []
+
+    succeeded = False
+    try:
+        # Start any required services
+        for service_obj in test_runner.required_services:
+            service = service_obj()
+            service.start_service(tempdir=test_runner.tempdir)
+            running_services.append(service)
+
+        succeeded = test_runner.run_tests(suite)
+    finally:
+        # Stop all the running services
+        for service in running_services:
+            service.stop_service()
+
+    if options['coverage']:
+        coverage.stop()
+        coverage.report(test_runner.source_files, ignore_errors=True,
+                        show_missing=False)
+
+    sys.exit(not succeeded)
 
=== added file 'ubuntuone/devtools/runners/txrunner.py'
--- ubuntuone/devtools/runners/txrunner.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/runners/txrunner.py	2012-08-02 15:49:22 +0000
@@ -0,0 +1,126 @@
+# Copyright 2009-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""The twisted test runner and options."""
+import sys
+
+from twisted.scripts import trial
+from twisted.trial.runner import TrialRunner
+
+from ubuntuone.devtools.errors import TestError
+from ubuntuone.devtools.runners import BaseTestOptions, BaseTestRunner
+
+__all__ = ['TestRunner', 'TestOptions']
+
+
+class TestRunner(BaseTestRunner, TrialRunner):
+    """The twisted test runner implementation."""
+
+    def __init__(self, options=None):
+        # Handle running trial in debug or dry-run mode
+        self.config = options
+
+        try:
+            reactor_name = ('ubuntuone.devtools.reactors.%s' %
+                            self.config['reactor'])
+            reactor = __import__(reactor_name, None, None, [''])
+        except ImportError:
+            raise TestError('The specified reactor is not supported.')
+        else:
+            try:
+                reactor.install(options=self.config)
+            except ImportError:
+                raise TestError(
+                    'The Python package providing the requested reactor is '
+                    'not installed. You can find it here: %s' %
+                    reactor.REACTOR_URL)
+
+        mode = None
+        if self.config['debug']:
+            mode = TrialRunner.DEBUG
+        if self.config['dry-run']:
+            mode = TrialRunner.DRY_RUN
+
+        # Hook up to the parent test runner
+        super(TestRunner, self).__init__(
+            options=options,
+            reporterFactory=self.config['reporter'],
+            mode=mode,
+            profile=self.config['profile'],
+            logfile=self.config['logfile'],
+            tracebackFormat=self.config['tbformat'],
+            realTimeErrors=self.config['rterrors'],
+            uncleanWarnings=self.config['unclean-warnings'],
+            forceGarbageCollection=self.config['force-gc'])
+        # Named for trial compatibility.
+        # pylint: disable=C0103
+        self.workingDirectory = self.working_dir
+        # pylint: enable=C0103
+
+    def run_tests(self, suite):
+        """Run the twisted test suite."""
+        if self.config['until-failure']:
+            result = self.runUntilFailure(suite)
+        else:
+            result = self.run(suite)
+        return result.wasSuccessful()
+
+
+def _get_default_reactor():
+    """Return the platform-dependent default reactor to use."""
+    default_reactor = 'gi'
+    if sys.platform in ['darwin', 'win32']:
+        default_reactor = 'twisted'
+    return default_reactor
+
+
+class TestOptions(trial.Options, BaseTestOptions):
+    """Class for twisted options handling."""
+
+    optFlags = [["help-reactors", None],
+                ]
+
+    optParameters = [["reactor", "r", _get_default_reactor()],
+                     ]
+
+    def __init__(self, *args, **kwargs):
+        super(TestOptions, self).__init__(*args, **kwargs)
+        self['rterrors'] = True
+
+    def opt_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.')
+        print()
+        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
 
=== modified file 'ubuntuone/devtools/testcases/dbus.py'
--- ubuntuone/devtools/testcases/dbus.py	2012-03-30 17:44:03 +0000
+++ ubuntuone/devtools/testcases/dbus.py	2012-08-02 15:49:22 +0000
@@ -97,7 +97,7 @@
         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_ADDRES is wrong.')
+            raise InvalidSessionBus('DBUS_SESSION_BUS_ADDRESS is wrong.')
 
         # Set up the main loop and bus connection
         self.loop = DBusGMainLoop(set_as_default=True)
 
=== added file 'ubuntuone/devtools/utils.py'
--- ubuntuone/devtools/utils.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/utils.py	2012-08-02 15:49:22 +0000
@@ -0,0 +1,167 @@
+# Copyright 2009-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Utilities for Ubuntu One developer tools."""
+
+import getopt
+import sys
+
+from ubuntuone.devtools.errors import UsageError
+__all__ = ['OptionParser']
+
+
+def accumulate_list_attr(class_obj, attr, list_obj, base_class=None):
+    """Get all of the list attributes of attr from the class hierarchy,
+       and return a list of the lists."""
+    for base in class_obj.__bases__:
+        accumulate_list_attr(base, attr, list_obj)
+    if base_class is None or base_class in class_obj.__bases__:
+        list_obj.extend(class_obj.__dict__.get(attr, []))
+
+
+def unpack_padded(length, sequence, default=None):
+    """Pads a sequence to length with value of default.
+
+    Returns a list containing the original and padded values.
+    """
+    newlist = [default] * length
+    newlist[:len(sequence)] = list(sequence)
+    return newlist
+
+
+class OptionParser(dict):
+    """Base options for our test runner."""
+
+    def __init__(self, *args, **kwargs):
+        super(OptionParser, self).__init__(*args, **kwargs)
+
+        # Store info about the options and defaults
+        self.long_opts = []
+        self.short_opts = ''
+        self.docs = {}
+        self.defaults = {}
+        self.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.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.long_opts and
+                (len(opt) == 1 and opt not in self.short_opts)):
+                raise UsageError('No such options: "%s"' % opt)
+
+            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, has_default=False):
+        """Parse the arguments as either flags or parameters."""
+        long_opts, short_opts = [], ''
+        docs, defaults, dispatch = {}, {}, {}
+
+        _args = []
+        accumulate_list_attr(self.__class__, 'optFlags', _args)
+
+        for _arg in _args:
+            try:
+                if has_default:
+                    l_opt, s_opt, default, doc = unpack_padded(4, _arg)
+                else:
+                    default = False
+                    l_opt, s_opt, doc = unpack_padded(3, _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
+            long_opts.append(l_opt)
+            if s_opt is not None:
+                short_opts = short_opts + s_opt
+                docs[s_opt] = docs[l_opt]
+                dispatch[s_opt] = dispatch[l_opt]
+                defaults[s_opt] = defaults[l_opt]
+
+        return long_opts, short_opts, docs, defaults, None, dispatch
+
+    def _get_flags(self):
+        """Get the flag options."""
+        return self._parse_arguments(has_default=False)
+
+    def _get_params(self):
+        """Get the parameters options."""
+        return self._parse_arguments(has_default=True)