pytest-testcontainers-django 0.2.2__tar.gz → 0.2.3__tar.gz

{pytest_testcontainers_django-0.2.2 → pytest_testcontainers_django-0.2.3}/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.3] - 2026-06-01
+
+### Fixed
+
+- The rootdir-conftest preload no longer dumps a spurious traceback
+  (`preloading rootdir conftest.py raised; continuing`) when the conftest
+  transitively touches the Django app registry before `django.setup()` has
+  run — e.g. `model_bakery` >= 1.20 calling `apps.is_installed()` at import.
+  0.2.1 added a quiet-deferral shortcut, but it only recognised
+  `ImproperlyConfigured` (raised when `DJANGO_SETTINGS_MODULE` is unset).
+  When the settings module *is* configured early but the app registry has
+  not been populated yet, Django raises the sibling exception
+  `AppRegistryNotReady` ("Apps aren't loaded yet.") instead — which is *not*
+  a subclass of `ImproperlyConfigured`, so the shortcut missed it and the
+  benign deferral was logged as an error. The predicate (renamed
+  `_is_django_not_configured` → `_is_django_not_ready`) now matches both
+  exceptions by class name.
+
 ## [0.2.2] - 2026-05-14
 
 ### Fixed

{pytest_testcontainers_django-0.2.2 → pytest_testcontainers_django-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-testcontainers-django
-Version: 0.2.2
+Version: 0.2.3
 Summary: Bridge between pytest-testcontainers and pytest-django: starts the DB container before Django imports settings.
 Project-URL: Homepage, https://github.com/iplweb/pytest-testcontainers-django
 Project-URL: Repository, https://github.com/iplweb/pytest-testcontainers-django

{pytest_testcontainers_django-0.2.2 → pytest_testcontainers_django-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytest-testcontainers-django"
-version = "0.2.2"
+version = "0.2.3"
 description = "Bridge between pytest-testcontainers and pytest-django: starts the DB container before Django imports settings."
 readme = "README.md"
 requires-python = ">=3.10"

{pytest_testcontainers_django-0.2.2 → pytest_testcontainers_django-0.2.3}/src/pytest_testcontainers_django/plugin.py

@@ -94,18 +94,32 @@ def _resolve_baseline_path(config: DjangoContainerConfig) -> DjangoContainerConf
     return replace(config, postgres=new_pg)
 
 
-def _is_django_not_configured(exc: BaseException) -> bool:
-    """Walk ``__cause__`` / ``__context__`` for Django's ``ImproperlyConfigured``.
-
-    Matched by type name to avoid importing Django from this plugin (preload
-    runs before Django is configured, and the plugin must work in setups
-    where Django is loaded lazily).
+# Django's two "not ready yet" signals, both of which a rootdir-conftest
+# preload can legitimately trigger before pytest-django has run
+# ``django.setup()``.  Matched by class name (not isinstance) so the plugin
+# never imports Django itself — preload runs before Django is configured and
+# the plugin must work where Django is loaded lazily.  ``apps.is_installed()``
+# (called at import by ``model_bakery`` >= 1.20) raises ``ImproperlyConfigured``
+# when ``DJANGO_SETTINGS_MODULE`` is unset, but ``AppRegistryNotReady`` when
+# settings *are* configured yet the app registry has not been populated — the
+# latter is a sibling class, NOT a subclass, so it must be listed explicitly.
+_DJANGO_NOT_READY_EXC_NAMES = frozenset({"ImproperlyConfigured", "AppRegistryNotReady"})
+
+
+def _is_django_not_ready(exc: BaseException) -> bool:
+    """Walk ``__cause__`` / ``__context__`` for a Django "not ready yet" signal.
+
+    Returns ``True`` if any exception in the chain is one of
+    :data:`_DJANGO_NOT_READY_EXC_NAMES` (matched by type name) — meaning the
+    preload import failed only because Django settings/apps were not ready,
+    which is benign: pytest's normal trylast loader re-imports the conftest
+    later, after ``django.setup()``, where it succeeds.
     """
     seen: set[int] = set()
     cur: BaseException | None = exc
     while cur is not None and id(cur) not in seen:
         seen.add(id(cur))
-        if type(cur).__name__ == "ImproperlyConfigured":
+        if type(cur).__name__ in _DJANGO_NOT_READY_EXC_NAMES:
             return True
         cur = cur.__cause__ or cur.__context__
     return False
@@ -191,22 +205,23 @@ def _preload_rootdir_conftest(early_config: pytest.Config) -> None:
             consider_namespace_packages=consider_namespace_packages,
         )
     except Exception as exc:
-        if _is_django_not_configured(exc):
+        if _is_django_not_ready(exc):
             # Expected at preload time: the conftest transitively imports code
-            # that touches Django settings (e.g. model_bakery>=1.20 calls
+            # that touches Django settings/apps (e.g. model_bakery>=1.20 calls
             # apps.is_installed() at module import). Our hook runs before
-            # pytest-django has configured DJANGO_SETTINGS_MODULE, so the
-            # import fails here.  Pytest's own trylast loader will re-import
-            # the conftest later (after Django is configured *and* after our
-            # env injection has populated DB host/port), where it will
-            # succeed.  Caveat: any register() calls *before* the failing
-            # import won't run early — users hitting this should configure
-            # via pyproject.toml's [tool.pytest-testcontainers-django]
-            # instead, or move the offending import.
+            # pytest-django has run django.setup(), so the import fails here
+            # with either ImproperlyConfigured (settings module unset) or
+            # AppRegistryNotReady (settings configured, app registry not yet
+            # populated).  Pytest's own trylast loader will re-import the
+            # conftest later (after Django is set up *and* after our env
+            # injection has populated DB host/port), where it will succeed.
+            # Caveat: any register() calls *before* the failing import won't
+            # run early — users hitting this should configure via
+            # pyproject.toml's [tool.pytest-testcontainers-django] instead,
+            # or move the offending import.
             logger.debug(
-                "preloading rootdir conftest.py deferred: Django settings "
-                "not configured yet (will be re-imported by pytest's normal "
-                "loader)"
+                "preloading rootdir conftest.py deferred: Django not ready "
+                "yet (will be re-imported by pytest's normal loader)"
             )
             return
         # Real conftest error — pytest's trylast loader would re-raise it

{pytest_testcontainers_django-0.2.2 → pytest_testcontainers_django-0.2.3}/tests/test_plugin.py

@@ -459,6 +459,41 @@ if not getattr(sys, "_ttd_preload_seen", False):
     assert "preloading rootdir conftest.py raised" not in combined, combined
 
 
+def test_django_not_ready_predicate_matches_both_deferral_exceptions() -> None:
+    """``_is_django_not_ready`` must recognise BOTH Django "not ready yet"
+    signals raised at preload time, matched by class name (the plugin must
+    not import Django itself):
+
+    * ``ImproperlyConfigured`` — ``DJANGO_SETTINGS_MODULE`` not set; raised
+      when ``apps.is_installed()`` reaches ``settings.INSTALLED_APPS``.
+    * ``AppRegistryNotReady`` — settings *are* configured but
+      ``django.setup()`` / ``apps.populate()`` has not run yet.  This is the
+      common real-world case (``model_bakery`` >= 1.20 calls
+      ``apps.is_installed()`` at import once the settings module is pinned
+      early) and is NOT a subclass of ``ImproperlyConfigured``, so a check
+      for the latter alone misses it.
+
+    Unrelated exceptions (a plain ``ValueError`` etc.) must NOT match, and
+    the predicate must follow the ``__cause__`` / ``__context__`` chain.
+    """
+    from pytest_testcontainers_django.plugin import _is_django_not_ready
+
+    class ImproperlyConfigured(Exception):
+        pass
+
+    class AppRegistryNotReady(Exception):
+        pass
+
+    assert _is_django_not_ready(ImproperlyConfigured("settings not configured"))
+    assert _is_django_not_ready(AppRegistryNotReady("Apps aren't loaded yet."))
+    assert not _is_django_not_ready(ValueError("unrelated"))
+
+    # Chained: the deferral signal hides behind an unrelated wrapper.
+    chained = RuntimeError("import failed")
+    chained.__cause__ = AppRegistryNotReady("Apps aren't loaded yet.")
+    assert _is_django_not_ready(chained)
+
+
 def test_preload_still_logs_traceback_for_unrelated_conftest_errors(
     pytester: pytest.Pytester,
 ) -> None: