- rework the test exclusions system to work on a consistent theme

1 files changed, 4 insertions, 306 deletions

diff --git a/test/lib/testing.py b/test/lib/testing.py
index 02d592235..1de446f91 100644
--- a/test/lib/testing.py
+++ b/test/lib/testing.py
@@ -1,7 +1,6 @@
 """TestCase and TestSuite artifacts and testing decorators."""
 
 import itertools
-import operator
 import re
 import sys
 import types
@@ -16,18 +15,11 @@ from engines import drop_all_tables
 from sqlalchemy import exc as sa_exc, util, types as sqltypes, schema, \
     pool, orm
 from sqlalchemy.engine import default
-from nose import SkipTest
+from exclusions import db_spec, _is_excluded, fails_if, skip_if, future,\
+    fails_on, fails_on_everything_except, skip, only_on, exclude, against,\
+    _server_version
 
-
-_ops = { '<': operator.lt,
-         '>': operator.gt,
-         '==': operator.eq,
-         '!=': operator.ne,
-         '<=': operator.le,
-         '>=': operator.ge,
-         'in': operator.contains,
-         'between': lambda val, pair: val >= pair[0] and val <= pair[1],
-         }
+crashes = skip
 
 # sugar ('testing.db'); set here by config() at runtime
 db = None
@@ -35,266 +27,6 @@ db = None
 # more sugar, installed by __init__
 requires = None
 
