- rename __multiple__ to __backend__, and apply __backend__ to a large number of tests.

- move out logging tests from test_execute to test_logging

4 files changed, 281 insertions, 234 deletions

diff --git a/test/engine/test_execute.py b/test/engine/test_execute.py
index c2dbb4a3b..aad43c1df 100644
--- a/test/engine/test_execute.py
+++ b/test/engine/test_execute.py
@@ -24,6 +24,8 @@ from contextlib import contextmanager
 
 users, metadata, users_autoinc = None, None, None
 class ExecuteTest(fixtures.TestBase):
+    __backend__ = True
+
     @classmethod
     def setup_class(cls):
         global users, users_autoinc, metadata
@@ -462,6 +464,8 @@ class ExecuteTest(fixtures.TestBase):
             eng.dispose()
 
 class ConvenienceExecuteTest(fixtures.TablesTest):
+    __backend__ = True
+
     @classmethod
     def define_tables(cls, metadata):
         cls.table = Table('exec_test', metadata,
@@ -617,6 +621,8 @@ class ConvenienceExecuteTest(fixtures.TablesTest):
         self._assert_no_data()
 
 class CompiledCacheTest(fixtures.TestBase):
+    __backend__ = True
+
     @classmethod
     def setup_class(cls):
         global users, metadata
@@ -648,240 +654,6 @@ class CompiledCacheTest(fixtures.TestBase):
         assert len(cache) == 1
         eq_(conn.execute("select count(*) from users").scalar(), 3)
 
-class LogParamsTest(fixtures.TestBase):
-    __only_on__ = 'sqlite'
-    __requires__ = 'ad_hoc_engines',
-
-    def setup(self):
-        self.eng = engines.testing_engine(options={'echo':True})
-        self.eng.execute("create table foo (data string)")
-        self.buf = logging.handlers.BufferingHandler(100)
-        for log in [
-            logging.getLogger('sqlalchemy.engine'),
-            logging.getLogger('sqlalchemy.pool')
-        ]:
-            log.addHandler(self.buf)
-
-    def teardown(self):
-        self.eng.execute("drop table foo")
-        for log in [
-            logging.getLogger('sqlalchemy.engine'),
-            logging.getLogger('sqlalchemy.pool')
-        ]:
-            log.removeHandler(self.buf)
-
-    def test_log_large_dict(self):
-        self.eng.execute(
-            "INSERT INTO foo (data) values (:data)",
-            [{"data":str(i)} for i in range(100)]
-        )
-        eq_(
-            self.buf.buffer[1].message,
-            "[{'data': '0'}, {'data': '1'}, {'data': '2'}, {'data': '3'}, "
-            "{'data': '4'}, {'data': '5'}, {'data': '6'}, {'data': '7'}"
-            "  ... displaying 10 of 100 total bound "
-            "parameter sets ...  {'data': '98'}, {'data': '99'}]"
-        )
-
-    def test_log_large_list(self):
-        self.eng.execute(
-            "INSERT INTO foo (data) values (?)",
-            [(str(i), ) for i in range(100)]
-        )
-        eq_(
-            self.buf.buffer[1].message,
-            "[('0',), ('1',), ('2',), ('3',), ('4',), ('5',), "
-            "('6',), ('7',)  ... displaying 10 of 100 total "
-            "bound parameter sets ...  ('98',), ('99',)]"
-        )
-
-    def test_error_large_dict(self):
-        assert_raises_message(
-            tsa.exc.DBAPIError,
-            r".*'INSERT INTO nonexistent \(data\) values \(:data\)' "
-            "\[{'data': '0'}, {'data': '1'}, {'data': '2'}, "
-            "{'data': '3'}, {'data': '4'}, {'data': '5'}, "
-            "{'data': '6'}, {'data': '7'}  ... displaying 10 of "
-            "100 total bound parameter sets ...  {'data': '98'}, {'data': '99'}\]",
-            lambda: self.eng.execute(
-                "INSERT INTO nonexistent (data) values (:data)",
-                [{"data":str(i)} for i in range(100)]
-            )
-        )
-
-    def test_error_large_list(self):
-        assert_raises_message(
-            tsa.exc.DBAPIError,
-            r".*INSERT INTO nonexistent \(data\) values "
-            "\(\?\)' \[\('0',\), \('1',\), \('2',\), \('3',\), "
-            "\('4',\), \('5',\), \('6',\), \('7',\)  ... displaying "
-            "10 of 100 total bound parameter sets ...  "
-            "\('98',\), \('99',\)\]",
-            lambda: self.eng.execute(
-                "INSERT INTO nonexistent (data) values (?)",
-                [(str(i), ) for i in range(100)]
-            )
-        )
-
-class LoggingNameTest(fixtures.TestBase):
-    __requires__ = 'ad_hoc_engines',
-
-    def _assert_names_in_execute(self, eng, eng_name, pool_name):
-        eng.execute(select([1]))
-        assert self.buf.buffer
-        for name in [b.name for b in self.buf.buffer]:
-            assert name in (
-                'sqlalchemy.engine.base.Engine.%s' % eng_name,
-                'sqlalchemy.pool.%s.%s' %
-                    (eng.pool.__class__.__name__, pool_name)
-            )
-
-    def _assert_no_name_in_execute(self, eng):
-        eng.execute(select([1]))
-        assert self.buf.buffer
-        for name in [b.name for b in self.buf.buffer]:
-            assert name in (
-                'sqlalchemy.engine.base.Engine',
-                'sqlalchemy.pool.%s' % eng.pool.__class__.__name__
-            )
-
-    def _named_engine(self, **kw):
-        options = {
-            'logging_name':'myenginename',
-            'pool_logging_name':'mypoolname',
-            'echo':True
-        }
-        options.update(kw)
-        return engines.testing_engine(options=options)
-
-    def _unnamed_engine(self, **kw):
-        kw.update({'echo':True})
-        return engines.testing_engine(options=kw)
-
-    def setup(self):
-        self.buf = logging.handlers.BufferingHandler(100)
-        for log in [
-            logging.getLogger('sqlalchemy.engine'),
-            logging.getLogger('sqlalchemy.pool')
-        ]:
-            log.addHandler(self.buf)
-
-    def teardown(self):
-        for log in [
-            logging.getLogger('sqlalchemy.engine'),
-            logging.getLogger('sqlalchemy.pool')
-        ]:
-            log.removeHandler(self.buf)
-
-    def test_named_logger_names(self):
-        eng = self._named_engine()
-        eq_(eng.logging_name, "myenginename")
-        eq_(eng.pool.logging_name, "mypoolname")
-
-    def test_named_logger_names_after_dispose(self):
-        eng = self._named_engine()
-        eng.execute(select([1]))
-        eng.dispose()
-        eq_(eng.logging_name, "myenginename")
-        eq_(eng.pool.logging_name, "mypoolname")
-
-    def test_unnamed_logger_names(self):
-        eng = self._unnamed_engine()
-        eq_(eng.logging_name, None)
-        eq_(eng.pool.logging_name, None)
-
-    def test_named_logger_execute(self):
-        eng = self._named_engine()
-        self._assert_names_in_execute(eng, "myenginename", "mypoolname")
-
-    def test_named_logger_echoflags_execute(self):
-        eng = self._named_engine(echo='debug', echo_pool='debug')
-        self._assert_names_in_execute(eng, "myenginename", "mypoolname")
-
-    def test_named_logger_execute_after_dispose(self):
-        eng = self._named_engine()
-        eng.execute(select([1]))
-        eng.dispose()
-        self._assert_names_in_execute(eng, "myenginename", "mypoolname")
-
-    def test_unnamed_logger_execute(self):
-        eng = self._unnamed_engine()
-        self._assert_no_name_in_execute(eng)
-
-    def test_unnamed_logger_echoflags_execute(self):
-        eng = self._unnamed_engine(echo='debug', echo_pool='debug')
-        self._assert_no_name_in_execute(eng)
-
-class EchoTest(fixtures.TestBase):
-    __requires__ = 'ad_hoc_engines',
-
-    def setup(self):
-        self.level = logging.getLogger('sqlalchemy.engine').level
-        logging.getLogger('sqlalchemy.engine').setLevel(logging.WARN)
-        self.buf = logging.handlers.BufferingHandler(100)
-        logging.getLogger('sqlalchemy.engine').addHandler(self.buf)
-
-    def teardown(self):
-        logging.getLogger('sqlalchemy.engine').removeHandler(self.buf)
-        logging.getLogger('sqlalchemy.engine').setLevel(self.level)
-
-    def testing_engine(self):
-        e = engines.testing_engine()
-
-        # do an initial execute to clear out 'first connect'
-        # messages
-        e.execute(select([10])).close()
-        self.buf.flush()
-
-        return e
-
-    def test_levels(self):
-        e1 = engines.testing_engine()
-
-        eq_(e1._should_log_info(), False)
-        eq_(e1._should_log_debug(), False)
-        eq_(e1.logger.isEnabledFor(logging.INFO), False)
-        eq_(e1.logger.getEffectiveLevel(), logging.WARN)
-
-        e1.echo = True
-        eq_(e1._should_log_info(), True)
-        eq_(e1._should_log_debug(), False)
-        eq_(e1.logger.isEnabledFor(logging.INFO), True)
-        eq_(e1.logger.getEffectiveLevel(), logging.INFO)
-
-        e1.echo = 'debug'
-        eq_(e1._should_log_info(), True)
-        eq_(e1._should_log_debug(), True)
-        eq_(e1.logger.isEnabledFor(logging.DEBUG), True)
-        eq_(e1.logger.getEffectiveLevel(), logging.DEBUG)
-
-        e1.echo = False
-        eq_(e1._should_log_info(), False)
-        eq_(e1._should_log_debug(), False)
-        eq_(e1.logger.isEnabledFor(logging.INFO), False)
-        eq_(e1.logger.getEffectiveLevel(), logging.WARN)
-
-    def test_echo_flag_independence(self):
-        """test the echo flag's independence to a specific engine."""
-
-        e1 = self.testing_engine()
-        e2 = self.testing_engine()
-
-        e1.echo = True
-        e1.execute(select([1])).close()
-        e2.execute(select([2])).close()
-
-        e1.echo = False
-        e1.execute(select([3])).close()
-        e2.execute(select([4])).close()
-
-        e2.echo = True
-        e1.execute(select([5])).close()
-        e2.execute(select([6])).close()
-
-        assert self.buf.buffer[0].getMessage().startswith("SELECT 1")
-        assert self.buf.buffer[2].getMessage().startswith("SELECT 6")
-        assert len(self.buf.buffer) == 4
 
 class MockStrategyTest(fixtures.TestBase):
     def _engine_fixture(self):
@@ -912,6 +684,7 @@ class MockStrategyTest(fixtures.TestBase):
         )
 
 class ResultProxyTest(fixtures.TestBase):
