Merge lp:~dobey/ubuntuone-dev-tools/update-4-0 into lp:ubuntuone-dev-tools/stable-4-0

[dobey]

[Rodney Dawes]

    Test the new options parser
    Fix up handling of temp-directory and the test path args for non-txrunner usage
    Implement synonyms usage in options so some options work more correctly
    Add the necessary function definitions for twisted OptionsParser to handle the coverage flag correctly
    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

[lp:~dobey/ubuntuone-dev-tools/update-4-0]

79. By dobey on 2012-08-21

[Rodney Dawes]

    Test the new options parser
    Fix up handling of temp-directory and the test path args for non-txrunner usage
    Implement synonyms usage in options so some options work more correctly
    Add the necessary function definitions for twisted OptionsParser to handle the coverage flag correctly
    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

=== modified file '.bzrignore'
--- .bzrignore	2010-07-14 21:39:08 +0000
+++ .bzrignore	2012-08-20 19:38:21 +0000
@@ -1,3 +1,4 @@
+.coverage
 MANIFEST
 build
 dist

=== modified file 'bin/u1trial'
--- bin/u1trial	2012-06-05 21:33:33 +0000
+++ bin/u1trial	2012-08-20 19:38:21 +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-20 19:38:21 +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-07-31 14:45:32 +0000
+++ setup.py	2012-08-20 19:38:21 +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-20 19:38:21 +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-20 19:38:21 +0000
@@ -0,0 +1,303 @@
+# Copyright 2009-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""The base test runner object."""
+
+from __future__ import print_function, unicode_literals
+
+import coverage
+import gc
+import inspect
+import os
+import re
+import sys
+import unittest
+
+from ubuntuone.devtools.errors import TestError, UsageError
+from ubuntuone.devtools.testing.txcheck import TXCheckSuite
+from ubuntuone.devtools.utils import OptionParser
+
+__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],
+                     ['temp-directory', None, '_trial_temp', None],
+                     ]
+
+    def __init__(self, *args, **kwargs):
+        super(BaseTestOptions, self).__init__(*args, **kwargs)
+        self['tests'] = set()
+
+    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'] = map(unicode.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(unicode.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_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.
+    # pylint: disable=C0103
+    def parseArgs(self, *args):
+        """Handle the extra arguments."""
+        self['tests'].update(args)
+    # pylint: enable=C0103
+
+
+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-20 19:38:21 +0000
@@ -0,0 +1,133 @@
+# Copyright 2009-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""The twisted test runner and options."""
+
+from __future__ import print_function, unicode_literals
+
+import sys
+
+from twisted.scripts import trial
+from twisted.trial.runner import TrialRunner
+
+from ubuntuone.devtools.errors import TestError
+from ubuntuone.devtools.runners import BaseTestOptions, BaseTestRunner
+
+__all__ = ['TestRunner', 'TestOptions']
+
+
+class TestRunner(BaseTestRunner, TrialRunner):
+    """The twisted test runner implementation."""
+
+    def __init__(self, options=None):
+        # Handle running trial in debug or dry-run mode
+        self.config = options
+
+        try:
+            reactor_name = ('ubuntuone.devtools.reactors.%s' %
+                            self.config['reactor'])
+            reactor = __import__(reactor_name, None, None, [''])
+        except ImportError:
+            raise TestError('The specified reactor is not supported.')
+        else:
+            try:
+                reactor.install(options=self.config)
+            except ImportError:
+                raise TestError(
+                    'The Python package providing the requested reactor is '
+                    'not installed. You can find it here: %s' %
+                    reactor.REACTOR_URL)
+
+        mode = None
+        if self.config['debug']:
+            mode = TrialRunner.DEBUG
+        if self.config['dry-run']:
+            mode = TrialRunner.DRY_RUN
+
+        # Hook up to the parent test runner
+        super(TestRunner, self).__init__(
+            options=options,
+            reporterFactory=self.config['reporter'],
+            mode=mode,
+            profile=self.config['profile'],
+            logfile=self.config['logfile'],
+            tracebackFormat=self.config['tbformat'],
+            realTimeErrors=self.config['rterrors'],
+            uncleanWarnings=self.config['unclean-warnings'],
+            forceGarbageCollection=self.config['force-gc'])
+        # Named for trial compatibility.
+        # pylint: disable=C0103
+        self.workingDirectory = self.working_dir
+        # pylint: enable=C0103
+
+    def run_tests(self, suite):
+        """Run the twisted test suite."""
+        if self.config['until-failure']:
+            result = self.runUntilFailure(suite)
+        else:
+            result = self.run(suite)
+        return result.wasSuccessful()
+
+
+def _get_default_reactor():
+    """Return the platform-dependent default reactor to use."""
+    default_reactor = 'gi'
+    if sys.platform in ['darwin', 'win32']:
+        default_reactor = 'twisted'
+    return default_reactor
+
+
+class TestOptions(trial.Options, BaseTestOptions):
+    """Class for twisted options handling."""
+
+    optFlags = [["help-reactors", None],
+                ]
+
+    optParameters = [["reactor", "r", _get_default_reactor()],
+                     ]
+
+    def __init__(self, *args, **kwargs):
+        super(TestOptions, self).__init__(*args, **kwargs)
+        self['rterrors'] = True
+
+    def opt_coverage(self, option):
+        """Handle special flags."""
+        self['coverage'] = True
+    opt_c = opt_coverage
+
+    def opt_help_reactors(self):
+        """Help on available reactors for use with tests"""
+        synopsis = ('')
+        print(synopsis)
+        print('Need to get list of reactors and print them here.\n')
+        sys.exit(0)
+
+    def opt_reactor(self, option):
+        """Which reactor to use (see --help-reactors for a list
+           of possibilities)
+           """
+        self['reactor'] = option
+    opt_r = opt_reactor

