piccolo 1.14.0__py3-none-any.whl → 1.16.0__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.14.0"
+__VERSION__ = "1.16.0"

piccolo/apps/user/tables.py

@@ -91,10 +91,14 @@ class BaseUser(Table, tablename="piccolo_user"):
             raise ValueError("A password must be provided.")
 
         if len(password) < cls._min_password_length:
-            raise ValueError("The password is too short.")
+            raise ValueError(
+                f"The password is too short. (min {cls._min_password_length})"
+            )
 
         if len(password) > cls._max_password_length:
-            raise ValueError("The password is too long.")
+            raise ValueError(
+                f"The password is too long. (max {cls._max_password_length})"
+            )
 
         if password.startswith("pbkdf2_sha256"):
             logger.warning(

piccolo/query/base.py

@@ -79,9 +79,7 @@ class Query(t.Generic[TableInstance, QueryResponseType]):
                 if column._alias is not None:
                     json_column_names.append(column._alias)
                 elif len(column._meta.call_chain) > 0:
-                    json_column_names.append(
-                        column._meta.get_default_alias().replace("$", ".")
-                    )
+                    json_column_names.append(column._meta.get_default_alias())
                 else:
                     json_column_names.append(column._meta.name)
 

piccolo/query/methods/refresh.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import typing as t
-from dataclasses import dataclass
 
+from piccolo.utils.encoding import JSONDict
 from piccolo.utils.sync import run_sync
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -10,7 +10,6 @@ if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
 
-@dataclass
 class Refresh:
     """
     Used to refresh :class:`Table <piccolo.table.Table>` instances with the
@@ -22,11 +21,33 @@ class Refresh:
     :param columns:
         Which columns to refresh - it not specified, then all columns are
         refreshed.
+    :param load_json:
+        Whether to load ``JSON`` / ``JSONB`` columns as objects, instead of
+        just a string.
 
     """
 
-    instance: Table
-    columns: t.Optional[t.Sequence[Column]] = None
+    def __init__(
+        self,
+        instance: Table,
+        columns: t.Optional[t.Sequence[Column]] = None,
+        load_json: bool = False,
+    ):
+        self.instance = instance
+
+        if columns:
+            for column in columns:
+                if len(column._meta.call_chain) > 0:
+                    raise ValueError(
+                        "We can't currently selectively refresh certain "
+                        "columns on child objects (e.g. Concert.band_1.name). "
+                        "Please just specify top level columns (e.g. "
+                        "Concert.band_1), and the entire child object will be "
+                        "refreshed."
+                    )
+
+        self.columns = columns
+        self.load_json = load_json
 
     @property
     def _columns(self) -> t.Sequence[Column]:
@@ -40,6 +61,63 @@ class Refresh:
             i for i in self.instance._meta.columns if not i._meta.primary_key
         ]
 
+    def _get_columns(self, instance: Table, columns: t.Sequence[Column]):
+        """
+        If `prefetch` was used on the object, for example::
+
+            >>> await Band.objects(Band.manager)
+
+        We should also update the prefetched object.
+
+        It works multiple level deep. If we refresh this::
+
+            >>> await Album.objects(Album.band.manager).first()
+
+        It will update the nested `band` object, and also the `manager`
+        object.
+
+        """
+        from piccolo.columns.column_types import ForeignKey
+        from piccolo.table import Table
+
+        select_columns = []
+
+        for column in columns:
+            if isinstance(column, ForeignKey) and isinstance(
+                (child_instance := getattr(instance, column._meta.name)),
+                Table,
+            ):
+                select_columns.extend(
+                    self._get_columns(
+                        child_instance,
+                        # Fetch all columns (even the primary key, just in
+                        # case the foreign key now references a different row).
+                        column.all_columns(),
+                    )
+                )
+            else:
+                select_columns.append(column)
+
+        return select_columns
+
+    def _update_instance(self, instance: Table, data_dict: t.Dict):
+        """
+        Update the table instance. It is called recursively, if the instance
+        has child instances.
+        """
+        for key, value in data_dict.items():
+            if isinstance(value, dict) and not isinstance(value, JSONDict):
+                # If the value is a dict, then it's a child instance.
+                if all(i is None for i in value.values()):
+                    # If all values in the nested object are None, then we can
+                    # safely assume that the object itself is null, as the
+                    # primary key value must be null.
+                    setattr(instance, key, None)
+                else:
+                    self._update_instance(getattr(instance, key), value)
+            else:
+                setattr(instance, key, value)
+
     async def run(
         self, in_pool: bool = True, node: t.Optional[str] = None
     ) -> Table:
@@ -54,7 +132,6 @@ class Refresh:
         Modifies the instance in place, but also returns it as a convenience.
 
         """
-
         instance = self.instance
 
         if not instance._exists_in_db:
@@ -71,20 +148,24 @@ class Refresh:
         if not columns:
             raise ValueError("No columns to fetch.")
 
-        updated_values = (
-            await instance.__class__.select(*columns)
+        select_columns = self._get_columns(
+            instance=self.instance, columns=columns
+        )
+
+        data_dict = (
+            await instance.__class__.select(*select_columns)
             .where(pk_column == primary_key_value)
+            .output(nested=True, load_json=self.load_json)
             .first()
             .run(node=node, in_pool=in_pool)
         )
 
-        if updated_values is None:
+        if data_dict is None:
             raise ValueError(
                 "The object doesn't exist in the database any more."
             )
 
-        for key, value in updated_values.items():
-            setattr(instance, key, value)
+        self._update_instance(instance=instance, data_dict=data_dict)
 
         return instance
 

piccolo/query/methods/select.py

@@ -406,6 +406,9 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
     def output(self: Self, *, load_json: bool, as_list: bool) -> SelectJSON:  # type: ignore  # noqa: E501
         ...
 
+    @t.overload
+    def output(self: Self, *, load_json: bool, nested: bool) -> Self: ...
+
     @t.overload
     def output(self: Self, *, nested: bool) -> Self: ...
 

piccolo/table.py

@@ -541,7 +541,9 @@ class Table(metaclass=TableMetaclass):
         )
 
     def refresh(
-        self, columns: t.Optional[t.Sequence[Column]] = None
+        self,
+        columns: t.Optional[t.Sequence[Column]] = None,
+        load_json: bool = False,
     ) -> Refresh:
         """
         Used to fetch the latest data for this instance from the database.
