test(types): cover validate_fields branches with focused unit tests

Add ``TestValidateFieldsHelpers`` exercising the new
``_validate_only_fields`` / ``_validate_exclude_fields`` helpers and
the ``validate_fields`` orchestrator directly (i.e. without going
through ``DjangoObjectType.__init_subclass_with_meta__``), so each
warning branch fails a focused test rather than only being detected
via integration coverage.

Coverage:

* ``_validate_only_fields``: known field (no warning), model attribute
  (attribute warning), unknown name (missing-field warning), ``None``
  (no-op).
* ``_validate_exclude_fields``: real field (no warning), custom field
  (no-effect warning), unknown name (missing-attribute warning),
  ``None`` (no-op).
* ``validate_fields`` orchestrator: ``ALL_FIELDS`` sentinel
  normalisation; combined call delegating to both helpers.

Each test follows the team docstring template (Name / Description /
Assumptions / Expectations) and asserts on the warning message text via
``pytest.warns(..., match=...)`` so a regression in either the
extraction or the message wording surfaces a focused failure.

Made-with: Cursor

Author: firaskafri

graphene_django/tests/test_types.py

@@ -832,3 +832,266 @@ class Query(ObjectType):
     assert "type Reporter implements Node {" not in schema
     assert "type ReporterConnection {" not in schema
     assert "type ReporterEdge {" not in schema
