bpo-40823: Use loadTestsFromTestCase() iso. makeSuite() in sqlite3 tests (GH-20538)
diff --git a/Lib/sqlite3/test/dbapi.py b/Lib/sqlite3/test/dbapi.py
index 3131c1e..7985cd3 100644
--- a/Lib/sqlite3/test/dbapi.py
+++ b/Lib/sqlite3/test/dbapi.py
@@ -29,61 +29,61 @@
class ModuleTests(unittest.TestCase):
- def CheckAPILevel(self):
+ def test_api_level(self):
self.assertEqual(sqlite.apilevel, "2.0",
"apilevel is %s, should be 2.0" % sqlite.apilevel)
- def CheckThreadSafety(self):
+ def test_thread_safety(self):
self.assertEqual(sqlite.threadsafety, 1,
"threadsafety is %d, should be 1" % sqlite.threadsafety)
- def CheckParamStyle(self):
+ def test_param_style(self):
self.assertEqual(sqlite.paramstyle, "qmark",
"paramstyle is '%s', should be 'qmark'" %
sqlite.paramstyle)
- def CheckWarning(self):
+ def test_warning(self):
self.assertTrue(issubclass(sqlite.Warning, Exception),
"Warning is not a subclass of Exception")
- def CheckError(self):
+ def test_error(self):
self.assertTrue(issubclass(sqlite.Error, Exception),
"Error is not a subclass of Exception")
- def CheckInterfaceError(self):
+ def test_interface_error(self):
self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error),
"InterfaceError is not a subclass of Error")
- def CheckDatabaseError(self):
+ def test_database_error(self):
self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error),
"DatabaseError is not a subclass of Error")
- def CheckDataError(self):
+ def test_data_error(self):
self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError),
"DataError is not a subclass of DatabaseError")
- def CheckOperationalError(self):
+ def test_operational_error(self):
self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
"OperationalError is not a subclass of DatabaseError")
- def CheckIntegrityError(self):
+ def test_integrity_error(self):
self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
"IntegrityError is not a subclass of DatabaseError")
- def CheckInternalError(self):
+ def test_internal_error(self):
self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError),
"InternalError is not a subclass of DatabaseError")
- def CheckProgrammingError(self):
+ def test_programming_error(self):
self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
"ProgrammingError is not a subclass of DatabaseError")
- def CheckNotSupportedError(self):
+ def test_not_supported_error(self):
self.assertTrue(issubclass(sqlite.NotSupportedError,
sqlite.DatabaseError),
"NotSupportedError is not a subclass of DatabaseError")
- def CheckSharedCacheDeprecated(self):
+ def test_shared_cache_deprecated(self):
for enable in (True, False):
with self.assertWarns(DeprecationWarning) as cm:
sqlite.enable_shared_cache(enable)
@@ -101,38 +101,38 @@ def setUp(self):
def tearDown(self):
self.cx.close()
- def CheckCommit(self):
+ def test_commit(self):
self.cx.commit()
- def CheckCommitAfterNoChanges(self):
+ def test_commit_after_no_changes(self):
"""
A commit should also work when no changes were made to the database.
"""
self.cx.commit()
self.cx.commit()
- def CheckRollback(self):
+ def test_rollback(self):
self.cx.rollback()
- def CheckRollbackAfterNoChanges(self):
+ def test_rollback_after_no_changes(self):
"""
A rollback should also work when no changes were made to the database.
"""
self.cx.rollback()
self.cx.rollback()
- def CheckCursor(self):
+ def test_cursor(self):
cu = self.cx.cursor()
- def CheckFailedOpen(self):
+ def test_failed_open(self):
YOU_CANNOT_OPEN_THIS = "/foo/bar/bla/23534/mydb.db"
with self.assertRaises(sqlite.OperationalError):
con = sqlite.connect(YOU_CANNOT_OPEN_THIS)
- def CheckClose(self):
+ def test_close(self):
self.cx.close()
- def CheckExceptions(self):
+ def test_exceptions(self):
# Optional DB-API extension.
self.assertEqual(self.cx.Warning, sqlite.Warning)
self.assertEqual(self.cx.Error, sqlite.Error)
@@ -145,7 +145,7 @@ def CheckExceptions(self):
self.assertEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
self.assertEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
- def CheckInTransaction(self):
+ def test_in_transaction(self):
# Can't use db from setUp because we want to test initial state.
cx = sqlite.connect(":memory:")
cu = cx.cursor()
@@ -163,11 +163,11 @@ def CheckInTransaction(self):
row = cu.fetchone()
self.assertEqual(cx.in_transaction, False)
- def CheckInTransactionRO(self):
+ def test_in_transaction_ro(self):
with self.assertRaises(AttributeError):
self.cx.in_transaction = True
- def CheckOpenWithPathLikeObject(self):
+ def test_open_with_path_like_object(self):
""" Checks that we can successfully connect to a database using an object that
is PathLike, i.e. has __fspath__(). """
self.addCleanup(unlink, TESTFN)
@@ -178,7 +178,7 @@ def __fspath__(self):
with sqlite.connect(path) as cx:
cx.execute('create table test(id integer)')
- def CheckOpenUri(self):
+ def test_open_uri(self):
self.addCleanup(unlink, TESTFN)
with sqlite.connect(TESTFN) as cx:
cx.execute('create table test(id integer)')
@@ -203,21 +203,21 @@ def tearDown(self):
self.cu.close()
self.cx.close()
- def CheckExecuteNoArgs(self):
+ def test_execute_no_args(self):
self.cu.execute("delete from test")
- def CheckExecuteIllegalSql(self):
+ def test_execute_illegal_sql(self):
with self.assertRaises(sqlite.OperationalError):
self.cu.execute("select asdf")
- def CheckExecuteTooMuchSql(self):
+ def test_execute_too_much_sql(self):
with self.assertRaises(sqlite.Warning):
self.cu.execute("select 5+4; select 4+5")
- def CheckExecuteTooMuchSql2(self):
+ def test_execute_too_much_sql2(self):
self.cu.execute("select 5+4; -- foo bar")
- def CheckExecuteTooMuchSql3(self):
+ def test_execute_too_much_sql3(self):
self.cu.execute("""
select 5+4;
@@ -226,53 +226,53 @@ def CheckExecuteTooMuchSql3(self):
*/
""")
- def CheckExecuteWrongSqlArg(self):
+ def test_execute_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.execute(42)
- def CheckExecuteArgInt(self):
+ def test_execute_arg_int(self):
self.cu.execute("insert into test(id) values (?)", (42,))
- def CheckExecuteArgFloat(self):
+ def test_execute_arg_float(self):
self.cu.execute("insert into test(income) values (?)", (2500.32,))
- def CheckExecuteArgString(self):
+ def test_execute_arg_string(self):
self.cu.execute("insert into test(name) values (?)", ("Hugo",))
- def CheckExecuteArgStringWithZeroByte(self):
+ def test_execute_arg_string_with_zero_byte(self):
self.cu.execute("insert into test(name) values (?)", ("Hu\x00go",))
self.cu.execute("select name from test where id=?", (self.cu.lastrowid,))
row = self.cu.fetchone()
self.assertEqual(row[0], "Hu\x00go")
- def CheckExecuteNonIterable(self):
+ def test_execute_non_iterable(self):
with self.assertRaises(ValueError) as cm:
self.cu.execute("insert into test(id) values (?)", 42)
self.assertEqual(str(cm.exception), 'parameters are of unsupported type')
- def CheckExecuteWrongNoOfArgs1(self):
+ def test_execute_wrong_no_of_args1(self):
# too many parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)", (17, "Egon"))
- def CheckExecuteWrongNoOfArgs2(self):
+ def test_execute_wrong_no_of_args2(self):
# too little parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
- def CheckExecuteWrongNoOfArgs3(self):
+ def test_execute_wrong_no_of_args3(self):
# no parameters, parameters are needed
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
- def CheckExecuteParamList(self):
+ def test_execute_param_list(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", ["foo"])
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
- def CheckExecuteParamSequence(self):
+ def test_execute_param_sequence(self):
class L:
def __len__(self):
return 1
@@ -285,7 +285,7 @@ def __getitem__(self, x):
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
- def CheckExecuteParamSequenceBadLen(self):
+ def test_execute_param_sequence_bad_len(self):
# Issue41662: Error in __len__() was overridden with ProgrammingError.
class L:
def __len__(self):
@@ -297,13 +297,13 @@ def __getitem__(slf, x):
with self.assertRaises(ZeroDivisionError):
self.cu.execute("select name from test where name=?", L())
- def CheckExecuteDictMapping(self):
+ def test_execute_dict_mapping(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", {"name": "foo"})
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
- def CheckExecuteDictMapping_Mapping(self):
+ def test_execute_dict_mapping_mapping(self):
class D(dict):
def __missing__(self, key):
return "foo"
@@ -313,32 +313,32 @@ def __missing__(self, key):
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
- def CheckExecuteDictMappingTooLittleArgs(self):
+ def test_execute_dict_mapping_too_little_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name and id=:id", {"name": "foo"})
- def CheckExecuteDictMappingNoArgs(self):
+ def test_execute_dict_mapping_no_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name")
- def CheckExecuteDictMappingUnnamed(self):
+ def test_execute_dict_mapping_unnamed(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=?", {"name": "foo"})
- def CheckClose(self):
+ def test_close(self):
self.cu.close()
- def CheckRowcountExecute(self):
+ def test_rowcount_execute(self):
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("update test set name='bar'")
self.assertEqual(self.cu.rowcount, 2)
- def CheckRowcountSelect(self):
+ def test_rowcount_select(self):
"""
pysqlite does not know the rowcount of SELECT statements, because we
don't fetch all rows after executing the select statement. The rowcount
@@ -347,12 +347,12 @@ def CheckRowcountSelect(self):
self.cu.execute("select 5 union select 6")
self.assertEqual(self.cu.rowcount, -1)
- def CheckRowcountExecutemany(self):
+ def test_rowcount_executemany(self):
self.cu.execute("delete from test")
self.cu.executemany("insert into test(name) values (?)", [(1,), (2,), (3,)])
self.assertEqual(self.cu.rowcount, 3)
- def CheckTotalChanges(self):
+ def test_total_changes(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.assertLess(2, self.cx.total_changes, msg='total changes reported wrong value')
@@ -361,10 +361,10 @@ def CheckTotalChanges(self):
# Sequences are required by the DB-API, iterators
# enhancements in pysqlite.
- def CheckExecuteManySequence(self):
+ def test_execute_many_sequence(self):
self.cu.executemany("insert into test(income) values (?)", [(x,) for x in range(100, 110)])
- def CheckExecuteManyIterator(self):
+ def test_execute_many_iterator(self):
class MyIter:
def __init__(self):
self.value = 5
@@ -378,26 +378,26 @@ def __next__(self):
self.cu.executemany("insert into test(income) values (?)", MyIter())
- def CheckExecuteManyGenerator(self):
+ def test_execute_many_generator(self):
def mygen():
for i in range(5):
yield (i,)
self.cu.executemany("insert into test(income) values (?)", mygen())
- def CheckExecuteManyWrongSqlArg(self):
+ def test_execute_many_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.executemany(42, [(3,)])
- def CheckExecuteManySelect(self):
+ def test_execute_many_select(self):
with self.assertRaises(sqlite.ProgrammingError):
self.cu.executemany("select ?", [(3,)])
- def CheckExecuteManyNotIterable(self):
+ def test_execute_many_not_iterable(self):
with self.assertRaises(TypeError):
self.cu.executemany("insert into test(income) values (?)", 42)
- def CheckFetchIter(self):
+ def test_fetch_iter(self):
# Optional DB-API extension.
self.cu.execute("delete from test")
self.cu.execute("insert into test(id) values (?)", (5,))
@@ -409,19 +409,19 @@ def CheckFetchIter(self):
self.assertEqual(lst[0], 5)
self.assertEqual(lst[1], 6)
- def CheckFetchone(self):
+ def test_fetchone(self):
self.cu.execute("select name from test")
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
row = self.cu.fetchone()
self.assertEqual(row, None)
- def CheckFetchoneNoStatement(self):
+ def test_fetchone_no_statement(self):
cur = self.cx.cursor()
row = cur.fetchone()
self.assertEqual(row, None)
- def CheckArraySize(self):
+ def test_array_size(self):
# must default ot 1
self.assertEqual(self.cu.arraysize, 1)
@@ -438,51 +438,51 @@ def CheckArraySize(self):
self.assertEqual(len(res), 2)
- def CheckFetchmany(self):
+ def test_fetchmany(self):
self.cu.execute("select name from test")
res = self.cu.fetchmany(100)
self.assertEqual(len(res), 1)
res = self.cu.fetchmany(100)
self.assertEqual(res, [])
- def CheckFetchmanyKwArg(self):
+ def test_fetchmany_kw_arg(self):
"""Checks if fetchmany works with keyword arguments"""
self.cu.execute("select name from test")
res = self.cu.fetchmany(size=100)
self.assertEqual(len(res), 1)
- def CheckFetchall(self):
+ def test_fetchall(self):
self.cu.execute("select name from test")
res = self.cu.fetchall()
self.assertEqual(len(res), 1)
res = self.cu.fetchall()
self.assertEqual(res, [])
- def CheckSetinputsizes(self):
+ def test_setinputsizes(self):
self.cu.setinputsizes([3, 4, 5])
- def CheckSetoutputsize(self):
+ def test_setoutputsize(self):
self.cu.setoutputsize(5, 0)
- def CheckSetoutputsizeNoColumn(self):
+ def test_setoutputsize_no_column(self):
self.cu.setoutputsize(42)
- def CheckCursorConnection(self):
+ def test_cursor_connection(self):
# Optional DB-API extension.
self.assertEqual(self.cu.connection, self.cx)
- def CheckWrongCursorCallable(self):
+ def test_wrong_cursor_callable(self):
with self.assertRaises(TypeError):
def f(): pass
cur = self.cx.cursor(f)
- def CheckCursorWrongClass(self):
+ def test_cursor_wrong_class(self):
class Foo: pass
foo = Foo()
with self.assertRaises(TypeError):
cur = sqlite.Cursor(foo)
- def CheckLastRowIDOnReplace(self):
+ def test_last_row_id_on_replace(self):
"""
INSERT OR REPLACE and REPLACE INTO should produce the same behavior.
"""
@@ -492,7 +492,7 @@ def CheckLastRowIDOnReplace(self):
self.cu.execute(sql.format(statement), (1, 'foo'))
self.assertEqual(self.cu.lastrowid, 1)
- def CheckLastRowIDOnIgnore(self):
+ def test_last_row_id_on_ignore(self):
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
@@ -502,7 +502,7 @@ def CheckLastRowIDOnIgnore(self):
('test',))
self.assertEqual(self.cu.lastrowid, 2)
- def CheckLastRowIDInsertOR(self):
+ def test_last_row_id_insert_o_r(self):
results = []
for statement in ('FAIL', 'ABORT', 'ROLLBACK'):
sql = 'INSERT OR {} INTO test(unique_test) VALUES (?)'
@@ -530,7 +530,7 @@ def tearDown(self):
self.cur.close()
self.con.close()
- def CheckConCursor(self):
+ def test_con_cursor(self):
def run(con, errors):
try:
cur = con.cursor()
@@ -548,7 +548,7 @@ def run(con, errors):
if len(errors) > 0:
self.fail("\n".join(errors))
- def CheckConCommit(self):
+ def test_con_commit(self):
def run(con, errors):
try:
con.commit()
@@ -566,7 +566,7 @@ def run(con, errors):
if len(errors) > 0:
self.fail("\n".join(errors))
- def CheckConRollback(self):
+ def test_con_rollback(self):
def run(con, errors):
try:
con.rollback()
@@ -584,7 +584,7 @@ def run(con, errors):
if len(errors) > 0:
self.fail("\n".join(errors))
- def CheckConClose(self):
+ def test_con_close(self):
def run(con, errors):
try:
con.close()
@@ -602,7 +602,7 @@ def run(con, errors):
if len(errors) > 0:
self.fail("\n".join(errors))
- def CheckCurImplicitBegin(self):
+ def test_cur_implicit_begin(self):
def run(cur, errors):
try:
cur.execute("insert into test(name) values ('a')")
@@ -620,7 +620,7 @@ def run(cur, errors):
if len(errors) > 0:
self.fail("\n".join(errors))
- def CheckCurClose(self):
+ def test_cur_close(self):
def run(cur, errors):
try:
cur.close()
@@ -638,7 +638,7 @@ def run(cur, errors):
if len(errors) > 0:
self.fail("\n".join(errors))
- def CheckCurExecute(self):
+ def test_cur_execute(self):
def run(cur, errors):
try:
cur.execute("select name from test")
@@ -657,7 +657,7 @@ def run(cur, errors):
if len(errors) > 0:
self.fail("\n".join(errors))
- def CheckCurIterNext(self):
+ def test_cur_iter_next(self):
def run(cur, errors):
try:
row = cur.fetchone()
@@ -678,29 +678,29 @@ def run(cur, errors):
self.fail("\n".join(errors))
class ConstructorTests(unittest.TestCase):
- def CheckDate(self):
+ def test_date(self):
d = sqlite.Date(2004, 10, 28)
- def CheckTime(self):
+ def test_time(self):
t = sqlite.Time(12, 39, 35)
- def CheckTimestamp(self):
+ def test_timestamp(self):
ts = sqlite.Timestamp(2004, 10, 28, 12, 39, 35)
- def CheckDateFromTicks(self):
+ def test_date_from_ticks(self):
d = sqlite.DateFromTicks(42)
- def CheckTimeFromTicks(self):
+ def test_time_from_ticks(self):
t = sqlite.TimeFromTicks(42)
- def CheckTimestampFromTicks(self):
+ def test_timestamp_from_ticks(self):
ts = sqlite.TimestampFromTicks(42)
- def CheckBinary(self):
+ def test_binary(self):
b = sqlite.Binary(b"\0'")
class ExtensionTests(unittest.TestCase):
- def CheckScriptStringSql(self):
+ def test_script_string_sql(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.executescript("""
@@ -713,31 +713,31 @@ def CheckScriptStringSql(self):
res = cur.fetchone()[0]
self.assertEqual(res, 5)
- def CheckScriptSyntaxError(self):
+ def test_script_syntax_error(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(x); asdf; create table test2(x)")
- def CheckScriptErrorNormal(self):
+ def test_script_error_normal(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
- def CheckCursorExecutescriptAsBytes(self):
+ def test_cursor_executescript_as_bytes(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(ValueError) as cm:
cur.executescript(b"create table test(foo); insert into test(foo) values (5);")
self.assertEqual(str(cm.exception), 'script argument must be unicode.')
- def CheckConnectionExecute(self):
+ def test_connection_execute(self):
con = sqlite.connect(":memory:")
result = con.execute("select 5").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.execute")
- def CheckConnectionExecutemany(self):
+ def test_connection_executemany(self):
con = sqlite.connect(":memory:")
con.execute("create table test(foo)")
con.executemany("insert into test(foo) values (?)", [(3,), (4,)])
@@ -745,46 +745,46 @@ def CheckConnectionExecutemany(self):
self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany")
self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
- def CheckConnectionExecutescript(self):
+ def test_connection_executescript(self):
con = sqlite.connect(":memory:")
con.executescript("create table test(foo); insert into test(foo) values (5);")
result = con.execute("select foo from test").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.executescript")
class ClosedConTests(unittest.TestCase):
- def CheckClosedConCursor(self):
+ def test_closed_con_cursor(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur = con.cursor()
- def CheckClosedConCommit(self):
+ def test_closed_con_commit(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.commit()
- def CheckClosedConRollback(self):
+ def test_closed_con_rollback(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.rollback()
- def CheckClosedCurExecute(self):
+ def test_closed_cur_execute(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur.execute("select 4")
- def CheckClosedCreateFunction(self):
+ def test_closed_create_function(self):
con = sqlite.connect(":memory:")
con.close()
def f(x): return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_function("foo", 1, f)
- def CheckClosedCreateAggregate(self):
+ def test_closed_create_aggregate(self):
con = sqlite.connect(":memory:")
con.close()
class Agg:
@@ -797,7 +797,7 @@ def finalize(self):
with self.assertRaises(sqlite.ProgrammingError):
con.create_aggregate("foo", 1, Agg)
- def CheckClosedSetAuthorizer(self):
+ def test_closed_set_authorizer(self):
con = sqlite.connect(":memory:")
con.close()
def authorizer(*args):
@@ -805,21 +805,21 @@ def authorizer(*args):
with self.assertRaises(sqlite.ProgrammingError):
con.set_authorizer(authorizer)
- def CheckClosedSetProgressCallback(self):
+ def test_closed_set_progress_callback(self):
con = sqlite.connect(":memory:")
con.close()
def progress(): pass
with self.assertRaises(sqlite.ProgrammingError):
con.set_progress_handler(progress, 100)
- def CheckClosedCall(self):
+ def test_closed_call(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con()
class ClosedCurTests(unittest.TestCase):
- def CheckClosed(self):
+ def test_closed(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.close()
@@ -857,7 +857,7 @@ def tearDown(self):
self.cu.close()
self.cx.close()
- def CheckOnConflictRollbackWithExplicitTransaction(self):
+ def test_on_conflict_rollback_with_explicit_transaction(self):
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
@@ -872,7 +872,7 @@ def CheckOnConflictRollbackWithExplicitTransaction(self):
# Transaction should have rolled back and nothing should be in table.
self.assertEqual(self.cu.fetchall(), [])
- def CheckOnConflictAbortRaisesWithExplicitTransactions(self):
+ def test_on_conflict_abort_raises_with_explicit_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cx.isolation_level = None # autocommit mode
@@ -888,7 +888,7 @@ def CheckOnConflictAbortRaisesWithExplicitTransactions(self):
# Expect the first two inserts to work, third to do nothing.
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
- def CheckOnConflictRollbackWithoutTransaction(self):
+ def test_on_conflict_rollback_without_transaction(self):
# Start of implicit transaction
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
@@ -898,7 +898,7 @@ def CheckOnConflictRollbackWithoutTransaction(self):
# Implicit transaction is rolled back on error.
self.assertEqual(self.cu.fetchall(), [])
- def CheckOnConflictAbortRaisesWithoutTransactions(self):
+ def test_on_conflict_abort_raises_without_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
@@ -909,20 +909,20 @@ def CheckOnConflictAbortRaisesWithoutTransactions(self):
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
- def CheckOnConflictFail(self):
+ def test_on_conflict_fail(self):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
self.assertEqual(self.cu.fetchall(), [])
- def CheckOnConflictIgnore(self):
+ def test_on_conflict_ignore(self):
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
# Nothing should happen.
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('foo',)])
- def CheckOnConflictReplace(self):
+ def test_on_conflict_replace(self):
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Data!', 'foo')")
# There shouldn't be an IntegrityError exception.
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Very different data!', 'foo')")
@@ -931,20 +931,20 @@ def CheckOnConflictReplace(self):
def suite():
- module_suite = unittest.makeSuite(ModuleTests, "Check")
- connection_suite = unittest.makeSuite(ConnectionTests, "Check")
- cursor_suite = unittest.makeSuite(CursorTests, "Check")
- thread_suite = unittest.makeSuite(ThreadTests, "Check")
- constructor_suite = unittest.makeSuite(ConstructorTests, "Check")
- ext_suite = unittest.makeSuite(ExtensionTests, "Check")
- closed_con_suite = unittest.makeSuite(ClosedConTests, "Check")
- closed_cur_suite = unittest.makeSuite(ClosedCurTests, "Check")
- on_conflict_suite = unittest.makeSuite(SqliteOnConflictTests, "Check")
- return unittest.TestSuite((
- module_suite, connection_suite, cursor_suite, thread_suite,
- constructor_suite, ext_suite, closed_con_suite, closed_cur_suite,
- on_conflict_suite,
- ))
+ tests = [
+ ClosedConTests,
+ ClosedCurTests,
+ ConnectionTests,
+ ConstructorTests,
+ CursorTests,
+ ExtensionTests,
+ ModuleTests,
+ SqliteOnConflictTests,
+ ThreadTests,
+ ]
+ return unittest.TestSuite(
+ [unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
+ )
def test():
runner = unittest.TextTestRunner()