@@ -551,6 +553,10 @@ class Table(metaclass=TableMetaclass):
             If you only want to refresh certain columns, specify them here.
             Otherwise all columns are refreshed.
 
+        :param load_json:
+            Whether to load ``JSON`` / ``JSONB`` columns as objects, instead of
+            just a string.
+
         Example usage::
 
             # Get an instance from the database.
@@ -564,7 +570,7 @@ class Table(metaclass=TableMetaclass):
             instance.refresh().run_sync()
 
         """
-        return Refresh(instance=self, columns=columns)
+        return Refresh(instance=self, columns=columns, load_json=load_json)
 
     @t.overload
     def get_related(

piccolo/testing/test_case.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import typing as t
+from unittest import IsolatedAsyncioTestCase, TestCase
+
+from piccolo.engine import Engine, engine_finder
+from piccolo.table import (
+    Table,
+    create_db_tables,
+    create_db_tables_sync,
+    drop_db_tables,
+    drop_db_tables_sync,
+)
+
+
+class TableTest(TestCase):
+    """
+    Identical to :class:`AsyncTableTest <piccolo.testing.test_case.AsyncTableTest>`,
+    except it only work for sync tests. Only use this if you can't make your
+    tests async (perhaps you're on Python 3.7 where ``IsolatedAsyncioTestCase``
+    isn't available).
+
+    For example::
+
+        class TestBand(TableTest):
+            tables = [Band]
+
+            def test_band(self):
+                ...
+
+    """  # noqa: E501
+
+    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 AsyncTableTest(IsolatedAsyncioTestCase):
+    """
+    Used for tests where we need to create Piccolo tables - they will
+    automatically be created and dropped.
+
+    For example::
+
+        class TestBand(AsyncTableTest):
+            tables = [Band]
+
+            async def test_band(self):
+                ...
+
+    """
+
+    tables: t.List[t.Type[Table]]
+
+    async def asyncSetUp(self) -> None:
+        await create_db_tables(*self.tables)
+
+    async def asyncTearDown(self) -> None:
+        await drop_db_tables(*self.tables)
+
+
+class AsyncTransactionTest(IsolatedAsyncioTestCase):
+    """
+    Wraps each test in a transaction, which is automatically rolled back when
+    the test finishes.
+
+    .. warning::
+        Python 3.11 and above only.
+
+    If your test suite just contains ``AsyncTransactionTest`` tests, then you
+    can setup your database tables once before your test suite runs. Any
+    changes made to your tables by the tests will be rolled back automatically.
+
+    Here's an example::
+
+        from piccolo.testing.test_case import AsyncTransactionTest
+
+
+        class TestBandEndpoint(AsyncTransactionTest):
+
+            async def test_band_response(self):
+                \"\"\"
+                Make sure the endpoint returns a 200.
+                \"\"\"
+                band = Band({Band.name: "Pythonistas"})
+                await band.save()
+
+                # Using an API testing client, like httpx:
+                response = await client.get(f"/bands/{band.id}/")
+                self.assertEqual(response.status_code, 200)
+
+    We add a ``Band`` to the database, but any subsequent tests won't see it,
+    as the changes are rolled back automatically.
+
+    """
+
+    # We use `engine_finder` to find the current `Engine`, but you can
+    # explicity set it here if you prefer:
+    #
+    # class MyTest(AsyncTransactionTest):
+    #     db = DB
+    #
+    #     ...
+    #
+    db: t.Optional[Engine] = None
+
+    async def asyncSetUp(self) -> None:
+        db = self.db or engine_finder()
+        assert db is not None
+        self.transaction = db.transaction()
+        # This is only available in Python 3.11 and above:
+        await self.enterAsyncContext(cm=self.transaction)  # type: ignore
+
+    async def asyncTearDown(self):
+        await super().asyncTearDown()
+        await self.transaction.rollback()

piccolo/utils/encoding.py

@@ -29,5 +29,46 @@ def dump_json(data: t.Any, pretty: bool = False) -> str:
         return json.dumps(data, **params)  # type: ignore
 
 
+class JSONDict(dict):
+    """
+    Once we have parsed a JSON string into a dictionary, we can't distinguish
+    it from other dictionaries.
+
+    Sometimes we might want to - for example::
+
+        >>> await Album.select(
+        ...     Album.all_columns(),
+        ...     Album.recording_studio.all_columns()
+        ... ).output(
+        ...     nested=True,
+        ...     load_json=True
+        ... )
+
+        [{
+            'id': 1,
+            'band': 1,
+            'name': 'Awesome album 1',
+            'recorded_at': {
+                'id': 1,
+                'facilities': {'restaurant': True, 'mixing_desk': True},
+                'name': 'Abbey Road'
+            },
+            'release_date': datetime.date(2021, 1, 1)
+        }]
+
+    Facilities could be mistaken for a table.
+
+    """
+
+    ...
+
+
 def load_json(data: str) -> t.Any:
-    return orjson.loads(data) if ORJSON else json.loads(data)  # type: ignore
+    response = (
+        orjson.loads(data) if ORJSON else json.loads(data)  # type: ignore
+    )
+
+    if isinstance(response, dict):
+        return JSONDict(**response)
+
+    return response

{piccolo-1.14.0.dist-info → piccolo-1.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.14.0
+Version: 1.16.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend

{piccolo-1.14.0.dist-info → piccolo-1.16.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-piccolo/__init__.py,sha256=vQd7XyktulZvg_rtkaOpG-2W02Gb_wFd8aev4i-MHeA,23
+piccolo/__init__.py,sha256=ysxGt_oXPqT-SJ1UbC7NdyUSaoEEi94z0BdzyvNNY2Y,23
 piccolo/custom_types.py,sha256=7HMQAze-5mieNLfbQ5QgbRQgR2abR7ol0qehv2SqROY,604
 piccolo/main.py,sha256=1VsFV67FWTUikPTysp64Fmgd9QBVa_9wcwKfwj2UCEA,5117
 piccolo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/querystring.py,sha256=yZdURtiVSlxkkEVJoFKAmL2OfNxrUr8xfsfuBBB7IuY,9662
 piccolo/schema.py,sha256=qNNy4tG_HqnXR9t3hHMgYXtGxHabwQAhUpc6RKLJ_gE,7960
-piccolo/table.py,sha256=IfXT9rtm1sBN-u_A8-_0gj6fJf3_RGSPtWMJa-FX9jw,49569
+piccolo/table.py,sha256=nS3zuhGNPZ4H9s_E3ieFbrE_u1Tr6TenBVw_nrrtmRQ,49766
 piccolo/table_reflection.py,sha256=jrN1nHerDJ4tU09GtNN3hz7ap-7rXnSUjljFO6LB2H0,7094
 piccolo/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -104,7 +104,7 @@ piccolo/apps/tester/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 piccolo/apps/tester/commands/run.py,sha256=phFxim2ogARAviW-YT11y9F-L5SJxSioAIepUzQeAWU,2431
 piccolo/apps/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/user/piccolo_app.py,sha256=yfw1J9FEnBWdgGdUdNMnqp06Wzm5_s9TO2r5KLchrLM,842
-piccolo/apps/user/tables.py,sha256=ZSXtOC9OANCKC6cq5ZCj3CqRwraibFDwtf1VVIBfmKQ,8954
+piccolo/apps/user/tables.py,sha256=KgPqONdl1SDV-3cGq5aS-za_v_5_TGHQqNFYXF0M3Jw,9082
 piccolo/apps/user/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/user/commands/change_password.py,sha256=F7mlhtTUY7uENSK8vds5oibIDJTz7QBQdrl7EB-lF9Q,649
 piccolo/apps/user/commands/change_permissions.py,sha256=LScsKJUMJqIi54cZ1SgS9Wb356KB0t7smu94FDXLfVk,1463
@@ -146,7 +146,7 @@ piccolo/engine/finder.py,sha256=GjzBNtzRzH79fjtRn7OI3nZiOXE8JfoQWAvHVPrPNx4,507
 piccolo/engine/postgres.py,sha256=DekL3KafCdzSAEQ6_EgOiUB1ERXh2xpePYwI9QvmN-c,18955
 piccolo/engine/sqlite.py,sha256=KwJc3UttBP_8qSREbLJshqEfROF17ENf0Ju9BwI5_so,25236
 piccolo/query/__init__.py,sha256=bcsMV4813rMRAIqGv4DxI4eyO4FmpXkDv9dfTk5pt3A,699
-piccolo/query/base.py,sha256=2eyfgqdzl5bKQBRpmxil_HoXpCEDGGrh84q62ZmfBNk,14680
+piccolo/query/base.py,sha256=iI9Fv3oOw7T4ZWZvRKRwdtClvQtSaAepslH24vwxZVA,14616
 piccolo/query/mixins.py,sha256=EFEFb9It4y1mR6_JXLn139h5M9KgeP750STYy5M4MLs,21951
 piccolo/query/proxy.py,sha256=Yq4jNc7IWJvdeO3u7_7iPyRy2WhVj8KsIUcIYHBIi9Q,1839
 piccolo/query/functions/__init__.py,sha256=pZkzOIh7Sg9HPNOeegOwAS46Oxt31ATlSVmwn-lxCbc,605
@@ -168,16 +168,17 @@ piccolo/query/methods/indexes.py,sha256=J-QUqaBJwpgahskUH0Cu0Mq7zEKcfVAtDsUVIVX-
 piccolo/query/methods/insert.py,sha256=ssLJ_wn08KnOwwr7t-VILyn1P4hrvM63CfPIcAJWT5k,4701
 piccolo/query/methods/objects.py,sha256=iahDUziUtlx7pJ2uBAhdm3hCTmg2AS9C8cal1my5KR0,11705
 piccolo/query/methods/raw.py,sha256=VhYpCB52mZk4zqFTsqK5CHKTDGskUjISXTBV7UjohmA,600
-piccolo/query/methods/refresh.py,sha256=P1Eo_HYU_L7kcGM_cvDDgyLi1boCXY7Pc4tv_eDAzvc,2769
-piccolo/query/methods/select.py,sha256=KDbLRkADM9xNQsoNYN_eNSwapFACQCUNiCvw0B5tmko,21315
+piccolo/query/methods/refresh.py,sha256=wg1zghKfwz-VmqK4uWa4GNMiDtK-skTqow591Hb3ONM,5854
+piccolo/query/methods/select.py,sha256=UH-y2g3Ub7bEowfLObrrhw0W-HepTXWCmuMPhk13roE,21406
 piccolo/query/methods/table_exists.py,sha256=0yb3n6Jd2ovSBWlZ-gl00K4E7Jnbj7J8qAAX5d7hvNk,1259
 piccolo/query/methods/update.py,sha256=LfWqIXEl1aecc0rkVssTFmwyD6wXGhlKcTrUVhtlEsw,3705
 piccolo/testing/__init__.py,sha256=pRFSqRInfx95AakOq54atmvqoB-ue073q2aR8u8zR40,83
 piccolo/testing/model_builder.py,sha256=lVEiEe71xrH8SSjzFc2l0s-VaCXHeg9Bo5oAYOEbLrI,6545
 piccolo/testing/random_builder.py,sha256=0LkGpanQ7P1R82gLIMQyK9cm1LdZkPvxbShTEf3jeH4,2128
+piccolo/testing/test_case.py,sha256=JHQCIAeuO6H2ZbcFHQUhlvUWVFjzKoakDlqVYJvYhtg,3281
 piccolo/utils/__init__.py,sha256=SDFFraauI9Op8dCRkreQv1dwUcab8Mi1eC-n0EwlTy8,36
 piccolo/utils/dictionary.py,sha256=8vRPxgaXadDVhqihP1UxL7nUBgM6Gpe_Eu3xJq7zzGM,1886
-piccolo/utils/encoding.py,sha256=W34oj1F2f8zeirMceHZnAnJL2T8rPoiqXt-DJ-hzRGk,835
+piccolo/utils/encoding.py,sha256=CtSODJOkT3TVHfGlTDXozDsClBCJbGGqluc6_UlJ-7c,1761
 piccolo/utils/lazy_loader.py,sha256=T8GChEqtKWcBegn-6g_BQ7hOg2Xu1bedFh7Z8E7xcOY,1912
 piccolo/utils/list.py,sha256=4hPGiksJWxL226W7gyYBcqVGgMTgVa2jP8zvalc3zw8,1541
 piccolo/utils/naming.py,sha256=d7_mMscguK799RMhxFDifRgn8Ply5wiy2k1KkP22WUs,276
@@ -237,43 +238,43 @@ tests/apps/sql_shell/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 tests/apps/sql_shell/commands/test_run.py,sha256=6p0nqCoG_qNLrKeBuHspmer_SrMwEF-vfp9LbPj2W2E,425
 tests/apps/tester/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/apps/user/test_tables.py,sha256=E9mGAOiDjVtIJYqZzlvPU_JFz6RZzGAVeE0Lk5VjGb4,9523
+tests/apps/user/test_tables.py,sha256=5ImGAWpIKxlqweGeJRMiVOHaBJxRwSzsp3GZ7x6lzCo,9807
 tests/apps/user/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/user/commands/test_change_password.py,sha256=IEIlnny68jt4UFOaUOwHk9C7WHED51wYoSNX-YIi7rU,1051
 tests/apps/user/commands/test_change_permissions.py,sha256=uVKEiT1EKot3VA2TDETdQ1hsWL-83rLQrJl4jIxPgqo,2108
 tests/apps/user/commands/test_create.py,sha256=iJ3Tti62rHwvdcTwNXrc5JPam6vR1qxKRdMN456vm3o,2250
 tests/apps/user/commands/test_list.py,sha256=ipPfGdW6fH7q-Jc7JcYUvlioGmH9GQU0WImZGC2m-XQ,2840
 tests/columns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/columns/test_array.py,sha256=QixxML6vRq-PUliqbZSKd_LE5T4fEj5nq5e1NpOhng0,11590
+tests/columns/test_array.py,sha256=niIkAPRQp49bkpbctaMgpcDai4TMAbM9qkrTGhPFsQY,11627
 tests/columns/test_base.py,sha256=CTqCNcrqAJTjLXe3MCZgTczrmB3jcVRcOpU4FilpLoQ,3918
-tests/columns/test_bigint.py,sha256=KqIw6UP3vGs3cyL1I1An8RfXMmjZvfSIuKYhgkqX5zI,1021
-tests/columns/test_boolean.py,sha256=dFqyUnzXU8JSflI511Vt3Gxk62lpIVgH37vnDEz0E2M,1611
-tests/columns/test_bytea.py,sha256=-XCXTKboPSfowhU7nceRnkhVCJ60Kus52b3f67xAlAo,1367
-tests/columns/test_choices.py,sha256=xDWgcguCH4pu8w3JpIcSyurpghPsbc4OQmzjup2iTIw,4029
+tests/columns/test_bigint.py,sha256=KzfiItv0cYQZR35V_TL485AitDnOZQfTzC3C2YCLSn4,1058
+tests/columns/test_boolean.py,sha256=qm0tg-gKcoYHNV1WVFxgbG4CsngxAJlg-hsGeTNklN8,1626
+tests/columns/test_bytea.py,sha256=doN8S1eFVU4ntSXIg4IgMSZcbvqW1WJ-AEm3OjKLGkI,1382
+tests/columns/test_choices.py,sha256=q8TLe7nvGERXyGO_XEryEBR-DuWwFY1jPpscsrXjdXo,4066
 tests/columns/test_combination.py,sha256=BuBwR7k5X1EkOWraZpjqU6gvtb6ow_k-7N1KQBiW2RA,1681
-tests/columns/test_date.py,sha256=WnwtCS81mYsDpwDrMnZRDjHA7ag-bxMPundRxtTlv1A,1015
+tests/columns/test_date.py,sha256=QLC6kJMQwM-1mbUP4ksJVM7P8WwjzGZyynH3rHHdSew,1030
 tests/columns/test_db_column_name.py,sha256=v0QFOQp_atqzMB1n40simVwHeBDi5nyN1N2bSPX5k6w,7670
 tests/columns/test_defaults.py,sha256=rwlU1fXt3cCl7C51eLlZXqgWkE-K5W0pHvTrwkAKyCo,2896
-tests/columns/test_double_precision.py,sha256=Nx1vgmQqwn1PgBC6KcPO9yHKe9v8lCQXrEA1GcUJIn4,529
+tests/columns/test_double_precision.py,sha256=7rhcSfDkb2fBh_zEG4UGwD_GW1sy6U9-8NooHuCS09Q,544
 tests/columns/test_get_sql_value.py,sha256=mKgsInN374jzV99y9mg_ZiG-AvnJgz36SZi89xL7RZM,1768
-tests/columns/test_interval.py,sha256=R3fyC7IX35neiu64XR7KX58ylpPzeU2zSEbaKdbW4I4,2765
-tests/columns/test_json.py,sha256=nbNXo0CISU8w3CjIF7nxBmRfEdenGFmc0o9YfhMvpKg,3467
-tests/columns/test_jsonb.py,sha256=Np3FZf3AspTGRWCCMrTYEsw6uTJPI8u3SZkOvH5ERRg,6690
-tests/columns/test_numeric.py,sha256=WrilQrWc-_g8DGLUvmllSBL01xqYqDORt3ypplnRizA,736
-tests/columns/test_primary_key.py,sha256=hXnTF-kFgrFNjawvJstmR3YQCM59qJ4NWkMD9vRY8FI,4871
-tests/columns/test_readable.py,sha256=OFK2n_k-eqRLdjEg1X2aOFPNwhtGDPNBli4DAh3i6vw,743
-tests/columns/test_real.py,sha256=bSjACkbnJzrN9dEWVb0UdWqSDfxdGz5HMWc8PUsJUl4,496
-tests/columns/test_reference.py,sha256=d7vm7AHinISA-HjlA8zyPCRaAGPtnc5NOXUvK4SeQFg,2329
-tests/columns/test_reserved_column_names.py,sha256=BpqN49n_AaiPjaaJ43hLhFXQHb8NV6ig8nvgKvN0Smc,1404
-tests/columns/test_smallint.py,sha256=t-LNX7XXy-k5_lhGXwELyC0LB9Iq4WrBVQdvEYf5EaQ,984
-tests/columns/test_time.py,sha256=qyG4jjSO_B2DfkjQo3nIff2T201c75EI7M6CYspK5QM,1560
-tests/columns/test_timestamp.py,sha256=lkb1pQW41kQ_c7zLjPfls7EgnIMnvG9AK3ePb5izJU0,1671
-tests/columns/test_timestamptz.py,sha256=Py27sx45-xQElhuLVxNtZjBxz3t6VJUbyUGW3H4W7eU,2615
-tests/columns/test_uuid.py,sha256=ifCyIrO6usYO33WM0FgwuPPhYzs4zVKD3MViIT61J7c,357
-tests/columns/test_varchar.py,sha256=Oyt8t7msCfIiZdU9B23zjlV6atFv4sX3iMSDJc565Oc,681
+tests/columns/test_interval.py,sha256=2M18pfoGxLLosEvwTmuC4zQkM6jWwU0Nv2fqViW3xOs,2780
+tests/columns/test_json.py,sha256=_cziJvw2uT8e_4u9lKhmU56lgQeE7bEqCXYf6AzfChA,3482
+tests/columns/test_jsonb.py,sha256=eJQoxpyuQ4yrX-GMJhRkZntyd4tX6M6RhAxYn2-ISII,6727
+tests/columns/test_numeric.py,sha256=AkTvdvjSsfRsMM79tx4AskUpsTizGBLMY_tC2OII9U4,751
+tests/columns/test_primary_key.py,sha256=foNG9eTQUJ5yiEVQ7faIEMycW_VuZ7vgzknYXaZ-QXM,4886
+tests/columns/test_readable.py,sha256=xKVfJuxZcfyncNVKXNryl2WFREX655jwD9DxiLArQiU,758
+tests/columns/test_real.py,sha256=O_lwiNU4RIHSMY33QuWT0WTvNzV-2ATYYtdbI46E42c,511
+tests/columns/test_reference.py,sha256=-pDKZl0kjRHz17U-_bldHD4rpg7Ga27lIzXMKOazbWA,2344
+tests/columns/test_reserved_column_names.py,sha256=S39hq9Ex8QXlbnfjlPLtzwaxICTkXe43Nr2um1S37jI,1419
+tests/columns/test_smallint.py,sha256=5tm8BpyUmun7uIROaKBgSb27dGu-waqtQAAvpvS66ek,1024
+tests/columns/test_time.py,sha256=eQ4S-FMhULvkp6OwQaMbheBgQUVFCJ9JGMsKFpsM_vg,1597
+tests/columns/test_timestamp.py,sha256=vD7F0J_8rZkX_PngfjaMcs5Ugq3lM8GUJXzU7cQLNZM,1686
+tests/columns/test_timestamptz.py,sha256=P7zblPC6Fjjdk6iOhVUGIKnFFzbbUPVNSY98qbuqE7U,2630
+tests/columns/test_uuid.py,sha256=taFYNvRZjQztMPbTQHYtwQutvcLnKPt6_aUxsf2o04Q,372
+tests/columns/test_varchar.py,sha256=fbwBdimHoGaylfrqkFIgQ5m2q80umSoUNHIwofM6j_c,721
 tests/columns/m2m/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/columns/m2m/base.py,sha256=uH92ECQuY5AjpQXPySwrlruZPZzB4LH2V2FUSXmHRLQ,14563
-tests/columns/m2m/test_m2m.py,sha256=LtNsHQ8xAzBFLiZVZhWEB56zu25FnaWtzJ62FZH3heI,12647
+tests/columns/m2m/test_m2m.py,sha256=0ObmIHUJF6CZoNBznc5xXVr5_BbGBqOmWwtpg8IcPt4,13055
 tests/columns/m2m/test_m2m_schema.py,sha256=oxu7eAjFFpDjnq9Eq-5OTNmlnsEIMFWx18OItfpVs-s,339
 tests/conf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conf/example.py,sha256=K8sTttLpEac8rQlOLDY500IGkHj3P3NoyFbCMnT1EqY,347
@@ -303,10 +304,10 @@ tests/query/test_gather.py,sha256=okWANrBoh0Ut1RomWoffiWNpFqiITF6qti-Aa3uYtRk,73
 tests/query/test_querystring.py,sha256=QrqyjwUlFlf5LrsJ7DgjCruq811I0UvrDFPud6rfZNI,5019
 tests/query/test_slots.py,sha256=I9ZjAYqAJNSFAWg9UyAqy7bm-Z52KiyQ2C_yHk2qqqI,1010
 tests/query/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/query/functions/base.py,sha256=sCIolQlvOMlnrLJJBAfJV-Tg8dCzkGnCs83JqRQpKkk,500
-tests/query/functions/test_datetime.py,sha256=247Vpbyuq0s-SU-883t6W5ghF8xiz44LzdHd2nJ0mZ4,2963
+tests/query/functions/base.py,sha256=XbLpoSp05PPbGl7aSPW29GGrDKL2B-KsCxji7GhhPNI,515
+tests/query/functions/test_datetime.py,sha256=X_5LR9XouPiQL-GQWen-NtokunCBHDuZ5gk9elNJNd4,3000
 tests/query/functions/test_functions.py,sha256=510fqRrOrAZ9NyFoZtlF6lIdiiLriWhZ7vvveWZ8rsc,1984
-tests/query/functions/test_math.py,sha256=nrHrThxurZIvbqlN4mjfxtKqLdBxOrWoeIZ_QCRJuTs,1271
+tests/query/functions/test_math.py,sha256=wHaGQdEKISI8WeG9zGVNv62IrWSp4mMH3dPxVxoHy3s,1286
 tests/query/functions/test_string.py,sha256=RMojkBUzw1Ikrb3nTa7VjJ4FsKfrjpuHUyxQDA-F5Cs,1800
 tests/query/functions/test_type_conversion.py,sha256=WeYR9UfJnbidle07-akQ1g9hFCd93qT8xUhDF3c58n4,3235
 tests/query/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -336,7 +337,7 @@ tests/table/test_objects.py,sha256=bir86ks-Ngy8x9Eu9bekOrh6twBYdEkIgTdbBWY6x9s,8
 tests/table/test_output.py,sha256=ZnpPbgVp79JcB6E_ooWQxOpOlhkwNUlMxC-1LSIEc2Y,4304
 tests/table/test_raw.py,sha256=9PTvYngQi41nYd5lKzkJdTqsEcwrdOXcvZjq-W26CwQ,1683
 tests/table/test_ref.py,sha256=eYNRnYHzNMXuMbV3B1ca5EidpIg4500q6hr1ccuVaso,269
-tests/table/test_refresh.py,sha256=ZXGLGHeMZcWnhZPB4eCasv1RkojPt6nUbxaE7WlyJbo,2804
+tests/table/test_refresh.py,sha256=-BaLS6fZiR2RtQaFa7D9WGBjrbrss1-tt5xz1NE_m8E,9250
 tests/table/test_repr.py,sha256=uahz3_GffGQrf2mDE-4-Pu4AmSLBAyso6-9rbohCl58,446
 tests/table/test_select.py,sha256=jgeiahIlNFVijxYb3a54g1sJWVfH3llaYrsTBmdicrs,40390
 tests/table/test_str.py,sha256=eztWNULcjARR1fr9X5n4tojhDNgDfatVyNHwuYrzHAo,1731
@@ -353,6 +354,7 @@ tests/table/instance/test_to_dict.py,sha256=gkiYkmcI5qcy5E-ERWWmO-Q8uyVSFfcpJ8d5
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_model_builder.py,sha256=bgs-cOYXtnrfgWydU2sZvs2N_Lt2T7La7AAMfIsOev4,6206
 tests/testing/test_random_builder.py,sha256=Upz9P1bhICVo0udI6Li-5eEdrXKbv8rMMLe0uK6pqB0,1694
+tests/testing/test_test_case.py,sha256=qyDWYT44EZNyuWhaZXgSOpX48RaRw5u4FgNi87FYt2k,1691
 tests/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/utils/test_dictionary.py,sha256=GdWujlYQy6t09p2aQHPibkkPNbBYwkFwomKrVnztJTo,1480
 tests/utils/test_encoding.py,sha256=x1CHLm0rRheZaXz7at3SgkgcrZOmtMB-NtvJC77wQKE,326
@@ -365,9 +367,9 @@ tests/utils/test_sql_values.py,sha256=vzxRmy16FfLZPH-sAQexBvsF9MXB8n4smr14qoEOS5
 tests/utils/test_sync.py,sha256=9ytVo56y2vPQePvTeIi9lHIouEhWJbodl1TmzkGFrSo,799
 tests/utils/test_table_reflection.py,sha256=SIzuat-IpcVj1GCFyOWKShI8YkhdOPPFH7qVrvfyPNE,3794
 tests/utils/test_warnings.py,sha256=NvSC_cvJ6uZcwAGf1m-hLzETXCqprXELL8zg3TNLVMw,269
-piccolo-1.14.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
-piccolo-1.14.0.dist-info/METADATA,sha256=4rDBz-Wbqp-MdHwcZd3LaxJToiNqW5hVFQkCOkCD8LU,5178
-piccolo-1.14.0.dist-info/WHEEL,sha256=rWxmBtp7hEUqVLOnTaDOPpR-cZpCDkzhhcBce-Zyd5k,91
-piccolo-1.14.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.14.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.14.0.dist-info/RECORD,,
+piccolo-1.16.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-1.16.0.dist-info/METADATA,sha256=qsjW9UTKSwkT62sKfdGnTFyllEcn8bE1yKIj54iu4Ek,5178
+piccolo-1.16.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+piccolo-1.16.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
+piccolo-1.16.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-1.16.0.dist-info/RECORD,,

{piccolo-1.14.0.dist-info → piccolo-1.16.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.0.4)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/apps/user/test_tables.py

@@ -109,7 +109,7 @@ class TestLogin(TestCase):
             BaseUser.update_password_sync(username, malicious_password)
         self.assertEqual(
             manager.exception.__str__(),
-            "The password is too long.",
+            f"The password is too long. (max {BaseUser._max_password_length})",
         )
 
         # Test short passwords
@@ -118,7 +118,10 @@ class TestLogin(TestCase):
             BaseUser.update_password_sync(username, short_password)
         self.assertEqual(
             manager.exception.__str__(),
-            "The password is too short.",
+            (
+                "The password is too short. (min "
+                f"{BaseUser._min_password_length})"
+            ),
         )
 
         # Test no password
@@ -205,7 +208,11 @@ class TestCreateUser(TestCase):
             BaseUser.create_user_sync(username="bob", password="abc")
 
         self.assertEqual(
-            manager.exception.__str__(), "The password is too short."
+            manager.exception.__str__(),
+            (
+                "The password is too short. (min "
+                f"{BaseUser._min_password_length})"
+            ),
         )
 
     def test_long_password_error(self):
@@ -216,7 +223,8 @@ class TestCreateUser(TestCase):
             )
 
         self.assertEqual(
-            manager.exception.__str__(), "The password is too long."
+            manager.exception.__str__(),
+            f"The password is too long. (max {BaseUser._max_password_length})",
         )
 
     def test_no_username_error(self):

tests/columns/m2m/test_m2m.py

@@ -4,6 +4,7 @@ import decimal
 import uuid
 from unittest import TestCase
 
+from piccolo.utils.encoding import JSONDict
 from tests.base import engines_skip
 
 try:
@@ -376,6 +377,9 @@ class TestM2MComplexSchema(TestCase):
 
             if isinstance(column, UUID):
                 self.assertIn(type(returned_value), (uuid.UUID, asyncpgUUID))
+            elif isinstance(column, (JSON, JSONB)):
+                self.assertEqual(type(returned_value), JSONDict)
+                self.assertEqual(original_value, returned_value)
             else:
                 self.assertEqual(
                     type(original_value),
@@ -401,6 +405,9 @@ class TestM2MComplexSchema(TestCase):
             if isinstance(column, UUID):
                 self.assertIn(type(returned_value), (uuid.UUID, asyncpgUUID))
                 self.assertEqual(str(original_value), str(returned_value))
+            elif isinstance(column, (JSON, JSONB)):
+                self.assertEqual(type(returned_value), JSONDict)
+                self.assertEqual(original_value, returned_value)
             else:
                 self.assertEqual(
                     type(original_value),

tests/columns/test_array.py

@@ -14,7 +14,8 @@ from piccolo.columns.column_types import (
 )
 from piccolo.querystring import QueryString
 from piccolo.table import Table
-from tests.base import TableTest, engines_only, engines_skip, sqlite_only
+from piccolo.testing.test_case import TableTest
+from tests.base import engines_only, engines_skip, sqlite_only
 
 
 class MyTable(Table):

tests/columns/test_bigint.py

@@ -2,7 +2,8 @@ import os
 
 from piccolo.columns.column_types import BigInt
 from piccolo.table import Table
-from tests.base import TableTest, engines_only
+from piccolo.testing.test_case import TableTest
+from tests.base import engines_only
 
 
 class MyTable(Table):

tests/columns/test_boolean.py

@@ -2,7 +2,7 @@ import typing as t
 
 from piccolo.columns.column_types import Boolean
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_bytea.py

@@ -1,6 +1,6 @@
 from piccolo.columns.column_types import Bytea
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_choices.py

@@ -2,7 +2,8 @@ import enum
 
 from piccolo.columns.column_types import Array, Varchar
 from piccolo.table import Table
-from tests.base import TableTest, engines_only
+from piccolo.testing.test_case import TableTest
+from tests.base import engines_only
 from tests.example_apps.music.tables import Shirt
 
 

tests/columns/test_date.py

@@ -3,7 +3,7 @@ import datetime
 from piccolo.columns.column_types import Date
 from piccolo.columns.defaults.date import DateNow
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_double_precision.py

@@ -1,6 +1,6 @@
 from piccolo.columns.column_types import DoublePrecision
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_interval.py

@@ -3,7 +3,7 @@ import datetime
 from piccolo.columns.column_types import Interval
 from piccolo.columns.defaults.interval import IntervalCustom
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_json.py

@@ -1,6 +1,6 @@
 from piccolo.columns.column_types import JSON
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_jsonb.py

@@ -1,6 +1,7 @@
 from piccolo.columns.column_types import JSONB, ForeignKey, Varchar
 from piccolo.table import Table
-from tests.base import TableTest, engines_only, engines_skip
+from piccolo.testing.test_case import TableTest
+from tests.base import engines_only, engines_skip
 
 
 class RecordingStudio(Table):

tests/columns/test_numeric.py

@@ -2,7 +2,7 @@ from decimal import Decimal
 
 from piccolo.columns.column_types import Numeric
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_primary_key.py

@@ -8,7 +8,7 @@ from piccolo.columns.column_types import (
     Varchar,
 )
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTableDefaultPrimaryKey(Table):

tests/columns/test_readable.py

@@ -1,7 +1,7 @@
 from piccolo import columns
 from piccolo.columns.readable import Readable
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_real.py

@@ -1,6 +1,6 @@
 from piccolo.columns.column_types import Real
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_reference.py

@@ -8,7 +8,7 @@ from unittest import TestCase
 from piccolo.columns import ForeignKey, Varchar
 from piccolo.columns.reference import LazyTableReference
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class Band(Table):

tests/columns/test_reserved_column_names.py

@@ -1,6 +1,6 @@
 from piccolo.columns.column_types import Integer, Varchar
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class Concert(Table):

tests/columns/test_smallint.py

@@ -2,8 +2,8 @@ import os
 
 from piccolo.columns.column_types import SmallInt
 from piccolo.table import Table
-
-from ..base import TableTest, engines_only
+from piccolo.testing.test_case import TableTest
+from tests.base import engines_only
 
 
 class MyTable(Table):

tests/columns/test_time.py

@@ -4,7 +4,8 @@ from functools import partial
 from piccolo.columns.column_types import Time
 from piccolo.columns.defaults.time import TimeNow
 from piccolo.table import Table
-from tests.base import TableTest, engines_skip
+from piccolo.testing.test_case import TableTest
+from tests.base import engines_skip
 
 
 class MyTable(Table):

tests/columns/test_timestamp.py

@@ -3,7 +3,7 @@ import datetime
 from piccolo.columns.column_types import Timestamp
 from piccolo.columns.defaults.timestamp import TimestampNow
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_timestamptz.py

@@ -9,7 +9,7 @@ from piccolo.columns.defaults.timestamptz import (
     TimestamptzOffset,
 )
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_uuid.py

@@ -2,7 +2,7 @@ import uuid
 
 from piccolo.columns.column_types import UUID
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class MyTable(Table):

tests/columns/test_varchar.py

@@ -1,7 +1,7 @@
 from piccolo.columns.column_types import Varchar
 from piccolo.table import Table
-
-from ..base import TableTest, engines_only
+from piccolo.testing.test_case import TableTest
+from tests.base import engines_only
 
 
 class MyTable(Table):

tests/query/functions/base.py

@@ -1,4 +1,4 @@
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 from tests.example_apps.music.tables import Band, Manager
 
 

tests/query/functions/test_datetime.py

@@ -12,7 +12,8 @@ from piccolo.query.functions.datetime import (
     Year,
 )
 from piccolo.table import Table
-from tests.base import TableTest, engines_only, sqlite_only
+from piccolo.testing.test_case import TableTest
+from tests.base import engines_only, sqlite_only
 
 
 class Concert(Table):

tests/query/functions/test_math.py

@@ -3,7 +3,7 @@ import decimal
 from piccolo.columns import Numeric
 from piccolo.query.functions.math import Abs, Ceil, Floor, Round
 from piccolo.table import Table
-from tests.base import TableTest
+from piccolo.testing.test_case import TableTest
 
 
 class Ticket(Table):

tests/table/test_refresh.py

@@ -1,5 +1,14 @@
+import typing as t
+
+from piccolo.testing.test_case import TableTest
 from tests.base import DBTestCase
-from tests.example_apps.music.tables import Band
+from tests.example_apps.music.tables import (
+    Band,
+    Concert,
+    Manager,
+    RecordingStudio,
+    Venue,
+)
 
 
 class TestRefresh(DBTestCase):
@@ -24,9 +33,55 @@ class TestRefresh(DBTestCase):
         # Refresh `band`, and make sure it has the correct data.
         band.refresh().run_sync()
 
-        self.assertTrue(band.name == "Pythonistas!!!")
-        self.assertTrue(band.popularity == 8000)
-        self.assertTrue(band.id == initial_data["id"])
+        self.assertEqual(band.name, "Pythonistas!!!")
+        self.assertEqual(band.popularity, 8000)
+        self.assertEqual(band.id, initial_data["id"])
+
+    def test_refresh_with_prefetch(self) -> None:
+        """
+        Make sure ``refresh`` works, when the object used prefetch to get
+        nested objets (the nested objects should be updated too).
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Modify the data in the database.
+        Manager.update({Manager.name: "Guido!!!"}).where(
+            Manager.name == "Guido"
+        ).run_sync()
+
+        # Refresh `band`, and make sure it has the correct data.
+        band.refresh().run_sync()
+
+        self.assertEqual(band.manager.name, "Guido!!!")
+
+    def test_refresh_with_prefetch_multiple_layers_deep(self) -> None:
+        """
+        Make sure ``refresh`` works, when the object used prefetch to get
+        nested objets (the nested objects should be updated too).
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Modify the data in the database.
+        Manager.update({Manager.name: "Guido!!!"}).where(
+            Manager.name == "Guido"
+        ).run_sync()
+
+        # Refresh `band`, and make sure it has the correct data.
+        band.refresh().run_sync()
+
+        self.assertEqual(band.manager.name, "Guido!!!")
 
     def test_columns(self) -> None:
         """
@@ -50,9 +105,9 @@ class TestRefresh(DBTestCase):
         )
         query.run_sync()
 
