piccolo 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

tests/table/test_output.py

@@ -1,8 +1,9 @@
 import json
 from unittest import TestCase
 
-from tests.base import DBTestCase, engine_is
-from tests.example_apps.music.tables import Band, RecordingStudio
+from piccolo.table import create_db_tables_sync, drop_db_tables_sync
+from tests.base import DBTestCase
+from tests.example_apps.music.tables import Band, Instrument, RecordingStudio
 
 
 class TestOutputList(DBTestCase):
@@ -32,51 +33,102 @@ class TestOutputJSON(DBTestCase):
 
 
 class TestOutputLoadJSON(TestCase):
+    tables = [RecordingStudio, Instrument]
+    json = {"a": 123}
+
     def setUp(self):
-        RecordingStudio.create_table().run_sync()
+        create_db_tables_sync(*self.tables)
+
+        recording_studio = RecordingStudio(
+            {
+                RecordingStudio.facilities: self.json,
+                RecordingStudio.facilities_b: self.json,
+            }
+        )
+        recording_studio.save().run_sync()
+
+        instrument = Instrument(
+            {
+                Instrument.recording_studio: recording_studio,
+                Instrument.name: "Piccolo",
+            }
+        )
+        instrument.save().run_sync()
 
     def tearDown(self):
-        RecordingStudio.alter().drop_table().run_sync()
+        drop_db_tables_sync(*self.tables)
 
     def test_select(self):
-        json = {"a": 123}
-
-        RecordingStudio(facilities=json, facilities_b=json).save().run_sync()
-
-        results = RecordingStudio.select().output(load_json=True).run_sync()
-
-        if engine_is("cockroach"):
-            self.assertEqual(
-                results,
-                [
-                    {
-                        "id": results[0]["id"],
-                        "facilities": {"a": 123},
-                        "facilities_b": {"a": 123},
-                    }
-                ],
+        results = (
+            RecordingStudio.select(
+                RecordingStudio.facilities, RecordingStudio.facilities_b
             )
-        else:
-            self.assertEqual(
-                results,
-                [
-                    {
-                        "id": 1,
-                        "facilities": {"a": 123},
-                        "facilities_b": {"a": 123},
-                    }
-                ],
+            .output(load_json=True)
+            .run_sync()
+        )
+
+        self.assertEqual(
+            results,
+            [
+                {
+                    "facilities": self.json,
+                    "facilities_b": self.json,
+                }
+            ],
+        )
+
+    def test_join(self):
+        """
+        Make sure it works correctly when the JSON column is on a joined table.
+
+        https://github.com/piccolo-orm/piccolo/issues/1001
+
+        """
+        results = (
+            Instrument.select(
+                Instrument.name,
+                Instrument.recording_studio._.facilities,
             )
+            .output(load_json=True)
+            .run_sync()
+        )
 
-    def test_objects(self):
-        json = {"a": 123}
+        self.assertEqual(
+            results,
+            [
+                {
+                    "name": "Piccolo",
+                    "recording_studio.facilities": self.json,
+                }
+            ],
+        )
 
-        RecordingStudio(facilities=json, facilities_b=json).save().run_sync()
+    def test_join_with_alias(self):
+        results = (
+            Instrument.select(
+                Instrument.name,
+                Instrument.recording_studio._.facilities.as_alias(
+                    "facilities"
+                ),
+            )
+            .output(load_json=True)
+            .run_sync()
+        )
 
-        results = RecordingStudio.objects().output(load_json=True).run_sync()
+        self.assertEqual(
+            results,
+            [
+                {
+                    "name": "Piccolo",
+                    "facilities": self.json,
+                }
+            ],
+        )
 
-        self.assertEqual(results[0].facilities, json)
-        self.assertEqual(results[0].facilities_b, json)
+    def test_objects(self):
+        results = RecordingStudio.objects().output(load_json=True).run_sync()
+        self.assertEqual(results[0].facilities, self.json)
+        self.assertEqual(results[0].facilities_b, self.json)
 
 
 class TestOutputNested(DBTestCase):

tests/table/test_select.py

@@ -7,7 +7,8 @@ from piccolo.apps.user.tables import BaseUser
 from piccolo.columns import Date, Varchar
 from piccolo.columns.combination import WhereRaw
 from piccolo.query import OrderByRaw
-from piccolo.query.methods.select import Avg, Count, Max, Min, SelectRaw, Sum
+from piccolo.query.functions.aggregate import Avg, Count, Max, Min, Sum
+from piccolo.query.methods.select import SelectRaw
 from piccolo.query.mixins import DistinctOnError
 from piccolo.table import Table, create_db_tables_sync, drop_db_tables_sync
 from tests.base import (
@@ -927,14 +928,6 @@ class TestSelect(DBTestCase):
         self.assertEqual(float(response["popularity_avg"]), 1003.3333333333334)
         self.assertEqual(response["popularity_sum"], 3010)
 
-    def test_avg_validation(self):
-        with self.assertRaises(ValueError):
-            Band.select(Avg(Band.name)).run_sync()
-
-    def test_sum_validation(self):
-        with self.assertRaises(ValueError):
-            Band.select(Sum(Band.name)).run_sync()
-
     def test_columns(self):
         """
         Make sure the colums method can be used to specify which columns to