piccolo 1.8.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

tests/columns/test_get_sql_value.py

@@ -0,0 +1,66 @@
+import datetime
+from unittest import TestCase
+
+from tests.base import engines_only
+from tests.example_apps.music.tables import Band
+
+
+@engines_only("postgres", "cockroach")
+class TestArrayPostgres(TestCase):
+
+    def test_string(self):
+        self.assertEqual(
+            Band.name.get_sql_value(["a", "b", "c"]),
+            '\'{"a","b","c"}\'',
+        )
+
+    def test_int(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3]),
+            "'{1,2,3}'",
+        )
+
+    def test_nested(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3, [4, 5, 6]]),
+            "'{1,2,3,{4,5,6}}'",
+        )
+
+    def test_time(self):
+        self.assertEqual(
+            Band.name.get_sql_value([datetime.time(hour=8, minute=0)]),
+            "'{\"08:00:00\"}'",
+        )
+
+
+@engines_only("sqlite")
+class TestArraySQLite(TestCase):
+    """
+    Note, we use ``.replace(" ", "")`` because we serialise arrays using
+    Python's json library, and there is inconsistency between Python versions
+    (some output ``["a", "b", "c"]``, and others ``["a","b","c"]``).
+    """
+
+    def test_string(self):
+        self.assertEqual(
+            Band.name.get_sql_value(["a", "b", "c"]).replace(" ", ""),
+            '\'["a","b","c"]\'',
+        )
+
+    def test_int(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3]).replace(" ", ""),
+            "'[1,2,3]'",
+        )
+
+    def test_nested(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3, [4, 5, 6]]).replace(" ", ""),
+            "'[1,2,3,[4,5,6]]'",
+        )
+
+    def test_time(self):
+        self.assertEqual(
+            Band.name.get_sql_value([datetime.time(hour=8, minute=0)]),
+            "'[\"08:00:00\"]'",
+        )

tests/conf/test_apps.py

@@ -85,7 +85,7 @@ class TestAppConfig(TestCase):
         config = AppConfig(
             app_name="music", migrations_folder_path=pathlib.Path(__file__)
         )
