Merge lp:~dobey/ubuntu/precise/ubuntuone-dev-tools/release-2-99-0 into lp:ubuntu/precise/ubuntuone-dev-tools

[dobey]

[Daniel Holbach (dholbach)]

Needs bug 907888 to be resolved first. changelog entry has wrong email address, but that not a big deal.

[lp:~dobey/ubuntu/precise/ubuntuone-dev-tools/release-2-99-0]

8. By dobey on 2011-12-23

Fix e-mail

9. By dobey on 2012-01-04

New upstream release.

10. By dobey on 2012-01-04

Fix dirspec dep to be 2.99.0 and not 3.1

[Ken VanDine (ken-vandine)]

Looks good

review: Approve

=== modified file 'PKG-INFO'
--- PKG-INFO	2011-09-13 14:48:46 +0000
+++ PKG-INFO	2012-01-04 20:35:34 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: ubuntuone-dev-tools
-Version: 0.2.0
+Version: 2.99.1
 Summary: Ubuntu One development tools and utilities
 Home-page: http://launchpad.net/ubuntuone-dev-tools
 Author: UNKNOWN
 
=== modified file 'bin/u1lint'
--- bin/u1lint	2011-09-13 14:48:46 +0000
+++ bin/u1lint	2012-01-04 20:35:34 +0000
@@ -4,7 +4,7 @@
 #
 # Author: Rodney Dawes <[e-mail]>
 #
-# Copyright 2009-2010 Canonical Ltd.
+# Copyright 2009-2011 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
@@ -25,7 +25,7 @@
 import subprocess
 import sys
 
-from xdg.BaseDirectory import xdg_data_dirs
+from dirspec.basedir import xdg_data_dirs
 
 SRCDIR = os.environ.get('SRCDIR', os.getcwd())
 
@@ -33,7 +33,7 @@
 class InvalidSetupException(Exception):
     """Raised when the env is not correctly setup."""
 
-    
+
 def find_python_installation_path():
     """Return the path where python was installed."""
     assert(sys.platform == 'win32')
@@ -98,7 +98,8 @@
         # the default is to assume that the script is executable and that it
         # can be found in the path
         return [script, ]
-    
+
+
 def find_pylintrc():
     """Return the first pylintrc found."""
     # Use the pylintrc in the source tree if there is one
@@ -114,8 +115,10 @@
             return full_name
     return None
 
+
 PYLINTRC = find_pylintrc()
 
+
 def _read_pylintrc_ignored():
     """Get the ignored files list from pylintrc"""
     try:
@@ -129,6 +132,7 @@
         return []
     # pylint: enable=E1103
 
+
 def _group_lines_by_file(data):
     """Format file:line:message output as lines grouped by file."""
     did_fail = False
@@ -156,6 +160,7 @@
 
     return (did_fail, "\n".join(outputs))
 
+
 def _find_files():
     """Find all Python files under the current tree."""
     pyfiles = []
@@ -199,7 +204,7 @@
     else:
         pylint_args = get_subprocess_start_info('pylint')
         # append the extra args to the start info