+    __backend__ = True
 
     def test_nontuple_row(self):
         """ensure the C version of BaseRowProxy handles
@@ -1171,6 +944,7 @@ class AlternateResultProxyTest(fixtures.TestBase):
 
 class EngineEventsTest(fixtures.TestBase):
     __requires__ = 'ad_hoc_engines',
+    __backend__ = True
 
     def tearDown(self):
         Engine.dispatch._clear()
diff --git a/test/engine/test_logging.py b/test/engine/test_logging.py
new file mode 100644
index 000000000..94ea22813
--- /dev/null
+++ b/test/engine/test_logging.py
@@ -0,0 +1,255 @@
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message, \
+    config, is_
+import re
+from sqlalchemy.testing.util import picklers
+from sqlalchemy.interfaces import ConnectionProxy
+from sqlalchemy import MetaData, Integer, String, INT, VARCHAR, func, \
+    bindparam, select, event, TypeDecorator, create_engine, Sequence
+from sqlalchemy.sql import column, literal
+from sqlalchemy.testing.schema import Table, Column
+import sqlalchemy as tsa
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
+from sqlalchemy import util
+from sqlalchemy.testing.engines import testing_engine
+import logging.handlers
+from sqlalchemy.dialects.oracle.zxjdbc import ReturningParam
+from sqlalchemy.engine import result as _result, default
+from sqlalchemy.engine.base import Engine
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.mock import Mock, call, patch
+
+class LogParamsTest(fixtures.TestBase):
+    __only_on__ = 'sqlite'
+    __requires__ = 'ad_hoc_engines',
+
+    def setup(self):
+        self.eng = engines.testing_engine(options={'echo':True})
+        self.eng.execute("create table foo (data string)")
+        self.buf = logging.handlers.BufferingHandler(100)
+        for log in [
+            logging.getLogger('sqlalchemy.engine'),
+            logging.getLogger('sqlalchemy.pool')
+        ]:
+            log.addHandler(self.buf)
+
+    def teardown(self):
+        self.eng.execute("drop table foo")
+        for log in [
+            logging.getLogger('sqlalchemy.engine'),
+            logging.getLogger('sqlalchemy.pool')
+        ]:
+            log.removeHandler(self.buf)
+
+    def test_log_large_dict(self):
+        self.eng.execute(
+            "INSERT INTO foo (data) values (:data)",
+            [{"data":str(i)} for i in range(100)]
+        )
+        eq_(
+            self.buf.buffer[1].message,
+            "[{'data': '0'}, {'data': '1'}, {'data': '2'}, {'data': '3'}, "
+            "{'data': '4'}, {'data': '5'}, {'data': '6'}, {'data': '7'}"
+            "  ... displaying 10 of 100 total bound "
+            "parameter sets ...  {'data': '98'}, {'data': '99'}]"
+        )
+
+    def test_log_large_list(self):
+        self.eng.execute(
+            "INSERT INTO foo (data) values (?)",
+            [(str(i), ) for i in range(100)]
+        )
+        eq_(
+            self.buf.buffer[1].message,
+            "[('0',), ('1',), ('2',), ('3',), ('4',), ('5',), "
+            "('6',), ('7',)  ... displaying 10 of 100 total "
+            "bound parameter sets ...  ('98',), ('99',)]"
+        )
+
+    def test_error_large_dict(self):
+        assert_raises_message(
+            tsa.exc.DBAPIError,
+            r".*'INSERT INTO nonexistent \(data\) values \(:data\)' "
+            "\[{'data': '0'}, {'data': '1'}, {'data': '2'}, "
+            "{'data': '3'}, {'data': '4'}, {'data': '5'}, "
+            "{'data': '6'}, {'data': '7'}  ... displaying 10 of "
+            "100 total bound parameter sets ...  {'data': '98'}, {'data': '99'}\]",
+            lambda: self.eng.execute(
+                "INSERT INTO nonexistent (data) values (:data)",
+                [{"data":str(i)} for i in range(100)]
+            )
+        )
+
+    def test_error_large_list(self):
+        assert_raises_message(
+            tsa.exc.DBAPIError,
+            r".*INSERT INTO nonexistent \(data\) values "
+            "\(\?\)' \[\('0',\), \('1',\), \('2',\), \('3',\), "
+            "\('4',\), \('5',\), \('6',\), \('7',\)  ... displaying "
+            "10 of 100 total bound parameter sets ...  "
+            "\('98',\), \('99',\)\]",
+            lambda: self.eng.execute(
+                "INSERT INTO nonexistent (data) values (?)",
+                [(str(i), ) for i in range(100)]
+            )
+        )
+
+class LoggingNameTest(fixtures.TestBase):
+    __requires__ = 'ad_hoc_engines',
+
+    def _assert_names_in_execute(self, eng, eng_name, pool_name):
+        eng.execute(select([1]))
+        assert self.buf.buffer
+        for name in [b.name for b in self.buf.buffer]:
+            assert name in (
+                'sqlalchemy.engine.base.Engine.%s' % eng_name,
+                'sqlalchemy.pool.%s.%s' %
+                    (eng.pool.__class__.__name__, pool_name)
+            )
+
+    def _assert_no_name_in_execute(self, eng):
+        eng.execute(select([1]))
+        assert self.buf.buffer
+        for name in [b.name for b in self.buf.buffer]:
+            assert name in (
+                'sqlalchemy.engine.base.Engine',
+                'sqlalchemy.pool.%s' % eng.pool.__class__.__name__
+            )
+
+    def _named_engine(self, **kw):
+        options = {
+            'logging_name':'myenginename',
+            'pool_logging_name':'mypoolname',
+            'echo':True
+        }
+        options.update(kw)
+        return engines.testing_engine(options=options)
+
+    def _unnamed_engine(self, **kw):
+        kw.update({'echo':True})
+        return engines.testing_engine(options=kw)
+
+    def setup(self):
+        self.buf = logging.handlers.BufferingHandler(100)
+        for log in [
+            logging.getLogger('sqlalchemy.engine'),
+            logging.getLogger('sqlalchemy.pool')
+        ]:
+            log.addHandler(self.buf)
+
+    def teardown(self):
+        for log in [
+            logging.getLogger('sqlalchemy.engine'),
+            logging.getLogger('sqlalchemy.pool')
+        ]:
+            log.removeHandler(self.buf)
+
+    def test_named_logger_names(self):
+        eng = self._named_engine()
+        eq_(eng.logging_name, "myenginename")
+        eq_(eng.pool.logging_name, "mypoolname")
+
+    def test_named_logger_names_after_dispose(self):
+        eng = self._named_engine()
+        eng.execute(select([1]))
+        eng.dispose()
+        eq_(eng.logging_name, "myenginename")
+        eq_(eng.pool.logging_name, "mypoolname")
+
+    def test_unnamed_logger_names(self):
+        eng = self._unnamed_engine()
+        eq_(eng.logging_name, None)
+        eq_(eng.pool.logging_name, None)
+
+    def test_named_logger_execute(self):
+        eng = self._named_engine()
+        self._assert_names_in_execute(eng, "myenginename", "mypoolname")
+
+    def test_named_logger_echoflags_execute(self):
+        eng = self._named_engine(echo='debug', echo_pool='debug')
+        self._assert_names_in_execute(eng, "myenginename", "mypoolname")
+
+    def test_named_logger_execute_after_dispose(self):
+        eng = self._named_engine()
+        eng.execute(select([1]))
+        eng.dispose()
+        self._assert_names_in_execute(eng, "myenginename", "mypoolname")
+
+    def test_unnamed_logger_execute(self):
+        eng = self._unnamed_engine()
+        self._assert_no_name_in_execute(eng)
+
+    def test_unnamed_logger_echoflags_execute(self):
+        eng = self._unnamed_engine(echo='debug', echo_pool='debug')
+        self._assert_no_name_in_execute(eng)
+
+class EchoTest(fixtures.TestBase):
+    __requires__ = 'ad_hoc_engines',
+
+    def setup(self):
+        self.level = logging.getLogger('sqlalchemy.engine').level
+        logging.getLogger('sqlalchemy.engine').setLevel(logging.WARN)
+        self.buf = logging.handlers.BufferingHandler(100)
+        logging.getLogger('sqlalchemy.engine').addHandler(self.buf)
+
+    def teardown(self):
+        logging.getLogger('sqlalchemy.engine').removeHandler(self.buf)
+        logging.getLogger('sqlalchemy.engine').setLevel(self.level)
+
+    def testing_engine(self):
+        e = engines.testing_engine()
+
+        # do an initial execute to clear out 'first connect'
+        # messages
+        e.execute(select([10])).close()
+        self.buf.flush()
+
+        return e
+
+    def test_levels(self):
+        e1 = engines.testing_engine()
+
+        eq_(e1._should_log_info(), False)
+        eq_(e1._should_log_debug(), False)
+        eq_(e1.logger.isEnabledFor(logging.INFO), False)
+        eq_(e1.logger.getEffectiveLevel(), logging.WARN)
+
+        e1.echo = True
+        eq_(e1._should_log_info(), True)
+        eq_(e1._should_log_debug(), False)
+        eq_(e1.logger.isEnabledFor(logging.INFO), True)
+        eq_(e1.logger.getEffectiveLevel(), logging.INFO)
+
+        e1.echo = 'debug'
+        eq_(e1._should_log_info(), True)
+        eq_(e1._should_log_debug(), True)
+        eq_(e1.logger.isEnabledFor(logging.DEBUG), True)
+        eq_(e1.logger.getEffectiveLevel(), logging.DEBUG)
+
+        e1.echo = False
+        eq_(e1._should_log_info(), False)
+        eq_(e1._should_log_debug(), False)
+        eq_(e1.logger.isEnabledFor(logging.INFO), False)
+        eq_(e1.logger.getEffectiveLevel(), logging.WARN)
+
+    def test_echo_flag_independence(self):
+        """test the echo flag's independence to a specific engine."""
+
+        e1 = self.testing_engine()
+        e2 = self.testing_engine()
+
+        e1.echo = True
+        e1.execute(select([1])).close()
+        e2.execute(select([2])).close()
+
+        e1.echo = False
+        e1.execute(select([3])).close()
+        e2.execute(select([4])).close()
+
+        e2.echo = True
+        e1.execute(select([5])).close()
+        e2.execute(select([6])).close()
+
+        assert self.buf.buffer[0].getMessage().startswith("SELECT 1")
+        assert self.buf.buffer[2].getMessage().startswith("SELECT 6")
+        assert len(self.buf.buffer) == 4
diff --git a/test/engine/test_reflection.py b/test/engine/test_reflection.py
index a53893549..1db37851d 100644
--- a/test/engine/test_reflection.py
+++ b/test/engine/test_reflection.py
@@ -15,6 +15,7 @@ from sqlalchemy.util import ue
 metadata, users = None, None
 
 class ReflectionTest(fixtures.TestBase, ComparesTables):
