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

tests/columns/test_varchar.py

@@ -1,9 +1,7 @@
-from unittest import TestCase
-
 from piccolo.columns.column_types import Varchar
 from piccolo.table import Table
 
-from ..base import engines_only
+from ..base import TableTest, engines_only
 
 
 class MyTable(Table):
@@ -11,7 +9,7 @@ class MyTable(Table):
 
 
 @engines_only("postgres", "cockroach")
-class TestVarchar(TestCase):
+class TestVarchar(TableTest):
     """
     SQLite doesn't enforce any constraints on max character length.
 
@@ -20,11 +18,7 @@ class TestVarchar(TestCase):
     Might consider enforcing this at the ORM level instead in the future.
     """
 
-    def setUp(self):
-        MyTable.create_table().run_sync()
-
-    def tearDown(self):
-        MyTable.alter().drop_table().run_sync()
+    tables = [MyTable]
 
     def test_length(self):
         row = MyTable(name="bob")

tests/query/functions/base.py

@@ -1,21 +1,8 @@
-import typing as t
-from unittest import TestCase
-
-from piccolo.table import Table, create_db_tables_sync, drop_db_tables_sync
+from tests.base import TableTest
 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):
+class BandTest(TableTest):
     tables = [Band, Manager]
 
     def setUp(self) -> None:

tests/query/functions/test_datetime.py

@@ -0,0 +1,112 @@
+import datetime
+
+from piccolo.columns import Timestamp
+from piccolo.query.functions.datetime import (
+    Day,
+    Extract,
+    Hour,
+    Minute,
+    Month,
+    Second,
+    Strftime,
+    Year,
+)
+from piccolo.table import Table
+from tests.base import TableTest, engines_only, sqlite_only
+
+
+class Concert(Table):
+    starts = Timestamp()
+
+
+class DatetimeTest(TableTest):
+    tables = [Concert]
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.concert = Concert(
+            {
+                Concert.starts: datetime.datetime(
+                    year=2024, month=6, day=14, hour=23, minute=46, second=10
+                )
+            }
+        )
+        self.concert.save().run_sync()
+
+
+@engines_only("postgres", "cockroach")
+class TestExtract(DatetimeTest):
+    def test_extract(self):
+        self.assertEqual(
+            Concert.select(
+                Extract(Concert.starts, "year", alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": self.concert.starts.year}],
+        )
+
+    def test_invalid_format(self):
+        with self.assertRaises(ValueError):
+            Extract(
+                Concert.starts,
+                "abc123",  # type: ignore
+                alias="starts_year",
+            )
+
+
+@sqlite_only
+class TestStrftime(DatetimeTest):
+    def test_strftime(self):
+        self.assertEqual(
+            Concert.select(
+                Strftime(Concert.starts, "%Y", alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": str(self.concert.starts.year)}],
+        )
+
+
+class TestDatabaseAgnostic(DatetimeTest):
+    def test_year(self):
+        self.assertEqual(
+            Concert.select(
+                Year(Concert.starts, alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": self.concert.starts.year}],
+        )
+
+    def test_month(self):
+        self.assertEqual(
+            Concert.select(
+                Month(Concert.starts, alias="starts_month")
+            ).run_sync(),
+            [{"starts_month": self.concert.starts.month}],
+        )
+
+    def test_day(self):
+        self.assertEqual(
+            Concert.select(Day(Concert.starts, alias="starts_day")).run_sync(),
+            [{"starts_day": self.concert.starts.day}],
+        )
+
+    def test_hour(self):
+        self.assertEqual(
+            Concert.select(
+                Hour(Concert.starts, alias="starts_hour")
+            ).run_sync(),
+            [{"starts_hour": self.concert.starts.hour}],
+        )
+
+    def test_minute(self):
+        self.assertEqual(
+            Concert.select(
+                Minute(Concert.starts, alias="starts_minute")
+            ).run_sync(),
+            [{"starts_minute": self.concert.starts.minute}],
+        )
+
+    def test_second(self):
+        self.assertEqual(
+            Concert.select(
+                Second(Concert.starts, alias="starts_second")
+            ).run_sync(),
+            [{"starts_second": self.concert.starts.second}],
+        )

tests/query/functions/test_math.py

@@ -3,15 +3,14 @@ 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
+from tests.base import TableTest
 
 
 class Ticket(Table):
     price = Numeric(digits=(5, 2))
 
 
-class TestMath(FunctionTest):
+class TestMath(TableTest):
 
     tables = [Ticket]
 

tests/query/functions/test_string.py

@@ -1,10 +1,13 @@
-from piccolo.query.functions.string import Upper
+import pytest
+
+from piccolo.query.functions.string import Concat, Upper
+from tests.base import engine_version_lt, is_running_sqlite
 from tests.example_apps.music.tables import Band
 
 from .base import BandTest
 
 
-class TestUpperFunction(BandTest):
+class TestUpper(BandTest):
 
     def test_column(self):
         """
@@ -23,3 +26,32 @@ class TestUpperFunction(BandTest):
         """
         response = Band.select(Upper(Band.manager._.name)).run_sync()
         self.assertListEqual(response, [{"upper": "GUIDO"}])
+
+
+@pytest.mark.skipif(
+    is_running_sqlite() and engine_version_lt(3.44),
+    reason="SQLite version not supported",
+)
+class TestConcat(BandTest):
+
+    def test_column_and_string(self):
+        response = Band.select(
+            Concat(Band.name, "!!!", alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas!!!"}])
+
+    def test_column_and_column(self):
+        response = Band.select(
+            Concat(Band.name, Band.popularity, alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas1000"}])
+
+    def test_join(self):
+        response = Band.select(
+            Concat(Band.name, "-", Band.manager._.name, alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas-Guido"}])
+
+    def test_min_args(self):
+        with self.assertRaises(ValueError):
+            Concat()