From 038d64b9018678c2d72661fabbdae033751ecb0a Mon Sep 17 00:00:00 2001 From: lufte Date: Mon, 28 Jun 2021 22:58:15 -0300 Subject: Update test_sql unit tests --- tests/unit/misc/test_sql.py | 152 ++++++++++++++++++++++++++------------------ 1 file changed, 90 insertions(+), 62 deletions(-) (limited to 'tests') diff --git a/tests/unit/misc/test_sql.py b/tests/unit/misc/test_sql.py index f6fa68869..b287d6a29 100644 --- a/tests/unit/misc/test_sql.py +++ b/tests/unit/misc/test_sql.py @@ -28,7 +28,7 @@ from PyQt5.QtSql import QSqlError from qutebrowser.misc import sql -pytestmark = pytest.mark.usefixtures('init_sql') +pytestmark = pytest.mark.usefixtures('data_tmpdir') class TestUserVersion: @@ -120,23 +120,26 @@ class TestSqlError: assert err.text() == "db text" -def test_init(): - sql.SqlTable('Foo', ['name', 'val', 'lucky']) +def test_init_table(data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_init_table.db')) + db.table('Foo', ['name', 'val', 'lucky']) # should not error if table already exists - sql.SqlTable('Foo', ['name', 'val', 'lucky']) + db.table('Foo', ['name', 'val', 'lucky']) -def test_insert(qtbot): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky']) +def test_insert(qtbot, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_insert.db')) + table = db.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): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky'], - constraints={'name': 'PRIMARY KEY'}) +def test_insert_replace(qtbot, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_insert_replace.db')) + table = db.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) with qtbot.wait_signal(table.changed): @@ -147,8 +150,9 @@ def test_insert_replace(qtbot): table.insert({'name': 'one', 'val': 11, 'lucky': True}, replace=False) -def test_insert_batch(qtbot): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky']) +def test_insert_batch(qtbot, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_insert_batch.db')) + table = db.table('Foo', ['name', 'val', 'lucky']) with qtbot.wait_signal(table.changed): table.insert_batch({'name': ['one', 'nine', 'thirteen'], @@ -160,9 +164,10 @@ def test_insert_batch(qtbot): ('thirteen', 13, True)] -def test_insert_batch_replace(qtbot): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky'], - constraints={'name': 'PRIMARY KEY'}) +def test_insert_batch_replace(qtbot, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_insert_batch_replace.db')) + table = db.table('Foo', ['name', 'val', 'lucky'], + constraints={'name': 'PRIMARY KEY'}) with qtbot.wait_signal(table.changed): table.insert_batch({'name': ['one', 'nine', 'thirteen'], @@ -185,8 +190,9 @@ def test_insert_batch_replace(qtbot): 'lucky': [True, True]}) -def test_iter(): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky']) +def test_iter(data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_iter.db')) + table = db.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}) @@ -205,15 +211,17 @@ def test_iter(): ([{"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): - table = sql.SqlTable('Foo', ['a', 'b']) +def test_select(rows, sort_by, sort_order, limit, result, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_select.db')) + table = db.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): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky']) +def test_delete(qtbot, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_delete.db')) + table = db.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}) @@ -227,8 +235,9 @@ def test_delete(qtbot): assert not list(table) -def test_len(): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky']) +def test_len(data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_len.db')) + table = db.table('Foo', ['name', 'val', 'lucky']) assert len(table) == 0 table.insert({'name': 'one', 'val': 1, 'lucky': False}) assert len(table) == 1 @@ -238,15 +247,17 @@ def test_len(): assert len(table) == 3 -def test_bool(): - table = sql.SqlTable('Foo', ['name']) +def test_bool(data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_bool.db')) + table = db.table('Foo', ['name']) assert not table table.insert({'name': 'one'}) assert table -def test_bool_benchmark(benchmark): - table = sql.SqlTable('Foo', ['number']) +def test_bool_benchmark(benchmark, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_bool_benchmark.db')) + table = db.table('Foo', ['number']) # Simulate a history table table.create_index('NumberIndex', 'number') @@ -258,8 +269,9 @@ def test_bool_benchmark(benchmark): benchmark(run) -def test_contains(): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky']) +def test_contains(data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_contains.db')) + table = db.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}) @@ -279,8 +291,9 @@ def test_contains(): assert not val_query.run(val=10).value() -def test_delete_all(qtbot): - table = sql.SqlTable('Foo', ['name', 'val', 'lucky']) +def test_delete_all(qtbot, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_delete_all.db')) + table = db.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}) @@ -290,95 +303,110 @@ def test_delete_all(qtbot): def test_version(): - assert isinstance(sql.version(), str) + assert isinstance(sql.Database.version(), str) class TestSqlQuery: - def test_prepare_error(self): + def test_prepare_error(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_prepare_error')) with pytest.raises(sql.BugError) as excinfo: - sql.Query('invalid') + db.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): - q = sql.Query('SELECT 0 WHERE 0', forward_only=forward_only) + def test_forward_only(self, forward_only, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_forward_only.db')) + q = db.query('SELECT 0 WHERE 0', forward_only=forward_only) assert q.query.isForwardOnly() == forward_only - def test_iter_inactive(self): - q = sql.Query('SELECT 0') + def test_iter_inactive(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_iter_inactive.db')) + q = db.query('SELECT 0') with pytest.raises(sql.BugError, match='Cannot iterate inactive query'): next(iter(q)) - def test_iter_empty(self): - q = sql.Query('SELECT 0 AS col WHERE 0') + def test_iter_empty(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_iter_empty.db')) + q = db.query('SELECT 0 AS col WHERE 0') q.run() with pytest.raises(StopIteration): next(iter(q)) - def test_iter(self): - q = sql.Query('SELECT 0 AS col') + def test_iter(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_iter.db')) + q = db.query('SELECT 0 AS col') q.run() result = next(iter(q)) assert result.col == 0 - def test_iter_multiple(self): - q = sql.Query('VALUES (1), (2), (3);') + def test_iter_multiple(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_iter_multiple.db')) + q = db.query('VALUES (1), (2), (3);') res = list(q.run()) assert len(res) == 3 assert res[0].column1 == 1 - def test_run_binding(self): - q = sql.Query('SELECT :answer') + def test_run_binding(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_run_binding.db')) + q = db.query('SELECT :answer') q.run(answer=42) assert q.value() == 42 - def test_run_missing_binding(self): - q = sql.Query('SELECT :answer') + def test_run_missing_binding(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_run_missing_binding.db')) + q = db.query('SELECT :answer') with pytest.raises(sql.BugError, match='Missing bound values!'): q.run() - def test_run_batch(self): - q = sql.Query('SELECT :answer') + def test_run_batch(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_run_batch.db')) + q = db.query('SELECT :answer') q.run_batch(values={'answer': [42]}) assert q.value() == 42 - def test_run_batch_missing_binding(self): - q = sql.Query('SELECT :answer') + def test_run_batch_missing_binding(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_run_batch_missing_binding.db')) + q = db.query('SELECT :answer') with pytest.raises(sql.BugError, match='Missing bound values!'): q.run_batch(values={}) - def test_value_missing(self): - q = sql.Query('SELECT 0 WHERE 0') + def test_value_missing(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_value_missing.db')) + q = db.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): + def test_num_rows_affected_not_active(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_num_rows_affected_not_active.db')) with pytest.raises(AssertionError): - q = sql.Query('SELECT 0') + q = db.query('SELECT 0') q.rows_affected() - def test_num_rows_affected_select(self): + def test_num_rows_affected_select(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_num_rows_affected_select.db')) with pytest.raises(AssertionError): - q = sql.Query('SELECT 0') + q = db.query('SELECT 0') q.run() q.rows_affected() @pytest.mark.parametrize('condition', [0, 1]) - def test_num_rows_affected(self, condition): - table = sql.SqlTable('Foo', ['name']) + def test_num_rows_affected(self, condition, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_num_rows_affected.db')) + table = db.table('Foo', ['name']) table.insert({'name': 'helloworld'}) - q = sql.Query(f'DELETE FROM Foo WHERE {condition}') + q = db.query(f'DELETE FROM Foo WHERE {condition}') q.run() assert q.rows_affected() == condition - def test_bound_values(self): - q = sql.Query('SELECT :answer') + def test_bound_values(self, data_tmpdir): + db = sql.Database(str(data_tmpdir / 'test_bound_values.db')) + q = db.query('SELECT :answer') q.run(answer=42) assert q.bound_values() == {':answer': 42} -- cgit v1.2.3-54-g00ecf