+    __backend__ = True
 
     @testing.exclude('mssql', '<', (10, 0, 0),
                      'Date is only supported on MSSQL 2008+')
@@ -1016,6 +1017,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
             _drop_views(metadata.bind)
 
 class CreateDropTest(fixtures.TestBase):
+    __backend__ = True
 
     @classmethod
     def setup_class(cls):
@@ -1103,6 +1105,8 @@ class CreateDropTest(fixtures.TestBase):
         metadata.drop_all(bind=testing.db)
 
 class SchemaManipulationTest(fixtures.TestBase):
+    __backend__ = True
+
     def test_append_constraint_unique(self):
         meta = MetaData()
 
@@ -1119,6 +1123,8 @@ class SchemaManipulationTest(fixtures.TestBase):
         assert addresses.constraints == set([addresses.primary_key, fk])
 
 class UnicodeReflectionTest(fixtures.TestBase):
+    __backend__ = True
+
     @classmethod
     def setup_class(cls):
         cls.metadata = metadata = MetaData()
@@ -1226,6 +1232,7 @@ class UnicodeReflectionTest(fixtures.TestBase):
             )
 
 class SchemaTest(fixtures.TestBase):
+    __backend__ = True
 
     @testing.requires.schemas
     @testing.requires.cross_schema_fk_reflection
