- unit tests have been migrated from unittest to nose.

See README.unittests for information on how to run
the tests.  [ticket:970]

11 files changed, 197 insertions, 215 deletions

diff --git a/test/engine/_base.py b/test/engine/_base.py
index 3c31d378a..ec91243d2 100644
--- a/test/engine/_base.py
+++ b/test/engine/_base.py
@@ -1,5 +1,6 @@
-from testlib import sa, testing
-from testlib.testing import adict
+import sqlalchemy as sa
+from sqlalchemy.test import testing
+from sqlalchemy.test.testing import adict
 
 
 class TablesTest(testing.TestBase):
@@ -27,41 +28,38 @@ class TablesTest(testing.TestBase):
     tables = None
     other_artifacts = None
 
-    def setUpAll(self):
-        if self.run_setup_bind is None:
-            assert self.bind is not None
-        assert self.run_deletes in (None, 'each')
-        if self.run_inserts == 'once':
-            assert self.run_deletes is None
+    @classmethod
+    def setup_class(cls):
+        if cls.run_setup_bind is None:
+            assert cls.bind is not None
+        assert cls.run_deletes in (None, 'each')
+        if cls.run_inserts == 'once':
+            assert cls.run_deletes is None
 
-        cls = self.__class__
         if cls.tables is None:
             cls.tables = adict()
         if cls.other_artifacts is None:
             cls.other_artifacts = adict()
 
-        if self.bind is None:
-            setattr(type(self), 'bind', self.setup_bind())
-
-        if self.metadata is None:
-            setattr(type(self), 'metadata', sa.MetaData())
+        if cls.bind is None:
+            setattr(cls, 'bind', cls.setup_bind())
 
-        if self.metadata.bind is None:
-            self.metadata.bind = self.bind
+        if cls.metadata is None:
+            setattr(cls, 'metadata', sa.MetaData())
 
-        if self.run_define_tables:
-            self.define_tables(self.metadata)
-            self.metadata.create_all()
-            self.tables.update(self.metadata.tables)
+        if cls.metadata.bind is None:
+            cls.metadata.bind = cls.bind
 
-        if self.run_inserts:
-            self._load_fixtures()
-            self.insert_data()
+        if cls.run_define_tables == 'once':
+            cls.define_tables(cls.metadata)
+            cls.metadata.create_all()
+            cls.tables.update(cls.metadata.tables)
 
-    def setUp(self):
-        if self._sa_first_test:
-            return
+        if cls.run_inserts == 'once':
+            cls._load_fixtures()
+            cls.insert_data()
 
+    def setup(self):
         cls = self.__class__
 
         if self.setup_bind == 'each':
@@ -79,7 +77,7 @@ class TablesTest(testing.TestBase):
             self._load_fixtures()
             self.insert_data()
 
-    def tearDown(self):
+    def teardown(self):
         # no need to run deletes if tables are recreated on setup
         if self.run_define_tables != 'each' and self.run_deletes:
             for table in reversed(self.metadata.sorted_tables):
@@ -92,33 +90,39 @@ class TablesTest(testing.TestBase):
         if self.run_dispose_bind == 'each':
             self.dispose_bind(self.bind)
 
-    def tearDownAll(self):
-        self.metadata.drop_all()
+    @classmethod
+    def teardown_class(cls):
+        cls.metadata.drop_all()
 
-        if self.dispose_bind:
-            self.dispose_bind(self.bind)
+        if cls.dispose_bind:
+            cls.dispose_bind(cls.bind)
 
-        self.metadata.bind = None
+        cls.metadata.bind = None
 
-        if self.run_setup_bind is not None:
-            self.bind = None
+        if cls.run_setup_bind is not None:
+            cls.bind = None
 
-    def setup_bind(self):
+    @classmethod
+    def setup_bind(cls):
         return testing.db
 
-    def dispose_bind(self, bind):
+    @classmethod
+    def dispose_bind(cls, bind):
         if hasattr(bind, 'dispose'):
             bind.dispose()
         elif hasattr(bind, 'close'):
             bind.close()
 
-    def define_tables(self, metadata):
+    @classmethod
+    def define_tables(cls, metadata):
         raise NotImplementedError()
 
-    def fixtures(self):
+    @classmethod
+    def fixtures(cls):
         return {}
 
-    def insert_data(self):
+    @classmethod
+    def insert_data(cls):
         pass
 
     def sql_count_(self, count, fn):
@@ -147,14 +151,17 @@ class TablesTest(testing.TestBase):
 class AltEngineTest(testing.TestBase):
     engine = None
 
