- test updates

4 files changed, 102 insertions, 49 deletions

diff --git a/lib/sqlalchemy/testing/exclusions.py b/lib/sqlalchemy/testing/exclusions.py
index 07e3e7b7f..c53d98568 100644
--- a/lib/sqlalchemy/testing/exclusions.py
+++ b/lib/sqlalchemy/testing/exclusions.py
@@ -3,43 +3,35 @@ from nose import SkipTest
 from ..util import decorator
 from . import config
 from .. import util
+import contextlib
 
 
-class fails_if(object):
+class skip_if(object):
     def __init__(self, predicate, reason=None):
         self.predicate = _as_predicate(predicate)
         self.reason = reason
 
+    _fails_on = None
+
     @property
     def enabled(self):
         return not self.predicate()
 
-    def __call__(self, fn):
-        @decorator
-        def decorate(fn, *args, **kw):
-            if not self.predicate():
-                return fn(*args, **kw)
+    @contextlib.contextmanager
+    def fail_if(self, name='block'):
+        try:
+            yield
+        except Exception, ex:
+            if self.predicate():
+                print ("%s failed as expected (%s): %s " % (
+                    name, self.predicate, str(ex)))
             else:
-                try:
-                    fn(*args, **kw)
-                except Exception, ex:
-                    print ("'%s' failed as expected (%s): %s " % (
-                        fn.__name__, self.predicate, str(ex)))
-                    return True
-                else:
-                    raise AssertionError(
-                        "Unexpected success for '%s' (%s)" %
-                        (fn.__name__, self.predicate))
-        return decorate(fn)
-
-class skip_if(object):
-    def __init__(self, predicate, reason=None):
-        self.predicate = _as_predicate(predicate)
-        self.reason = reason
-
-    @property
-    def enabled(self):
-        return not self.predicate()
+                raise
+        else:
+            if self.predicate():
+                raise AssertionError(
+                    "Unexpected success for '%s' (%s)" %
+                    (name, self.predicate))
 
     def __call__(self, fn):
         @decorator
@@ -56,6 +48,22 @@ class skip_if(object):
                         )
                 raise SkipTest(msg)
             else:
+                if self._fails_on:
+                    with self._fails_on.fail_if(name=fn.__name__):
+                        return fn(*args, **kw)
+                else:
+                    return fn(*args, **kw)
+        return decorate(fn)
+
+    def fails_on(self, other, reason=None):
+        self._fails_on = skip_if(other, reason)
+        return self
+
+class fails_if(skip_if):
+    def __call__(self, fn):
+        @decorator
+        def decorate(fn, *args, **kw):
+            with self.fail_if(name=fn.__name__):
                 return fn(*args, **kw)
         return decorate(fn)
 
@@ -264,10 +272,10 @@ def db_spec(*dbs):
         )
 
 def open():
-    return skip_if(BooleanPredicate(False))
+    return skip_if(BooleanPredicate(False, "mark as execute"))
 
 def closed():
-    return skip_if(BooleanPredicate(True))
+    return skip_if(BooleanPredicate(True, "marked as skip"))
 
 @decorator
 def future(fn, *args, **kw):
diff --git a/lib/sqlalchemy/testing/requirements.py b/lib/sqlalchemy/testing/requirements.py
index f86572c6d..4df2163b7 100644
--- a/lib/sqlalchemy/testing/requirements.py
+++ b/lib/sqlalchemy/testing/requirements.py
@@ -37,12 +37,24 @@ class SuiteRequirements(Requirements):
         return exclusions.open()
 
     @property
+    def self_referential_foreign_keys(self):
+        """Target database must support self-referential foreign keys."""
+
+        return exclusions.open()
+
+    @property
     def foreign_key_ddl(self):
         """Target database must support the DDL phrases for FOREIGN KEY."""
 
         return exclusions.open()
 
     @property
+    def named_constraints(self):
+        """target database must support names for constraints."""
+
+        return exclusions.open()
+
+    @property
     def autoincrement_insert(self):
         """target platform generates new surrogate integer primary key values
         when insert() is executed, excluding the pk column."""
diff --git a/lib/sqlalchemy/testing/suite/test_insert.py b/lib/sqlalchemy/testing/suite/test_insert.py
index 0a9896ffb..61b11966b 100644
--- a/lib/sqlalchemy/testing/suite/test_insert.py
+++ b/lib/sqlalchemy/testing/suite/test_insert.py
@@ -105,7 +105,32 @@ class InsertBehaviorTest(fixtures.TablesTest):
         assert r.is_insert
         assert not r.returns_rows
 
