- testbase is gone, replaced by testenv

- Importing testenv has no side effects- explicit functions provide similar behavior to the old immediate behavior of testbase
- testing.db has the configured db
- Fixed up the perf/* scripts

11 files changed, 151 insertions, 137 deletions

diff --git a/test/dialect/access.py b/test/dialect/access.py
index 0aa75930a..52a72e66a 100644
--- a/test/dialect/access.py
+++ b/test/dialect/access.py
@@ -1,10 +1,15 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 from sqlalchemy import *
 from sqlalchemy.databases import access
 from testlib import *
 
+
 class BasicTest(AssertMixin):
     # A simple import of the database/ module should work on all systems.
     def test_import(self):
         # we got this far, right?
         return True
+
+
+if __name__ == "__main__":
+    testenv.main()
diff --git a/test/dialect/alltests.py b/test/dialect/alltests.py
index 3e34f737e..d40f0d6d4 100644
--- a/test/dialect/alltests.py
+++ b/test/dialect/alltests.py
@@ -1,16 +1,19 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 import unittest
 
+
 def suite():
     modules_to_test = (
         'dialect.access',
         'dialect.firebird',
         'dialect.informix',
+        'dialect.maxdb',
         'dialect.mssql',
         'dialect.mysql',
         'dialect.oracle',
         'dialect.postgres',
         'dialect.sqlite',
+        'dialect.sybase',
         )
     alltests = unittest.TestSuite()
     for name in modules_to_test:
@@ -21,6 +24,5 @@ def suite():
     return alltests
 
 
-
 if __name__ == '__main__':
-    testbase.main(suite())
+    testenv.main(suite())
diff --git a/test/dialect/firebird.py b/test/dialect/firebird.py
index 6b2a35c87..e327bf151 100644
--- a/test/dialect/firebird.py
+++ b/test/dialect/firebird.py
@@ -1,4 +1,4 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 from sqlalchemy import *
 from sqlalchemy.databases import firebird
 from sqlalchemy.exceptions import ProgrammingError
@@ -12,7 +12,7 @@ class DomainReflectionTest(AssertMixin):
     __only_on__ = 'firebird'
 
     def setUpAll(self):
-        con = testbase.db.connect()
+        con = testing.db.connect()
         try:
             con.execute('CREATE DOMAIN int_domain AS INTEGER DEFAULT 42 NOT NULL')
             con.execute('CREATE DOMAIN str_domain AS VARCHAR(255)')
@@ -39,7 +39,7 @@ class DomainReflectionTest(AssertMixin):
                        END''')
 
     def tearDownAll(self):
-        con = testbase.db.connect()
+        con = testing.db.connect()
         con.execute('DROP TABLE testtable')
         con.execute('DROP DOMAIN int_domain')
         con.execute('DROP DOMAIN str_domain')
@@ -48,7 +48,7 @@ class DomainReflectionTest(AssertMixin):
         con.execute('DROP GENERATOR gen_testtable_id')
 
     def test_table_is_reflected(self):
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
         table = Table('testtable', metadata, autoload=True)
         self.assertEquals(set(table.columns.keys()),
                           set(['question', 'answer', 'remark', 'photo', 'd', 't', 'dt']),
@@ -89,15 +89,15 @@ class CompileTest(SQLCompileTest):
 class MiscFBTests(PersistTest):
 
     __only_on__ = 'firebird'
-    
+
     def test_strlen(self):
         # On FB the length() function is implemented by an external
         # UDF, strlen().  Various SA tests fail because they pass a
         # parameter to it, and that does not work (it always results
         # the maximum string length the UDF was declared to accept).
         # This test checks that at least it works ok in other cases.
-        
-        meta = MetaData(testbase.db)
+
+        meta = MetaData(testing.db)
         t = Table('t1', meta,
             Column('id', Integer, Sequence('t1idseq'), primary_key=True),
             Column('name', String(10))
@@ -111,8 +111,8 @@ class MiscFBTests(PersistTest):
             meta.drop_all()
 
     def test_server_version_info(self):
-        version = testbase.db.dialect.server_version_info(testbase.db.connect())
+        version = testing.db.dialect.server_version_info(testing.db.connect())
         assert len(version) == 3, "Got strange version info: %s" % repr(version)
 
 if __name__ == '__main__':
-    testbase.main()
+    testenv.main()
diff --git a/test/dialect/informix.py b/test/dialect/informix.py
index 2e7dbe39c..da518075b 100644
--- a/test/dialect/informix.py
+++ b/test/dialect/informix.py
@@ -1,10 +1,15 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 from sqlalchemy import *
 from sqlalchemy.databases import informix
 from testlib import *
 
+
 class BasicTest(AssertMixin):
     # A simple import of the database/ module should work on all systems.
     def test_import(self):
         # we got this far, right?
         return True
+
+
+if __name__ == "__main__":
+    testenv.main()
diff --git a/test/dialect/maxdb.py b/test/dialect/maxdb.py
index 5397fbba6..4ec9faa6c 100644
--- a/test/dialect/maxdb.py
+++ b/test/dialect/maxdb.py
@@ -1,6 +1,6 @@
 """MaxDB-specific tests."""
 
-import testbase
+import testenv; testenv.configure_for_tests()
 import StringIO, sys
 from sqlalchemy import *
 from sqlalchemy import exceptions, sql
@@ -29,11 +29,11 @@ class ReflectionTest(AssertMixin):
         decimal assignment and selection behavior.
         """
 
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         try:
             if isinstance(tabledef, basestring):
                 # run textual CREATE TABLE
-                testbase.db.execute(tabledef)
+                testing.db.execute(tabledef)
             else:
                 _t = tabledef.tometadata(meta)
                 _t.create()
@@ -52,7 +52,7 @@ class ReflectionTest(AssertMixin):
                                            tuple([2] + vals)])
         finally:
             try:
-                testbase.db.execute("DROP TABLE dectest")
+                testing.db.execute("DROP TABLE dectest")
             except exceptions.DatabaseError:
                 pass
 
@@ -130,9 +130,9 @@ class ReflectionTest(AssertMixin):
     def test_assorted_type_aliases(self):
         """Ensures that aliased types are reflected properly."""
 
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         try:
-            testbase.db.execute("""
+            testing.db.execute("""
             CREATE TABLE assorted (
               c1 INT,
               c2 BINARY(2),
@@ -164,7 +164,7 @@ class ReflectionTest(AssertMixin):
                 self.assert_(isinstance(col.type, expected[i]))
         finally:
             try:
-                testbase.db.execute("DROP TABLE assorted")
+                testing.db.execute("DROP TABLE assorted")
             except exceptions.DatabaseError:
                 pass
 
@@ -177,7 +177,7 @@ class DBAPITest(AssertMixin):
     __only_on__ = 'maxdb'
 
     def test_dbapi_breaks_sequences(self):
-        con = testbase.db.connect().connection
+        con = testing.db.connect().connection
 
         cr = con.cursor()
         cr.execute('CREATE SEQUENCE busto START WITH 1 INCREMENT BY 1')
@@ -195,7 +195,7 @@ class DBAPITest(AssertMixin):
             cr.execute('DROP SEQUENCE busto')
 
     def test_dbapi_breaks_mod_binds(self):
-        con = testbase.db.connect().connection
+        con = testing.db.connect().connection
 
         cr = con.cursor()
         # OK
@@ -212,8 +212,8 @@ class DBAPITest(AssertMixin):
         cr.execute('SELECT MOD(?, 2) FROM DUAL', [3])
 
     def test_dbapi_breaks_close(self):
-        dialect = testbase.db.dialect
-        cargs, ckw = dialect.create_connect_args(testbase.db.url)
+        dialect = testing.db.dialect
+        cargs, ckw = dialect.create_connect_args(testing.db.url)
 
         # There doesn't seem to be a way to test for this as it occurs in
         # regular usage- the warning doesn't seem to go through 'warnings'.
@@ -232,8 +232,9 @@ class DBAPITest(AssertMixin):
             self.assert_(True)
 
     def test_modulo_operator(self):
-        st = str(select([sql.column('col') % 5]).compile(testbase.db))
+        st = str(select([sql.column('col') % 5]).compile(testing.db))
         self.assertEquals(st, 'SELECT mod(col, ?) FROM DUAL')
 
+
 if __name__ == "__main__":
-    testbase.main()
+    testenv.main()
diff --git a/test/dialect/mssql.py b/test/dialect/mssql.py
index 00b0db9cc..0b7a8444b 100755
--- a/test/dialect/mssql.py
+++ b/test/dialect/mssql.py
@@ -1,11 +1,10 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 import re
 from sqlalchemy import *
 from sqlalchemy.sql import table, column
 from sqlalchemy.databases import mssql
 from testlib import *
 
-# TODO: migrate all MS-SQL tests here
 
 class CompileTest(SQLCompileTest):
     __dialect__ = mssql.MSSQLDialect()
@@ -59,14 +58,14 @@ class ReflectionTest(PersistTest):
     __only_on__ = 'mssql'
 
     def testidentity(self):
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         table = Table(
             'identity_test', meta,
             Column('col1', Integer, Sequence('fred', 2, 3), primary_key=True)
         )
         table.create()
 
-        meta2 = MetaData(testbase.db)
+        meta2 = MetaData(testing.db)
         try:
             table2 = Table('identity_test', meta2, autoload=True)
             assert table2.c['col1'].sequence.start == 2
@@ -79,7 +78,7 @@ class QueryTest(PersistTest):
     __only_on__ = 'mssql'
 
     def test_fetchid_trigger(self):
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         t1 = Table('t1', meta,
                 Column('id', Integer, Sequence('fred', 100, 1), primary_key=True),
                 Column('descr', String(200)))
@@ -87,7 +86,7 @@ class QueryTest(PersistTest):
                 Column('id', Integer, Sequence('fred', 200, 1), primary_key=True),
                 Column('descr', String(200)))
         meta.create_all()
-        con = testbase.db.connect()
+        con = testing.db.connect()
         con.execute("""create trigger paj on t1 for insert as
             insert into t2 (descr) select descr from inserted""")
 
@@ -104,8 +103,8 @@ class QueryTest(PersistTest):
             meta.drop_all()
 
     def test_insertid_schema(self):
-        meta = MetaData(testbase.db)
-        con = testbase.db.connect()
+        meta = MetaData(testing.db)
+        con = testing.db.connect()
         con.execute('create schema paj')
         tbl = Table('test', meta, Column('id', Integer, primary_key=True), schema='paj')
         tbl.create()
@@ -116,21 +115,21 @@ class QueryTest(PersistTest):
             con.execute('drop schema paj')
 
     def test_insertid_reserved(self):
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         table = Table(
             'select', meta,
             Column('col', Integer, primary_key=True)
         )
         table.create()
 
-        meta2 = MetaData(testbase.db)
+        meta2 = MetaData(testing.db)
         try:
             table.insert().execute(col=7)
         finally:
             table.drop()
 
     def test_select_limit_nooffset(self):
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
 
         users = Table('query_users', metadata,
             Column('user_id', INT, primary_key = True),
@@ -157,7 +156,7 @@ class GenerativeQueryTest(PersistTest):
 
     def setUpAll(self):
         global foo, metadata
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
         foo = Table('foo', metadata,
                     Column('id', Integer, Sequence('foo_id_seq'),
                            primary_key=True),
@@ -167,7 +166,7 @@ class GenerativeQueryTest(PersistTest):
         mapper(Foo, foo)
         metadata.create_all()
 
-        sess = create_session(bind=testbase.db)
+        sess = create_session(bind=testing.db)
         for i in range(100):
             sess.save(Foo(bar=i, range=i%10))
         sess.flush()
@@ -177,7 +176,7 @@ class GenerativeQueryTest(PersistTest):
         clear_mappers()
 
     def test_slice_mssql(self):
-        sess = create_session(bind=testbase.db)
+        sess = create_session(bind=testing.db)
         query = sess.query(Foo)
         orig = query.all()
         assert list(query[:10]) == orig[:10]
@@ -185,4 +184,4 @@ class GenerativeQueryTest(PersistTest):
 
 
 if __name__ == "__main__":
-    testbase.main()
+    testenv.main()
diff --git a/test/dialect/mysql.py b/test/dialect/mysql.py
index df6a2547b..2b589f625 100644
--- a/test/dialect/mysql.py
+++ b/test/dialect/mysql.py
@@ -1,4 +1,4 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 import sets
 from sqlalchemy import *
 from sqlalchemy import sql, exceptions
@@ -12,7 +12,7 @@ class TypesTest(AssertMixin):
     __only_on__ = 'mysql'
 
     def test_basic(self):
-        meta1 = MetaData(testbase.db)
+        meta1 = MetaData(testing.db)
         table = Table(
             'mysql_types', meta1,
             Column('id', Integer, primary_key=True),
@@ -28,7 +28,7 @@ class TypesTest(AssertMixin):
         try:
             table.drop(checkfirst=True)
             table.create()
-            meta2 = MetaData(testbase.db)
+            meta2 = MetaData(testing.db)
             t2 = Table('mysql_types', meta2, autoload=True)
             assert isinstance(t2.c.num1.type, mysql.MSInteger)
             assert t2.c.num1.type.unsigned
@@ -156,13 +156,13 @@ class TypesTest(AssertMixin):
              'SMALLINT(4) UNSIGNED ZEROFILL'),
            ]
 
-        table_args = ['test_mysql_numeric', MetaData(testbase.db)]
+        table_args = ['test_mysql_numeric', MetaData(testing.db)]
         for index, spec in enumerate(columns):
             type_, args, kw, res = spec
             table_args.append(Column('c%s' % index, type_(*args, **kw)))
 
         numeric_table = Table(*table_args)
-        gen = testbase.db.dialect.schemagenerator(testbase.db.dialect, testbase.db, None, None)
+        gen = testing.db.dialect.schemagenerator(testing.db.dialect, testing.db, None, None)
 
         for col in numeric_table.c:
             index = int(col.name[1:])
@@ -240,13 +240,13 @@ class TypesTest(AssertMixin):
              '''ENUM('foo','bar') UNICODE''')
            ]
 
-        table_args = ['test_mysql_charset', MetaData(testbase.db)]
+        table_args = ['test_mysql_charset', MetaData(testing.db)]
         for index, spec in enumerate(columns):
             type_, args, kw, res = spec
             table_args.append(Column('c%s' % index, type_(*args, **kw)))
 
         charset_table = Table(*table_args)
-        gen = testbase.db.dialect.schemagenerator(testbase.db.dialect, testbase.db, None, None)
+        gen = testing.db.dialect.schemagenerator(testing.db.dialect, testing.db, None, None)
 
         for col in charset_table.c:
             index = int(col.name[1:])
@@ -265,7 +265,7 @@ class TypesTest(AssertMixin):
     def test_bit_50(self):
         """Exercise BIT types on 5.0+ (not valid for all engine types)"""
 
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         bit_table = Table('mysql_bits', meta,
                           Column('b1', mysql.MSBit),
                           Column('b2', mysql.MSBit()),
@@ -290,7 +290,7 @@ class TypesTest(AssertMixin):
         try:
             meta.create_all()
 
-            meta2 = MetaData(testbase.db)
+            meta2 = MetaData(testing.db)
             reflected = Table('mysql_bits', meta2, autoload=True)
 
             for table in bit_table, reflected:
@@ -327,7 +327,7 @@ class TypesTest(AssertMixin):
     def test_boolean(self):
         """Test BOOL/TINYINT(1) compatability and reflection."""
 
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         bool_table = Table('mysql_bool', meta,
                            Column('b1', BOOLEAN),
                            Column('b2', mysql.MSBoolean),
@@ -368,7 +368,7 @@ class TypesTest(AssertMixin):
             roundtrip([True, True, True, True], [True, True, 1, 1])
             roundtrip([False, False, 0, 0], [False, False, 0, 0])
 
-            meta2 = MetaData(testbase.db)
+            meta2 = MetaData(testing.db)
             # replace with reflected
             table = Table('mysql_bool', meta2, autoload=True)
             self.assert_eq(colspec(table.c.b3), 'b3 BOOL')
@@ -385,7 +385,7 @@ class TypesTest(AssertMixin):
     def test_timestamp(self):
         """Exercise funky TIMESTAMP default syntax."""
 
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
 
         try:
             columns = [
@@ -417,7 +417,7 @@ class TypesTest(AssertMixin):
                 self.assert_eq(colspec(t.c.t), "t %s" % expected)
                 self.assert_(repr(t.c.t))
                 t.create()
-                r = Table('mysql_ts%s' % idx, MetaData(testbase.db),
+                r = Table('mysql_ts%s' % idx, MetaData(testing.db),
                           autoload=True)
                 if len(spec) > 1:
                     self.assert_(r.c.t is not None)
@@ -427,7 +427,7 @@ class TypesTest(AssertMixin):
     def test_year(self):
         """Exercise YEAR."""
 
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         year_table = Table('mysql_year', meta,
                            Column('y1', mysql.MSYear),
                            Column('y2', mysql.MSYear),
@@ -439,7 +439,7 @@ class TypesTest(AssertMixin):
             self.assert_(repr(col))
         try:
             year_table.create()
-            reflected = Table('mysql_year', MetaData(testbase.db),
+            reflected = Table('mysql_year', MetaData(testing.db),
                               autoload=True)
 
             for table in year_table, reflected:
@@ -457,7 +457,7 @@ class TypesTest(AssertMixin):
     def test_set(self):
         """Exercise the SET type."""
 
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         set_table = Table('mysql_set', meta,
                           Column('s1', mysql.MSSet("'dq'", "'sq'")),
                           Column('s2', mysql.MSSet("'a'")),
@@ -471,7 +471,7 @@ class TypesTest(AssertMixin):
             self.assert_(repr(col))
         try:
             set_table.create()
-            reflected = Table('mysql_set', MetaData(testbase.db),
+            reflected = Table('mysql_set', MetaData(testing.db),
                               autoload=True)
 
             for table in set_table, reflected:
@@ -514,8 +514,8 @@ class TypesTest(AssertMixin):
     def test_enum(self):
         """Exercise the ENUM type."""
 
-        db = testbase.db
-        enum_table = Table('mysql_enum', MetaData(testbase.db),
+        db = testing.db
+        enum_table = Table('mysql_enum', MetaData(testing.db),
             Column('e1', mysql.MSEnum("'a'", "'b'")),
             Column('e2', mysql.MSEnum("'a'", "'b'"),
                    nullable=False),
@@ -559,8 +559,8 @@ class TypesTest(AssertMixin):
         # This is known to fail with MySQLDB 1.2.2 beta versions
         # which return these as sets.Set(['a']), sets.Set(['b'])
         # (even on Pythons with __builtin__.set)
-        if testbase.db.dialect.dbapi.version_info < (1, 2, 2, 'beta', 3) and \
-           testbase.db.dialect.dbapi.version_info >= (1, 2, 2):
+        if testing.db.dialect.dbapi.version_info < (1, 2, 2, 'beta', 3) and \
+           testing.db.dialect.dbapi.version_info >= (1, 2, 2):
             # these mysqldb seem to always uses 'sets', even on later pythons
             import sets
             def convert(value):
@@ -585,7 +585,7 @@ class TypesTest(AssertMixin):
 
         # MySQL 3.23 can't handle an ENUM of ''....
 
-        enum_table = Table('mysql_enum', MetaData(testbase.db),
+        enum_table = Table('mysql_enum', MetaData(testing.db),
             Column('e1', mysql.MSEnum("'a'")),
             Column('e2', mysql.MSEnum("''")),
             Column('e3', mysql.MSEnum("'a'", "''")),
@@ -596,7 +596,7 @@ class TypesTest(AssertMixin):
             self.assert_(repr(col))
         try:
             enum_table.create()
-            reflected = Table('mysql_enum', MetaData(testbase.db),
+            reflected = Table('mysql_enum', MetaData(testing.db),
                               autoload=True)
             for t in enum_table, reflected:
                 assert t.c.e1.type.enums == ["a"]
@@ -610,14 +610,14 @@ class TypesTest(AssertMixin):
     def test_default_reflection(self):
         """Test reflection of column defaults."""
 
-        def_table = Table('mysql_def', MetaData(testbase.db),
+        def_table = Table('mysql_def', MetaData(testing.db),
             Column('c1', String(10), PassiveDefault('')),
             Column('c2', String(10), PassiveDefault('0')),
             Column('c3', String(10), PassiveDefault('abc')))
 
         try:
             def_table.create()
-            reflected = Table('mysql_def', MetaData(testbase.db),
+            reflected = Table('mysql_def', MetaData(testing.db),
                               autoload=True)
             for t in def_table, reflected:
                 assert t.c.c1.default.arg == ''
@@ -662,7 +662,7 @@ class TypesTest(AssertMixin):
 
         columns = [Column('c%i' % (i + 1), t[0]) for i, t in enumerate(specs)]
 
-        db = testbase.db
+        db = testing.db
         m = MetaData(db)
         t_table = Table('mysql_types', m, *columns)
         try:
@@ -695,7 +695,7 @@ class TypesTest(AssertMixin):
             m.drop_all()
 
     def test_autoincrement(self):
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         try:
             Table('ai_1', meta,
                   Column('int_y', Integer, primary_key=True),
@@ -737,7 +737,7 @@ class TypesTest(AssertMixin):
 
             table_names = ['ai_1', 'ai_2', 'ai_3', 'ai_4',
                            'ai_5', 'ai_6', 'ai_7', 'ai_8']
-            mr = MetaData(testbase.db)
+            mr = MetaData(testing.db)
             mr.reflect(only=table_names)
 
             for tbl in [mr.tables[name] for name in table_names]:
@@ -928,8 +928,8 @@ class SQLTest(SQLCompileTest):
 
 
 def colspec(c):
-    return testbase.db.dialect.schemagenerator(testbase.db.dialect,
-        testbase.db, None, None).get_column_specification(c)
+    return testing.db.dialect.schemagenerator(testing.db.dialect,
+        testing.db, None, None).get_column_specification(c)
 
 if __name__ == "__main__":
-    testbase.main()
+    testenv.main()
diff --git a/test/dialect/oracle.py b/test/dialect/oracle.py
index cff96c21f..cc171af5f 100644
--- a/test/dialect/oracle.py
+++ b/test/dialect/oracle.py
@@ -1,4 +1,4 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 from sqlalchemy import *
 from sqlalchemy.sql import table, column
 from sqlalchemy.databases import oracle
@@ -9,7 +9,7 @@ class OutParamTest(AssertMixin):
     __only_on__ = 'oracle'
 
     def setUpAll(self):
-        testbase.db.execute("""
+        testing.db.execute("""
 create or replace procedure foo(x_in IN number, x_out OUT number, y_out OUT number) IS
   retval number;
     begin
@@ -20,12 +20,12 @@ create or replace procedure foo(x_in IN number, x_out OUT number, y_out OUT numb
         """)
 
     def test_out_params(self):
-        result = testbase.db.execute(text("begin foo(:x, :y, :z); end;", bindparams=[bindparam('x', Numeric), outparam('y', Numeric), outparam('z', Numeric)]), x=5)
+        result = testing.db.execute(text("begin foo(:x, :y, :z); end;", bindparams=[bindparam('x', Numeric), outparam('y', Numeric), outparam('z', Numeric)]), x=5)
         assert result.out_parameters == {'y':10, 'z':75}, result.out_parameters
         print result.out_parameters
 
     def tearDownAll(self):
-         testbase.db.execute("DROP PROCEDURE foo")
+         testing.db.execute("DROP PROCEDURE foo")
 
 
 class CompileTest(SQLCompileTest):
@@ -149,7 +149,7 @@ class TypesTest(SQLCompileTest):
 
     def test_reflect_raw(self):
         types_table = Table(
-        'all_types', MetaData(testbase.db),
+        'all_types', MetaData(testing.db),
             Column('owner', String(30), primary_key=True),
             Column('type_name', String(30), primary_key=True),
             autoload=True,
@@ -157,8 +157,8 @@ class TypesTest(SQLCompileTest):
         [[row[k] for k in row.keys()] for row in types_table.select().execute().fetchall()]
 
     def test_longstring(self):
-        metadata = MetaData(testbase.db)
-        testbase.db.execute("""
+        metadata = MetaData(testing.db)
+        testing.db.execute("""
         CREATE TABLE Z_TEST
         (
           ID        NUMERIC(22) PRIMARY KEY,
@@ -170,7 +170,7 @@ class TypesTest(SQLCompileTest):
             t.insert().execute(id=1.0, add_user='foobar')
             assert t.select().execute().fetchall() == [(1, 'foobar')]
         finally:
-            testbase.db.execute("DROP TABLE Z_TEST")
+            testing.db.execute("DROP TABLE Z_TEST")
 
 class SequenceTest(SQLCompileTest):
     def test_basic(self):
@@ -186,4 +186,4 @@ class SequenceTest(SQLCompileTest):
 
 
 if __name__ == '__main__':
-    testbase.main()
+    testenv.main()
diff --git a/test/dialect/postgres.py b/test/dialect/postgres.py
index a3d1f665b..760affe8f 100644
--- a/test/dialect/postgres.py
+++ b/test/dialect/postgres.py
@@ -1,4 +1,4 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 import datetime
 from sqlalchemy import *
 from sqlalchemy import exceptions
@@ -7,6 +7,7 @@ from sqlalchemy.engine.strategies import MockEngineStrategy
 from testlib import *
 from sqlalchemy.sql import table, column
 
+
 class SequenceTest(SQLCompileTest):
     def test_basic(self):
         seq = Sequence("my_seq_no_schema")
@@ -61,7 +62,7 @@ class ReturningTest(AssertMixin):
 
     @testing.exclude('postgres', '<', (8, 2))
     def test_update_returning(self):
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         table = Table('tables', meta,
             Column('id', Integer, primary_key=True),
             Column('persons', Integer),
@@ -81,7 +82,7 @@ class ReturningTest(AssertMixin):
 
     @testing.exclude('postgres', '<', (8, 2))
     def test_insert_returning(self):
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         table = Table('tables', meta,
             Column('id', Integer, primary_key=True),
             Column('persons', Integer),
@@ -102,7 +103,7 @@ class ReturningTest(AssertMixin):
             result3 = table.insert(postgres_returning=[(table.c.id*2).label('double_id')]).execute({'persons': 4, 'full': False})
             self.assertEqual([dict(row) for row in result3], [{'double_id':8}])
 
-            result4 = testbase.db.execute('insert into tables (id, persons, "full") values (5, 10, true) returning persons')
+            result4 = testing.db.execute('insert into tables (id, persons, "full") values (5, 10, true) returning persons')
             self.assertEqual([dict(row) for row in result4], [{'persons': 10}])
         finally:
             table.drop()
@@ -113,7 +114,7 @@ class InsertTest(AssertMixin):
 
     def setUpAll(self):
         global metadata
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
 
     def tearDown(self):
         metadata.drop_all()
@@ -183,7 +184,7 @@ class InsertTest(AssertMixin):
         # note that the test framework doesnt capture the "preexecute" of a seqeuence
         # or default.  we just see it in the bind params.
 
-        self.assert_sql(testbase.db, go, [], with_sequences=[
+        self.assert_sql(testing.db, go, [], with_sequences=[
             (
                 "INSERT INTO testtable (id, data) VALUES (:id, :data)",
                 {'id':30, 'data':'d1'}
@@ -224,7 +225,7 @@ class InsertTest(AssertMixin):
 
         # test the same series of events using a reflected
         # version of the table
-        m2 = MetaData(testbase.db)
+        m2 = MetaData(testing.db)
         table = Table(table.name, m2, autoload=True)
 
         def go():
@@ -236,7 +237,7 @@ class InsertTest(AssertMixin):
             table.insert(inline=True).execute({'id':33, 'data':'d7'})
             table.insert(inline=True).execute({'data':'d8'})
 
-        self.assert_sql(testbase.db, go, [], with_sequences=[
+        self.assert_sql(testing.db, go, [], with_sequences=[
             (
                 "INSERT INTO testtable (id, data) VALUES (:id, :data)",
                 {'id':30, 'data':'d1'}
@@ -284,7 +285,7 @@ class InsertTest(AssertMixin):
             table.insert(inline=True).execute({'id':33, 'data':'d7'})
             table.insert(inline=True).execute({'data':'d8'})
 
-        self.assert_sql(testbase.db, go, [], with_sequences=[
+        self.assert_sql(testing.db, go, [], with_sequences=[
             (
                 "INSERT INTO testtable (id, data) VALUES (:id, :data)",
                 {'id':30, 'data':'d1'}
@@ -351,7 +352,7 @@ class InsertTest(AssertMixin):
 
         # test the same series of events using a reflected
         # version of the table
-        m2 = MetaData(testbase.db)
+        m2 = MetaData(testing.db)
         table = Table(table.name, m2, autoload=True)
         table.insert().execute({'id':30, 'data':'d1'})
         try:
@@ -381,7 +382,7 @@ class DomainReflectionTest(AssertMixin):
     __only_on__ = 'postgres'
 
     def setUpAll(self):
-        con = testbase.db.connect()
+        con = testing.db.connect()
         try:
             con.execute('CREATE DOMAIN testdomain INTEGER NOT NULL DEFAULT 42')
             con.execute('CREATE DOMAIN alt_schema.testdomain INTEGER DEFAULT 0')
@@ -393,7 +394,7 @@ class DomainReflectionTest(AssertMixin):
         con.execute('CREATE TABLE crosschema (question integer, answer alt_schema.testdomain)')
 
     def tearDownAll(self):
-        con = testbase.db.connect()
+        con = testing.db.connect()
         con.execute('DROP TABLE testtable')
         con.execute('DROP TABLE alt_schema.testtable')
         con.execute('DROP TABLE crosschema')
@@ -401,31 +402,31 @@ class DomainReflectionTest(AssertMixin):
         con.execute('DROP DOMAIN alt_schema.testdomain')
 
     def test_table_is_reflected(self):
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
         table = Table('testtable', metadata, autoload=True)
         self.assertEquals(set(table.columns.keys()), set(['question', 'answer']), "Columns of reflected table didn't equal expected columns")
         self.assertEquals(table.c.answer.type.__class__, postgres.PGInteger)
 
     def test_domain_is_reflected(self):
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
         table = Table('testtable', metadata, autoload=True)
         self.assertEquals(str(table.columns.answer.default.arg), '42', "Reflected default value didn't equal expected value")
         self.assertFalse(table.columns.answer.nullable, "Expected reflected column to not be nullable.")
 
     def test_table_is_reflected_alt_schema(self):
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
         table = Table('testtable', metadata, autoload=True, schema='alt_schema')
         self.assertEquals(set(table.columns.keys()), set(['question', 'answer', 'anything']), "Columns of reflected table didn't equal expected columns")
         self.assertEquals(table.c.anything.type.__class__, postgres.PGInteger)
 
     def test_schema_domain_is_reflected(self):
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
         table = Table('testtable', metadata, autoload=True, schema='alt_schema')
         self.assertEquals(str(table.columns.answer.default.arg), '0', "Reflected default value didn't equal expected value")
         self.assertTrue(table.columns.answer.nullable, "Expected reflected column to be nullable.")
 
     def test_crosschema_domain_is_reflected(self):
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
         table = Table('crosschema', metadata, autoload=True)
         self.assertEquals(str(table.columns.answer.default.arg), '0', "Reflected default value didn't equal expected value")
         self.assertTrue(table.columns.answer.nullable, "Expected reflected column to be nullable.")
@@ -434,14 +435,14 @@ class MiscTest(AssertMixin):
     __only_on__ = 'postgres'
 
     def test_date_reflection(self):
-        m1 = MetaData(testbase.db)
+        m1 = MetaData(testing.db)
         t1 = Table('pgdate', m1,
             Column('date1', DateTime(timezone=True)),
             Column('date2', DateTime(timezone=False))
             )
         m1.create_all()
         try:
-            m2 = MetaData(testbase.db)
+            m2 = MetaData(testing.db)
             t2 = Table('pgdate', m2, autoload=True)
             assert t2.c.date1.type.timezone is True
             assert t2.c.date2.type.timezone is False
@@ -449,7 +450,7 @@ class MiscTest(AssertMixin):
             m1.drop_all()
 
     def test_pg_weirdchar_reflection(self):
-        meta1 = MetaData(testbase.db)
+        meta1 = MetaData(testing.db)
         subject = Table("subject", meta1,
                         Column("id$", Integer, primary_key=True),
                         )
@@ -460,7 +461,7 @@ class MiscTest(AssertMixin):
                         )
         meta1.create_all()
         try:
-            meta2 = MetaData(testbase.db)
+            meta2 = MetaData(testing.db)
             subject = Table("subject", meta2, autoload=True)
             referer = Table("referer", meta2, autoload=True)
             print str(subject.join(referer).onclause)
@@ -469,17 +470,17 @@ class MiscTest(AssertMixin):
             meta1.drop_all()
 
     def test_checksfor_sequence(self):
-        meta1 = MetaData(testbase.db)
+        meta1 = MetaData(testing.db)
         t = Table('mytable', meta1,
             Column('col1', Integer, Sequence('fooseq')))
         try:
-            testbase.db.execute("CREATE SEQUENCE fooseq")
+            testing.db.execute("CREATE SEQUENCE fooseq")
             t.create(checkfirst=True)
         finally:
             t.drop(checkfirst=True)
 
     def test_distinct_on(self):
-        t = Table('mytable', MetaData(testbase.db),
+        t = Table('mytable', MetaData(testing.db),
                   Column('id', Integer, primary_key=True),
                   Column('a', String(8)))
         self.assertEquals(
@@ -498,7 +499,7 @@ class MiscTest(AssertMixin):
     def test_schema_reflection(self):
         """note: this test requires that the 'alt_schema' schema be separate and accessible by the test user"""
 
-        meta1 = MetaData(testbase.db)
+        meta1 = MetaData(testing.db)
         users = Table('users', meta1,
             Column('user_id', Integer, primary_key = True),
             Column('user_name', String(30), nullable = False),
@@ -513,7 +514,7 @@ class MiscTest(AssertMixin):
         )
         meta1.create_all()
         try:
-            meta2 = MetaData(testbase.db)
+            meta2 = MetaData(testing.db)
             addresses = Table('email_addresses', meta2, autoload=True, schema="alt_schema")
             users = Table('users', meta2, mustexist=True, schema="alt_schema")
 
@@ -526,7 +527,7 @@ class MiscTest(AssertMixin):
             meta1.drop_all()
 
     def test_schema_reflection_2(self):
-        meta1 = MetaData(testbase.db)
+        meta1 = MetaData(testing.db)
         subject = Table("subject", meta1,
                         Column("id", Integer, primary_key=True),
                         )
@@ -537,7 +538,7 @@ class MiscTest(AssertMixin):
                         schema="alt_schema")
         meta1.create_all()
         try:
-            meta2 = MetaData(testbase.db)
+            meta2 = MetaData(testing.db)
             subject = Table("subject", meta2, autoload=True)
             referer = Table("referer", meta2, schema="alt_schema", autoload=True)
             print str(subject.join(referer).onclause)
@@ -546,7 +547,7 @@ class MiscTest(AssertMixin):
             meta1.drop_all()
 
     def test_schema_reflection_3(self):
-        meta1 = MetaData(testbase.db)
+        meta1 = MetaData(testing.db)
         subject = Table("subject", meta1,
                         Column("id", Integer, primary_key=True),
                         schema='alt_schema_2'
@@ -559,7 +560,7 @@ class MiscTest(AssertMixin):
 
         meta1.create_all()
         try:
-            meta2 = MetaData(testbase.db)
+            meta2 = MetaData(testing.db)
             subject = Table("subject", meta2, autoload=True, schema="alt_schema_2")
             referer = Table("referer", meta2, schema="alt_schema", autoload=True)
             print str(subject.join(referer).onclause)
@@ -573,8 +574,8 @@ class MiscTest(AssertMixin):
         that PassiveDefault upon insert."""
 
         try:
-            meta = MetaData(testbase.db)
-            testbase.db.execute("""
+            meta = MetaData(testing.db)
+            testing.db.execute("""
              CREATE TABLE speedy_users
              (
                  speedy_user_id   SERIAL     PRIMARY KEY,
@@ -590,7 +591,7 @@ class MiscTest(AssertMixin):
             l = t.select().execute().fetchall()
             assert l == [(1, 'user', 'lala')]
         finally:
-            testbase.db.execute("drop table speedy_users", None)
+            testing.db.execute("drop table speedy_users", None)
 
     def test_create_partial_index(self):
         tbl = Table('testtbl', MetaData(), Column('data',Integer))
@@ -617,7 +618,7 @@ class TimezoneTest(AssertMixin):
 
     def setUpAll(self):
         global tztable, notztable, metadata
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
 
         # current_timestamp() in postgres is assumed to return TIMESTAMP WITH TIMEZONE
         tztable = Table('tztable', metadata,
@@ -636,7 +637,7 @@ class TimezoneTest(AssertMixin):
 
     def test_with_timezone(self):
         # get a date with a tzinfo
-        somedate = testbase.db.connect().scalar(func.current_timestamp().select())
+        somedate = testing.db.connect().scalar(func.current_timestamp().select())
         tztable.insert().execute(id=1, name='row1', date=somedate)
         c = tztable.update(tztable.c.id==1).execute(name='newname')
         print tztable.select(tztable.c.id==1).execute().fetchone()
@@ -653,7 +654,7 @@ class ArrayTest(AssertMixin):
 
     def setUpAll(self):
         global metadata, arrtable
-        metadata = MetaData(testbase.db)
+        metadata = MetaData(testing.db)
 
         arrtable = Table('arrtable', metadata,
             Column('id', Integer, primary_key=True),
@@ -665,7 +666,7 @@ class ArrayTest(AssertMixin):
         metadata.drop_all()
 
     def test_reflect_array_column(self):
-        metadata2 = MetaData(testbase.db)
+        metadata2 = MetaData(testing.db)
         tbl = Table('arrtable', metadata2, autoload=True)
         self.assertTrue(isinstance(tbl.c.intarr.type, postgres.PGArray))
         self.assertTrue(isinstance(tbl.c.strarr.type, postgres.PGArray))
@@ -705,4 +706,4 @@ class ArrayTest(AssertMixin):
         arrtable.delete().execute()
 
 if __name__ == "__main__":
-    testbase.main()
+    testenv.main()
diff --git a/test/dialect/sqlite.py b/test/dialect/sqlite.py
index 726a27183..f04093b89 100644
--- a/test/dialect/sqlite.py
+++ b/test/dialect/sqlite.py
@@ -1,6 +1,6 @@
 """SQLite-specific tests."""
 
-import testbase
+import testenv; testenv.configure_for_tests()
 import datetime
 from sqlalchemy import *
 from sqlalchemy import exceptions
@@ -12,7 +12,7 @@ class TestTypes(AssertMixin):
     __only_on__ = 'sqlite'
 
     def test_date(self):
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         t = Table('testdate', meta,
                   Column('id', Integer, primary_key=True),
                   Column('adate', Date),
@@ -44,7 +44,7 @@ class DialectTest(AssertMixin):
         is updated in the future.
         """
 
-        meta = MetaData(testbase.db)
+        meta = MetaData(testing.db)
         t = Table('reserved', meta,
                   Column('safe', Integer),
                   Column('true', Integer),
@@ -62,12 +62,12 @@ class DialectTest(AssertMixin):
         """Tests autoload of tables created with quoted column names."""
 
         # This is quirky in sqlite.
-        testbase.db.execute("""CREATE TABLE "django_content_type" (
+        testing.db.execute("""CREATE TABLE "django_content_type" (
             "id" integer NOT NULL PRIMARY KEY,
             "django_stuff" text NULL
         )
         """)
-        testbase.db.execute("""
+        testing.db.execute("""
         CREATE TABLE "django_admin_log" (
             "id" integer NOT NULL PRIMARY KEY,
             "action_time" datetime NOT NULL,
@@ -77,14 +77,14 @@ class DialectTest(AssertMixin):
         )
         """)
         try:
-            meta = MetaData(testbase.db)
+            meta = MetaData(testing.db)
             table1 = Table("django_admin_log", meta, autoload=True)
             table2 = Table("django_content_type", meta, autoload=True)
             j = table1.join(table2)
             assert j.onclause == table1.c.content_type_id==table2.c.id
         finally:
-            testbase.db.execute("drop table django_admin_log")
-            testbase.db.execute("drop table django_content_type")
+            testing.db.execute("drop table django_admin_log")
+            testing.db.execute("drop table django_content_type")
 
 
 class InsertTest(AssertMixin):
@@ -112,7 +112,7 @@ class InsertTest(AssertMixin):
     @testing.exclude('sqlite', '<', (3, 4))
     def test_empty_insert_pk1(self):
         self._test_empty_insert(
-            Table('a', MetaData(testbase.db),
+            Table('a', MetaData(testing.db),
                   Column('id', Integer, primary_key=True)))
 
     @testing.exclude('sqlite', '<', (3, 4))
@@ -120,7 +120,7 @@ class InsertTest(AssertMixin):
         self.assertRaises(
             exceptions.DBAPIError,
             self._test_empty_insert,
-            Table('b', MetaData(testbase.db),
+            Table('b', MetaData(testing.db),
                   Column('x', Integer, primary_key=True),
                   Column('y', Integer, primary_key=True)))
 
@@ -129,7 +129,7 @@ class InsertTest(AssertMixin):
         self.assertRaises(
             exceptions.DBAPIError,
             self._test_empty_insert,
-            Table('c', MetaData(testbase.db),
+            Table('c', MetaData(testing.db),
                   Column('x', Integer, primary_key=True),
                   Column('y', Integer, PassiveDefault('123'),
                          primary_key=True)))
@@ -137,20 +137,20 @@ class InsertTest(AssertMixin):
     @testing.exclude('sqlite', '<', (3, 4))
     def test_empty_insert_pk4(self):
         self._test_empty_insert(
-            Table('d', MetaData(testbase.db),
+            Table('d', MetaData(testing.db),
                   Column('x', Integer, primary_key=True),
                   Column('y', Integer, PassiveDefault('123'))))
 
     @testing.exclude('sqlite', '<', (3, 4))
     def test_empty_insert_nopk1(self):
         self._test_empty_insert(
-            Table('e', MetaData(testbase.db),
+            Table('e', MetaData(testing.db),
                   Column('id', Integer)))
 
     @testing.exclude('sqlite', '<', (3, 4))
     def test_empty_insert_nopk2(self):
         self._test_empty_insert(
-            Table('f', MetaData(testbase.db),
+            Table('f', MetaData(testing.db),
                   Column('x', Integer),
                   Column('y', Integer)))
 
@@ -171,4 +171,4 @@ class InsertTest(AssertMixin):
 
 
 if __name__ == "__main__":
-    testbase.main()
+    testenv.main()
diff --git a/test/dialect/sybase.py b/test/dialect/sybase.py
index 973624381..cdc8066b4 100644
--- a/test/dialect/sybase.py
+++ b/test/dialect/sybase.py
@@ -1,8 +1,9 @@
-import testbase
+import testenv; testenv.configure_for_tests()
 from sqlalchemy import *
 from sqlalchemy.databases import sybase
 from testlib import *
 
+
 class BasicTest(AssertMixin):
     # A simple import of the database/ module should work on all systems.
     def test_import(self):
@@ -11,4 +12,4 @@ class BasicTest(AssertMixin):
 
 
 if __name__ == "__main__":
-    testbase.main()
+    testenv.main()