-    def setUpAll(self):
-        type(self).engine = self.create_engine()
-        testing.TestBase.setUpAll(self)
-
-    def tearDownAll(self):
-        testing.TestBase.tearDownAll(self)
-        self.engine.dispose()
-        type(self).engine = None
-
-    def create_engine(self):
+    @classmethod
+    def setup_class(cls):
+        cls.engine = cls.create_engine()
+        super(AltEngineTest, cls).setup_class()
+        
+    @classmethod
+    def teardown_class(cls):
+        cls.engine.dispose()
+        cls.engine = None
+        super(AltEngineTest, cls).teardown_class()
+        
+    @classmethod
+    def create_engine(cls):
         raise NotImplementedError
diff --git a/test/engine/alltests.py b/test/engine/alltests.py
deleted file mode 100644
index ed722aa3b..000000000
--- a/test/engine/alltests.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import testenv; testenv.configure_for_tests()
-from testlib import sa_unittest as unittest
-
-
-def suite():
-    modules_to_test = (
-        # connectivity, execution
-        'engine.parseconnect',
-        'engine.pool',
-        'engine.bind',
-        'engine.reconnect',
-        'engine.execute',
-        'engine.metadata',
-        'engine.transaction',
-
-        # schema/tables
-        'engine.reflection',
-        'engine.ddlevents',
-
-        )
-    alltests = unittest.TestSuite()
-    for name in modules_to_test:
-        mod = __import__(name)
-        for token in name.split('.')[1:]:
-            mod = getattr(mod, token)
-        alltests.addTest(unittest.findTestCases(mod, suiteClass=None))
-    return alltests
-
-
-if __name__ == '__main__':
-    testenv.main(suite())
diff --git a/test/engine/bind.py b/test/engine/test_bind.py
index 5b8605aad..7fd3009bc 100644
--- a/test/engine/bind.py
+++ b/test/engine/test_bind.py
@@ -1,11 +1,14 @@
 """tests the "bind" attribute/argument across schema and SQL,
 including the deprecated versions of these arguments"""
 
-import testenv; testenv.configure_for_tests()
+from sqlalchemy.test.testing import eq_
 from sqlalchemy import engine, exc
 from sqlalchemy import MetaData, ThreadLocalMetaData
-from testlib.sa import Table, Column, Integer, text
-from testlib import sa, testing
+from sqlalchemy import Integer, text
+from sqlalchemy.test.schema import Table
+from sqlalchemy.test.schema import Column
+import sqlalchemy as sa
+from sqlalchemy.test import testing
 
 
 class BindTest(testing.TestBase):
@@ -43,7 +46,7 @@ class BindTest(testing.TestBase):
                 meth()
                 assert False
             except exc.UnboundExecutionError, e:
