refactoring so tests can be run for sqlite

Author: dantownsend

docs/src/piccolo/engines/index.rst

@@ -103,6 +103,8 @@ variable accordingly.
 
     DB = SQLiteEngine(path='my_test_db.sqlite')
 
+.. hint:: You can also specify sub modules, like `my_module.piccolo_conf`.
+
 .. _EngineTypes:
 
 Engine types

piccolo/engine/finder.py

@@ -46,7 +46,8 @@ def engine_finder(module_name: t.Optional[str] = None) -> t.Optional[Engine]:
             )
         elif not isinstance(engine, Engine):
             warnings.warn(
-                f"{module_name} contains a {ENGINE_VAR} variable of the wrong type - it should be an Engine subclass."
+                f"{module_name} contains a {ENGINE_VAR} variable of the wrong "
+                "type - it should be an Engine subclass."
             )
 
     return engine

piccolo/query/base.py

@@ -13,7 +13,11 @@
 
 class Query(object):
     def __init__(
-        self, table: Table, base: QueryString = QueryString(""), *args, **kwargs
+        self,
+        table: Table,
+        base: QueryString = QueryString(""),
+        *args,
+        **kwargs,
     ) -> None:
         self.base = base
         self.table = table

piccolo/table.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 import copy
 import typing as t
-from functools import wraps
 
 from piccolo.engine import Engine, engine_finder
 from piccolo.columns import Column, PrimaryKey, ForeignKey
@@ -14,7 +13,6 @@
     Exists,
     Insert,
     Objects,
-    Query,
     Raw,
     Select,
     TableExists,
@@ -42,6 +40,10 @@ def __new__(cls, name, bases, namespace, **kwds):
         if not tablename:
             table.Meta.tablename = _camel_to_snake(name)
 
+        db = getattr(Meta, "db", None) if Meta else None
+        if not db:
+            table.Meta.db = engine_finder()
+
         columns = []
 
         # In case super classes also have columns.
@@ -133,7 +135,9 @@ def save(self) -> t.Union[Insert, Update]:
 
         if type(self.id) == int:
             # pre-existing row
-            kwargs = {i: getattr(self, i._name, None) for i in cls.Meta.columns}
+            kwargs = {
+                i: getattr(self, i._name, None) for i in cls.Meta.columns
+            }
             _id = kwargs.pop("id")
             return cls.update().values(kwargs).where(cls.id == _id)
         else:

test.sqlite

@@ -1,9 +1,10 @@
 import asyncio
 from unittest import TestCase
 
-import asyncpg
+from piccolo.engine.finder import engine_finder
 
-from .example_project.tables import Band
+
+ENGINE = engine_finder()
 
 
 class DBTestCase(TestCase):
@@ -12,36 +13,38 @@ class DBTestCase(TestCase):
     """
 
     def run_sync(self, query):
-        async def _run():
-            connection = await asyncpg.connect(**Band.Meta.db.config)
-            await connection.execute(query)
-            await connection.close()
-
-        asyncio.run(_run())
+        asyncio.run(ENGINE.run(query))
 
     def create_table(self):
-        self.run_sync('''
+        self.run_sync(
+            """
             CREATE TABLE manager (
                 id SERIAL PRIMARY KEY,
                 name VARCHAR(50)
-            );''')
+            );"""
+        )
 
-        self.run_sync('''
+        self.run_sync(
+            """
             CREATE TABLE band (
                 id SERIAL PRIMARY KEY,
                 name VARCHAR(50),
                 manager INTEGER REFERENCES manager,
                 popularity SMALLINT
-            );''')
+            );"""
+        )
 
     def insert_row(self):
