fixing tests for sqlite

Author: dantownsend

piccolo/query/base.py

@@ -98,7 +98,7 @@ async def run(self, in_pool=True):
         else:
             responses = []
             # TODO - run in a transaction
-            for querystring in self.querystring:
+            for querystring in self.querystrings:
                 results = await engine.run_querystring(
                     querystring, in_pool=in_pool
                 )

piccolo/query/methods/alter.py

@@ -51,7 +51,7 @@ def querystring(self) -> QueryString:
 class DropColumn(AlterColumnStatement):
     @property
     def querystring(self) -> QueryString:
-        return QueryString(f"DROP {self.column_name}")
+        return QueryString(f"DROP COLUMN {self.column_name}")
 
 
 @dataclasses.dataclass

piccolo/query/methods/select.py

@@ -213,6 +213,16 @@ def querystrings(self) -> t.Sequence[QueryString]:
             query += " {}"
             args.append(self.order_by_delegate._order_by.querystring)
 
+        if (
+            engine_type == "sqlite"
+            and self.offset_delegate._offset
+            and not self.limit_delegate._limit
+        ):
+            raise ValueError(
+                "A limit clause must be provided when doing an offset with "
+                "SQLite."
+            )
+
         if self.limit_delegate._limit:
             query += " {}"
             args.append(self.limit_delegate._limit.querystring)

tests/table/test_alter.py

@@ -1,6 +1,6 @@
 from piccolo.columns import Integer
 
-from ..base import DBTestCase
+from ..base import DBTestCase, postgres_only
 from ..example_project.tables import Band, Manager
 
 
@@ -26,8 +26,14 @@ def test_rename_column(self):
         self._test_rename("popularity")
 
 
-class TestDrop(DBTestCase):
-    def _test_drop(self, column):
+@postgres_only
+class TestDropColumn(DBTestCase):
+    """
+    Unfortunately this only works with Postgres at the moment.
+
+    SQLite has very limited support for ALTER statements.
+    """
+    def _test_drop(self, column: str):
         self.insert_row()
 
         Band.alter().drop_column(column).run_sync()
@@ -64,6 +70,7 @@ def test_add(self):
         self.assertEqual(response[0]["weight"], None)
 
 
+@postgres_only
 class TestUnique(DBTestCase):
     def test_unique(self):
         unique_query = Manager.alter().set_unique(Manager.name, True)
@@ -90,6 +97,8 @@ def test_unique(self):
         self.assertTrue(len(response), 2)
 
 
+# TODO - make it work for SQLite. Should work.
+@postgres_only
 class TestMultiple(DBTestCase):
     """
     Make sure multiple alter statements work correctly.

tests/table/test_instance.py

@@ -1,4 +1,4 @@
-from ..base import DBTestCase
+from ..base import DBTestCase, sqlite_only, postgres_only
 from ..example_project.tables import Band
 
 
@@ -7,12 +7,20 @@ class TestInstance(DBTestCase):
     Test instantiating Table instances
     """
 
-    def test_insert(self):
+    @postgres_only
+    def test_insert_postgres(self):
         Pythonistas = Band(name="Pythonistas")
         self.assertEqual(
             Pythonistas.__str__(), "(DEFAULT,null,'Pythonistas',0)"
         )
 
+    @sqlite_only
+    def test_insert_sqlite(self):
+        Pythonistas = Band(name="Pythonistas")
+        self.assertEqual(
+            Pythonistas.__str__(), "(null,null,'Pythonistas',0)"
+        )
+
     def test_non_existant_column(self):
         with self.assertRaises(ValueError):
             Band(name="Pythonistas", foo="bar")

tests/table/test_objects.py

@@ -1,4 +1,4 @@
-from ..base import DBTestCase
+from ..base import DBTestCase, postgres_only, sqlite_only
 from ..example_project.tables import Band
 
 
@@ -25,13 +25,37 @@ def test_get_all(self):
             == "Rustaceans"
         )
 
-    def test_offset(self):
+    @postgres_only
+    def test_offset_postgres(self):
+        """
+        Postgres can do an offset without a limit clause.
+        """
         self.insert_rows()
-
         response = Band.objects().order_by(Band.name).offset(1).run_sync()
 
         print(f"response = {response}")
 
         self.assertEqual(
             [i.name for i in response], ["Pythonistas", "Rustaceans"]
         )
+
+    @sqlite_only
+    def test_offset_sqlite(self):
+        """
+        SQLite requires a limit clause for offset to work.
+        """
+        self.insert_rows()
+        query = Band.objects().order_by(Band.name).offset(1)
+
+        with self.assertRaises(ValueError):
+            query.run_sync()
+
+        query = query.limit(5)
+
+        response = query.run_sync()
+
+        print(f"response = {response}")
+
+        self.assertEqual(
+            [i.name for i in response], ["Pythonistas", "Rustaceans"]
+        )

tests/table/test_select.py

@@ -1,4 +1,4 @@
-from ..base import DBTestCase
+from ..base import DBTestCase, postgres_only, sqlite_only
 from ..example_project.tables import Band, Concert
 
 
@@ -218,7 +218,8 @@ def test_limit(self):
 
         self.assertEqual(response, [{"name": "CSharps"}])
 
-    def test_offset(self):
+    @postgres_only
+    def test_offset_postgres(self):
         self.insert_rows()
 
         response = (
@@ -235,6 +236,27 @@ def test_offset(self):
             response, [{"name": "Pythonistas"}, {"name": "Rustaceans"}]
         )
 
+    @sqlite_only
+    def test_offset_sqlite(self):
+        """
+        SQLite requires a limit clause for offset to work.
+        """
+        self.insert_rows()
+
+        query = Band.select().columns(Band.name).order_by(Band.name).offset(1)
+
+        with self.assertRaises(ValueError):
+            query.run_sync()
+
+        query = query.limit(5)
+        response = query.run_sync()
+
+        print(f"response = {response}")
+
+        self.assertEqual(
+            response, [{"name": "Pythonistas"}, {"name": "Rustaceans"}]
+        )
+
     def test_first(self):
         self.insert_rows()
 

tests/test-requirements.txt

@@ -1,5 +1,5 @@
-coveralls==1.8.2
-flake8==3.5.0
-mypy==0.720
-pytest-cov==2.7.1
+coveralls==1.10.0
+flake8==3.7.9
+mypy==0.761
+pytest-cov==2.8.1
 pytest==3.8.0