=== 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-20 19:38:21 +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/tests/test_utils.py'
--- ubuntuone/devtools/tests/test_utils.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/tests/test_utils.py	2012-08-20 19:38:21 +0000
@@ -0,0 +1,110 @@
+# -*- 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.
+"""Test the utils module."""
+
+from __future__ import print_function, unicode_literals
+
+from twisted.internet.defer import inlineCallbacks
+from ubuntuone.devtools.errors import UsageError
+from ubuntuone.devtools.testcases import BaseTestCase
+from ubuntuone.devtools.utils import OptionParser
+
+
+class FakeOptions(OptionParser):
+    """Fake options class for testing."""
+
+    optFlags = [['foo', 'f', 'Save the manatees.'],
+                ['bar', None, 'Beyond all recognition.'],
+                ]
+
+    optParameters = [['stuff', 's', 'things'],
+                     ]
+
+    def __init__(self, *args, **kwargs):
+        super(FakeOptions, self).__init__(*args, **kwargs)
+
+    def opt_foo(self):
+        """Handle the foo flag."""
+        pass
+
+    def opt_stuff(self, option):
+        """Handle the stuff option."""
+        self['stuff'] = option
+
+
+class OptionParserTestCase(BaseTestCase):
+    """Test the OptionParser class."""
+
+    @inlineCallbacks
+    def setUp(self, *args, **kwargs):
+        yield super(OptionParserTestCase, self).setUp(*args, **kwargs)
+        self.options = FakeOptions()
+
+    def test_get_flags_long_arg(self):
+        """Test that getting a flag works properly."""
+        args = ['--foo', 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertTrue(self.options['foo'])
+
+    def test_get_flags_short_arg(self):
+        """Test that using the short version of a flag works."""
+        args = ['-f', 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertTrue(self.options['foo'])
+
+    def test_get_params_combined_arg(self):
+        """Test that getting a parameter works properly."""
+        expected = 'baz'
+        args = ['--stuff=' + expected, 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertEqual(expected, self.options['stuff'])
+
+    def test_get_params_missing_arg(self):
+        """Test that passing no parameter argument fails correctly."""
+        args = ['--stuff']
+        self.assertRaises(UsageError, self.options.parseOptions, options=args)
+
+    def test_get_params_short_arg(self):
+        """Test that using the short version of a parameter works."""
+        expected = 'baz'
+        args = ['-s', expected, 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertEqual(expected, self.options['stuff'])
+
+    def test_get_params_split_arg(self):
+        """Test that passing a parameter argument separately works."""
+        expected = 'baz'
+        args = ['--stuff', expected, 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertEqual(expected, self.options['stuff'])
+
+    def test_unknown_option(self):
+        """Test that passing an unknown option fails."""
+        args = ['--unknown', 'pathname']
+        self.assertRaises(UsageError, self.options.parseOptions, options=args)

=== added file 'ubuntuone/devtools/utils.py'
--- ubuntuone/devtools/utils.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/utils.py	2012-08-20 19:38:21 +0000
@@ -0,0 +1,180 @@
+# Copyright 2009-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Utilities for Ubuntu One developer tools."""
+
+from __future__ import print_function, unicode_literals
+
+import getopt
+import sys
+
+from ubuntuone.devtools.errors import UsageError
+__all__ = ['OptionParser']
+
+
+def accumulate_list_attr(class_obj, attr, list_obj, base_class=None):
+    """Get all of the list attributes of attr from the class hierarchy,
+       and return a list of the lists."""
+    for base in class_obj.__bases__:
+        accumulate_list_attr(base, attr, list_obj)
+    if base_class is None or base_class in class_obj.__bases__:
+        list_obj.extend(class_obj.__dict__.get(attr, []))
+
+
+def unpack_padded(length, sequence, default=None):
+    """Pads a sequence to length with value of default.
+
+    Returns a list containing the original and padded values.
+    """
+    newlist = [default] * length
+    newlist[:len(sequence)] = list(sequence)
+    return newlist
+
+
+class OptionParser(dict):
+    """Base options for our test runner."""
+
+    def __init__(self, *args, **kwargs):
+        super(OptionParser, self).__init__(*args, **kwargs)
+
+        # Store info about the options and defaults
+        self.long_opts = []
+        self.short_opts = ''
+        self.docs = {}
+        self.defaults = {}
+        self.synonyms = {}
+        self.dispatch = {}
+
+        # Get the options and defaults
+        for _get in [self._get_flags, self._get_params]:
+            # We don't use variable 'syns' here. It's just to pad the result.
+            # pylint: disable=W0612
+            (long_opts, short_opts, docs, defaults, syns, dispatch) = _get()
+            # pylint: enable=W0612
+            self.long_opts.extend(long_opts)
+            self.short_opts = self.short_opts + short_opts
+            self.docs.update(docs)
+            self.update(defaults)
+            self.defaults.update(defaults)
+            self.synonyms.update(syns)
+            self.dispatch.update(dispatch)
+
+    # We use some camelcase names for trial compatibility here.
+    # pylint: disable=C0103
+    def parseOptions(self, options=None):
+        """Parse the options."""
+        if options is None:
+            options = sys.argv[1:]
+
+        try:
+            opts, args = getopt.getopt(options,
+                                       self.short_opts, self.long_opts)
+        except getopt.error as e:
+            raise UsageError(e)
+
+        for opt, arg in opts:
+            if opt[1] == '-':
+                opt = opt[2:]
+            else:
+                opt = opt[1:]
+
+            if (opt not in self.synonyms.keys()):
+                raise UsageError('No such options: "%s"' % opt)
+
+            opt = self.synonyms[opt]
+            if self.defaults[opt] is False:
+                self[opt] = True
+            else:
+                self.dispatch[opt](arg)
+
+        try:
+            self.parseArgs(*args)
+        except TypeError:
+            raise UsageError('Wrong number of arguments.')
+
+        self.postOptions()
+
+    def postOptions(self):
+        """Called after options are parsed."""
+
+    def parseArgs(self, *args):
+        """Override to handle extra arguments specially."""
+    # pylint: enable=C0103
+
+    def _parse_arguments(self, arg_type=None, has_default=False):
+        """Parse the arguments as either flags or parameters."""
+        long_opts, short_opts = [], ''
+        docs, defaults, syns, dispatch = {}, {}, {}, {}
+
+        _args = []
+        accumulate_list_attr(self.__class__, arg_type, _args)
+
+        for _arg in _args:
+            try:
+                if has_default:
+                    l_opt, s_opt, default, doc = unpack_padded(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
+            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)