-def fails_if(callable_, reason=None):
-    """Mark a test as expected to fail if callable_ returns True.
-
-    If the callable returns false, the test is run and reported as normal.
-    However if the callable returns true, the test is expected to fail and the
-    unit test logic is inverted: if the test fails, a success is reported.  If
-    the test succeeds, a failure is reported.
-    """
-
-    docstring = getattr(callable_, '__doc__', None) or callable_.__name__
-    description = docstring.split('\n')[0]
-
-    @decorator
-    def decorate(fn, *args, **kw):
-        if not callable_():
-            return fn(*args, **kw)
-        else:
-            try:
-                fn(*args, **kw)
-            except Exception, ex:
-                print ("'%s' failed as expected (condition: %s): %s " % (
-                    fn.__name__, description, str(ex)))
-                return True
-            else:
-                raise AssertionError(
-                    "Unexpected success for '%s' (condition: %s)" %
-                    (fn.__name__, description))
-    return decorate
-
-@decorator
-def future(fn, *args, **kw):
-    """Mark a test as expected to unconditionally fail.
-
-    Takes no arguments, omit parens when using as a decorator.
-    """
-
-    try:
-        fn(*args, **kw)
-    except Exception, ex:
-        print ("Future test '%s' failed as expected: %s " % (
-            fn.__name__, str(ex)))
-        return True
-    else:
-        raise AssertionError(
-            "Unexpected success for future test '%s'" % fn.__name__)
-
-def db_spec(*dbs):
-    dialects = set([x for x in dbs if '+' not in x])
-    drivers = set([x[1:] for x in dbs if x.startswith('+')])
-    specs = set([tuple(x.split('+')) for x in dbs if '+' in x and x not in drivers])
-
-    def check(engine):
-        return engine.name in dialects or \
-            engine.driver in drivers or \
-            (engine.name, engine.driver) in specs
-
-    return check
-
-
-def fails_on(dbs, reason):
-    """Mark a test as expected to fail on the specified database
-    implementation.
-
-    Unlike ``crashes``, tests marked as ``fails_on`` will be run
-    for the named databases.  The test is expected to fail and the unit test
-    logic is inverted: if the test fails, a success is reported.  If the test
-    succeeds, a failure is reported.
-    """
-
-    spec = db_spec(dbs)
-
-    @decorator
-    def decorate(fn, *args, **kw):
-        if not spec(config.db):
-            return fn(*args, **kw)
-        else:
-            try:
-                fn(*args, **kw)
-            except Exception, ex:
-                print ("'%s' failed as expected on DB implementation "
-                        "'%s+%s': %s" % (
-                    fn.__name__, config.db.name, config.db.driver, reason))
-                return True
-            else:
-                raise AssertionError(
-                     "Unexpected success for '%s' on DB implementation '%s+%s'" %
-                     (fn.__name__, config.db.name, config.db.driver))
-    return decorate
-
-def fails_on_everything_except(*dbs):
-    """Mark a test as expected to fail on most database implementations.
-
-    Like ``fails_on``, except failure is the expected outcome on all
-    databases except those listed.
-    """
-
-    spec = db_spec(*dbs)
-
-    @decorator
-    def decorate(fn, *args, **kw):
-        if spec(config.db):
-            return fn(*args, **kw)
-        else:
-            try:
-                fn(*args, **kw)
-            except Exception, ex:
-                print ("'%s' failed as expected on DB implementation "
-                        "'%s+%s': %s" % (
-                    fn.__name__, config.db.name, config.db.driver, str(ex)))
-                return True
-            else:
-                raise AssertionError(
-                  "Unexpected success for '%s' on DB implementation '%s+%s'" %
-                  (fn.__name__, config.db.name, config.db.driver))
-    return decorate
-
-def crashes(db, reason):
-    """Mark a test as unsupported by a database implementation.
-
-    ``crashes`` tests will be skipped unconditionally.  Use for feature tests
-    that cause deadlocks or other fatal problems.
-
-    """
-    carp = _should_carp_about_exclusion(reason)
-    spec = db_spec(db)
-    @decorator
-    def decorate(fn, *args, **kw):
-        if spec(config.db):
-            msg = "'%s' unsupported on DB implementation '%s+%s': %s" % (
-                fn.__name__, config.db.name, config.db.driver, reason)
-            print msg
-            if carp:
-                print >> sys.stderr, msg
-            return True
-        else:
-            return fn(*args, **kw)
-    return decorate
-
-def _block_unconditionally(db, reason):
-    """Mark a test as unsupported by a database implementation.
-
-    Will never run the test against any version of the given database, ever,
-    no matter what.  Use when your assumptions are infallible; past, present
-    and future.
-
-    """
-    carp = _should_carp_about_exclusion(reason)
-    spec = db_spec(db)
-    @decorator
-    def decorate(fn, *args, **kw):
-        if spec(config.db):
-            msg = "'%s' unsupported on DB implementation '%s+%s': %s" % (
-                fn.__name__, config.db.name, config.db.driver, reason)
-            raise SkipTest(msg)
-        else:
-            return fn(*args, **kw)
-    return decorate
-
-def only_on(dbs, reason):
-    carp = _should_carp_about_exclusion(reason)
-    spec = db_spec(*util.to_list(dbs))
-    @decorator
-    def decorate(fn, *args, **kw):
-        if spec(config.db):
-            return fn(*args, **kw)
-        else:
-            msg = "'%s' unsupported on DB implementation '%s+%s': %s" % (
-                fn.__name__, config.db.name, config.db.driver, reason)
-            raise SkipTest(msg)
-    return decorate
-
-def exclude(db, op, spec, reason):
-    """Mark a test as unsupported by specific database server versions.
-
-    Stackable, both with other excludes and other decorators. Examples::
-
-      # Not supported by mydb versions less than 1, 0
-      @exclude('mydb', '<', (1,0))
-      # Other operators work too
-      @exclude('bigdb', '==', (9,0,9))
-      @exclude('yikesdb', 'in', ((0, 3, 'alpha2'), (0, 3, 'alpha3')))
-
-    """
-    carp = _should_carp_about_exclusion(reason)
-
-    @decorator
-    def decorate(fn, *args, **kw):
-        if _is_excluded(db, op, spec):
-            msg = "'%s' unsupported on DB %s version '%s': %s" % (
-                fn.__name__, config.db.name, _server_version(), reason)
-            raise SkipTest(msg)
-        else:
-            return fn(*args, **kw)
-    return decorate
-
-def _should_carp_about_exclusion(reason):
-    """Guard against forgotten exclusions."""
-    assert reason
-    for _ in ('todo', 'fixme', 'xxx'):
-        if _ in reason.lower():
-            return True
-    else:
-        if len(reason) < 4:
-            return True
-
-def _is_excluded(db, op, spec):
-    """Return True if the configured db matches an exclusion specification.
-
-    db:
-      A dialect name
-    op:
-      An operator or stringified operator, such as '=='
-    spec:
-      A value that will be compared to the dialect's server_version_info
-      using the supplied operator.
-
-    Examples::
-      # Not supported by mydb versions less than 1, 0
-      _is_excluded('mydb', '<', (1,0))
-      # Other operators work too
-      _is_excluded('bigdb', '==', (9,0,9))
-      _is_excluded('yikesdb', 'in', ((0, 3, 'alpha2'), (0, 3, 'alpha3')))
-    """
-
-    vendor_spec = db_spec(db)
-
-    if not vendor_spec(config.db):
-        return False
-
-    version = _server_version()
-
-    oper = hasattr(op, '__call__') and op or _ops[op]
-    return oper(version, spec)
-
-def _server_version(bind=None):
-    """Return a server_version_info tuple."""
-
-    if bind is None:
-        bind = config.db
-
-    # force metadata to be retrieved
-    conn = bind.connect()
-    version = getattr(bind.dialect, 'server_version_info', ())
-    conn.close()
-    return version
-
-def skip_if(predicate, reason=None):
-    """Skip a test if predicate is true."""
-    reason = reason or predicate.__name__
-    carp = _should_carp_about_exclusion(reason)
-
-    @decorator
-    def decorate(fn, *args, **kw):
-        if predicate():
-            msg = "'%s' skipped on DB %s version '%s': %s" % (
-                fn.__name__, config.db.name, _server_version(), reason)
-            raise SkipTest(msg)
-        else:
-            return fn(*args, **kw)
-    return decorate
 
 def emits_warning(*messages):
     """Mark a test as emitting a warning.
@@ -442,40 +174,6 @@ def global_cleanup_assertions():
     testutil.lazy_gc()
     assert not pool._refs, str(pool._refs)
 
-def against(*queries):
-    """Boolean predicate, compares to testing database configuration.
-
-    Given one or more dialect names, returns True if one is the configured
-    database engine.
-
-    Also supports comparison to database version when provided with one or
-    more 3-tuples of dialect name, operator, and version specification::
-
-      testing.against('mysql', 'postgresql')
-      testing.against(('mysql', '>=', (5, 0, 0))
-    """
-
-    for query in queries:
-        if isinstance(query, basestring):
-            if db_spec(query)(config.db):
-                return True
-        else:
-            name, op, spec = query
-            if not db_spec(name)(config.db):
-                continue
-
-            have = _server_version()
-
-            oper = hasattr(op, '__call__') and op or _ops[op]
-            if oper(have, spec):
-                return True
-    return False
-
-def _chain_decorators_on(fn, *decorators):
-    """Apply a series of decorators to fn, returning a decorated function."""
-    for decorator in reversed(decorators):
-        fn = decorator(fn)
-    return fn
 
 def run_as_contextmanager(ctx, fn, *arg, **kw):
     """Run the given function under the given contextmanager,