- factor consistent set_isolation_level(), get_isolation_level()

per-connection methods for sqlite, postgresql, psycopg2 dialects
- move isolation test suite to test engines/test_transaction
- preparing for [ticket:2001]

4 files changed, 73 insertions, 49 deletions

diff --git a/test/dialect/test_postgresql.py b/test/dialect/test_postgresql.py
index 083d32b15..f8ca65e60 100644
--- a/test/dialect/test_postgresql.py
+++ b/test/dialect/test_postgresql.py
@@ -1382,40 +1382,6 @@ class MiscTest(TestBase, AssertsExecutionResults, AssertsCompiledSQL):
             ])
 
 
-    @testing.fails_on('postgresql+pypostgresql',
-                      'pypostgresql bombs on multiple calls')
-    def test_set_isolation_level(self):
-        """Test setting the isolation level with create_engine"""
-
-        eng = create_engine(testing.db.url)
-        eq_(eng.execute('show transaction isolation level').scalar(),
-            'read committed')
-        eng = create_engine(testing.db.url,
-                            isolation_level='SERIALIZABLE')
-        eq_(eng.execute('show transaction isolation level').scalar(),
-            'serializable')
-
-        # check that it stays
-        conn = eng.connect()
-        eq_(conn.execute('show transaction isolation level').scalar(),
-            'serializable')
-        conn.close()
-
-        conn = eng.connect()
-        eq_(conn.execute('show transaction isolation level').scalar(),
-            'serializable')
-        conn.close()
-
-        eng = create_engine(testing.db.url, isolation_level='FOO')
-        if testing.db.driver == 'zxjdbc':
-            exception_cls = eng.dialect.dbapi.Error
-        elif testing.db.driver == 'psycopg2':
-            exception_cls = exc.InvalidRequestError
-        else:
-            exception_cls = eng.dialect.dbapi.ProgrammingError
-        assert_raises(exception_cls, eng.execute,
-                      'show transaction isolation level')
-
     @testing.fails_on('+zxjdbc', 'psycopg2/pg8000 specific assertion')
     @testing.fails_on('pypostgresql',
                       'psycopg2/pg8000 specific assertion')
diff --git a/test/dialect/test_sqlite.py b/test/dialect/test_sqlite.py
index 2413c12e8..b99f58bd2 100644
--- a/test/dialect/test_sqlite.py
+++ b/test/dialect/test_sqlite.py
@@ -353,20 +353,6 @@ class DialectTest(TestBase, AssertsExecutionResults):
         finally:
             meta.drop_all()
 
-    def test_set_isolation_level(self):
-        """Test setting the read uncommitted/serializable levels"""
-
-        eng = create_engine(testing.db.url)
-        eq_(eng.execute('PRAGMA read_uncommitted').scalar(), 0)
-        eng = create_engine(testing.db.url,
-                            isolation_level='READ UNCOMMITTED')
-        eq_(eng.execute('PRAGMA read_uncommitted').scalar(), 1)
-        eng = create_engine(testing.db.url,
-                            isolation_level='SERIALIZABLE')
-        eq_(eng.execute('PRAGMA read_uncommitted').scalar(), 0)
-        assert_raises(exc.ArgumentError, create_engine, testing.db.url,
-                      isolation_level='FOO')
-
     def test_create_index_with_schema(self):
         """Test creation of index with explicit schema"""
 
diff --git a/test/engine/test_transaction.py b/test/engine/test_transaction.py
index bec8b0037..1fb0267bb 100644
--- a/test/engine/test_transaction.py
+++ b/test/engine/test_transaction.py
@@ -1,5 +1,5 @@
 from test.lib.testing import eq_, assert_raises, \
-    assert_raises_message
+    assert_raises_message, ne_
 import sys
 import time
 import threading
@@ -1109,3 +1109,66 @@ class ForUpdateTest(TestBase):
                 update_style='nowait')
         self.assert_(len(errors) != 0)
 
+class IsolationLevelTest(TestBase):
+    def _default_isolation_level(self):
+        if testing.against('sqlite'):
+            return 'SERIALIZABLE'
+        elif testing.against('postgresql'):
+            return 'READ COMMITTED'
+        else:
+            assert False, "default isolation level not known"
+
+    def _non_default_isolation_level(self):
+        if testing.against('sqlite'):
+            return 'READ UNCOMMITTED'
+        elif testing.against('postgresql'):
+            return 'SERIALIZABLE'
+        else:
+            assert False, "non default isolation level not known"
+
+    @testing.requires.isolation_level
+    def test_engine_param_stays(self):
+
+        eng = create_engine(testing.db.url)
+        isolation_level = eng.dialect.get_isolation_level(eng.connect().connection)
+        level = self._non_default_isolation_level()
+
+        ne_(isolation_level, level)
+
+        eng = create_engine(testing.db.url,
+                            isolation_level=level)
+        eq_(
+            eng.dialect.get_isolation_level(eng.connect().connection),
+            level
+        )
+
+        # check that it stays
+        conn = eng.connect()
+        eq_(
+            eng.dialect.get_isolation_level(conn.connection),
+            level
+        )
+        conn.close()
+
+        conn = eng.connect()
+        eq_(
+            eng.dialect.get_isolation_level(conn.connection),
+            level
+        )
+        conn.close()
+
+    @testing.requires.isolation_level
+    def test_default_level(self):
+        eng = create_engine(testing.db.url)
+        isolation_level = eng.dialect.get_isolation_level(eng.connect().connection)
+        eq_(isolation_level, self._default_isolation_level())
+
+    @testing.requires.isolation_level
+    def test_invalid_level(self):
+        eng = create_engine(testing.db.url, isolation_level='FOO')
+        assert_raises_message(
+            exc.ArgumentError, 
+                "Invalid value '%s' for isolation_level. "
+                "Valid isolation levels for %s are %s" % 
+                (eng.dialect.name, "FOO", ", ".join(eng.dialect._isolation_lookup)),
+            eng.connect)
diff --git a/test/lib/requires.py b/test/lib/requires.py
index b689250d2..03bda74d2 100644
--- a/test/lib/requires.py
+++ b/test/lib/requires.py
@@ -11,6 +11,7 @@ from testing import \
      exclude, \
      emits_warning_on,\
      skip_if,\
+     only_on,\
      fails_on,\
      fails_on_everything_except
 
@@ -92,6 +93,14 @@ def independent_connections(fn):
                 'SQL Server 2005+ is required for independent connections'),
         )
 
+def isolation_level(fn):
+    return _chain_decorators_on(
+        fn,
+        only_on(('postgresql', 'sqlite'), "DBAPI has no isolation level support"),
+        fails_on('postgresql+pypostgresql',
+                      'pypostgresql bombs on multiple isolation level calls')
+    )
+
 def row_triggers(fn):
     """Target must support standard statement-running EACH ROW triggers."""
     return _chain_decorators_on(