@@ -1430,6 +1437,7 @@ def _drop_views(con, schema=None):
 
 class ReverseCasingReflectTest(fixtures.TestBase, AssertsCompiledSQL):
     __dialect__ = 'default'
+    __backend__ = True
 
     @testing.requires.denormalized_names
     def setup(self):
@@ -1456,6 +1464,7 @@ class ReverseCasingReflectTest(fixtures.TestBase, AssertsCompiledSQL):
 
 class CaseSensitiveTest(fixtures.TablesTest):
     """Nail down case sensitive behaviors, mostly on MySQL."""
+    __backend__ = True
 
     @classmethod
     def define_tables(cls, metadata):
@@ -1502,6 +1511,7 @@ class CaseSensitiveTest(fixtures.TablesTest):
 
 
 class ColumnEventsTest(fixtures.RemovesEvents, fixtures.TestBase):
+    __backend__ = True
 
     @classmethod
     def setup_class(cls):
diff --git a/test/engine/test_transaction.py b/test/engine/test_transaction.py
index c373133d1..ee626a50e 100644
--- a/test/engine/test_transaction.py
+++ b/test/engine/test_transaction.py
@@ -15,6 +15,8 @@ from sqlalchemy.testing import fixtures
 
 users, metadata = None, None
 class TransactionTest(fixtures.TestBase):
