added decorators for restricting tests to certain engines

Author: dantownsend

.gitignore

@@ -12,3 +12,4 @@ dist/
 piccolo.sqlite
 _build/
 .coverage
+*.sqlite

piccolo/engine/finder.py

@@ -4,7 +4,7 @@
 import typing as t
 import warnings
 
-from .base import Engine
+from piccolo.engine.base import Engine
 
 
 DEFAULT_MODULE_NAME = "piccolo_conf"

test.sqlite

@@ -1,12 +1,26 @@
 import asyncio
 from unittest import TestCase
 
+import pytest
+
 from piccolo.engine.finder import engine_finder
+from piccolo.engine.postgres import PostgresEngine
+from piccolo.engine.sqlite import SQLiteEngine
 
 
 ENGINE = engine_finder()
 
 
+postgres_only = pytest.mark.skipif(
+    not isinstance(ENGINE, PostgresEngine), reason="Only running for Postgres"
+)
+
+
+sqlite_only = pytest.mark.skipif(
+    not isinstance(ENGINE, SQLiteEngine), reason="Only running for SQLite"
+)
+
+
 class DBTestCase(TestCase):
     """
     Using raw SQL, otherwise tests are too reliant on other Piccolo code.

tests/base.py

@@ -2,10 +2,11 @@
 
 from unittest import TestCase
 
-from ..base import DBTestCase
+from ..base import DBTestCase, postgres_only
 from ..example_project.tables import Manager
 
 
+@postgres_only
 class TestPool(DBTestCase):
     async def create_pool(self):
         await Manager.Meta.db.start_connnection_pool()

tests/engine/test_pool.py

@@ -1,10 +1,11 @@
 from unittest import TestCase
 
 from ..example_project.tables import Band, Manager
+from ..base import postgres_only
 
 
+@postgres_only
 class TestTransaction(TestCase):
-
     def test_error(self):
         """
         Make sure queries in a transaction aren't committed if a query fails.
@@ -13,36 +14,22 @@ def test_error(self):
         transaction.add(
             Manager.create(),
             Band.create(),
-            Band.raw('MALFORMED QUERY ... SHOULD ERROR')
+            Band.raw("MALFORMED QUERY ... SHOULD ERROR"),
         )
         try:
             transaction.run_sync()
         except Exception:
             pass
-        self.assertTrue(
-            not Band.table_exists().run_sync()
-        )
-        self.assertTrue(
-            not Manager.table_exists().run_sync()
-        )
+        self.assertTrue(not Band.table_exists().run_sync())
+        self.assertTrue(not Manager.table_exists().run_sync())
 
     def test_succeeds(self):
         transaction = Band.Meta.db.transaction()
-        transaction.add(
-            Manager.create(),
-            Band.create()
-        )
+        transaction.add(Manager.create(), Band.create())
         transaction.run_sync()
 
-        self.assertTrue(
-            Band.table_exists().run_sync()
-        )
-        self.assertTrue(
-            Manager.table_exists().run_sync()
-        )
+        self.assertTrue(Band.table_exists().run_sync())
+        self.assertTrue(Manager.table_exists().run_sync())
 
-        transaction.add(
-            Band.drop(),
-            Manager.drop()
-        )
+        transaction.add(Band.drop(), Manager.drop())
         transaction.run_sync()