django-postgres-denormalize 1.0.0__tar.gz → 1.0.1__tar.gz

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/CHANGELOG.rst

@@ -1,3 +1,8 @@
+v1.0.1 (2026-10-19)
+-------------------
+Altered:
+ * Fixed system checks incorrectly firing on excluded models.
+
 v1.0.0 (2026-10-18)
 -------------------
 Added:

{django_postgres_denormalize-1.0.0/src/django_postgres_denormalize.egg-info → django_postgres_denormalize-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-postgres-denormalize
-Version: 1.0.0
+Version: 1.0.1
 Summary: Trigger-maintained copies of ancestor columns for Django on PostgreSQL.
 Author-email: DjanQuiltDB Project <djanquiltdb@portal42.net>
 License-Expression: BSD-3-Clause

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/docs/guides/drift.rst

@@ -76,10 +76,9 @@ Before you run it on a large table, note the following:
   leaf, gets a history row.
 * **Unique constraints.** When a copy is part of a unique constraint, the correction can make two rows collide, and the
   PostgreSQL error names only the first collision (see :ref:`collisions <migration_collisions>`).
-* **Excluded models.** The call skips a model that ``EXCLUDE_MODELS`` lists, such as an audit table, because its rows
-  record past values. ``also_fill`` writes the copies of such a model, but it overwrites every row with the current
-  value. It is meant for filling a new column, not for repairs (see :ref:`copies on excluded models
-  <excluded_model_copies>`).
+* **Excluded models.** The call skips an excluded model, such as an audit table, because its rows record past values.
+  ``also_fill`` writes the copies of such a model, but it overwrites every row with the current value. It is meant for
+  filling a new column, not for repairs (see :ref:`copies on excluded models <excluded_model_copies>`).
 
 
 In a migration

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/docs/guides/exclusions.rst

@@ -12,9 +12,14 @@ This package skips an excluded model entirely:
 * it gets no triggers, so nothing ever rewrites its copies;
 * :func:`~postgres_denormalize.fields.get_denormalized_fields` returns nothing for it, so the drift filter and the
   backfill skip it (unless ``also_fill`` names it explicitly, see :doc:`/guides/migrations`);
-* the project-wide system checks do not look at it.
-
-Its denormalized columns still get their type, so the table is created and migrated like any other.
+* the project-wide system checks do not look at it;
+* its fields skip the field checks that compare the declaration with the lookup path, such as ``W009`` for an
+  ``on_delete`` rule that differs from the path. ``EXCLUDE_MODELS_SILENCED_CHECKS`` chooses which ones (see
+  :doc:`/reference/settings`).
+
+Its denormalized columns still get their type, so the table is created and migrated like any other. The type, and the
+target of a foreign key copy, come from the lookup path, so the path must resolve on the excluded model too. The field
+checks that report a path that does not resolve therefore still run by default.
 
 Without either key, no model is excluded. An ``EXCLUDE_MODELS`` entry that names no installed model is reported
 (``E401``, see :doc:`/reference/checks`).

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/docs/integrations/djanquiltdb.rst

@@ -7,9 +7,9 @@ Django project across PostgreSQL schemas and nodes. Both libraries work on their
 does not need DjanQuiltDB, or any familiarity with it.
 
 In a sharded project, the copies have to be checked and corrected in each shard, and a lookup path has to stay inside
-the shard. DjanQuiltDB's ``postgres-denormalize`` extra installs a plugin with helpers that find and correct out-of-date
-copies in one shard or in every shard. DjanQuiltDB's own system checks report a lookup path whose cascade trigger would
-write across shards::
+the shard. DjanQuiltDB's own system checks report a lookup path whose cascade trigger or fill trigger would write across
+shards. DjanQuiltDB's ``postgres-denormalize`` extra installs a plugin with helpers that find and correct out-of-date
+copies in one shard or in every shard::
 
     pip install djanquiltdb[postgres-denormalize]
 

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/docs/reference/checks.rst

@@ -36,6 +36,12 @@ Each denormalized field checks its own declaration:
                                  See :doc:`/guides/fields`.
 ================================ =======================================================================================
 
+A field on an excluded model (see :doc:`/guides/exclusions`) skips the checks that ``EXCLUDE_MODELS_SILENCED_CHECKS``
+lists. By default, these are ``E002``, ``E003``, ``E004`` and ``W009``, which compare the declaration with the lookup
+path. No trigger writes the column of an excluded model, so they say nothing useful there. The field still infers its
+target, column type and ``on_delete`` rule from the path, so the other checks still run. See
+:doc:`/reference/settings`.
+
 
 Project checks
 --------------

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/docs/reference/settings.rst

@@ -22,7 +22,8 @@ EXCLUDE_MODELS
 --------------
 
 A list of model labels, ``'app_label.ModelName'``, matched case-insensitively. This package skips the models that it
-lists: they get no triggers, no drift filter, no backfill and no project checks. By default it lists nothing. An entry
+lists: they get no triggers, no drift filter, no backfill and no project checks, and their fields skip the checks that
+``EXCLUDE_MODELS_SILENCED_CHECKS`` lists. By default it lists nothing. An entry
 that is not a string with exactly one dot raises ``ImproperlyConfigured``, and an entry that names no installed model is
 reported by ``postgres_denormalize.E401``. See :doc:`/guides/exclusions`.
 
@@ -36,6 +37,36 @@ Use it when the models to exclude follow a rule, and not a list. A model is excl
 callable, raise ``ImproperlyConfigured``. See :doc:`/guides/exclusions` for what the callback is called with.
 
 
+EXCLUDE_MODELS_SILENCED_CHECKS
+------------------------------
+
+A list of the field checks (see :doc:`/reference/checks`) that a field on an excluded model skips, as check ids such as
+``'postgres_denormalize.W009'``, the way ``SILENCED_SYSTEM_CHECKS`` names them. It does not change the checks of a
+field on any other model. The default skips the checks that compare the declaration with the lookup path:
+
+.. code-block:: python
+
+    # settings.py
+    POSTGRES_DENORMALIZE = {
+        'EXCLUDE_MODELS_SILENCED_CHECKS': [
+            'postgres_denormalize.E002',
+            'postgres_denormalize.E003',
+            'postgres_denormalize.E004',
+            'postgres_denormalize.W009',
+        ],
+    }
+
+No trigger writes the column of an excluded model, so these checks say nothing useful there. An audit package, for
+example, declares ``on_delete=DO_NOTHING`` on every foreign key that it copies, and W009 would report each copy. The
+field still infers its target, its column type and its ``on_delete`` rule from the lookup path, so by default it still
+reports a path that cannot give them: ``E001`` and ``E005`` to ``E008``. An empty list runs every field check on
+excluded models, and a list of all nine skips them all.
+
+Only the ids of the field checks, ``E001`` to ``E008`` and ``W009``, can be listed, because the project checks skip
+excluded models altogether. Any other entry, and a value that is not a list, raise ``ImproperlyConfigured``. Changing
+the list changes no trigger, so ``makemigrations`` writes no migration for it.
+
+
 REDUNDANT_COPY_CHECK
 --------------------
 

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1/src/django_postgres_denormalize.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-postgres-denormalize
-Version: 1.0.0
+Version: 1.0.1
 Summary: Trigger-maintained copies of ancestor columns for Django on PostgreSQL.
 Author-email: DjanQuiltDB Project <djanquiltdb@portal42.net>
 License-Expression: BSD-3-Clause

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/src/postgres_denormalize/__init__.py

@@ -33,4 +33,4 @@ The package has these modules:
   and ``EXCLUDE_MODELS_CALLBACK``, which name the models that this package skips.
 """
 
-__version__ = '1.0.0'
+__version__ = '1.0.1'

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/src/postgres_denormalize/checks.py

@@ -2,7 +2,9 @@
 System checks that look at the project as a whole rather than at one field.
 
 The field-level checks (a lookup path that does not resolve, a nullable hop, a target that differs from the path) are
-part of each field's own ``check()``. The checks here are registered under the ``postgres_denormalize`` tag:
+part of each field's own ``check()``. A field on an excluded model skips the field checks that
+``EXCLUDE_MODELS_SILENCED_CHECKS`` lists. The checks here skip excluded models altogether. They are registered under the
+``postgres_denormalize`` tag:
 
 - ``E301``: pgtrigger neither writes triggers into migrations nor installs them after ``migrate``, so the triggers that
   this package derives would never reach the database.

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/src/postgres_denormalize/conf.py

@@ -5,11 +5,15 @@ package reads it.
 Every key is optional::
 
     POSTGRES_DENORMALIZE = {
-        # Models that this package skips: no triggers, no drift filter, no backfill, no project checks. This is for
-        # models that have denormalized fields on purpose without keeping them in sync, such as audit tables. A model is
-        # excluded when either key says so.
+        # Models that this package skips: no triggers, no drift filter, no backfill, no project checks, and only some
+        # field checks. This is for models that have denormalized fields on purpose without keeping them in sync, such
+        # as audit tables. A model is excluded when either key says so.
         'EXCLUDE_MODELS': ['tenancy.TaskAudit'],  # model labels, matched case-insensitively
         'EXCLUDE_MODELS_CALLBACK': 'myproject.audit.is_audit_model',  # a callable, or a dotted path to one
+        # The field checks that the fields of excluded models skip, as check ids. By default, these are E002, E003,
+        # E004 and W009, which compare the declaration with the lookup path. That matters only for a field that a
+        # trigger writes. Changing this list changes no trigger, so makemigrations writes no migration for it.
+        'EXCLUDE_MODELS_SILENCED_CHECKS': ['postgres_denormalize.W009'],
         'REDUNDANT_COPY_CHECK': {
             'LEVEL': 'warning',  # or 'error', or 'off'
             'APPS': None,  # app labels to check; None checks every app outside site-packages
@@ -36,6 +40,12 @@ SETTING_NAME = 'POSTGRES_DENORMALIZE'
 
 LEVELS = ('off', 'warning', 'error')
 
+# The ids of the checks that each denormalized field runs on its own declaration. EXCLUDE_MODELS_SILENCED_CHECKS can
+# list only these, because the project checks skip excluded models altogether.
+FIELD_CHECKS = tuple(
+    f'postgres_denormalize.{code}' for code in ('E001', 'E002', 'E003', 'E004', 'E005', 'E006', 'E007', 'E008', 'W009')
+)
+
 DEFAULT_REDUNDANT_COPY_CHECK = {
     'LEVEL': 'warning',
     'APPS': None,
@@ -46,6 +56,14 @@ DEFAULT_REDUNDANT_COPY_CHECK = {
 DEFAULTS = {
     'EXCLUDE_MODELS': (),
     'EXCLUDE_MODELS_CALLBACK': None,
+    # The checks that compare the declaration with the lookup path. The others find a path that gives the field no
+    # target, column type or on_delete rule, which a field on an excluded model needs too.
+    'EXCLUDE_MODELS_SILENCED_CHECKS': (
+        'postgres_denormalize.E002',
+        'postgres_denormalize.E003',
+        'postgres_denormalize.E004',
+        'postgres_denormalize.W009',
+    ),
     'REDUNDANT_COPY_CHECK': DEFAULT_REDUNDANT_COPY_CHECK,
     'ORDERING_CHECK_LEVEL': 'warning',
     'ISOLATION_CHECK_LEVEL': 'warning',
@@ -137,6 +155,16 @@ def validate_settings():
             f'{SETTING_NAME}["EXCLUDE_MODELS_CALLBACK"] must be a callable or a dotted path to one.'
         )
 
+    silenced = get_setting('EXCLUDE_MODELS_SILENCED_CHECKS')
+    if isinstance(silenced, str) or not isinstance(silenced, (list, tuple, set, frozenset)):
+        raise ImproperlyConfigured(f'{SETTING_NAME}["EXCLUDE_MODELS_SILENCED_CHECKS"] must be a list of check ids.')
+    unknown = [check_id for check_id in silenced if check_id not in FIELD_CHECKS]
+    if unknown:
+        raise ImproperlyConfigured(
+            f'{SETTING_NAME}["EXCLUDE_MODELS_SILENCED_CHECKS"] contains {", ".join(map(repr, unknown))}, but it can '
+            f'list only the field checks: {", ".join(FIELD_CHECKS)}.'
+        )
+
     redundant = configured.get('REDUNDANT_COPY_CHECK', {})
     if not isinstance(redundant, dict):
         raise ImproperlyConfigured(f'{SETTING_NAME}["REDUNDANT_COPY_CHECK"] must be a dict.')
@@ -167,4 +195,4 @@ def _validate_level(key, value):
         raise ImproperlyConfigured(f'{SETTING_NAME}["{key}"] is {value!r}; use one of {", ".join(LEVELS)}.')
 
 
-__all__ = ['DEFAULTS', 'LEVELS', 'get_setting', 'is_excluded', 'validate_settings']
+__all__ = ['DEFAULTS', 'FIELD_CHECKS', 'LEVELS', 'get_setting', 'is_excluded', 'validate_settings']

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/src/postgres_denormalize/fields.py

@@ -216,8 +216,26 @@ class DenormalizedMixin:
     def check(self, **kwargs):
         return [*super().check(**kwargs), *self._check_denormalize_from()]
 
+    def _silenced_checks(self):
+        """
+        Return the ids of the checks that this field skips.
+
+        A field on an excluded model skips the checks that ``EXCLUDE_MODELS_SILENCED_CHECKS`` lists. No trigger writes
+        its column, so by default it skips the checks that compare the declaration with the lookup path. Its target,
+        column type and ``on_delete`` rule still come from the path, so the checks that find a path that cannot give
+        them still run.
+        """
+        if conf.is_excluded(self.model):
+            return frozenset(conf.get_setting('EXCLUDE_MODELS_SILENCED_CHECKS'))
+        return frozenset()
+
     def _check_denormalize_from(self):
+        # Each check reports the first problem that it finds. A silenced check is skipped, rather than its message
+        # dropped, so that the checks after it still run.
+        silenced = self._silenced_checks()
         if '__' not in self.denormalize_from:
+            if 'postgres_denormalize.E001' in silenced:
+                return []
             return self._error(
                 'postgres_denormalize.E001',
                 f'`denormalize_from` is `{self.denormalize_from}`, which is a column on the same row, not a column '
@@ -227,25 +245,30 @@ class DenormalizedMixin:
         try:
             chain = self.resolve_chain()
         except PathRefused as refusal:
+            if refusal.code in silenced:
+                return []
             return self._error(refusal.code, f'{refusal}.', refusal.hint)
         except (FieldDoesNotExist, ValueError) as exception:
+            if 'postgres_denormalize.E001' in silenced:
+                return []
             return self._error(
                 'postgres_denormalize.E001',
                 f'`denormalize_from` is `{self.denormalize_from}`, which does not resolve: {exception}.',
             )
 
-        if chain[0].null:
+        if chain[0].null and 'postgres_denormalize.E002' not in silenced:
             return self._error(
                 'postgres_denormalize.E002',
                 f'`denormalize_from` is `{self.denormalize_from}`, which starts at the nullable foreign key '
                 f'`{chain[0].name}`, so the trigger computes NULL for every row where `{chain[0].name}` is empty.',
             )
 
-        return self._check_end_of_chain(chain)
+        return self._check_end_of_chain(chain, silenced)
 
-    def _check_end_of_chain(self, chain):
+    def _check_end_of_chain(self, chain, silenced):
         """
-        Check the field at the end of the lookup path. Each concrete class allows different fields there.
+        Check the field at the end of the lookup path, skipping the checks in ``silenced``. Each concrete class allows
+        different fields there.
         """
         raise NotImplementedError
 
@@ -428,39 +451,42 @@ class DenormalizedForeignKey(DenormalizedMixin, models.ForeignKey):
             return self._check_denormalize_from()
         return super().check(**kwargs)
 
-    def _check_end_of_chain(self, chain):
+    def _check_end_of_chain(self, chain, silenced):
         end = chain[-1].related_model._meta.label
-        if not self.target_is_known:
-            return self._error(
-                'postgres_denormalize.E003',
-                f'The target of the field is not known, but `{self.denormalize_from}` ends at {end}.',
-            )
-        if chain[-1].related_model is not self.related_model:
-            return self._error(
-                'postgres_denormalize.E003',
-                f'The field points at {self.related_model._meta.label}, but `{self.denormalize_from}` ends at {end}.',
-            )
-        if chain[-1].target_field != self.target_field:
-            return self._error(
-                'postgres_denormalize.E003',
-                f'The field points at {end}.{self.target_field.name}, but `{self.denormalize_from}` ends at '
-                f'{end}.{chain[-1].target_field.name}. Declare the field with the same to_field as the last hop, or '
-                f'without one.',
-            )
+        if 'postgres_denormalize.E003' not in silenced:
+            if not self.target_is_known:
+                return self._error(
+                    'postgres_denormalize.E003',
+                    f'The target of the field is not known, but `{self.denormalize_from}` ends at {end}.',
+                )
+            if chain[-1].related_model is not self.related_model:
+                return self._error(
+                    'postgres_denormalize.E003',
+                    f'The field points at {self.related_model._meta.label}, but `{self.denormalize_from}` ends at '
+                    f'{end}.',
+                )
+            if chain[-1].target_field != self.target_field:
+                return self._error(
+                    'postgres_denormalize.E003',
+                    f'The field points at {end}.{self.target_field.name}, but `{self.denormalize_from}` ends at '
+                    f'{end}.{chain[-1].target_field.name}. Declare the field with the same to_field as the last hop, '
+                    f'or without one.',
+                )
 
         nullable = [hop.name for hop in chain[1:] if hop.null]
-        if nullable and not self.null:
+        if nullable and not self.null and 'postgres_denormalize.E004' not in silenced:
             return self._error(
                 'postgres_denormalize.E004',
                 f'`{self.denormalize_from}` crosses the nullable foreign key `{nullable[0]}`, so the trigger writes '
                 'NULL for every row where it is empty. Declare the field with null=True, or without null.',
             )
 
-        return self._check_on_delete_rule(chain)
+        return self._check_on_delete_rule(chain, silenced)
 
-    def _check_on_delete_rule(self, chain):
+    def _check_on_delete_rule(self, chain, silenced):
         """
-        Check the ``on_delete`` rule against the rule that the lookup path implies (see ``infer_on_delete``).
+        Check the ``on_delete`` rule against the rule that the lookup path implies (see ``infer_on_delete``), skipping
+        the checks in ``silenced``.
         """
         inferred, deciding_hop = infer_on_delete(chain)
         hop_label = f'{deciding_hop.model._meta.label}.{deciding_hop.name}'
@@ -468,6 +494,8 @@ class DenormalizedForeignKey(DenormalizedMixin, models.ForeignKey):
             if self.on_delete_is_known:
                 # A declared rule cannot be compared with a custom rule along the path.
                 return []
+            if 'postgres_denormalize.E008' in silenced:
+                return []
             return self._error(
                 'postgres_denormalize.E008',
                 f'`{self.denormalize_from}` crosses {hop_label}, which has the custom on_delete rule '
@@ -475,7 +503,7 @@ class DenormalizedForeignKey(DenormalizedMixin, models.ForeignKey):
                 hint='Declare on_delete on the field.',
             )
         declared = self.remote_field.on_delete
-        if declared is not inferred:
+        if declared is not inferred and 'postgres_denormalize.W009' not in silenced:
             return self._warning(
                 'postgres_denormalize.W009',
                 f'The field declares on_delete={describe_rule(declared)}, but `{self.denormalize_from}` implies '
@@ -575,7 +603,9 @@ class DenormalizedField(DenormalizedMixin, models.Field):
             kwargs['base_field'] = self._base_field
         return name, path, args, kwargs
 
-    def _check_end_of_chain(self, chain):
+    def _check_end_of_chain(self, chain, silenced):
+        if 'postgres_denormalize.E005' in silenced:
+            return []
         source = chain[-1]
         if source.is_relation:
             return self._error(
@@ -681,10 +711,10 @@ def get_denormalized_fields(model):
     proxy model, therefore get no triggers, no drift filter and no backfill for the fields of the parent, because the
     triggers of the parent already keep those columns correct.
 
-    For an excluded model (see ``EXCLUDE_MODELS``) this returns no fields, so the model gets no triggers, no drift
-    filter and no backfill. The usual reason to exclude a model is an audit table that copies the fields of a tracked
-    model, including the denormalized ones. Its rows record the value that a copy had at the time, so no trigger may
-    rewrite them.
+    For an excluded model (see ``EXCLUDE_MODELS`` and ``EXCLUDE_MODELS_CALLBACK``) this returns no fields, so the model
+    gets no triggers, no drift filter and no backfill. The usual reason to exclude a model is an audit table that copies
+    the fields of a tracked model, including the denormalized ones. Its rows record the value that a copy had at the
+    time, so no trigger may rewrite them.
     """
     if conf.is_excluded(model):
         return []

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/tests/isolated/test_fields.py

@@ -8,9 +8,10 @@ from django.db.migrations.autodetector import MigrationAutodetector
 from django.db.migrations.operations import AlterField
 from django.db.migrations.state import ProjectState
 from django.db.models.functions import Length
-from django.test import SimpleTestCase
+from django.test import SimpleTestCase, override_settings
 from django.test.utils import isolate_apps
 
+from postgres_denormalize import conf
 from postgres_denormalize.fields import (
     INFERRED_TARGET,
     DenormalizedField,
@@ -868,3 +869,172 @@ class OnDeleteInferenceTestCase(SimpleTestCase):
         chain = field.resolve_chain()
 
         self.assertEqual(infer_on_delete(chain), (models.PROTECT, chain[0]))
+
+
+AUDIT_CALLBACK = 'catalog.exclusions.is_audit_model'
+
+
+@isolate_apps('isolated')
+@override_settings(POSTGRES_DENORMALIZE={'EXCLUDE_MODELS_CALLBACK': AUDIT_CALLBACK})
+class ExcludedModelChecksTestCase(SimpleTestCase):
+    """
+    The callback excludes every model whose name ends in ``audit``. Each test declares the same field on a leaf and on
+    an audit model of that leaf, and compares the checks of the two copies.
+    """
+
+    def declare_copies(self, suffix, make_field, owner_rule=models.PROTECT, owner_null=False, first_hop_null=False):
+        """
+        Declare Owner, Parent, Leaf and LeafAudit, each with ``suffix`` in its name, and return the field ``copy`` of
+        Leaf and of LeafAudit.
+
+        Parent.owner has the rule ``owner_rule``, and is nullable when ``owner_null`` is true. Leaf and LeafAudit each
+        have the foreign key ``parent``, which is nullable when ``first_hop_null`` is true, and the field that
+        ``make_field`` returns.
+        """
+        owner = type(f'Owner{suffix}', (models.Model,), {'__module__': __name__})
+        parent = type(
+            f'Parent{suffix}',
+            (models.Model,),
+            {'__module__': __name__, 'owner': models.ForeignKey(owner, on_delete=owner_rule, null=owner_null)},
+        )
+        copies = []
+        for name in (f'Leaf{suffix}', f'Leaf{suffix}Audit'):
+            leaf = type(
+                name,
+                (models.Model,),
+                {
+                    '__module__': __name__,
+                    'parent': models.ForeignKey(parent, on_delete=models.CASCADE, null=first_hop_null),
+                    'copy': make_field(),
+                },
+            )
+            copies.append(leaf._meta.get_field('copy'))
+        return copies
+
+    def check_ids(self, field):
+        return [message.id for message in field.check()]
+
+    def test_a_declared_rule_that_differs_from_the_path_is_muted_on_an_excluded_model(self):
+        """
+        Case: Parent.owner is PROTECT. Leaf and LeafAudit copy parent__owner with on_delete=DO_NOTHING, which an audit
+              package declares on every foreign key that it copies.
+        Expected: The copy on Leaf reports warning W009. The copy on LeafAudit reports nothing.
+        """
+        leaf, audit = self.declare_copies(
+            '', lambda: DenormalizedForeignKey('parent__owner', on_delete=models.DO_NOTHING, related_name='+')
+        )
+
+        self.assertEqual(self.check_ids(leaf), ['postgres_denormalize.W009'])
+        self.assertEqual(self.check_ids(audit), [])
+
+    def test_the_checks_that_compare_the_declaration_with_the_path_are_muted_on_an_excluded_model(self):
+        """
+        Case: Leaf and LeafAudit copy parent__owner three times: with a nullable first hop, with to=Parent, and with
+              null=False across the nullable hop Parent.owner.
+        Expected: The copy on Leaf reports E002, E003 and E004 in turn. The copy on LeafAudit reports nothing.
+        """
+        cases = [
+            (
+                'postgres_denormalize.E002',
+                {'first_hop_null': True},
+                lambda: DenormalizedForeignKey('parent__owner', on_delete=models.PROTECT, null=True, related_name='+'),
+            ),
+            (
+                'postgres_denormalize.E003',
+                {},
+                lambda: DenormalizedForeignKey(
+                    'parent__owner', on_delete=models.PROTECT, to='isolated.Parent1', related_name='+'
+                ),
+            ),
+            (
+                'postgres_denormalize.E004',
+                {'owner_null': True},
+                lambda: DenormalizedForeignKey('parent__owner', on_delete=models.PROTECT, null=False, related_name='+'),
+            ),
+        ]
+        for index, (check_id, options, make_field) in enumerate(cases):
+            with self.subTest(check_id=check_id):
+                leaf, audit = self.declare_copies(index, make_field, **options)
+
+                self.assertEqual(self.check_ids(leaf), [check_id])
+                self.assertEqual(self.check_ids(audit), [])
+
+    def test_the_checks_that_find_no_target_type_or_rule_are_still_reported_on_an_excluded_model(self):
+        """
+        Case: Leaf and LeafAudit copy parent__missing as a DenormalizedForeignKey and as a DenormalizedField. Then they
+              copy parent__owner without on_delete, while Parent.owner has a custom on_delete rule.
+        Expected: Both copies report E001, E001 and E008 in turn.
+        """
+        cases = [
+            ('postgres_denormalize.E001', {}, lambda: DenormalizedForeignKey('parent__missing', related_name='+')),
+            ('postgres_denormalize.E001', {}, lambda: DenormalizedField('parent__missing')),
+            (
+                'postgres_denormalize.E008',
+                {'owner_rule': custom_rule},
+                lambda: DenormalizedForeignKey('parent__owner', related_name='+'),
+            ),
+        ]
+        for index, (check_id, options, make_field) in enumerate(cases):
+            with self.subTest(index=index, check_id=check_id):
+                for field in self.declare_copies(index, make_field, **options):
+                    self.assertEqual(self.check_ids(field), [check_id])
+
+    def test_a_muted_check_does_not_hide_the_checks_after_it(self):
+        """
+        Case: Leaf and LeafAudit copy parent__owner as a DenormalizedField, through a nullable first hop. The path
+              ends at a foreign key, which a DenormalizedField cannot copy.
+        Expected: The copy on Leaf reports E002, the first problem. The copy on LeafAudit skips the muted E002 and
+                  reports E005.
+        """
+        leaf, audit = self.declare_copies('', lambda: DenormalizedField('parent__owner'), first_hop_null=True)
+
+        self.assertEqual(self.check_ids(leaf), ['postgres_denormalize.E002'])
+        self.assertEqual(self.check_ids(audit), ['postgres_denormalize.E005'])
+
+    def test_the_setting_chooses_the_checks_that_are_muted(self):
+        """
+        Case: EXCLUDE_MODELS_SILENCED_CHECKS is empty, and then lists every field check. Leaf and LeafAudit copy
+              parent__owner with on_delete=DO_NOTHING while Parent.owner is PROTECT, and copy parent__missing.
+        Expected: With the empty list, the copy on LeafAudit reports W009 and E001, as the copy on Leaf does. With every
+                  field check listed, the copies on LeafAudit report nothing, and the copies on Leaf still report W009
+                  and E001.
+        """
+        rule_copies = self.declare_copies(
+            'Rule', lambda: DenormalizedForeignKey('parent__owner', on_delete=models.DO_NOTHING, related_name='+')
+        )
+        path_copies = self.declare_copies('Path', lambda: DenormalizedForeignKey('parent__missing', related_name='+'))
+
+        def setting(silenced):
+            return override_settings(
+                POSTGRES_DENORMALIZE={
+                    'EXCLUDE_MODELS_CALLBACK': AUDIT_CALLBACK,
+                    'EXCLUDE_MODELS_SILENCED_CHECKS': silenced,
+                }
+            )
+
+        with setting([]):
+            for field in rule_copies:
+                self.assertEqual(self.check_ids(field), ['postgres_denormalize.W009'])
+            for field in path_copies:
+                self.assertEqual(self.check_ids(field), ['postgres_denormalize.E001'])
+
+        with setting(list(conf.FIELD_CHECKS)):
+            self.assertEqual(self.check_ids(rule_copies[0]), ['postgres_denormalize.W009'])
+            self.assertEqual(self.check_ids(path_copies[0]), ['postgres_denormalize.E001'])
+            self.assertEqual(self.check_ids(rule_copies[1]), [])
+            self.assertEqual(self.check_ids(path_copies[1]), [])
+
+    def test_the_checks_of_django_still_run_on_an_excluded_model(self):
+        """
+        Case: Leaf and LeafAudit copy parent__owner with on_delete=SET_NULL and null=False while Parent.owner is
+              PROTECT. Django's own checks refuse SET_NULL on a column that cannot be NULL.
+        Expected: The copy on Leaf reports Django's fields.E320 and W009. The copy on LeafAudit reports only
+                  fields.E320.
+        """
+        leaf, audit = self.declare_copies(
+            '',
+            lambda: DenormalizedForeignKey('parent__owner', on_delete=models.SET_NULL, null=False, related_name='+'),
+        )
+
+        self.assertEqual(self.check_ids(leaf), ['fields.E320', 'postgres_denormalize.W009'])
+        self.assertEqual(self.check_ids(audit), ['fields.E320'])

{django_postgres_denormalize-1.0.0 → django_postgres_denormalize-1.0.1}/tests/test_conf.py

@@ -15,6 +15,15 @@ class GetSettingTestCase(SimpleTestCase):
         """
         self.assertEqual(conf.get_setting('EXCLUDE_MODELS'), ())
         self.assertIsNone(conf.get_setting('EXCLUDE_MODELS_CALLBACK'))
+        self.assertEqual(
+            conf.get_setting('EXCLUDE_MODELS_SILENCED_CHECKS'),
+            (
+                'postgres_denormalize.E002',
+                'postgres_denormalize.E003',
+                'postgres_denormalize.E004',
+                'postgres_denormalize.W009',
+            ),
+        )
         self.assertEqual(conf.get_setting('ORDERING_CHECK_LEVEL'), 'warning')
         self.assertEqual(conf.get_setting('ISOLATION_CHECK_LEVEL'), 'warning')
         self.assertEqual(conf.get_setting('REDUNDANT_COPY_CHECK'), conf.DEFAULT_REDUNDANT_COPY_CHECK)
@@ -157,6 +166,40 @@ class ValidateSettingsTestCase(SimpleTestCase):
         """
         conf.validate_settings()
 
+    def test_refuses_silenced_checks_that_are_not_a_list_of_field_checks(self):
+        """
+        Case: EXCLUDE_MODELS_SILENCED_CHECKS is a string, and then a list with the project check W101 and the
+              misspelt 'postgres_denormalize.W9'.
+        Expected: For the string, an ImproperlyConfigured error that asks for a list of check ids. For the list, an
+                  ImproperlyConfigured error that names both entries and the field checks that can be listed.
+        """
+        self.assertRefused(
+            {'EXCLUDE_MODELS_SILENCED_CHECKS': 'postgres_denormalize.W009'}, 'must be a list of check ids'
+        )
+        with override_settings(
+            POSTGRES_DENORMALIZE={
+                'EXCLUDE_MODELS_SILENCED_CHECKS': ['postgres_denormalize.W101', 'postgres_denormalize.W9']
+            }
+        ):
+            with self.assertRaises(ImproperlyConfigured) as raised:
+                conf.validate_settings()
+        message = str(raised.exception)
+        self.assertIn("'postgres_denormalize.W101', 'postgres_denormalize.W9'", message)
+        self.assertIn('postgres_denormalize.E001', message)
+        self.assertIn('postgres_denormalize.W009', message)
+
+    def test_accepts_silenced_checks_from_none_to_every_field_check(self):
+        """
+        Case: EXCLUDE_MODELS_SILENCED_CHECKS is an empty list, and then a list of every field check.
+        Expected: No error for either.
+        """
+        for silenced in ([], list(conf.FIELD_CHECKS)):
+            with (
+                self.subTest(silenced=silenced),
+                override_settings(POSTGRES_DENORMALIZE={'EXCLUDE_MODELS_SILENCED_CHECKS': silenced}),
+            ):
+                conf.validate_settings()
+
     def test_refuses_a_redundant_copy_check_that_is_not_a_dict(self):
         """
         Case: REDUNDANT_COPY_CHECK is the string 'error'.