+
+
+class TestValidateFieldsHelpers:
+    """Direct unit tests for the ``validate_fields`` extraction in
+    :mod:`graphene_django.types`.
+
+    These tests exercise :func:`_validate_only_fields`,
+    :func:`_validate_exclude_fields`, and the
+    :func:`validate_fields` orchestrator in isolation — without going
+    through ``DjangoObjectType.__init_subclass_with_meta__`` — so each
+    warning case fails a focused test rather than only being detected
+    via integration coverage on type construction.
+
+    Scenarios covered:
+
+    * ``_validate_only_fields``
+        - happy path: requested name is in ``all_field_names`` (no warning)
+        - requested name resolves to a non-field model attribute (warning
+          about "matches an attribute")
+        - requested name is unknown to the model (warning about "doesn't
+          exist on Django model")
+        - ``only_fields=None`` is a no-op
+        - ``only_fields=ALL_FIELDS`` is normalised to a no-op by the
+          orchestrator and is therefore exercised through ``validate_fields``
+    * ``_validate_exclude_fields``
+        - happy path: excluded name corresponds to a real model field
+          (no warning)
+        - excluded name is a custom field on the type (warning about
+          "Excluding the custom field")
+        - excluded name is unknown to the model (warning about "does not
+          have a field or attribute")
+        - ``exclude_fields=None`` is a no-op
+    * ``validate_fields`` orchestrator
+        - ``ALL_FIELDS`` sentinel for ``only_fields`` is normalised to
+          empty iteration (and therefore emits no warning)
+        - delegates to both helpers (combined-warning happy path)
+
+    The tests assert on the message text via ``pytest.warns(..., match=...)``
+    so a regression in the error wording also fails a focused test.
+    """
+
+    @staticmethod
+    def _all_field_names():
+        """Reusable set of "real" converted-field names for ReporterModel."""
+        return {"first_name", "last_name", "email", "pets", "custom_field"}
+
+    def test_only_fields_known_field_emits_no_warning(self):
+        """
+        Name: only_fields, known field, no warning
+        Description: A name present in ``all_field_names`` short-circuits via
+            ``continue`` and emits no warning.
+        Assumptions: ``first_name`` is one of the converted fields supplied
+            in ``all_field_names``.
+        Expectations: ``warnings.simplefilter("error")`` does not raise — i.e.
+            no warning is emitted.
+        """
+        from ..types import _validate_only_fields
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            _validate_only_fields(
+                ["first_name"], self._all_field_names(), ReporterModel, "TestType"
+            )
+
+    def test_only_fields_model_attribute_warns_about_attribute(self):
+        """
+        Name: only_fields, attribute-not-field, attribute warning
+        Description: A name that exists as a Python attribute on the model but
+            is not a model field (e.g. ``Reporter.some_method``) must produce
+            the "matches an attribute" warning so the user knows to declare
+            the field on the type.
+        Assumptions: ``Reporter.some_method`` is defined on the model and is
+            not in ``all_field_names``.
+        Expectations: A ``UserWarning`` whose message matches the
+            "matches an attribute on Django model" wording is emitted.
+        """
+        from ..types import _validate_only_fields
+
+        with pytest.warns(
+            UserWarning,
+            match=r"matches an attribute on Django model .* but it's not a model field",
+        ):
+            _validate_only_fields(
+                ["some_method"], self._all_field_names(), ReporterModel, "TestType"
+            )
+
+    def test_only_fields_unknown_name_warns_about_missing_field(self):
+        """
+        Name: only_fields, unknown name, missing-field warning
+        Description: A name that is neither a converted field nor any
+            attribute on the model must produce the "doesn't exist on
+            Django model" warning so the user knows it is a typo or stale
+            entry in ``Meta.fields``.
+        Assumptions: ``"foo"`` is not a field of ReporterModel and is not
+            in ``all_field_names``.
+        Expectations: A ``UserWarning`` whose message matches the
+            "doesn't exist on Django model" wording is emitted.
+        """
+        from ..types import _validate_only_fields
+
+        with pytest.warns(
+            UserWarning,
+            match=r"Field name \"foo\" doesn't exist on Django model",
+        ):
+            _validate_only_fields(
+                ["foo"], self._all_field_names(), ReporterModel, "TestType"
+            )
+
+    def test_only_fields_none_is_a_noop(self):
+        """
+        Name: only_fields, None argument, no-op
+        Description: Passing ``None`` for ``only_fields`` must iterate over
+            an empty sequence and emit no warning.
+        Assumptions: The helper uses ``only_fields or ()`` so ``None`` is
+            normalised at call site.
+        Expectations: ``warnings.simplefilter("error")`` does not raise.
+        """
+        from ..types import _validate_only_fields
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            _validate_only_fields(
+                None, self._all_field_names(), ReporterModel, "TestType"
+            )
+
+    def test_exclude_fields_real_model_field_emits_no_warning(self):
+        """
+        Name: exclude_fields, real model field, no warning
+        Description: Excluding a name that exists on the model and is not
+            also a custom field on the type is the happy path and produces
+            no warning.
+        Assumptions: ``"first_name"`` is on ReporterModel and is not in the
+            ``all_field_names`` set passed in (we deliberately use a set
+            without it to model "this is a real field, not a custom one").
+        Expectations: ``warnings.simplefilter("error")`` does not raise.
+        """
+        from ..types import _validate_exclude_fields
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            _validate_exclude_fields(
+                ["first_name"],
+                {"custom_field"},
+                ReporterModel,
+                "TestType",
+            )
+
+    def test_exclude_fields_custom_field_warns_about_no_effect(self):
+        """
+        Name: exclude_fields, custom field, "no effect" warning
+        Description: Excluding a name that maps to a custom field declared
+            directly on the ``DjangoObjectType`` has no effect (since
+            ``Meta.exclude`` only filters auto-converted model fields), so
+            a warning must be emitted.
+        Assumptions: ``"custom_field"`` is in the supplied ``all_field_names``
+            (i.e. it was added by the user as a custom field on the type).
+        Expectations: A ``UserWarning`` whose message matches the
+            "Excluding the custom field" wording is emitted.
+        """
+        from ..types import _validate_exclude_fields
+
+        with pytest.warns(
+            UserWarning,
+            match=r"Excluding the custom field \"custom_field\" on DjangoObjectType",
+        ):
+            _validate_exclude_fields(
+                ["custom_field"],
+                self._all_field_names(),
+                ReporterModel,
+                "TestType",
+            )
+
+    def test_exclude_fields_unknown_name_warns_about_missing_attribute(self):
+        """
+        Name: exclude_fields, unknown name, missing-attribute warning
+        Description: Excluding a name that is neither a custom field nor any
+            attribute of the model must produce the "does not have a field
+            or attribute" warning to flag the typo or stale entry.
+        Assumptions: ``"foo"`` does not exist on ReporterModel and is not in
+            ``all_field_names``.
+        Expectations: A ``UserWarning`` matching the "does not have a field
+            or attribute" wording is emitted.
+        """
+        from ..types import _validate_exclude_fields
+
+        with pytest.warns(
+            UserWarning,
+            match=r"does not have a field or attribute named \"foo\"",
+        ):
+            _validate_exclude_fields(
+                ["foo"], self._all_field_names(), ReporterModel, "TestType"
+            )
+
+    def test_exclude_fields_none_is_a_noop(self):
+        """
+        Name: exclude_fields, None argument, no-op
+        Description: Passing ``None`` for ``exclude_fields`` must iterate
+            over an empty sequence and emit no warning.
+        Assumptions: The helper uses ``exclude_fields or ()`` so ``None`` is
+            normalised at call site.
+        Expectations: ``warnings.simplefilter("error")`` does not raise.
+        """
+        from ..types import _validate_exclude_fields
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            _validate_exclude_fields(
+                None, self._all_field_names(), ReporterModel, "TestType"
+            )
+
+    def test_validate_fields_normalises_all_fields_sentinel(self):
+        """
+        Name: validate_fields, ALL_FIELDS sentinel
+        Description: The orchestrator must treat ``only_fields=ALL_FIELDS``
+            as an empty iteration so that the request "all fields" never
+            triggers a per-name warning loop.
+        Assumptions: :data:`graphene_django.types.ALL_FIELDS` is the sentinel
+            used to mean "all fields".
+        Expectations: No warning is emitted even though the
+            ``ALL_FIELDS`` string itself is not in ``all_field_names``.
+        """
+        from ..types import ALL_FIELDS, validate_fields
+
+        fake_fields = {"first_name": object(), "last_name": object()}
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            validate_fields(
+                "TestType",
+                ReporterModel,
+                fake_fields,
+                only_fields=ALL_FIELDS,
+                exclude_fields=None,
+            )
+
+    def test_validate_fields_delegates_to_both_helpers(self):
+        """
+        Name: validate_fields, delegates to both helpers
+        Description: The orchestrator must forward both ``only_fields`` and
+            ``exclude_fields`` to their respective helpers, so an invalid
+            entry in either list still surfaces a warning.
+        Assumptions: ``"foo"`` is unknown to the model in both contexts.
+        Expectations: Two warnings are emitted in a single call: one for
+            the missing-from-fields name and one for the
+            missing-from-exclude name.
+        """
+        from ..types import validate_fields
+
+        fake_fields = {"first_name": object()}
+        with warnings.catch_warnings(record=True) as recorded:
+            warnings.simplefilter("always")
+            validate_fields(
+                "TestType",
+                ReporterModel,
+                fake_fields,
+                only_fields=["foo"],
+                exclude_fields=["bar"],
+            )
+
+        messages = [str(w.message) for w in recorded]
+        assert any("Field name \"foo\" doesn't exist" in m for m in messages), messages
+        assert any(
+            "does not have a field or attribute named \"bar\"" in m for m in messages
+        ), messages