-        self.assertEqual(config.migrations_folder_path, __file__)
+        self.assertEqual(config.resolved_migrations_folder_path, __file__)
 
     def test_get_table_with_name(self):
         """

tests/engine/test_nested_transaction.py

@@ -45,10 +45,12 @@ class TestDifferentDB(TestCase):
 
         self.assertTrue(await Musician.table_exists().run())
         musician = await Musician.select("name").first().run()
+        assert musician is not None
         self.assertEqual(musician["name"], "Bob")
 
         self.assertTrue(await Roadie.table_exists().run())
         roadie = await Roadie.select("name").first().run()
+        assert roadie is not None
         self.assertEqual(roadie["name"], "Dave")
 
     def test_nested(self):

tests/engine/test_transaction.py

@@ -4,7 +4,6 @@ from unittest import TestCase
 
 import pytest
 
-from piccolo.engine.postgres import Atomic
 from piccolo.engine.sqlite import SQLiteEngine, TransactionType
 from piccolo.table import drop_db_tables_sync
 from piccolo.utils.sync import run_sync
@@ -58,7 +57,7 @@ class TestAtomic(TestCase):
             engine = Band._meta.db
             await engine.start_connection_pool()
 
-            atomic: Atomic = engine.atomic()
+            atomic = engine.atomic()
             atomic.add(
                 Manager.create_table(),
                 Band.create_table(),

tests/query/functions/base.py

@@ -0,0 +1,34 @@
+import typing as t
+from unittest import TestCase
+
+from piccolo.table import Table, create_db_tables_sync, drop_db_tables_sync
+from tests.example_apps.music.tables import Band, Manager
+
+
+class FunctionTest(TestCase):
+    tables: t.List[t.Type[Table]]
+
+    def setUp(self) -> None:
+        create_db_tables_sync(*self.tables)
+
+    def tearDown(self) -> None:
+        drop_db_tables_sync(*self.tables)
+
+
+class BandTest(FunctionTest):
+    tables = [Band, Manager]
+
+    def setUp(self) -> None:
+        super().setUp()
+
+        manager = Manager({Manager.name: "Guido"})
+        manager.save().run_sync()
+
+        band = Band(
+            {
+                Band.name: "Pythonistas",
+                Band.manager: manager,
+                Band.popularity: 1000,
+            }
+        )
+        band.save().run_sync()

tests/query/functions/test_functions.py

@@ -0,0 +1,64 @@
+from piccolo.query.functions import Reverse, Upper
+from piccolo.querystring import QueryString
+from tests.base import engines_skip
+from tests.example_apps.music.tables import Band
+
+from .base import BandTest
+
+
+@engines_skip("sqlite")
+class TestNested(BandTest):
+    """
+    Skip the the test for SQLite, as it doesn't support ``Reverse``.
+    """
+
+    def test_nested(self):
+        """
+        Make sure we can nest functions.
+        """
+        response = Band.select(Upper(Reverse(Band.name))).run_sync()
+        self.assertListEqual(response, [{"upper": "SATSINOHTYP"}])
+
+    def test_nested_with_joined_column(self):
+        """
+        Make sure nested functions can be used on a column from a joined table.
+        """
+        response = Band.select(Upper(Reverse(Band.manager._.name))).run_sync()
+        self.assertListEqual(response, [{"upper": "ODIUG"}])
+
+    def test_nested_within_querystring(self):
+        """
+        If we wrap a function in a custom QueryString - make sure the columns
+        are still accessible, so joins are successful.
+        """
+        response = Band.select(
+            QueryString("CONCAT({}, '!')", Upper(Band.manager._.name)),
+        ).run_sync()
+
+        self.assertListEqual(response, [{"concat": "GUIDO!"}])
+
+
+class TestWhereClause(BandTest):
+
+    def test_where(self):
+        """
+        Make sure where clauses work with functions.
+        """
+        response = (
+            Band.select(Band.name)
+            .where(Upper(Band.name) == "PYTHONISTAS")
+            .run_sync()
+        )
+        self.assertListEqual(response, [{"name": "Pythonistas"}])
+
+    def test_where_with_joined_column(self):
+        """
+        Make sure where clauses work with functions, when a joined column is
+        used.
+        """
+        response = (
+            Band.select(Band.name)
+            .where(Upper(Band.manager._.name) == "GUIDO")
+            .run_sync()
+        )
+        self.assertListEqual(response, [{"name": "Pythonistas"}])

tests/query/functions/test_math.py

@@ -0,0 +1,39 @@
+import decimal
+
+from piccolo.columns import Numeric
+from piccolo.query.functions.math import Abs, Ceil, Floor, Round
+from piccolo.table import Table
+
+from .base import FunctionTest
+
+
+class Ticket(Table):
+    price = Numeric(digits=(5, 2))
+
+
+class TestMath(FunctionTest):
+
+    tables = [Ticket]
+
+    def setUp(self):
+        super().setUp()
+        self.ticket = Ticket({Ticket.price: decimal.Decimal("36.50")})
+        self.ticket.save().run_sync()
+
+    def test_floor(self):
+        response = Ticket.select(Floor(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("36.00")}])
+
+    def test_ceil(self):
+        response = Ticket.select(Ceil(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("37.00")}])
+
+    def test_abs(self):
+        self.ticket.price = decimal.Decimal("-1.50")
+        self.ticket.save().run_sync()
+        response = Ticket.select(Abs(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("1.50")}])
+
+    def test_round(self):
+        response = Ticket.select(Round(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("37.00")}])

tests/query/functions/test_string.py

@@ -0,0 +1,25 @@
+from piccolo.query.functions.string import Upper
+from tests.example_apps.music.tables import Band
+
+from .base import BandTest
+
+
+class TestUpperFunction(BandTest):
+
+    def test_column(self):
+        """
+        Make sure we can uppercase a column's value.
+        """
+        response = Band.select(Upper(Band.name)).run_sync()
+        self.assertListEqual(response, [{"upper": "PYTHONISTAS"}])
+
+    def test_alias(self):
+        response = Band.select(Upper(Band.name, alias="name")).run_sync()
+        self.assertListEqual(response, [{"name": "PYTHONISTAS"}])
+
+    def test_joined_column(self):
+        """
+        Make sure we can uppercase a column's value from a joined table.
+        """
+        response = Band.select(Upper(Band.manager._.name)).run_sync()
+        self.assertListEqual(response, [{"upper": "GUIDO"}])

tests/query/functions/test_type_conversion.py

@@ -0,0 +1,134 @@
+from piccolo.columns import Integer, Text, Varchar
+from piccolo.query.functions import Cast, Length
+from tests.example_apps.music.tables import Band, Manager
+
+from .base import BandTest
+
+
+class TestCast(BandTest):
+    def test_varchar(self):
+        """
+        Make sure that casting to ``Varchar`` works.
+        """
+        response = Band.select(
+            Cast(
+                Band.popularity,
+                as_type=Varchar(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"popularity": "1000"}],
+        )
+
+    def test_text(self):
+        """
+        Make sure that casting to ``Text`` works.
+        """
+        response = Band.select(
+            Cast(
+                Band.popularity,
+                as_type=Text(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"popularity": "1000"}],
+        )
+
+    def test_integer(self):
+        """
+        Make sure that casting to ``Integer`` works.
+        """
+        Band.update({Band.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Cast(
+                Band.name,
+                as_type=Integer(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"name": 1111}],
+        )
+
+    def test_join(self):
+        """
+        Make sure that casting works with joins.
+        """
+        Manager.update({Manager.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Band.name,
+            Cast(
+                Band.manager.name,
+                as_type=Integer(),
+            ),
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [
+                {
+                    "name": "Pythonistas",
+                    "manager.name": 1111,
+                }
+            ],
+        )
+
+    def test_nested_inner(self):
+        """
+        Make sure ``Cast`` can be passed into other functions.
+        """
+        Band.update({Band.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Length(
+                Cast(
+                    Band.popularity,
+                    as_type=Varchar(),
+                )
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"length": 4}],
+        )
+
+    def test_nested_outer(self):
+        """
+        Make sure a querystring can be passed into ``Cast`` (meaning it can be
+        nested).
+        """
+        response = Band.select(
+            Cast(
+                Length(Band.name),
+                as_type=Varchar(),
+                alias="length",
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"length": str(len("Pythonistas"))}],
+        )
+
+    def test_where_clause(self):
+        """
+        Make sure ``Cast`` works in a where clause.
+        """
+        response = (
+            Band.select(Band.name, Band.popularity)
+            .where(Cast(Band.popularity, Varchar()) == "1000")
+            .run_sync()
+        )
+
+        self.assertListEqual(
+            response,
+            [{"name": "Pythonistas", "popularity": 1000}],
+        )

tests/query/test_querystring.py

@@ -1,6 +1,7 @@
 from unittest import TestCase
 
 from piccolo.querystring import QueryString
+from tests.base import postgres_only
 
 
 # TODO - add more extensive tests (increased nesting and argument count).
@@ -28,3 +29,138 @@ class TestQueryString(TestCase):
     def test_querystring_with_no_args(self):
         qs = QueryString("SELECT name FROM band")
         self.assertEqual(qs.compile_string(), ("SELECT name FROM band", []))
+
+
+@postgres_only
+class TestQueryStringOperators(TestCase):
+    """
+    Make sure basic operations can be used on ``QueryString``.
+    """
+
+    def test_add(self):
+        query = QueryString("SELECT price") + 1
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price + $1", [1]),
+        )
+
+    def test_multiply(self):
+        query = QueryString("SELECT price") * 2
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price * $1", [2]),
+        )
+
+    def test_divide(self):
+        query = QueryString("SELECT price") / 1
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price / $1", [1]),
+        )
+
+    def test_power(self):
+        query = QueryString("SELECT price") ** 2
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price ^ $1", [2]),
+        )
+
+    def test_subtract(self):
+        query = QueryString("SELECT price") - 1
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price - $1", [1]),
+        )
+
+    def test_modulus(self):
+        query = QueryString("SELECT price") % 1
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price % $1", [1]),
+        )
+
+    def test_like(self):
+        query = QueryString("strip(name)").like("Python%")
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("strip(name) LIKE $1", ["Python%"]),
+        )
+
+    def test_ilike(self):
+        query = QueryString("strip(name)").ilike("Python%")
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("strip(name) ILIKE $1", ["Python%"]),
+        )
+
+    def test_greater_than(self):
+        query = QueryString("SELECT price") > 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price > $1", [10]),
+        )
+
+    def test_greater_equal_than(self):
+        query = QueryString("SELECT price") >= 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price >= $1", [10]),
+        )
+
+    def test_less_than(self):
+        query = QueryString("SELECT price") < 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price < $1", [10]),
+        )
+
+    def test_less_equal_than(self):
+        query = QueryString("SELECT price") <= 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price <= $1", [10]),
+        )
+
+    def test_equals(self):
+        query = QueryString("SELECT price") == 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price = $1", [10]),
+        )
+
+    def test_not_equals(self):
+        query = QueryString("SELECT price") != 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price != $1", [10]),
+        )
+
+    def test_is_in(self):
+        query = QueryString("SELECT price").is_in([10, 20, 30])
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price IN $1", [[10, 20, 30]]),
+        )
+
+    def test_not_in(self):
+        query = QueryString("SELECT price").not_in([10, 20, 30])
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price NOT IN $1", [[10, 20, 30]]),
+        )

tests/table/test_indexes.py

@@ -1,5 +1,7 @@
+import typing as t
 from unittest import TestCase
 
+from piccolo.columns.base import Column
 from piccolo.columns.column_types import Integer
 from piccolo.table import Table
 from tests.example_apps.music.tables import Manager
@@ -45,12 +47,12 @@ class TestProblematicColumnName(TestCase):
     def tearDown(self):
         Concert.alter().drop_table().run_sync()
 
-    def test_problematic_name(self):
+    def test_problematic_name(self) -> None:
         """
         Make sure we can add an index to a column with a problematic name
         (which clashes with a SQL keyword).
         """
-        columns = [Concert.order]
+        columns: t.List[Column] = [Concert.order]
         Concert.create_index(columns=columns).run_sync()
         index_name = Concert._get_index_name([i._meta.name for i in columns])