+    __backend__ = True
+
     @classmethod
     def setup_class(cls):
         global users, metadata
@@ -412,6 +414,8 @@ class TransactionTest(fixtures.TestBase):
             eq_(result.fetchall(), [])
 
 class ResetAgentTest(fixtures.TestBase):
+    __backend__ = True
+
     def test_begin_close(self):
         with testing.db.connect() as connection:
             trans = connection.begin()
@@ -513,6 +517,7 @@ class ResetAgentTest(fixtures.TestBase):
             assert connection.connection._reset_agent is None
 
 class AutoRollbackTest(fixtures.TestBase):
+    __backend__ = True
 
     @classmethod
     def setup_class(cls):
@@ -678,6 +683,7 @@ tlengine = None
 
 class TLTransactionTest(fixtures.TestBase):
     __requires__ = ('ad_hoc_engines', )
+    __backend__ = True
 
     @classmethod
     def setup_class(cls):
@@ -1124,6 +1130,7 @@ counters = None
 
 class ForUpdateTest(fixtures.TestBase):
     __requires__ = 'ad_hoc_engines',
+    __backend__ = True
 
     @classmethod
     def setup_class(cls):
@@ -1254,6 +1261,7 @@ class ForUpdateTest(fixtures.TestBase):
 
 class IsolationLevelTest(fixtures.TestBase):
     __requires__ = ('isolation_level', 'ad_hoc_engines')
+    __backend__ = True
 
     def _default_isolation_level(self):
         if testing.against('sqlite'):