Update test_sql unit tests

1 files changed, 90 insertions, 62 deletions

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}