Disallow nesting of part_of_a_transaction

Add durable=True to the atomic call inside part_of_a_transaction
so that nesting is explicitly disallowed. This prevents tests from
looking like they nest partial-transaction behaviour, which does
not reflect real-world usage.

Fixes #150

Co-authored-by: Charlie Denton <charlie@meshy.co.uk>

Author: Giggitycountless

CHANGELOG.md

@@ -8,6 +8,8 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 
 - Added MariaDB and SQLite to the test matrix.
+- Disallowed nesting of `part_of_a_transaction` to prevent nonsense
+  implication of nested partial transactions in tests. Fixes #150.
 
 ## [1.0.0] - 2026-04-16
 

src/django_subatomic/test.py

@@ -32,5 +32,5 @@ def part_of_a_transaction(using: str | None = None) -> Generator[None]:
     Note that this does not handle after-commit callback simulation. If you need that,
     use [`transaction`][django_subatomic.db.transaction] instead.
     """
-    with transaction.atomic(using=using):
+    with transaction.atomic(using=using, durable=True):
         yield

tests/test_test.py

@@ -1,13 +1,26 @@
 from __future__ import annotations
 
+import re
+from typing import TYPE_CHECKING
+
 import pytest
+from django.db import transaction as django_transaction
 
 from django_subatomic import db, test
 
 
 DEFAULT = "default"
 pytestmark = [pytest.mark.django_db(databases=[DEFAULT])]
 
+if TYPE_CHECKING:
+    import contextlib
+    from typing import Protocol
+
+    class DBContextManager(Protocol):
+        def __call__(
+            self, *, using: str | None = None
+        ) -> contextlib.AbstractContextManager[None, None]: ...
+
 
 class TestPartOfATransaction:
     """
@@ -35,3 +48,28 @@ def _callback_which_should_not_be_called() -> None:
 
         with test.part_of_a_transaction():
             db.run_after_commit(_callback_which_should_not_be_called)
+
+    @pytest.mark.parametrize(
+        "transaction_manager",
+        (
+            db.transaction,
+            db.transaction_if_not_already,
+            django_transaction.atomic,
+            test.part_of_a_transaction,
+        ),
+    )
+    def test_fails_when_nested_inside_an_atomic_block(
+        self, transaction_manager: DBContextManager
+    ) -> None:
+        """
+        `part_of_a_transaction` cannot be nested inside another atomic block.
+        """
+        with transaction_manager():
+            with pytest.raises(
+                RuntimeError,
+                match=re.escape(
+                    "A durable atomic block cannot be nested within another atomic block."
+                ),
+            ):
+                with test.part_of_a_transaction():
+                    ...