From a7cdd23c005ae2673c8b066c60bd1d714db749e6 Mon Sep 17 00:00:00 2001 From: toofar Date: Sun, 4 Sep 2022 12:11:49 +1200 Subject: Swap SQL module aliases to avoid conflicts. It seems the rename script losses the alias when you re-run it. Probably gets confused, lets see if it ignores it when the other module is aliased. --- qutebrowser/completion/models/histcategory.py | 12 +++--- tests/unit/misc/test_sql.py | 56 +++++++++++++-------------- 2 files changed, 34 insertions(+), 34 deletions(-) diff --git a/qutebrowser/completion/models/histcategory.py b/qutebrowser/completion/models/histcategory.py index f9d29247c..52461dd2d 100644 --- a/qutebrowser/completion/models/histcategory.py +++ b/qutebrowser/completion/models/histcategory.py @@ -21,26 +21,26 @@ from typing import Optional -from qutebrowser.qt import widgets, sql as qtsql +from qutebrowser.qt import sql, widgets -from qutebrowser.misc import sql +from qutebrowser.misc import sql as qutesql from qutebrowser.utils import debug, message, log from qutebrowser.config import config from qutebrowser.completion.models import util -class HistoryCategory(qtsql.QSqlQueryModel): +class HistoryCategory(sql.QSqlQueryModel): """A completion category that queries the SQL history store.""" - def __init__(self, *, database: sql.Database, + def __init__(self, *, database: qutesql.Database, delete_func: util.DeleteFuncType = None, parent: widgets.QWidget = None) -> None: """Create a new History completion category.""" super().__init__(parent=parent) self._database = database self.name = "History" - self._query: Optional[sql.Query] = None + self._query: Optional[qutesql.Query] = None # advertise that this model filters by URL and title self.columns_to_filter = [0, 1] @@ -120,7 +120,7 @@ class HistoryCategory(qtsql.QSqlQueryModel): with debug.log_time('sql', 'Running completion query'): self._query.run(**{ str(i): w for i, w in enumerate(words)}) - except sql.KnownError as e: + except qutesql.KnownError as e: # Sometimes, the query we built up was invalid, for example, # due to a large amount of words. # Also catches failures in the DB we can't solve. diff --git a/tests/unit/misc/test_sql.py b/tests/unit/misc/test_sql.py index b968baf17..971d49229 100644 --- a/tests/unit/misc/test_sql.py +++ b/tests/unit/misc/test_sql.py @@ -24,8 +24,8 @@ import pytest import hypothesis from hypothesis import strategies -from qutebrowser.misc import sql -from qutebrowser.qt import sql as qtsql +from qutebrowser.misc import sql as qutesql +from qutebrowser.qt import sql pytestmark = pytest.mark.usefixtures('data_tmpdir') @@ -38,7 +38,7 @@ class TestUserVersion: (0x7FFF_FFFF, 0x7FFF, 0xFFFF), ]) def test_from_int(self, val, major, minor): - version = sql.UserVersion.from_int(val) + version = qutesql.UserVersion.from_int(val) assert version.major == major assert version.minor == minor @@ -47,13 +47,13 @@ class TestUserVersion: (0x7FFF, 0xFFFF, 0x7FFF_FFFF), ]) def test_to_int(self, major, minor, val): - version = sql.UserVersion(major, minor) + version = qutesql.UserVersion(major, minor) assert version.to_int() == val @pytest.mark.parametrize('val', [0x8000_0000, -1]) def test_from_int_invalid(self, val): with pytest.raises(AssertionError): - sql.UserVersion.from_int(val) + qutesql.UserVersion.from_int(val) @pytest.mark.parametrize('major, minor', [ (-1, 0), @@ -62,13 +62,13 @@ class TestUserVersion: (0x8000, 0), ]) def test_to_int_invalid(self, major, minor): - version = sql.UserVersion(major, minor) + version = qutesql.UserVersion(major, minor) with pytest.raises(AssertionError): version.to_int() @hypothesis.given(val=strategies.integers(min_value=0, max_value=0x7FFF_FFFF)) def test_from_int_hypothesis(self, val): - version = sql.UserVersion.from_int(val) + version = qutesql.UserVersion.from_int(val) assert version.to_int() == val @hypothesis.given( @@ -76,11 +76,11 @@ class TestUserVersion: minor=strategies.integers(min_value=0, max_value=0xFFFF) ) def test_to_int_hypothesis(self, major, minor): - version = sql.UserVersion(major, minor) + version = qutesql.UserVersion(major, minor) assert version.from_int(version.to_int()) == version -@pytest.mark.parametrize('klass', [sql.KnownError, sql.BugError]) +@pytest.mark.parametrize('klass', [qutesql.KnownError, qutesql.BugError]) def test_sqlerror(klass): text = "Hello World" err = klass(text) @@ -91,19 +91,19 @@ def test_sqlerror(klass): class TestSqlError: @pytest.mark.parametrize('error_code, exception', [ - (sql.SqliteErrorCode.BUSY, sql.KnownError), - (sql.SqliteErrorCode.CONSTRAINT, sql.BugError), + (qutesql.SqliteErrorCode.BUSY, qutesql.KnownError), + (qutesql.SqliteErrorCode.CONSTRAINT, qutesql.BugError), ]) def test_known(self, error_code, exception): - sql_err = qtsql.QSqlError("driver text", "db text", qtsql.QSqlError.ErrorType.UnknownError, + sql_err = sql.QSqlError("driver text", "db text", sql.QSqlError.ErrorType.UnknownError, error_code) with pytest.raises(exception): - sql.raise_sqlite_error("Message", sql_err) + qutesql.raise_sqlite_error("Message", sql_err) def test_logging(self, caplog): - sql_err = qtsql.QSqlError("driver text", "db text", qtsql.QSqlError.ErrorType.UnknownError, '23') - with pytest.raises(sql.BugError): - sql.raise_sqlite_error("Message", sql_err) + sql_err = sql.QSqlError("driver text", "db text", sql.QSqlError.ErrorType.UnknownError, '23') + with pytest.raises(qutesql.BugError): + qutesql.raise_sqlite_error("Message", sql_err) expected = ['SQL error:', 'type: UnknownError', @@ -113,9 +113,9 @@ class TestSqlError: assert caplog.messages == expected - @pytest.mark.parametrize('klass', [sql.KnownError, sql.BugError]) + @pytest.mark.parametrize('klass', [qutesql.KnownError, qutesql.BugError]) def test_text(self, klass): - sql_err = qtsql.QSqlError("driver text", "db text") + sql_err = sql.QSqlError("driver text", "db text") err = klass("Message", sql_err) assert err.text() == "db text" @@ -143,7 +143,7 @@ def test_insert_replace(qtbot, database): table.insert({'name': 'one', 'val': 11, 'lucky': True}, replace=True) assert list(table) == [('one', 11, True)] - with pytest.raises(sql.BugError): + with pytest.raises(qutesql.BugError): table.insert({'name': 'one', 'val': 11, 'lucky': True}, replace=False) @@ -179,7 +179,7 @@ def test_insert_batch_replace(qtbot, database): ('one', 11, True), ('nine', 19, True)] - with pytest.raises(sql.BugError): + with pytest.raises(qutesql.BugError): table.insert_batch({'name': ['one', 'nine'], 'val': [11, 19], 'lucky': [True, True]}) @@ -290,13 +290,13 @@ def test_delete_all(qtbot, database): def test_version(): - assert isinstance(sql.version(), str) + assert isinstance(qutesql.version(), str) class TestSqlQuery: def test_prepare_error(self, database): - with pytest.raises(sql.BugError) as excinfo: + with pytest.raises(qutesql.BugError) as excinfo: database.query('invalid') expected = ('Failed to prepare query "invalid": "near "invalid": ' @@ -310,7 +310,7 @@ class TestSqlQuery: def test_iter_inactive(self, database): q = database.query('SELECT 0') - with pytest.raises(sql.BugError, + with pytest.raises(qutesql.BugError, match='Cannot iterate inactive query'): next(iter(q)) @@ -339,7 +339,7 @@ class TestSqlQuery: def test_run_missing_binding(self, database): q = database.query('SELECT :answer') - with pytest.raises(sql.BugError, match='Missing bound values!'): + with pytest.raises(qutesql.BugError, match='Missing bound values!'): q.run() def test_run_batch(self, database): @@ -349,13 +349,13 @@ class TestSqlQuery: def test_run_batch_missing_binding(self, database): q = database.query('SELECT :answer') - with pytest.raises(sql.BugError, match='Missing bound values!'): + with pytest.raises(qutesql.BugError, match='Missing bound values!'): q.run_batch(values={}) 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'): + with pytest.raises(qutesql.BugError, match='No result for single-result query'): q.value() def test_num_rows_affected_not_active(self, database): @@ -391,10 +391,10 @@ class TestTransaction: my_table.insert({'column': 1}) my_table.insert({'column': 2}) - db2 = qtsql.QSqlDatabase.addDatabase('QSQLITE', 'db2') + db2 = sql.QSqlDatabase.addDatabase('QSQLITE', 'db2') db2.setDatabaseName(database.qt_database().databaseName()) db2.open() - query = qtsql.QSqlQuery(db2) + query = sql.QSqlQuery(db2) query.exec('select count(*) from my_table') query.next() assert query.record().value(0) == 0 -- cgit v1.2.3-54-g00ecf