-        self.run_sync('''
+        self.run_sync(
+            """
             INSERT INTO manager (
                 name
             ) VALUES (
                 'Guido'
-            );''')
-        self.run_sync('''
+            );"""
+        )
+        self.run_sync(
+            """
             INSERT INTO band (
                 name,
                 manager,
@@ -50,10 +53,12 @@ def insert_row(self):
                 'Pythonistas',
                 1,
                 1000
-            );''')
+            );"""
+        )
 
     def insert_rows(self):
-        self.run_sync('''
+        self.run_sync(
+            """
             INSERT INTO manager (
                 name
             ) VALUES (
@@ -62,8 +67,10 @@ def insert_rows(self):
                 'Graydon'
             ),(
                 'Mads'
-            );''')
-        self.run_sync('''
+            );"""
+        )
+        self.run_sync(
+            """
             INSERT INTO band (
                 name,
                 manager,
@@ -80,11 +87,12 @@ def insert_rows(self):
                 'CSharps',
                 3,
                 10
-            );''')
+            );"""
+        )
 
     def drop_table(self):
-        self.run_sync('DROP TABLE band;')
-        self.run_sync('DROP TABLE manager;')
+        self.run_sync("DROP TABLE band;")
+        self.run_sync("DROP TABLE manager;")
 
     def setUp(self):
         self.create_table()

tests/base.py

@@ -1,29 +1,28 @@
 import asyncio
 
-import asyncpg
-import pytest
+from piccolo.engine.finder import engine_finder
 
-from .example_project.tables import DB
 
+ENGINE = engine_finder()
 
-async def drop_tables():
-    connection = await asyncpg.connect(**DB.config)
-    for table in ['venue', 'concert', 'band', 'manager', 'migration']:
-        await connection.execute(f'DROP TABLE IF EXISTS {table}')
 
-    await connection.close()
+async def drop_tables():
+    for table in ["venue", "concert", "band", "manager", "migration"]:
+        await ENGINE.run(f"DROP TABLE IF EXISTS {table}")
 
 
 def pytest_sessionstart(session):
     """
+    Make sure all the tables have been dropped.
+
     https://docs.pytest.org/en/latest/reference.html#_pytest.hookspec.pytest_configure
     """
-    print('Session starting')
+    print("Session starting")
     asyncio.run(drop_tables())
 
 
-# def pytest_sessionfinish(session, exitstatus):
-#     """
-#     https://docs.pytest.org/en/latest/reference.html#_pytest.hookspec.pytest_sessionfinish
-#     """
-#     print('Session finishing')
+def pytest_sessionfinish(session, exitstatus):
+    """
+    https://docs.pytest.org/en/latest/reference.html#_pytest.hookspec.pytest_sessionfinish
+    """
+    print("Session finishing")

tests/conftest.py

@@ -1,50 +1,31 @@
 from piccolo import table
 from piccolo import columns
-from piccolo.engine import PostgresEngine
-
-
-DB = PostgresEngine({
-    'host': 'localhost',
-    'database': 'piccolo',
-    'user': 'piccolo',
-    'password': 'piccolo'
-})
 
 
 ###############################################################################
 # Simple example
 
+
 class Manager(table.Table):
     name = columns.Varchar(length=50)
 
-    class Meta():
-        db = DB
-
 
 class Band(table.Table):
     name = columns.Varchar(length=50)
     manager = columns.ForeignKey(Manager)
     popularity = columns.Integer()
 
-    class Meta():
-        db = DB
-
 
 ###############################################################################
 # More complex
 
+
 class Venue(table.Table):
     name = columns.Varchar(length=100)
     capacity = columns.Integer()
 
-    class Meta():
-        db = DB
-
 
 class Concert(table.Table):
     band_1 = columns.ForeignKey(Band)
     band_2 = columns.ForeignKey(Band)
     venue = columns.ForeignKey(Venue)
-
-    class Meta():
-        db = DB

tests/example_project/tables.py

@@ -2,28 +2,20 @@
 from unittest import TestCase
 
 from piccolo.extensions.user import BaseUser
-from ..example_project.tables import DB
-
-
-class User(BaseUser):
-    class Meta():
-        db = DB
-        tablename = 'custom_user'
 
 
 class TestCreateUserTable(TestCase):
-
     def test_create_user_table(self):
         """
         Make sure the table can be created.
         """
         exception = None
         try:
-            User.create().run_sync()
+            BaseUser.create().run_sync()
         except Exception as e:
             exception = e
         else:
-            User.drop().run_sync()
+            BaseUser.drop().run_sync()
 
         if exception:
             raise exception
@@ -32,60 +24,46 @@ def test_create_user_table(self):
 
 
 class TestHashPassword(TestCase):
-
     def test_hash_password(self):
         pass
 
 
 class TestLogin(TestCase):
-
     def setUp(self):
-        User.create().run_sync()
+        BaseUser.create().run_sync()
 
     def tearDown(self):
-        User.drop().run_sync()
+        BaseUser.drop().run_sync()
 
     def test_login(self):
         username = "bob"
         password = "Bob123$$$"
         email = "bob@bob.com"
 
-        user = User(
-            username=username,
-            password=password,
-            email=email
-        )
+        user = BaseUser(username=username, password=password, email=email)
 
         save_query = user.save()
 
         save_query.run_sync()
 
-        authenticated = asyncio.run(
-            User.login(username, password)
-        )
+        authenticated = asyncio.run(BaseUser.login(username, password))
         self.assertTrue(authenticated is not None)
 
-        authenticated = asyncio.run(
-            User.login(username, 'blablabla')
-        )
+        authenticated = asyncio.run(BaseUser.login(username, "blablabla"))
         self.assertTrue(not authenticated)
 
     def test_update_password(self):
         username = "bob"
         password = "Bob123$$$"
         email = "bob@bob.com"
 
-        user = User(
-            username=username,
-            password=password,
-            email=email
-        )
+        user = BaseUser(username=username, password=password, email=email)
         user.save().run_sync()
 
-        authenticated = User.login_sync(username, password)
+        authenticated = BaseUser.login_sync(username, password)
         self.assertTrue(authenticated is not None)
 
         new_password = "XXX111"
-        User.update_password_sync(username, new_password)
-        authenticated = User.login_sync(username, new_password)
+        BaseUser.update_password_sync(username, new_password)
+        authenticated = BaseUser.login_sync(username, new_password)
         self.assertTrue(authenticated is not None)

tests/extensions/test_user.py

@@ -0,0 +1,11 @@
+from piccolo.engine.postgres import PostgresEngine
+
+
+DB = PostgresEngine(
+    {
+        "host": "localhost",
+        "database": "piccolo",
+        "user": "piccolo",
+        "password": "piccolo",
+    }
+)