-                self.assertEquals(
+                eq_(
                     str(e),
                     "The MetaData "
                     "is not bound to an Engine or Connection.  "
@@ -61,7 +64,7 @@ class BindTest(testing.TestBase):
                 meth()
                 assert False
             except exc.UnboundExecutionError, e:
-                self.assertEquals(
+                eq_(
                     str(e),
                     "The Table 'test_table' "
                     "is not bound to an Engine or Connection.  "
@@ -85,7 +88,7 @@ class BindTest(testing.TestBase):
                 meth()
                 assert False
             except exc.UnboundExecutionError, e:
-                self.assertEquals(
+                eq_(
                     str(e),
                     "The Table 'test_table' "
                     "is not bound to an Engine or Connection.  "
@@ -219,5 +222,3 @@ class BindTest(testing.TestBase):
             metadata.drop_all(bind=testing.db)
 
 
-if __name__ == '__main__':
-    testenv.main()
diff --git a/test/engine/ddlevents.py b/test/engine/test_ddlevents.py
index 8274c6347..5716006d9 100644
--- a/test/engine/ddlevents.py
+++ b/test/engine/test_ddlevents.py
@@ -1,9 +1,11 @@
-import testenv; testenv.configure_for_tests()
+from sqlalchemy.test.testing import eq_, assert_raises, assert_raises_message
 from sqlalchemy.schema import DDL
 from sqlalchemy import create_engine
-from testlib.sa import MetaData, Table, Column, Integer, String
-import testlib.sa as tsa
-from testlib import TestBase, testing, engines
+from sqlalchemy import MetaData, Integer, String
+from sqlalchemy.test.schema import Table
+from sqlalchemy.test.schema import Column
+import sqlalchemy as tsa
+from sqlalchemy.test import TestBase, testing, engines
 
 
 class DDLEventTest(TestBase):
@@ -37,7 +39,7 @@ class DDLEventTest(TestBase):
             assert bind is self.bind
             self.state = action
 
-    def setUp(self):
+    def setup(self):
         self.bind = engines.mock_engine()
         self.metadata = MetaData()
         self.table = Table('t', self.metadata, Column('id', Integer))
@@ -174,14 +176,14 @@ class DDLEventTest(TestBase):
         fn = lambda *a: None
 
         table.append_ddl_listener('before-create', fn)
-        self.assertRaises(LookupError, table.append_ddl_listener, 'blah', fn)
+        assert_raises(LookupError, table.append_ddl_listener, 'blah', fn)
 
         metadata.append_ddl_listener('before-create', fn)
-        self.assertRaises(LookupError, metadata.append_ddl_listener, 'blah', fn)
+        assert_raises(LookupError, metadata.append_ddl_listener, 'blah', fn)
 
 
 class DDLExecutionTest(TestBase):
-    def setUp(self):
+    def setup(self):
         self.engine = engines.mock_engine()
         self.metadata = MetaData(self.engine)
         self.users = Table('users', self.metadata,
@@ -303,19 +305,19 @@ class DDLTest(TestBase):
 
         ddl = DDL('%(schema)s-%(table)s-%(fullname)s')
 
-        self.assertEquals(ddl._expand(sane_alone, bind), '-t-t')
-        self.assertEquals(ddl._expand(sane_schema, bind), 's-t-s.t')
-        self.assertEquals(ddl._expand(insane_alone, bind), '-"t t"-"t t"')
-        self.assertEquals(ddl._expand(insane_schema, bind),
+        eq_(ddl._expand(sane_alone, bind), '-t-t')
+        eq_(ddl._expand(sane_schema, bind), 's-t-s.t')
+        eq_(ddl._expand(insane_alone, bind), '-"t t"-"t t"')
+        eq_(ddl._expand(insane_schema, bind),
                           '"s s"-"t t"-"s s"."t t"')
 
         # overrides are used piece-meal and verbatim.
         ddl = DDL('%(schema)s-%(table)s-%(fullname)s-%(bonus)s',
                   context={'schema':'S S', 'table': 'T T', 'bonus': 'b'})
-        self.assertEquals(ddl._expand(sane_alone, bind), 'S S-T T-t-b')
-        self.assertEquals(ddl._expand(sane_schema, bind), 'S S-T T-s.t-b')
-        self.assertEquals(ddl._expand(insane_alone, bind), 'S S-T T-"t t"-b')
-        self.assertEquals(ddl._expand(insane_schema, bind),
+        eq_(ddl._expand(sane_alone, bind), 'S S-T T-t-b')
+        eq_(ddl._expand(sane_schema, bind), 'S S-T T-s.t-b')
+        eq_(ddl._expand(insane_alone, bind), 'S S-T T-"t t"-b')
+        eq_(ddl._expand(insane_schema, bind),
                           'S S-T T-"s s"."t t"-b')
     def test_filter(self):
         cx = self.mock_engine()
@@ -338,5 +340,3 @@ class DDLTest(TestBase):
         assert repr(DDL('s', on='engine', context={'a':1}))
 
 
-if __name__ == "__main__":
-    testenv.main()
diff --git a/test/engine/execute.py b/test/engine/test_execute.py
index 515c99d30..08bf80fe2 100644
--- a/test/engine/execute.py
+++ b/test/engine/test_execute.py
@@ -1,15 +1,17 @@
-import testenv; testenv.configure_for_tests()
+from sqlalchemy.test.testing import eq_
 import re
 from sqlalchemy.interfaces import ConnectionProxy
-from testlib.sa import MetaData, Table, Column, Integer, String, INT, \
-     VARCHAR, func, bindparam
-import testlib.sa as tsa
-from testlib import TestBase, testing, engines
+from sqlalchemy import MetaData, Integer, String, INT, VARCHAR, func, bindparam
+from sqlalchemy.test.schema import Table
+from sqlalchemy.test.schema import Column
+import sqlalchemy as tsa
+from sqlalchemy.test import TestBase, testing, engines
 
 
 users, metadata = None, None
 class ExecuteTest(TestBase):
-    def setUpAll(self):
+    @classmethod
+    def setup_class(cls):
         global users, metadata
         metadata = MetaData(testing.db)
         users = Table('users', metadata,
@@ -18,9 +20,10 @@ class ExecuteTest(TestBase):
         )
         metadata.create_all()
 
-    def tearDown(self):
+    def teardown(self):
         testing.db.connect().execute(users.delete())
-    def tearDownAll(self):
+    @classmethod
+    def teardown_class(cls):
         metadata.drop_all()
 
     @testing.fails_on_everything_except('firebird', 'maxdb', 'sqlite')
@@ -82,7 +85,7 @@ class ExecuteTest(TestBase):
     def test_empty_insert(self):
         """test that execute() interprets [] as a list with no params"""
         result = testing.db.execute(users.insert().values(user_name=bindparam('name')), [])
-        self.assertEquals(result.rowcount, 1)
+        eq_(result.rowcount, 1)
 
 class ProxyConnectionTest(TestBase):
     @testing.fails_on('firebird', 'Data type unknown')
@@ -162,5 +165,3 @@ class ProxyConnectionTest(TestBase):
             assert_stmts(cursor, cursor_stmts)
     
 
-if __name__ == "__main__":
-    testenv.main()
diff --git a/test/engine/metadata.py b/test/engine/test_metadata.py
index c8fc6f7e0..024d1b854 100644
--- a/test/engine/metadata.py
+++ b/test/engine/test_metadata.py
@@ -1,11 +1,12 @@
-import testenv; testenv.configure_for_tests()
+from sqlalchemy.test.testing import assert_raises, assert_raises_message
 import pickle
 from sqlalchemy import MetaData
-from testlib.sa import Table, Column, Integer, String, UniqueConstraint, \
-     CheckConstraint, ForeignKey
-import testlib.sa as tsa
-from testlib import TestBase, ComparesTables, testing, engines
-from testlib.testing import eq_
+from sqlalchemy import Integer, String, UniqueConstraint, CheckConstraint, ForeignKey
+from sqlalchemy.test.schema import Table
+from sqlalchemy.test.schema import Column
+import sqlalchemy as tsa
+from sqlalchemy.test import TestBase, ComparesTables, testing, engines
+from sqlalchemy.test.testing import eq_
 
 class MetaDataTest(TestBase, ComparesTables):
     def test_metadata_connect(self):
@@ -137,13 +138,13 @@ class MetaDataTest(TestBase, ComparesTables):
         
         
     def test_nonexistent(self):
-        self.assertRaises(tsa.exc.NoSuchTableError, Table,
+        assert_raises(tsa.exc.NoSuchTableError, Table,
                           'fake_table',
                           MetaData(testing.db), autoload=True)
 
 
 class TableOptionsTest(TestBase):
-    def setUp(self):
+    def setup(self):
         self.engine = engines.mock_engine()
         self.metadata = MetaData(self.engine)
 
@@ -160,5 +161,3 @@ class TableOptionsTest(TestBase):
         table2.create()
         assert [str(x) for x in self.engine.mock if 'CREATE VIRTUAL TABLE' in str(x)]
 
-if __name__ == '__main__':
-    testenv.main()
diff --git a/test/engine/parseconnect.py b/test/engine/test_parseconnect.py
index c82ca6d58..6b7ac37b2 100644
--- a/test/engine/parseconnect.py
+++ b/test/engine/test_parseconnect.py
@@ -1,9 +1,8 @@
-import testenv; testenv.configure_for_tests()
 import ConfigParser, StringIO
 import sqlalchemy.engine.url as url
 from sqlalchemy import create_engine, engine_from_config
-import testlib.sa as tsa
-from testlib import TestBase
+import sqlalchemy as tsa
+from sqlalchemy.test import TestBase
 
 
 class ParseConnectTest(TestBase):
@@ -229,5 +228,3 @@ class MockCursor(object):
         pass
 mock_dbapi = MockDBAPI()
 
-if __name__ == "__main__":
-    testenv.main()
diff --git a/test/engine/pool.py b/test/engine/test_pool.py
index b712e2412..43a0fc38b 100644
--- a/test/engine/pool.py
+++ b/test/engine/test_pool.py
@@ -1,8 +1,7 @@
-import testenv; testenv.configure_for_tests()
 import threading, time, gc
 from sqlalchemy import pool, interfaces
-import testlib.sa as tsa
-from testlib import TestBase
+import sqlalchemy as tsa
+from sqlalchemy.test import TestBase
 
 
 mcid = 1
@@ -37,10 +36,11 @@ mock_dbapi = MockDBAPI()
 
 
 class PoolTestBase(TestBase):    
-    def setUp(self):
+    def setup(self):
         pool.clear_managers()
         
-    def tearDownAll(self):
+    @classmethod
+    def teardown_class(cls):
        pool.clear_managers()
 
 class PoolTest(PoolTestBase):
@@ -662,5 +662,3 @@ class NullPoolTest(PoolTestBase):
     
         
     
-if __name__ == "__main__":
-    testenv.main()
diff --git a/test/engine/reconnect.py b/test/engine/test_reconnect.py
index 4f383d2dd..3a525c2a7 100644
--- a/test/engine/reconnect.py
+++ b/test/engine/test_reconnect.py
@@ -1,8 +1,10 @@
-import testenv; testenv.configure_for_tests()
+from sqlalchemy.test.testing import eq_
 import weakref
-from testlib.sa import select, MetaData, Table, Column, Integer, String, pool
-import testlib.sa as tsa
-from testlib import TestBase, testing, engines
+from sqlalchemy import select, MetaData, Integer, String, pool
+from sqlalchemy.test.schema import Table
+from sqlalchemy.test.schema import Column
+import sqlalchemy as tsa
+from sqlalchemy.test import TestBase, testing, engines
 import time
 import gc
 
@@ -47,7 +49,7 @@ class MockCursor(object):
 
 db, dbapi = None, None
 class MockReconnectTest(TestBase):
-    def setUp(self):
+    def setup(self):
         global db, dbapi
         dbapi = MockDBAPI()
 
@@ -176,17 +178,17 @@ class MockReconnectTest(TestBase):
 
 engine = None
 class RealReconnectTest(TestBase):
-    def setUp(self):
+    def setup(self):
         global engine
         engine = engines.reconnecting_engine()
 
-    def tearDown(self):
+    def teardown(self):
         engine.dispose()
 
     def test_reconnect(self):
         conn = engine.connect()
 
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
         assert not conn.closed
 
         engine.test_shutdown()
@@ -202,7 +204,7 @@ class RealReconnectTest(TestBase):
         assert conn.invalidated
 
         assert conn.invalidated
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
         assert not conn.invalidated
 
         # one more time
@@ -214,7 +216,7 @@ class RealReconnectTest(TestBase):
             if not e.connection_invalidated:
                 raise
         assert conn.invalidated
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
         assert not conn.invalidated
 
         conn.close()
@@ -222,7 +224,7 @@ class RealReconnectTest(TestBase):
     def test_null_pool(self):
         engine = engines.reconnecting_engine(options=dict(poolclass=pool.NullPool))
         conn = engine.connect()
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
         assert not conn.closed
         engine.test_shutdown()
         try:
@@ -233,12 +235,12 @@ class RealReconnectTest(TestBase):
                 raise
         assert not conn.closed
         assert conn.invalidated
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
         assert not conn.invalidated
         
     def test_close(self):
         conn = engine.connect()
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
         assert not conn.closed
 
         engine.test_shutdown()
@@ -252,14 +254,14 @@ class RealReconnectTest(TestBase):
 
         conn.close()
         conn = engine.connect()
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
 
     def test_with_transaction(self):
         conn = engine.connect()
 
         trans = conn.begin()
 
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
         assert not conn.closed
 
         engine.test_shutdown()
@@ -295,7 +297,7 @@ class RealReconnectTest(TestBase):
         assert not trans.is_active
 
         assert conn.invalidated
-        self.assertEquals(conn.execute(select([1])).scalar(), 1)
+        eq_(conn.execute(select([1])).scalar(), 1)
         assert not conn.invalidated
 
 class RecycleTest(TestBase):
@@ -304,19 +306,19 @@ class RecycleTest(TestBase):
             engine = engines.reconnecting_engine(options={'pool_recycle':1, 'pool_threadlocal':threadlocal})
         
             conn = engine.contextual_connect()
-            self.assertEquals(conn.execute(select([1])).scalar(), 1)
+            eq_(conn.execute(select([1])).scalar(), 1)
             conn.close()
 
             engine.test_shutdown()
             time.sleep(2)
     
             conn = engine.contextual_connect()
-            self.assertEquals(conn.execute(select([1])).scalar(), 1)
+            eq_(conn.execute(select([1])).scalar(), 1)
             conn.close()
     
 meta, table, engine = None, None, None
 class InvalidateDuringResultTest(TestBase):
-    def setUp(self):
+    def setup(self):
         global meta, table, engine
         engine = engines.reconnecting_engine()
         meta = MetaData(engine)
@@ -328,7 +330,7 @@ class InvalidateDuringResultTest(TestBase):
             [{'id':i, 'name':'row %d' % i} for i in range(1, 100)]
         )
 
-    def tearDown(self):
+    def teardown(self):
         meta.drop_all()
         engine.dispose()
 
@@ -350,5 +352,3 @@ class InvalidateDuringResultTest(TestBase):
 
         assert conn.invalidated
 
-if __name__ == '__main__':
-    testenv.main()
diff --git a/test/engine/reflection.py b/test/engine/test_reflection.py
index d8412237f..ea80776a6 100644
--- a/test/engine/reflection.py
+++ b/test/engine/test_reflection.py
@@ -1,8 +1,11 @@
-import testenv; testenv.configure_for_tests()
+from sqlalchemy.test.testing import eq_, assert_raises, assert_raises_message
 import StringIO, unicodedata
 import sqlalchemy as sa
-from testlib.sa import MetaData, Table, Column
-from testlib import TestBase, ComparesTables, testing, engines, sa as tsa
+from sqlalchemy import MetaData
+from sqlalchemy.test.schema import Table
+from sqlalchemy.test.schema import Column
+import sqlalchemy as tsa
+from sqlalchemy.test import TestBase, ComparesTables, testing, engines
 
 
 metadata, users = None, None
@@ -62,7 +65,7 @@ class ReflectionTest(TestBase, ComparesTables):
             foo = Table('foo', meta2, autoload=True,
                         include_columns=['b', 'f', 'e'])
             # test that cols come back in original order
-            self.assertEquals([c.name for c in foo.c], ['b', 'e', 'f'])
+            eq_([c.name for c in foo.c], ['b', 'e', 'f'])
             for c in ('b', 'f', 'e'):
                 assert c in foo.c
             for c in ('a', 'c', 'd'):
@@ -73,7 +76,7 @@ class ReflectionTest(TestBase, ComparesTables):
             foo = Table('foo', meta3, autoload=True)
             foo = Table('foo', meta3, include_columns=['b', 'f', 'e'],
                         useexisting=True)
-            self.assertEquals([c.name for c in foo.c], ['b', 'e', 'f'])
+            eq_([c.name for c in foo.c], ['b', 'e', 'f'])
             for c in ('b', 'f', 'e'):
                 assert c in foo.c
             for c in ('a', 'c', 'd'):
@@ -103,7 +106,7 @@ class ReflectionTest(TestBase, ComparesTables):
         dialect_module.ischema_names = {}
         try:
             m2 = MetaData(testing.db)
-            self.assertRaises(tsa.exc.SAWarning, Table, "test", m2, autoload=True)
+            assert_raises(tsa.exc.SAWarning, Table, "test", m2, autoload=True)
 
             @testing.emits_warning('Did not recognize type')
             def warns():
@@ -282,7 +285,7 @@ class ReflectionTest(TestBase, ComparesTables):
             a2 = Table('a', m2, include_columns=['z'], autoload=True)
             b2 = Table('b', m2, autoload=True)
             
-            self.assertRaises(tsa.exc.NoReferencedColumnError, a2.join, b2)
+            assert_raises(tsa.exc.NoReferencedColumnError, a2.join, b2)
         finally:
             meta.drop_all()
         
@@ -405,7 +408,7 @@ class ReflectionTest(TestBase, ComparesTables):
             Column('slot', sa.String(128)),
             )
             
-        self.assertRaisesMessage(tsa.exc.InvalidRequestError, "Could not find table 'pkgs' with which to generate a foreign key", metadata.create_all)
+        assert_raises_message(tsa.exc.InvalidRequestError, "Could not find table 'pkgs' with which to generate a foreign key", metadata.create_all)
 
     def test_composite_pks(self):
         """test reflection of a composite primary key"""
@@ -608,7 +611,8 @@ class ReflectionTest(TestBase, ComparesTables):
             m1.drop_all()
 
 class CreateDropTest(TestBase):
-    def setUpAll(self):
+    @classmethod
+    def setup_class(cls):
         global metadata, users
         metadata = MetaData()
         users = Table('users', metadata,
@@ -656,16 +660,16 @@ class CreateDropTest(TestBase):
 
     def test_createdrop(self):
         metadata.create_all(bind=testing.db)
-        self.assertEqual( testing.db.has_table('items'), True )
-        self.assertEqual( testing.db.has_table('email_addresses'), True )
+        eq_( testing.db.has_table('items'), True )
+        eq_( testing.db.has_table('email_addresses'), True )
         metadata.create_all(bind=testing.db)
-        self.assertEqual( testing.db.has_table('items'), True )
+        eq_( testing.db.has_table('items'), True )
 
         metadata.drop_all(bind=testing.db)
-        self.assertEqual( testing.db.has_table('items'), False )
-        self.assertEqual( testing.db.has_table('email_addresses'), False )
+        eq_( testing.db.has_table('items'), False )
+        eq_( testing.db.has_table('email_addresses'), False )
         metadata.drop_all(bind=testing.db)
-        self.assertEqual( testing.db.has_table('items'), False )
+        eq_( testing.db.has_table('items'), False )
 
     def test_tablenames(self):
         metadata.create_all(bind=testing.db)
@@ -800,7 +804,8 @@ class SchemaTest(TestBase):
 
 
 class HasSequenceTest(TestBase):
-    def setUpAll(self):
+    @classmethod
+    def setup_class(cls):
         global metadata, users
         metadata = MetaData()
         users = Table('users', metadata,
@@ -811,10 +816,8 @@ class HasSequenceTest(TestBase):
     @testing.requires.sequences
     def test_hassequence(self):
         metadata.create_all(bind=testing.db)
-        self.assertEqual(testing.db.dialect.has_sequence(testing.db, 'user_id_seq'), True)
+        eq_(testing.db.dialect.has_sequence(testing.db, 'user_id_seq'), True)
         metadata.drop_all(bind=testing.db)
-        self.assertEqual(testing.db.dialect.has_sequence(testing.db, 'user_id_seq'), False)
+        eq_(testing.db.dialect.has_sequence(testing.db, 'user_id_seq'), False)
 
 
-if __name__ == "__main__":
-    testenv.main()
diff --git a/test/engine/transaction.py b/test/engine/test_transaction.py
index 1fa385610..7d40adf6d 100644
--- a/test/engine/transaction.py
+++ b/test/engine/test_transaction.py
@@ -1,13 +1,15 @@
-import testenv; testenv.configure_for_tests()
+from sqlalchemy.test.testing import eq_, assert_raises, assert_raises_message
 import sys, time, threading
-from testlib.sa import create_engine, MetaData, Table, Column, INT, VARCHAR, \
-     Sequence, select, Integer, String, func, text
-from testlib import TestBase, testing
+from sqlalchemy import create_engine, MetaData, INT, VARCHAR, Sequence, select, Integer, String, func, text
+from sqlalchemy.test.schema import Table
+from sqlalchemy.test.schema import Column
+from sqlalchemy.test import TestBase, testing
 
 
 users, metadata = None, None
 class TransactionTest(TestBase):
-    def setUpAll(self):
+    @classmethod
+    def setup_class(cls):
         global users, metadata
         metadata = MetaData()
         users = Table('query_users', metadata,
@@ -17,9 +19,10 @@ class TransactionTest(TestBase):
         )
         users.create(testing.db)
 
-    def tearDown(self):
+    def teardown(self):
         testing.db.connect().execute(users.delete())
-    def tearDownAll(self):
+    @classmethod
+    def teardown_class(cls):
         users.drop(testing.db)
 
     def test_commits(self):
@@ -166,7 +169,7 @@ class TransactionTest(TestBase):
         connection.execute(users.insert(), user_id=3, user_name='user3')
         transaction.commit()
 
-        self.assertEquals(
+        eq_(
             connection.execute(select([users.c.user_id]).order_by(users.c.user_id)).fetchall(),
             [(1,),(3,)]
         )
@@ -183,7 +186,7 @@ class TransactionTest(TestBase):
         connection.execute(users.insert(), user_id=3, user_name='user3')
         transaction.commit()
 
-        self.assertEquals(
+        eq_(
             connection.execute(select([users.c.user_id]).order_by(users.c.user_id)).fetchall(),
             [(1,),(2,),(3,)]
         )
@@ -202,7 +205,7 @@ class TransactionTest(TestBase):
         connection.execute(users.insert(), user_id=4, user_name='user4')
         transaction.commit()
 
-        self.assertEquals(
+        eq_(
             connection.execute(select([users.c.user_id]).order_by(users.c.user_id)).fetchall(),
             [(1,),(4,)]
         )
@@ -230,7 +233,7 @@ class TransactionTest(TestBase):
         transaction.prepare()
         transaction.rollback()
 
-        self.assertEquals(
+        eq_(
             connection.execute(select([users.c.user_id]).order_by(users.c.user_id)).fetchall(),
             [(1,),(2,)]
         )
@@ -264,7 +267,7 @@ class TransactionTest(TestBase):
 
         transaction.commit()
 
-        self.assertEquals(
+        eq_(
             connection.execute(select([users.c.user_id]).order_by(users.c.user_id)).fetchall(),
             [(1,),(2,),(5,)]
         )
@@ -285,19 +288,17 @@ class TransactionTest(TestBase):
         connection.close()
         connection2 = testing.db.connect()
 
-        self.assertEquals(
+        eq_(
             connection2.execute(select([users.c.user_id]).order_by(users.c.user_id)).fetchall(),
             []
         )
 
         recoverables = connection2.recover_twophase()
-        self.assertTrue(
-            transaction.xid in recoverables
-        )
+        assert transaction.xid in recoverables
 
         connection2.commit_prepared(transaction.xid, recover=True)
 
-        self.assertEquals(
+        eq_(
             connection2.execute(select([users.c.user_id]).order_by(users.c.user_id)).fetchall(),
             [(1,)]
         )
@@ -327,16 +328,18 @@ class TransactionTest(TestBase):
         xa.commit()
 
         result = conn.execute(select([users.c.user_name]).order_by(users.c.user_id))
-        self.assertEqual(result.fetchall(), [('user1',),('user4',)])
+        eq_(result.fetchall(), [('user1',),('user4',)])
 
         conn.close()
 
 class AutoRollbackTest(TestBase):
-    def setUpAll(self):
+    @classmethod
+    def setup_class(cls):
         global metadata
         metadata = MetaData()
 
-    def tearDownAll(self):
+    @classmethod
+    def teardown_class(cls):
         metadata.drop_all(testing.db)
 
     def test_rollback_deadlock(self):
@@ -368,17 +371,19 @@ class ExplicitAutoCommitTest(TestBase):
 
     __only_on__ = 'postgres'
 
-    def setUpAll(self):
+    @classmethod
+    def setup_class(cls):
         global metadata, foo
         metadata = MetaData(testing.db)
         foo = Table('foo', metadata, Column('id', Integer, primary_key=True), Column('data', String(100)))
         metadata.create_all()
         testing.db.execute("create function insert_foo(varchar) returns integer as 'insert into foo(data) values ($1);select 1;' language sql")
 
-    def tearDown(self):
+    def teardown(self):
         foo.delete().execute()
 
-    def tearDownAll(self):
+    @classmethod
+    def teardown_class(cls):
         testing.db.execute("drop function insert_foo(varchar)")
         metadata.drop_all()
 
@@ -437,7 +442,8 @@ class ExplicitAutoCommitTest(TestBase):
 
 tlengine = None
 class TLTransactionTest(TestBase):
-    def setUpAll(self):
+    @classmethod
+    def setup_class(cls):
         global users, metadata, tlengine
         tlengine = create_engine(testing.db.url, strategy='threadlocal')
         metadata = MetaData()
@@ -447,15 +453,16 @@ class TLTransactionTest(TestBase):
             test_needs_acid=True,
         )
         users.create(tlengine)
-    def tearDown(self):
+    def teardown(self):
         tlengine.execute(users.delete())
-    def tearDownAll(self):
+    @classmethod
+    def teardown_class(cls):
         users.drop(tlengine)
         tlengine.dispose()
 
     def test_nested_unsupported(self):
-        self.assertRaises(NotImplementedError, tlengine.contextual_connect().begin_nested)
-        self.assertRaises(NotImplementedError, tlengine.begin_nested)
+        assert_raises(NotImplementedError, tlengine.contextual_connect().begin_nested)
+        assert_raises(NotImplementedError, tlengine.begin_nested)
         
     def test_connection_close(self):
         """test that when connections are closed for real, transactions are rolled back and disposed."""
@@ -688,14 +695,15 @@ class TLTransactionTest(TestBase):
         tlengine.prepare()
         tlengine.rollback()
 
-        self.assertEquals(
+        eq_(
             tlengine.execute(select([users.c.user_id]).order_by(users.c.user_id)).fetchall(),
             [(1,),(2,)]
         )
 
 counters = None
 class ForUpdateTest(TestBase):
-    def setUpAll(self):
+    @classmethod
+    def setup_class(cls):
         global counters, metadata
         metadata = MetaData()
         counters = Table('forupdate_counters', metadata,
@@ -704,9 +712,10 @@ class ForUpdateTest(TestBase):
             test_needs_acid=True,
         )
         counters.create(testing.db)
-    def tearDown(self):
+    def teardown(self):
         testing.db.connect().execute(counters.delete())
-    def tearDownAll(self):
+    @classmethod
+    def teardown_class(cls):
         counters.drop(testing.db)
 
     def increment(self, count, errors, update_style=True, delay=0.005):
@@ -829,5 +838,3 @@ class ForUpdateTest(TestBase):
         self.assert_(len(errors) != 0)
 
 
-if __name__ == "__main__":
-    testenv.main()