Fix two self-review bugs in the baseline + template-default flow

B1: _resolve_baseline_path mutated the caller's init_scripts list via
.insert(0, ...), so re-invocation would keep prepending the baseline
path. Now builds a new PostgresService via dataclasses.replace().

B2: apply_template_default ran BEFORE _resolve_baseline_path, so when a
user enabled use_django_pg_baseline=true with no other init_scripts,
the template default (SPEC §10.6) saw an empty list and skipped — and
DJANGO_DB_TEST_TEMPLATE was never injected, defeating the point of
loading a baseline. Reorder: baseline-resolve first, then template
default.

Adds three regression tests via pytester:
* baseline-only triggers template default (B2)
* register()'d shared PostgresService isn't mutated by the hook (B1)
* missing django-pg-baseline raises a clear error (N4)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mpasternak

src/pytest_testcontainers_django/plugin.py

@@ -68,7 +68,12 @@ def _is_xdist_worker() -> bool:
 
 
 def _resolve_baseline_path(config: DjangoContainerConfig) -> DjangoContainerConfig:
-    """SPEC §10.3 Path B — auto-prepend django-pg-baseline's path when flagged."""
+    """SPEC §10.3 Path B — auto-prepend django-pg-baseline's path when flagged.
+
+    Returns a new config; never mutates the caller's lists, so re-invocation
+    in the same process (pytester scenarios) doesn't keep prepending the
+    baseline path.
+    """
     if not config.use_django_pg_baseline:
         return config
     try:
@@ -79,9 +84,14 @@ def _resolve_baseline_path(config: DjangoContainerConfig) -> DjangoContainerConf
             "installed. Install it (e.g. `pip install pytest-testcontainers-django"
             "[baseline]`) or set the flag to false."
         ) from exc
+    from dataclasses import replace as _replace
+
     baseline = Path(get_baseline_path())
-    config.postgres.init_scripts.insert(0, baseline)
-    return config
+    new_pg = _replace(
+        config.postgres,
+        init_scripts=[baseline, *config.postgres.init_scripts],
+    )
+    return _replace(config, postgres=new_pg)
 
 
 def _preload_rootdir_conftest(early_config: pytest.Config) -> None:
@@ -130,7 +140,6 @@ def pytest_load_initial_conftests(
 
     rootdir = Path(getattr(early_config, "rootpath", Path.cwd()))
     config = _config.load_config(rootdir)
-    config = _config.apply_template_default(config)
 
     if _config.is_disabled(config, args):
         return
@@ -142,7 +151,13 @@ def pytest_load_initial_conftests(
         _env_snapshot = inject_worker(config)
         return
 
+    # Order matters: baseline resolution may add init scripts; the template
+    # default (SPEC §10.6) reads init_scripts to decide whether to default
+    # ``postgres_template = postgres_database``.  Resolving baseline first
+    # ensures use_django_pg_baseline=true triggers the template default
+    # even when the user didn't list any other postgres_init_scripts.
     config = _resolve_baseline_path(config)
+    config = _config.apply_template_default(config)
     _config.validate(config)
 
     _reuse_active = _config.is_reuse_enabled(config)

tests/test_plugin.py

@@ -232,6 +232,102 @@ def test_template_env_set():
     result.assert_outcomes(passed=1)
 
 
+def test_use_django_pg_baseline_triggers_template_default(
+    pytester: pytest.Pytester,
+) -> None:
+    """B2 regression: when only the auto-prepended baseline is in init_scripts,
+    apply_template_default still has to see it to default the template.
+    """
+    sql = pytester.path / "baseline.sql"
+    sql.write_text("-- baseline", encoding="utf-8")
+    _bootstrap(
+        pytester,
+        pyproject_extra="""
+postgres_database = "myapp"
+use_django_pg_baseline = true
+""",
+        conftest_extra=f"""
+import pathlib, sys, types
+fake = types.ModuleType("django_pg_baseline")
+fake.get_baseline_path = lambda: pathlib.Path({str(sql)!r})
+sys.modules["django_pg_baseline"] = fake
+""",
+    )
+    pytester.makepyfile(
+        """
+        import os
+
+        def test_template_defaulted_from_baseline_only():
+            assert os.environ["DJANGO_DB_TEST_TEMPLATE"] == "myapp"
+        """
+    )
+    result = pytester.runpytest("-p", "no:cacheprovider")
+    result.assert_outcomes(passed=1)
+
+
+def test_use_django_pg_baseline_missing_dep_raises(pytester: pytest.Pytester) -> None:
+    """N4 regression: clear error when flag is set but dep isn't installed."""
+    _bootstrap(
+        pytester,
+        pyproject_extra="""
+use_django_pg_baseline = true
+""",
+        conftest_extra="""
+import sys
+# Ensure the import fails inside the hook even if the package is installed
+# at the outer level.
+sys.modules["django_pg_baseline"] = None
+""",
+    )
+    pytester.makepyfile("def test_dummy(): pass")
+    result = pytester.runpytest("-p", "no:cacheprovider")
+    result.stderr.fnmatch_lines(["*django-pg-baseline*"])
+    assert result.ret != 0
+
+
+def test_baseline_path_resolution_does_not_mutate_register_config(
+    pytester: pytest.Pytester,
+) -> None:
+    """B1 regression: re-invoking the hook (or sharing one PostgresService
+    instance across processes via register()) must not keep prepending
+    the baseline path to init_scripts.
+    """
+    sql = pytester.path / "baseline.sql"
+    sql.write_text("-- baseline", encoding="utf-8")
+    _bootstrap(
+        pytester,
+        conftest_extra=f"""
+import pathlib, sys, types
+fake = types.ModuleType("django_pg_baseline")
+fake.get_baseline_path = lambda: pathlib.Path({str(sql)!r})
+sys.modules["django_pg_baseline"] = fake
+
+from pytest_testcontainers_django import (
+    DjangoContainerConfig, PostgresService, register,
+)
+
+# A user might construct one shared config and register it; the hook must
+# not mutate it.
+SHARED_PG = PostgresService(database="myapp")
+register(DjangoContainerConfig(postgres=SHARED_PG, use_django_pg_baseline=True))
+""",
+    )
+    pytester.makepyfile(
+        """
+        def test_init_scripts_not_doubled():
+            from pytest_testcontainers_django import plugin as p
+            from pytest_testcontainers_django import config as c
+            # The user's PostgresService.init_scripts must still be empty —
+            # the hook should have built a NEW config, not pushed onto theirs.
+            registered = c._REGISTERED
+            assert registered is not None
+            assert registered.postgres.init_scripts == [], registered.postgres.init_scripts
+        """
+    )
+    result = pytester.runpytest("-p", "no:cacheprovider")
+    result.assert_outcomes(passed=1)
+
+
 def test_invalid_init_script_path_fails_loudly(pytester: pytest.Pytester) -> None:
     _bootstrap(
         pytester,