From 484ac43cf1b090953ff4efde617f0a2fc07177cd Mon Sep 17 00:00:00 2001 From: lufte Date: Sat, 3 Jul 2021 01:00:32 -0300 Subject: Fix function name too short --- tests/unit/misc/test_sql.py | 140 ++++++++++++++++++++++---------------------- 1 file changed, 70 insertions(+), 70 deletions(-) (limited to 'tests') diff --git a/tests/unit/misc/test_sql.py b/tests/unit/misc/test_sql.py index 33af9d7c1..1262f0c3f 100644 --- a/tests/unit/misc/test_sql.py +++ b/tests/unit/misc/test_sql.py @@ -32,9 +32,9 @@ pytestmark = pytest.mark.usefixtures('data_tmpdir') @pytest.fixture -def db(data_tmpdir): - database = sql.Database(str(data_tmpdir / 'test_sql.db')) - return database +def database(data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_sql.db')) + return db class TestUserVersion: @@ -126,22 +126,22 @@ class TestSqlError: assert err.text() == "db text" -def test_init_table(db): - db.table('Foo', ['name', 'val', 'lucky']) +def test_init_table(database): + database.table('Foo', ['name', 'val', 'lucky']) # should not error if table already exists - db.table('Foo', ['name', 'val', 'lucky']) + database.table('Foo', ['name', 'val', 'lucky']) -def test_insert(qtbot, db): - table = db.table('Foo', ['name', 'val', 'lucky']) +def test_insert(qtbot, database): + table = database.table('Foo', ['name', 'val', 'lucky']) with qtbot.wait_signal(table.changed): table.insert({'name': 'one', 'val': 1, 'lucky': False}) with qtbot.wait_signal(table.changed): table.insert({'name': 'wan', 'val': 1, 'lucky': False}) -def test_insert_replace(qtbot, db): - table = db.table('Foo', ['name', 'val', 'lucky'], +def test_insert_replace(qtbot, database): + table = database.table('Foo', ['name', 'val', 'lucky'], constraints={'name': 'PRIMARY KEY'}) with qtbot.wait_signal(table.changed): table.insert({'name': 'one', 'val': 1, 'lucky': False}, replace=True) @@ -153,8 +153,8 @@ def test_insert_replace(qtbot, db): table.insert({'name': 'one', 'val': 11, 'lucky': True}, replace=False) -def test_insert_batch(qtbot, db): - table = db.table('Foo', ['name', 'val', 'lucky']) +def test_insert_batch(qtbot, database): + table = database.table('Foo', ['name', 'val', 'lucky']) with qtbot.wait_signal(table.changed): table.insert_batch({'name': ['one', 'nine', 'thirteen'], @@ -166,8 +166,8 @@ def test_insert_batch(qtbot, db): ('thirteen', 13, True)] -def test_insert_batch_replace(qtbot, db): - table = db.table('Foo', ['name', 'val', 'lucky'], +def test_insert_batch_replace(qtbot, database): + table = database.table('Foo', ['name', 'val', 'lucky'], constraints={'name': 'PRIMARY KEY'}) with qtbot.wait_signal(table.changed): @@ -191,8 +191,8 @@ def test_insert_batch_replace(qtbot, db): 'lucky': [True, True]}) -def test_iter(db): - table = db.table('Foo', ['name', 'val', 'lucky']) +def test_iter(database): + table = database.table('Foo', ['name', 'val', 'lucky']) table.insert({'name': 'one', 'val': 1, 'lucky': False}) table.insert({'name': 'nine', 'val': 9, 'lucky': False}) table.insert({'name': 'thirteen', 'val': 13, 'lucky': True}) @@ -211,15 +211,15 @@ def test_iter(db): ([{"a": 2, "b": 5}, {"a": 1, "b": 6}, {"a": 3, "b": 4}], 'a', 'asc', -1, [(1, 6), (2, 5), (3, 4)]), ]) -def test_select(rows, sort_by, sort_order, limit, result, db): - table = db.table('Foo', ['a', 'b']) +def test_select(rows, sort_by, sort_order, limit, result, database): + table = database.table('Foo', ['a', 'b']) for row in rows: table.insert(row) assert list(table.select(sort_by, sort_order, limit)) == result -def test_delete(qtbot, db): - table = db.table('Foo', ['name', 'val', 'lucky']) +def test_delete(qtbot, database): + table = database.table('Foo', ['name', 'val', 'lucky']) table.insert({'name': 'one', 'val': 1, 'lucky': False}) table.insert({'name': 'nine', 'val': 9, 'lucky': False}) table.insert({'name': 'thirteen', 'val': 13, 'lucky': True}) @@ -233,8 +233,8 @@ def test_delete(qtbot, db): assert not list(table) -def test_len(db): - table = db.table('Foo', ['name', 'val', 'lucky']) +def test_len(database): + table = database.table('Foo', ['name', 'val', 'lucky']) assert len(table) == 0 table.insert({'name': 'one', 'val': 1, 'lucky': False}) assert len(table) == 1 @@ -244,15 +244,15 @@ def test_len(db): assert len(table) == 3 -def test_bool(db): - table = db.table('Foo', ['name']) +def test_bool(database): + table = database.table('Foo', ['name']) assert not table table.insert({'name': 'one'}) assert table -def test_bool_benchmark(benchmark, db): - table = db.table('Foo', ['number']) +def test_bool_benchmark(benchmark, database): + table = database.table('Foo', ['number']) # Simulate a history table table.create_index('NumberIndex', 'number') @@ -264,8 +264,8 @@ def test_bool_benchmark(benchmark, db): benchmark(run) -def test_contains(db): - table = db.table('Foo', ['name', 'val', 'lucky']) +def test_contains(database): + table = database.table('Foo', ['name', 'val', 'lucky']) table.insert({'name': 'one', 'val': 1, 'lucky': False}) table.insert({'name': 'nine', 'val': 9, 'lucky': False}) table.insert({'name': 'thirteen', 'val': 13, 'lucky': True}) @@ -285,8 +285,8 @@ def test_contains(db): assert not val_query.run(val=10).value() -def test_delete_all(qtbot, db): - table = db.table('Foo', ['name', 'val', 'lucky']) +def test_delete_all(qtbot, database): + table = database.table('Foo', ['name', 'val', 'lucky']) table.insert({'name': 'one', 'val': 1, 'lucky': False}) table.insert({'name': 'nine', 'val': 9, 'lucky': False}) table.insert({'name': 'thirteen', 'val': 13, 'lucky': True}) @@ -301,118 +301,118 @@ def test_version(): class TestSqlQuery: - def test_prepare_error(self, db): + def test_prepare_error(self, database): with pytest.raises(sql.BugError) as excinfo: - db.query('invalid') + database.query('invalid') expected = ('Failed to prepare query "invalid": "near "invalid": ' 'syntax error Unable to execute statement"') assert str(excinfo.value) == expected @pytest.mark.parametrize('forward_only', [True, False]) - def test_forward_only(self, forward_only, db): - q = db.query('SELECT 0 WHERE 0', forward_only=forward_only) + def test_forward_only(self, forward_only, database): + q = database.query('SELECT 0 WHERE 0', forward_only=forward_only) assert q.query.isForwardOnly() == forward_only - def test_iter_inactive(self, db): - q = db.query('SELECT 0') + def test_iter_inactive(self, database): + q = database.query('SELECT 0') with pytest.raises(sql.BugError, match='Cannot iterate inactive query'): next(iter(q)) - def test_iter_empty(self, db): - q = db.query('SELECT 0 AS col WHERE 0') + def test_iter_empty(self, database): + q = database.query('SELECT 0 AS col WHERE 0') q.run() with pytest.raises(StopIteration): next(iter(q)) - def test_iter(self, db): - q = db.query('SELECT 0 AS col') + def test_iter(self, database): + q = database.query('SELECT 0 AS col') q.run() result = next(iter(q)) assert result.col == 0 - def test_iter_multiple(self, db): - q = db.query('VALUES (1), (2), (3);') + def test_iter_multiple(self, database): + q = database.query('VALUES (1), (2), (3);') res = list(q.run()) assert len(res) == 3 assert res[0].column1 == 1 - def test_run_binding(self, db): - q = db.query('SELECT :answer') + def test_run_binding(self, database): + q = database.query('SELECT :answer') q.run(answer=42) assert q.value() == 42 - def test_run_missing_binding(self, db): - q = db.query('SELECT :answer') + def test_run_missing_binding(self, database): + q = database.query('SELECT :answer') with pytest.raises(sql.BugError, match='Missing bound values!'): q.run() - def test_run_batch(self, db): - q = db.query('SELECT :answer') + def test_run_batch(self, database): + q = database.query('SELECT :answer') q.run_batch(values={'answer': [42]}) assert q.value() == 42 - def test_run_batch_missing_binding(self, db): - q = db.query('SELECT :answer') + def test_run_batch_missing_binding(self, database): + q = database.query('SELECT :answer') with pytest.raises(sql.BugError, match='Missing bound values!'): q.run_batch(values={}) - def test_value_missing(self, db): - q = db.query('SELECT 0 WHERE 0') + def test_value_missing(self, database): + q = database.query('SELECT 0 WHERE 0') q.run() with pytest.raises(sql.BugError, match='No result for single-result query'): q.value() - def test_num_rows_affected_not_active(self, db): + def test_num_rows_affected_not_active(self, database): with pytest.raises(AssertionError): - q = db.query('SELECT 0') + q = database.query('SELECT 0') q.rows_affected() - def test_num_rows_affected_select(self, db): + def test_num_rows_affected_select(self, database): with pytest.raises(AssertionError): - q = db.query('SELECT 0') + q = database.query('SELECT 0') q.run() q.rows_affected() @pytest.mark.parametrize('condition', [0, 1]) - def test_num_rows_affected(self, condition, db): - table = db.table('Foo', ['name']) + def test_num_rows_affected(self, condition, database): + table = database.table('Foo', ['name']) table.insert({'name': 'helloworld'}) - q = db.query(f'DELETE FROM Foo WHERE {condition}') + q = database.query(f'DELETE FROM Foo WHERE {condition}') q.run() assert q.rows_affected() == condition - def test_bound_values(self, db): - q = db.query('SELECT :answer') + def test_bound_values(self, database): + q = database.query('SELECT :answer') q.run(answer=42) assert q.bound_values() == {':answer': 42} class TestTransaction: - def test_successful_transaction(self, db): - my_table = db.table('my_table', ['column']) - with db.transaction(): + def test_successful_transaction(self, database): + my_table = database.table('my_table', ['column']) + with database.transaction(): my_table.insert({'column': 1}) my_table.insert({'column': 2}) db2 = QSqlDatabase.addDatabase('QSQLITE', 'db2') - db2.setDatabaseName(db.qt_database().databaseName()) + db2.setDatabaseName(database.qt_database().databaseName()) db2.open() query = QSqlQuery(db2) query.exec('select count(*) from my_table') query.next() assert query.record().value(0) == 0 - assert db.query('select count(*) from my_table').run().value() == 2 + assert database.query('select count(*) from my_table').run().value() == 2 - def test_failed_transaction(self, db): - my_table = db.table('my_table', ['column']) + def test_failed_transaction(self, database): + my_table = database.table('my_table', ['column']) try: - with db.transaction(): + with database.transaction(): my_table.insert({'column': 1}) my_table.insert({'column': 2}) raise Exception('something went horribly wrong') except Exception: pass - assert db.query('select count(*) from my_table').run().value() == 0 + assert database.query('select count(*) from my_table').run().value() == 0 -- cgit v1.2.3-54-g00ecf