-        pylint_args.extend(['--output-format=parseable', 
+        pylint_args.extend(['--output-format=parseable',
             '--include-ids=yes'])
         if PYLINTRC:
             pylint_args.append("--rcfile=" + PYLINTRC)
 
=== modified file 'bin/u1trial'
--- bin/u1trial	2011-09-13 14:48:46 +0000
+++ bin/u1trial	2012-01-04 20:35:34 +0000
@@ -4,7 +4,7 @@
 #
 # Author: Rodney Dawes <[e-mail]>
 #
-# Copyright 2009-2010 Canonical Ltd.
+# Copyright 2009-2011 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
@@ -28,11 +28,14 @@
 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."""
@@ -45,12 +48,10 @@
 class TestRunner(TrialRunner):
     """The test runner implementation."""
 
-    def __init__(self, force_gc=False):
-        from twisted.trial.reporter import TreeReporter
-
+    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, '_trial_temp')
+        homedir = os.path.join(trial_temp_dir, config['temp-directory'])
         os.environ['HOME'] = homedir
 
         # setup $XDG_*_HOME variables and create the directories
@@ -71,12 +72,29 @@
         # 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, 'tmp')
-        super(TestRunner, self).__init__(reporterFactory=TreeReporter,
-                                         realTimeErrors=True,
-                                         workingDirectory=working_dir,
-                                         forceGarbageCollection=force_gc)
+        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 = []
 
@@ -112,23 +130,11 @@
     def _collect_tests(self, path, test_pattern, ignored_modules,
         ignored_paths):
         """Return the set of unittests."""
-        suite = unittest.TestSuite()
+        suite = TXCheckSuite()
         if test_pattern:
             pattern = re.compile('.*%s.*' % test_pattern)
         else:
             pattern = None
-            
-        # get the ignored modules/tests
-        if ignored_modules:
-            ignored_modules = map(str.strip, ignored_modules.split(','))
-        else:
-            ignored_modules = []
-
-        # get the ignored paths
-        if ignored_paths:
-            ignored_paths = map(str.strip, ignored_paths.split(','))
-        else:
-            ignored_paths = []
 
         # Disable this lint warning as we need to access _tests in the
         # test suites, to collect the tests
@@ -169,100 +175,150 @@
                             suite.addTests(module_suite)
         return suite
 
-    # pylint: disable=E0202
-    def run(self, args, options=None):
+    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."""
-        success = 0
+        result = None
         running_services = []
-        if options.coverage:
-            coverage.erase()
-            coverage.start()
 
         try:
-            suite = unittest.TestSuite()
-            for path in args:
-                print "Adding path"
-                suite.addTest(self._collect_tests(path, options.test,
-                                                  options.ignored_modules,
-                                                  options.ignored_paths))
-            if options.loops:
-                old_suite = suite
-                suite = unittest.TestSuite()
-                for _ in xrange(options.loops):
-                    suite.addTest(old_suite)
-
             # 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).run(suite)
-            success = result.wasSuccessful()
+            result = super(TestRunner, self)._runWithoutDecoration(test)
         finally:
             # Stop all the running services
             for runner in running_services:
                 runner.stop_service()
 
-        if options.coverage:
-            coverage.stop()
-            coverage.report(self.source_files, ignore_errors=True,
-                            show_missing=False)
-
-        if not success:
-            sys.exit(1)
-        else:
-            sys.exit(0)
+        return result
+
+
+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", "glib"],
+                     ]
+
+    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."""
-    from optparse import OptionParser
-    usage = '%prog [options] path'
-    parser = OptionParser(usage=usage)
-    parser.add_option("-t", "--test", dest="test",
-                  help = "run specific tests, e.g: className.methodName")
-    parser.add_option("-l", "--loop", dest="loops", type="int", default=1,
-                      help = "loop selected tests LOOPS number of times",
-                      metavar="LOOPS")
-    parser.add_option("-c", "--coverage", action="store_true", dest="coverage",
-                      help="print a coverage report when finished")
-    parser.add_option("-i", "--ignored-modules", dest="ignored_modules",
-                      default=None, help="comma-separated test moodules "
-                      + "to ignore, e.g: test_gtk.py, test_account.py")
-    parser.add_option("-p", "--ignore-paths", dest="ignored_paths",
-                      default=None, help="comma-separated relative "
-                      + "paths to ignore. "
-                      + "e.g: tests/platform/windows, tests/platform/macosx")
-    parser.add_option("--force-gc", action="store_true", dest="force_gc", 
-                      default=False, help="Run gc.collect() before and after "
-                      "each test case.")
-    parser.add_option("--reactor", type="string", dest="reactor",
-                      default='glib',
-                      help="Run the tests using the specified reactor.",
-                      metavar="REACTOR")
-    parser.add_option("--gui", action="store_true", dest="use_gui",
-                      help="Use the GUI mode of some reactors.")
-    (options, args) = parser.parse_args()
-    if not args:
-        parser.print_help()
-        sys.exit(2)
+    if len(sys.argv) == 1:
+        sys.argv.append('--help')
+
+    config = Options()
+    config.parseOptions()
 
     try:
-        reactor_name = 'ubuntuone.devtools.reactors.%s' % options.reactor
+        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=options)
+            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
 
-    TestRunner(force_gc=options.force_gc).run(args, options)
+    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())
 
 
 if __name__ == '__main__':
 
=== modified file 'debian/changelog'
--- debian/changelog	2011-09-15 20:52:05 +0000
+++ debian/changelog	2012-01-04 20:35:34 +0000
@@ -1,3 +1,23 @@
+ubuntuone-dev-tools (2.99.1-0ubuntu1) precise; urgency=low
+
+  * New upstream release.
+
+ -- Rodney Dawes <[e-mail]>  Wed, 04 Jan 2012 13:12:03 -0500
+
+ubuntuone-dev-tools (2.99.0-0ubuntu1) precise; urgency=low
+
+  * New upstream release.
+    - Depends on dirspec now (LP: #888619)
+    - Pass options through to trial (LP: #890786)
+  * debian/control:
+    - Move python-gobject to Suggests
+    - Suggest python-qt4reactor
+  * debian/rules:
+    - Convert to pure dh
+    - Run unit tests during build
+
+ -- Rodney Dawes <[e-mail]>  Thu, 22 Dec 2011 16:33:22 -0500
+
 ubuntuone-dev-tools (0.2.0-0ubuntu1) oneiric; urgency=low
 
   * New upstream release.
 
=== modified file 'debian/control'
--- debian/control	2011-09-15 20:52:05 +0000
+++ debian/control	2012-01-04 20:35:34 +0000
@@ -3,27 +3,29 @@
 XSBC-Original-Maintainer: Rodney Dawes <[e-mail]>
 Section: python
 Priority: optional
-Standards-Version: 3.9.1
+Standards-Version: 3.9.2
+X-Python-Version: >= 2.6
 Build-Depends-Indep:
  dbus,
  pep8,
  pylint (>= 0.21.0),
  python-coverage,
  python-dbus,
+ python-dirspec (>= 2.99.0),
  python-gobject,
  python-qt4,
  python-setuptools,
- python-support,
- python-twisted-core,
- python-xdg
-Build-Depends: cdbs (>= 0.4.43), debhelper (>= 7.0.17), python-all
+ python-twisted-core
+Build-Depends: debhelper (>= 7.0.50),
+ python-all (>= 2.6.6-3)
 Homepage: http://launchpad.net/ubuntuone-dev-tools
 
 Package: python-ubuntuone-devtools
 Architecture: all
 Depends: ${python:Depends}, ${misc:Depends},
  dbus,
- python-dbus
+ python-dbus,
+ python-dirspec (>= 2.99.0)
 Description: Ubuntu One development tools - Python modules
  Ubuntu One development tools provides scripts, test cases, and other
  utilities for developing Python projects which need more integration
@@ -35,10 +37,9 @@
 Depends: ${python:Depends}, ${misc:Depends}, python,
  pylint (>= 0.21.0) | pyflakes,
  python-coverage,
- python-gobject,
  python-twisted-core,
- python-ubuntuone-devtools (= ${binary:Version}),
- python-xdg
+ python-ubuntuone-devtools (= ${binary:Version})
+Suggests: python-gobject, python-qt4reactor
 Description: Ubuntu One development tools
  Ubuntu One development tools provides scripts, test cases, and other
  utilities for developing Python projects which need more integration
 
=== removed file 'debian/pycompat'
--- debian/pycompat	2010-08-02 13:45:54 +0000
+++ debian/pycompat	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-2
 
=== modified file 'debian/rules'
--- debian/rules	2010-11-30 18:59:50 +0000
+++ debian/rules	2012-01-04 20:35:34 +0000
@@ -1,13 +1,8 @@
 #!/usr/bin/make -f
 
-include /usr/share/cdbs/1/rules/debhelper.mk
-DEB_PYTHON_SYSTEM=pysupport
-include /usr/share/cdbs/1/class/python-distutils.mk
-
-common-build-arch common-build-indep:: debian/stamp-check
-debian/stamp-check:
-	cd $(DEB_SRCDIR) && ./run-tests
-	touch $@
-
-makefile-clean::
-	rm -f debian/stamp-check
+%:
+	dh --with python2 $@
+
+override_dh_auto_test:
+	./run-tests
+
 
=== modified file 'run-tests'
--- run-tests	2011-09-13 14:48:46 +0000
+++ run-tests	2012-01-04 20:35:34 +0000
@@ -1,7 +1,7 @@
 #!/bin/bash
 # Author: Natalia Bidart <[e-mail]>
 #
-# Copyright 2010 Canonical Ltd.
+# Copyright 2010-2011 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
@@ -18,7 +18,8 @@
 
 bin/u1trial -c ubuntuone
 bin/u1trial --reactor=twisted ubuntuone
+echo "Running style checks..."
 bin/u1lint
-pep8 --repeat .
+pep8 --repeat . bin/*
 rm -rf _trial_temp
 rm -rf .coverage
 
=== modified file 'setup.py'
--- setup.py	2011-09-13 14:48:46 +0000
+++ setup.py	2012-01-04 20:35:34 +0000
@@ -21,7 +21,7 @@
 from distutils.core import setup, Command
 
 PACKAGE = 'ubuntuone-dev-tools'
-VERSION = '0.2.0'
+VERSION = '2.99.1'
 
 U1LINT = 'bin/u1lint'
 
@@ -51,7 +51,9 @@
       packages=['ubuntuone',
                 'ubuntuone.devtools',
                 'ubuntuone.devtools.reactors',
-                'ubuntuone.devtools.services'],
+                'ubuntuone.devtools.services',
+                'ubuntuone.devtools.testing',
+                'ubuntuone.devtools.testcases'],
       extra_path='ubuntuone-dev-tools',
       scripts=['bin/u1lint',
                'bin/u1trial',
 
=== modified file 'ubuntuone/devtools/reactors/glib.py'
--- ubuntuone/devtools/reactors/glib.py	2011-09-13 14:48:46 +0000
+++ ubuntuone/devtools/reactors/glib.py	2012-01-04 20:35:34 +0000
@@ -17,7 +17,7 @@
 def install(options=None):
     """Install the reactor and parse any options we might need."""
     reactor_name = None
-    if options is not None and options.use_gui:
+    if options is not None and options['gui']:
         reactor_name = 'twisted.internet.gtk2reactor'
     else:
         reactor_name = 'twisted.internet.glib2reactor'
 
=== modified file 'ubuntuone/devtools/reactors/qt4.py'
--- ubuntuone/devtools/reactors/qt4.py	2011-09-13 14:48:46 +0000
+++ ubuntuone/devtools/reactors/qt4.py	2012-01-04 20:35:34 +0000
@@ -22,12 +22,19 @@
 
 def install(options=None):
     """Install the reactor and parse any options we might need."""
-    if options is not None and options.use_gui:
+    if options is not None and options['gui']:
         from PyQt4.QtGui import QApplication
         # We must assign this to a variable, or we will get crashes in Qt
         # pylint: disable=W0612
         app = QApplication(sys.argv)
         # pylint: enable=W0612
 
-    qt4reactor = __import__('qtreactor.qt4reactor', None, None, [''])
+    try:
+        qt4reactor = __import__('qt4reactor', None, None, [''])
+    except ImportError:
+        # Leave this import in place for a couple of weeks
+        # until all the devs are using the packaged qt4reactor
+        # (nessita, 11-11-11)
+        qt4reactor = __import__('qtreactor.qt4reactor', None, None, [''])
+
     qt4reactor.install()
 
=== modified file 'ubuntuone/devtools/services/dbus.py'
--- ubuntuone/devtools/services/dbus.py	2011-09-13 14:48:46 +0000
+++ ubuntuone/devtools/services/dbus.py	2012-01-04 20:35:34 +0000
@@ -20,9 +20,9 @@
 import signal
 import subprocess
 
+from dirspec.basedir import load_data_paths
 from distutils.spawn import find_executable
 from urllib import quote
-from xdg.BaseDirectory import load_data_paths
 
 
 class DBusLaunchError(Exception):
 
=== modified file 'ubuntuone/devtools/testcase.py'
--- ubuntuone/devtools/testcase.py	2011-09-13 14:48:46 +0000
+++ ubuntuone/devtools/testcase.py	2012-01-04 20:35:34 +0000
@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
-
-# Author: Guillermo Gonzalez <[e-mail]>
 #
-# Copyright 2009-2010 Canonical Ltd.
+# Copyright 2011 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
@@ -15,245 +13,13 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-"""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.internet import defer
-from twisted.trial.unittest import TestCase, SkipTest
-
-# DBusRunner for DBusTestCase using tests
-from ubuntuone.devtools.services.dbus import DBusRunner
-
-
-# pylint: disable=F0401,C0103
-try:
-    import dbus
-except ImportError:
-    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
[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
-
-
-# pylint: enable=C0103
-
-
-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"""
-
-
-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), 0755)
-        if not os.access(path, os.W_OK):
-            os.chmod(path, 0755)
-        # 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), 0777)
-        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, 0755)
-        os.makedirs(path)
-
-
-@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
-        from urllib import unquote
-        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.')
-
-        # Set up the main loop and bus connection
-        self.loop = DBusGMainLoop(set_as_default=True)
-        self.bus = dbus.bus.BusConnection(address_or_type=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()
+"""Maintain old API."""
+
+import warnings
+warnings.warn(
+            'Deprecated import path; use ubuntuone.devtools.testcases'
+            'instead.', DeprecationWarning, stacklevel=2)
+
+# pylint: disable=W0401,W0614
+from ubuntuone.devtools.testcases import *
+from ubuntuone.devtools.testcases.dbus import *
 
=== added directory 'ubuntuone/devtools/testcases'
=== added file 'ubuntuone/devtools/testcases/__init__.py'
--- ubuntuone/devtools/testcases/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testcases/__init__.py	2012-01-04 20:35:34 +0000
@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2009-2011 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/>.
+
+"""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
+
+
+# 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), 0755)
+        if not os.access(path, os.W_OK):
+            os.chmod(path, 0755)
+        # 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), 0777)
+        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, 0755)
+        os.makedirs(path)
 
=== added file 'ubuntuone/devtools/testcases/dbus.py'
--- ubuntuone/devtools/testcases/dbus.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testcases/dbus.py	2012-01-04 20:35:34 +0000
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2009-2011 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/>.
+
+"""Base tests cases and test utilities."""
+
+from __future__ import absolute_import, with_statement
+
+import os
+
+from twisted.internet import defer
+
+# lint seems not tow work well when we use decorators
+# pylint:disable=W0611
+from ubuntuone.devtools.testcase import BaseTestCase, skipIf
+# pylint:enable=W0611
+# DBusRunner for DBusTestCase using tests
+from ubuntuone.devtools.services.dbus import DBusRunner
+
+
+# pylint: disable=F0401,C0103,W0406,E0611
+try:
+    import dbus
+except ImportError, 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
+        from urllib import unquote
+        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.')
+
+        # Set up the main loop and bus connection
+        self.loop = DBusGMainLoop(set_as_default=True)
+        self.bus = dbus.bus.BusConnection(address_or_type=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 directory 'ubuntuone/devtools/testing'
=== added file 'ubuntuone/devtools/testing/__init__.py'
--- ubuntuone/devtools/testing/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testing/__init__.py	2012-01-04 20:35:34 +0000
@@ -0,0 +1,1 @@
+"""Testing helpers."""
 
=== added file 'ubuntuone/devtools/testing/txcheck.py'
--- ubuntuone/devtools/testing/txcheck.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testing/txcheck.py	2012-01-04 20:35:34 +0000
@@ -0,0 +1,366 @@
+# -*- coding: utf-8 -*-
+
+# Author: Tim Cole <[e-mail]>
+#
+# Copyright 2011 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/>.
+
+"""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__.iteritems():
+            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()
+    test = lambda node: 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)