-        self.assertTrue(band.name == "Pythonistas!!!")
-        self.assertTrue(band.popularity == initial_data["popularity"])
-        self.assertTrue(band.id == initial_data["id"])
+        self.assertEqual(band.name, "Pythonistas!!!")
+        self.assertEqual(band.popularity, initial_data["popularity"])
+        self.assertEqual(band.id, initial_data["id"])
 
     def test_error_when_not_in_db(self) -> None:
         """
@@ -85,3 +140,159 @@ class TestRefresh(DBTestCase):
             "The instance's primary key value isn't defined.",
             str(manager.exception),
         )
+
+
+class TestRefreshWithPrefetch(TableTest):
+
+    tables = [Manager, Band, Concert, Venue]
+
+    def setUp(self):
+        super().setUp()
+
+        self.manager = Manager({Manager.name: "Guido"})
+        self.manager.save().run_sync()
+
+        self.band = Band(
+            {Band.name: "Pythonistas", Band.manager: self.manager}
+        )
+        self.band.save().run_sync()
+
+        self.concert = Concert({Concert.band_1: self.band})
+        self.concert.save().run_sync()
+
+    def test_single_layer(self) -> None:
+        """
+        Make sure ``refresh`` works, when the object used prefetch to get
+        nested objects (the nested objects should be updated too).
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Modify the data in the database.
+        self.manager.name = "Guido!!!"
+        self.manager.save().run_sync()
+
+        # Refresh `band`, and make sure it has the correct data.
+        band.refresh().run_sync()
+        self.assertEqual(band.manager.name, "Guido!!!")
+
+    def test_multiple_layers(self) -> None:
+        """
+        Make sure ``refresh`` works when ``prefetch`` was used to fetch objects
+        multiple layers deep.
+        """
+        concert = (
+            Concert.objects(Concert.band_1._.manager)
+            .where(Concert.band_1._.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert concert is not None
+
+        # Modify the data in the database.
+        self.manager.name = "Guido!!!"
+        self.manager.save().run_sync()
+
+        concert.refresh().run_sync()
+        self.assertEqual(concert.band_1.manager.name, "Guido!!!")
+
+    def test_updated_foreign_key(self) -> None:
+        """
+        If a foreign key now references a different row, make sure this
+        is refreshed correctly.
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Assign a different manager to the band
+        new_manager = Manager({Manager.name: "New Manager"})
+        new_manager.save().run_sync()
+        Band.update({Band.manager: new_manager.id}, force=True).run_sync()
+
+        # Refresh `band`, and make sure it references the new manager.
+        band.refresh().run_sync()
+        self.assertEqual(band.manager.id, new_manager.id)
+        self.assertEqual(band.manager.name, "New Manager")
+
+    def test_foreign_key_set_to_null(self):
+        """
+        Make sure that if the foreign key was set to null, that ``refresh``
+        sets the nested object to ``None``.
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Remove the manager from band
+        Band.update({Band.manager: None}, force=True).run_sync()
+
+        # Refresh `band`, and make sure the foreign key value is now `None`,
+        # instead of a nested object.
+        band.refresh().run_sync()
+        self.assertIsNone(band.manager)
+
+    def test_exception(self) -> None:
+        """
+        We don't currently let the user refresh specific fields from nested
+        objects - an exception should be raised.
+        """
+        with self.assertRaises(ValueError):
+            self.concert.refresh(columns=[Concert.band_1._.manager]).run_sync()
+
+        # Shouldn't raise an exception:
+        self.concert.refresh(columns=[Concert.band_1]).run_sync()
+
+
+class TestRefreshWithLoadJSON(TableTest):
+
+    tables = [RecordingStudio]
+
+    def setUp(self):
+        super().setUp()
+
+        self.recording_studio = RecordingStudio(
+            {RecordingStudio.facilities: {"piano": True}}
+        )
+        self.recording_studio.save().run_sync()
+
+    def test_load_json(self):
+        """
+        Make sure we can refresh an object, and load the JSON as a Python
+        object.
+        """
+        RecordingStudio.update(
+            {RecordingStudio.facilities: {"electric piano": True}},
+            force=True,
+        ).run_sync()
+
+        # Refresh without load_json:
+        self.recording_studio.refresh().run_sync()
+
+        self.assertEqual(
+            # Remove the white space, because some versions of Python add
+            # whitespace around JSON, and some don't.
+            self.recording_studio.facilities.replace(" ", ""),
+            '{"electricpiano":true}',
+        )
+
+        # Refresh with load_json:
+        self.recording_studio.refresh(load_json=True).run_sync()
+
+        self.assertDictEqual(
+            t.cast(dict, self.recording_studio.facilities),
+            {"electric piano": True},
+        )

tests/testing/test_test_case.py

@@ -0,0 +1,65 @@
+import sys
+
+import pytest
+
+from piccolo.engine import engine_finder
+from piccolo.testing.test_case import (
+    AsyncTableTest,
+    AsyncTransactionTest,
+    TableTest,
+)
+from tests.example_apps.music.tables import Band, Manager
+
+
+class TestTableTest(TableTest):
+    """
+    Make sure the tables are created automatically.
+    """
+
+    tables = [Band, Manager]
+
+    async def test_tables_created(self):
+        self.assertTrue(Band.table_exists().run_sync())
+        self.assertTrue(Manager.table_exists().run_sync())
+
+
+class TestAsyncTableTest(AsyncTableTest):
+    """
+    Make sure the tables are created automatically in async tests.
+    """
+
+    tables = [Band, Manager]
+
+    async def test_tables_created(self):
+        self.assertTrue(await Band.table_exists())
+        self.assertTrue(await Manager.table_exists())
+
+
+@pytest.mark.skipif(sys.version_info <= (3, 11), reason="Python 3.11 required")
+class TestAsyncTransaction(AsyncTransactionTest):
+    """
+    Make sure that the test exists within a transaction.
+    """
+
+    async def test_transaction_exists(self):
+        db = engine_finder()
+        assert db is not None
+        self.assertTrue(db.transaction_exists())
+
+
+@pytest.mark.skipif(sys.version_info <= (3, 11), reason="Python 3.11 required")
+class TestAsyncTransactionRolledBack(AsyncTransactionTest):
+    """
+    Make sure that the changes get rolled back automatically.
+    """
+
+    async def asyncTearDown(self):
+        await super().asyncTearDown()
+
+        assert Manager.table_exists().run_sync() is False
+
+    async def test_insert_data(self):
+        await Manager.create_table()
+
+        manager = Manager({Manager.name: "Guido"})
+        await manager.save()