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

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

@@ -7,6 +7,55 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.4] - 2026-06-19
+
+### Fixed
+
+- The plugin now actually works on its advertised `pytest >= 7.4` floor. The
+  rootdir-conftest preload (the mechanism that lets `register()` calls run
+  before pytest-django's hook) called the private `_loadconftestmodules`, which
+  **does not exist in pytest 7** — there the method is `_getconftestmodules`,
+  with a different signature and no `consider_namespace_packages` concept. On
+  pytest 7 the call raised `AttributeError`, was swallowed by the preload's
+  broad `except`, and the rootdir conftest was silently never preloaded, so
+  `register()`-based config and early env injection didn't take effect (6 tests
+  failed). The preload now dispatches on method presence: `_loadconftestmodules`
+  (with `consider_namespace_packages`) on pytest >= 8, falling back to
+  `_getconftestmodules(path, importmode, rootpath)` on pytest 7.
+
+### Added
+
+- Test matrix across pytest 7.x, 8.x and 9.x (Python 3.10–3.13), runnable
+  locally via `tox` (new `tox.ini`, `tox`/`tox-uv` added to the `dev` extra) and
+  mirrored in CI. The `py3.13 × pytest7` cell is excluded (pytest gained Python
+  3.13 support in 8.3). CI also splits linting into its own job.
+
+### Changed
+
+- Relaxed the pytest dependency cap from `<9` to `<10`, so the package installs
+  alongside pytest 9 (validated by the new matrix). Bumped the
+  `pytest-testcontainers` floor to `>= 0.2.0`, the release whose own pytest cap
+  was raised to `<10` (0.1.0 pinned `pytest < 9` and would otherwise block
+  pytest 9 transitively).
+
+## [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.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-testcontainers-django
-Version: 0.2.2
+Version: 0.2.4
 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
@@ -49,8 +49,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
 Requires-Dist: pytest-django>=4
-Requires-Dist: pytest-testcontainers<2,>=0.1
-Requires-Dist: pytest<9,>=7.4
+Requires-Dist: pytest-testcontainers<2,>=0.2
+Requires-Dist: pytest<10,>=7.4
 Requires-Dist: testcontainers<5,>=4.7
 Requires-Dist: tomli>=2; python_version < '3.11'
 Provides-Extra: baseline
@@ -62,6 +62,8 @@ Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: pytest-xdist; extra == 'dev'
 Requires-Dist: redis>=4; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: tox-uv>=1; extra == 'dev'
+Requires-Dist: tox>=4; extra == 'dev'
 Provides-Extra: redis
 Requires-Dist: redis>=4; extra == 'redis'
 Description-Content-Type: text/markdown

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytest-testcontainers-django"
-version = "0.2.2"
+version = "0.2.4"
 description = "Bridge between pytest-testcontainers and pytest-django: starts the DB container before Django imports settings."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -43,9 +43,11 @@ classifiers = [
     "Topic :: Software Development :: Testing",
 ]
 dependencies = [
-    "pytest >=7.4,<9",
+    # Upper bound is a precautionary major-version cap, not a known break.
+    # Validated against pytest 7/8/9 by the tox + CI matrix before each bump.
+    "pytest >=7.4,<10",
     "pytest-django >=4",
-    "pytest-testcontainers >=0.1,<2",
+    "pytest-testcontainers >=0.2,<2",
     "testcontainers >=4.7,<5",
     "tomli >=2 ; python_version < '3.11'",
 ]
@@ -60,6 +62,8 @@ dev = [
     "django >=4.2",
     "django-environ",
     "redis >=4",
+    "tox >=4",
+    "tox-uv >=1",
 ]
 
 [project.urls]

{pytest_testcontainers_django-0.2.2 → pytest_testcontainers_django-0.2.4}/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
@@ -182,31 +196,49 @@ def _preload_rootdir_conftest(early_config: pytest.Config) -> None:
     pluginmanager = early_config.pluginmanager
     rootpath = Path(getattr(early_config, "rootpath", Path.cwd()))
     importmode = early_config.getoption("importmode", default="prepend")
-    consider_namespace_packages = bool(early_config.getini("consider_namespace_packages"))
+    # pytest changed its private conftest-loading API across majors, so we
+    # dispatch on method presence (feature detection) rather than a version
+    # number:
+    #   * pytest >= 8.0 exposes ``_loadconftestmodules(path, importmode, rootpath,
+    #     *, consider_namespace_packages)`` together with the matching ini option.
+    #   * pytest 7.x has no such method; ``_getconftestmodules(path, importmode,
+    #     rootpath)`` performs the same conftest-import side effect and has no
+    #     namespace-packages concept (the ini does not exist there either).
+    loadconftestmodules = getattr(pluginmanager, "_loadconftestmodules", None)
     try:
-        pluginmanager._loadconftestmodules(  # type: ignore[attr-defined]
-            rootpath,
-            importmode,
-            rootpath,
-            consider_namespace_packages=consider_namespace_packages,
-        )
+        if loadconftestmodules is not None:
+            loadconftestmodules(
+                rootpath,
+                importmode,
+                rootpath,
+                consider_namespace_packages=bool(
+                    early_config.getini("consider_namespace_packages")
+                ),
+            )
+        else:
+            pluginmanager._getconftestmodules(  # type: ignore[attr-defined]
+                rootpath,
+                importmode,
+                rootpath,
+            )
     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.4}/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: