def _testable(self):
     try:
         webtest.setup_database(self.dbname, driver=self.driver)
         return True
     except ImportError, e:
         print >> web.debug, str(e), "(ignoring %s)" % self.__class__.__name__
         return False

 def _testable(self):
     try:
         webtest.setup_database(self.dbname)
         return True
     except ImportError, e:
         print >> web.debug, str(e), "(ignoring the %s tests)" % self.dbname
         return False

 def _testable(self):
     try:
         webtest.setup_database(self.dbname, driver=self.driver)
         print("Running tests for %s" % self.__class__.__name__, file=web.debug)
         return True
     except ImportError as e:
         print(str(e), "(ignoring %s)" % self.__class__.__name__, file=web.debug)
         return False

 def test_where(self):
     db = webtest.setup_database(self.dbname)
     db.insert("person", False, name="Foo")
     d = db.where("person", name="Foo").list()
     assert len(d) == 1
     d = db.where("person").list()
     assert len(d) == 1

 def testPooling(self):
     # can't test pooling if DBUtils is not installed
     try:
         import DBUtils
     except ImportError:
         return
     db = webtest.setup_database(self.dbname, pooling=True)
     self.assertEquals(db.ctx.db.__class__.__module__, 'DBUtils.PooledDB')
     db.select('person', limit=1)

 def make_session(self, app):
     db = webtest.setup_database("postgres")
     #db.printing = True
     db.query("" 
         + "CREATE TABLE session ("
         + "    session_id char(128) unique not null,"
         + "    atime timestamp default (current_timestamp at time zone 'utc'),"
         + "    data text)"
     )
     store = web.session.DBStore(db, 'session')
     return web.session.Session(app, store, {'count': 0})

 def make_session(self, app):
     db = webtest.setup_database("sqlite", "sqlite3")
     #db.printing = True
     db.query("" 
         + "CREATE TABLE session ("
         + "    session_id char(128) unique not null,"
         + "    atime timestamp default (datetime('now','utc')),"
         + "    data text)"
     )
     store = web.session.DBStore(db, 'session')
     return web.session.Session(app, store, {'count': 0})

 def tearDown(self):
     # there might be some error with the current connection, delete from a new connection
     self.db = webtest.setup_database(self.dbname, driver=self.driver)
     self.db.query('DROP TABLE person')

 def test_insert_default_values(self):
     db = webtest.setup_database(self.dbname)
     db.insert("person")

    def test_multiple_insert(self):
        db = webtest.setup_database(self.dbname)
        db.multiple_insert('person', [dict(name='a'), dict(name='b')], seqname=False)

        assert db.select("person", where="name='a'").list()
        assert db.select("person", where="name='b'").list()

 def testPooling(self):
     db = webtest.setup_database(self.dbname, pooling=True)
     self.assertEquals(db.ctx.db.__class__.__module__, 'DBUtils.PooledDB')
     db.select('person', limit=1)

 def test_result_is_true(self):
     db = webtest.setup_database(self.dbname)
     self.db.insert("person", False, name="user")
     self.assertEquals(bool(db.select("person")), True)

 def test_result_is_unicode(self):
     # TODO : not sure this test has still meaning with Py3
     db = webtest.setup_database(self.dbname)
     self.db.insert("person", False, name="user")
     name = db.select("person")[0].name
     self.assertEquals(type(name), unicode if PY2 else str)

 def tearDown(self):
     # there might be some error with the current connection, delete from a new connection
     self.db = webtest.setup_database("sqlite", "sqlite3")
     self.db.query("DROP TABLE session")

 def setUp(self):
     self.db = webtest.setup_database(self.dbname)
     # In mysql, transactions are supported only with INNODB engine.
     self.db.query("CREATE TABLE person (name text, email text) ENGINE=INNODB")

 def make_database(self):
     db = webtest.setup_database(self.dbname, driver=self.driver)
     db.query("CREATE TABLE users (usr text, passwd text, role text)")
     db.insert('users', usr=self.usr, passwd=self.crypted, role=self.role)
     return db

 def remove_database(self):
     self.db = webtest.setup_database(self.dbname, driver=self.driver)
     self.db.query("DROP TABLE users")

 def test_result_is_unicode(self):
     db = webtest.setup_database(self.dbname)
     self.db.insert('person', False, name='user')
     name = db.select('person')[0].name
     self.assertEquals(type(name), unicode)

 def tearDown(self):
     # there might be some error with the current connection, delete from a new connection
     self.db = webtest.setup_database("postgres")
     self.db.query('DROP TABLE session')

 def setUp(self):
     web.config._hasPooling = False
     webtest.setup_database(self.dbname)
     # In mysql, transactions are supported only with INNODB engine.
     web.query("CREATE TABLE person (name text, email text) ENGINE InnoDB")