+class ReturningTest(fixtures.TablesTest):
+    run_deletes = 'each'
+    __requires__ = 'returning',
+
+    @classmethod
+    def define_tables(cls, metadata):
+        Table('autoinc_pk', metadata,
+                Column('id', Integer, primary_key=True, \
+                                test_needs_autoincrement=True),
+                Column('data', String(50))
+            )
+
+    def test_explicit_returning_pk(self):
+        engine = config.db
+        table = self.tables.autoinc_pk
+        r = engine.execute(
+            table.insert().returning(
+                            table.c.id),
+            data="some data"
+        )
+        pk = r.first()[0]
+        fetched_pk = config.db.scalar(select([table.c.id]))
+        eq_(fetched_pk, pk)
+
+
 
-__all__ = ('InsertSequencingTest', 'InsertBehaviorTest')
+__all__ = ('InsertSequencingTest', 'InsertBehaviorTest', 'ReturningTest')
 
 
diff --git a/lib/sqlalchemy/testing/suite/test_reflection.py b/lib/sqlalchemy/testing/suite/test_reflection.py
index 171a10b89..a7c814db7 100644
--- a/lib/sqlalchemy/testing/suite/test_reflection.py
+++ b/lib/sqlalchemy/testing/suite/test_reflection.py
@@ -87,15 +87,25 @@ class ComponentReflectionTest(fixtures.TablesTest):
         else:
             schema_prefix = ""
 
-        users = Table('users', metadata,
-            Column('user_id', sa.INT, primary_key=True),
-            Column('test1', sa.CHAR(5), nullable=False),
-            Column('test2', sa.Float(5), nullable=False),
-            Column('parent_user_id', sa.Integer,
-                        sa.ForeignKey('%susers.user_id' % schema_prefix)),
-            schema=schema,
-            test_needs_fk=True,
-        )
+        if testing.requires.self_referential_foreign_keys.enabled:
+            users = Table('users', metadata,
+                Column('user_id', sa.INT, primary_key=True),
+                Column('test1', sa.CHAR(5), nullable=False),
+                Column('test2', sa.Float(5), nullable=False),
+                Column('parent_user_id', sa.Integer,
+                            sa.ForeignKey('%susers.user_id' % schema_prefix)),
+                schema=schema,
+                test_needs_fk=True,
+            )
+        else:
+            users = Table('users', metadata,
+                Column('user_id', sa.INT, primary_key=True),
+                Column('test1', sa.CHAR(5), nullable=False),
+                Column('test2', sa.Float(5), nullable=False),
+                schema=schema,
+                test_needs_fk=True,
+            )
+
         Table("dingalings", metadata,
                   Column('dingaling_id', sa.Integer, primary_key=True),
                   Column('address_id', sa.Integer,
@@ -278,17 +288,15 @@ class ComponentReflectionTest(fixtures.TablesTest):
         addr_pkeys = addr_cons['constrained_columns']
         eq_(addr_pkeys,  ['address_id'])
 
-        @testing.requires.reflects_pk_names
-        def go():
+        with testing.requires.reflects_pk_names.fail_if():
             eq_(addr_cons['name'], 'email_ad_pk')
-        go()
 
     @testing.requires.primary_key_constraint_reflection
     def test_get_pk_constraint(self):
         self._test_get_pk_constraint()
 
     @testing.requires.table_reflection
-    @testing.fails_on('sqlite', 'no schemas')
+    @testing.requires.schemas
     def test_get_pk_constraint_with_schema(self):
         self._test_get_pk_constraint(schema='test_schema')
 
@@ -317,23 +325,23 @@ class ComponentReflectionTest(fixtures.TablesTest):
                                             schema=schema)
         fkey1 = users_fkeys[0]
 
-        @testing.fails_on('sqlite', 'no support for constraint names')
-        def go():
+        with testing.requires.named_constraints.fail_if():
             self.assert_(fkey1['name'] is not None)
-        go()
 
         eq_(fkey1['referred_schema'], expected_schema)
         eq_(fkey1['referred_table'], users.name)
         eq_(fkey1['referred_columns'], ['user_id', ])
-        eq_(fkey1['constrained_columns'], ['parent_user_id'])
+        if testing.requires.self_referential_foreign_keys.enabled:
+            eq_(fkey1['constrained_columns'], ['parent_user_id'])
+
         #addresses
         addr_fkeys = insp.get_foreign_keys(addresses.name,
                                            schema=schema)
         fkey1 = addr_fkeys[0]
-        @testing.fails_on('sqlite', 'no support for constraint names')
-        def go():
+
+        with testing.requires.named_constraints.fail_if():
             self.assert_(fkey1['name'] is not None)
-        go()
+
         eq_(fkey1['referred_schema'], expected_schema)
         eq_(fkey1['referred_table'], users.name)
         eq_(fkey1['referred_columns'], ['user_id', ])