Exposes the underlining TestCase instance to avoid using "asserts" module

docs/helpers.rst

@@ -7,11 +7,7 @@ Assertions
 ----------
 
 All of Django's :class:`~django:django.test.TestCase`
-:ref:`django:assertions` are available in ``pytest_django.asserts``, e.g.
-
-::
-
-    from pytest_django.asserts import assertTemplateUsed
+:ref:`django:assertions` are available via the :fixture:`djt` fixture.
 
 Markers
 -------
@@ -301,6 +297,27 @@ Example
 Using the `admin_client` fixture will cause the test to automatically be marked
 for database use (no need to specify the :func:`~pytest.mark.django_db` mark).
 
+.. fixture:: djt
+
+``djt`` - Django test case assertions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Instance of the test case class. This fixture is particularly useful when you want
+to use Django's specialized assertions for testing web applications.
+
+Example
+"""""""
+
+::
+
+    def test_add(djt):
+        djt.assertEqual(1 + 1, 2)
+        djt.assertXMLEqual(..., ...)
+        djt.assertJSONEqual(..., ...)
+
+        with djt.assertNumQueries(2):
+            some_function()
+
 .. fixture:: admin_user
 
 ``admin_user`` - an admin user (superuser)

pytest_django/asserts.py

@@ -30,6 +30,15 @@ def _wrapper(name: str) -> Callable[..., Any]:
 
     @wraps(func)
     def assertion_func(*args: Any, **kwargs: Any) -> Any:
+        message = (
+            f"Using pytest_django.asserts.{name} is deprecated. "
+            f'Use fixture "djt" and djt.{name} instead.'
+        )
+        warnings.warn(
+            message,
+            DeprecationWarning,
+            stacklevel=2,
+        )
         return func(*args, **kwargs)
 
     return assertion_func

pytest_django/fixtures.py

@@ -44,6 +44,8 @@
     "django_db_reset_sequences",
     "django_db_serialized_rollback",
     "django_db_setup",
+    "django_testcase",
+    "django_testcase_class",
     "django_user_model",
     "django_username_field",
     "live_server",
@@ -204,15 +206,17 @@ def django_db_setup(  # noqa: PLR0917
 
 
 @pytest.fixture
-def _django_db_helper(
+def django_testcase_class(
     request: pytest.FixtureRequest,
     django_db_setup: None,  # noqa: ARG001
     django_db_blocker: DjangoDbBlocker,
 ) -> Generator[None]:
     if is_django_unittest(request):
-        yield
+        yield None
         return
 
+    import django.test
+
     marker = request.node.get_closest_marker("django_db")
     if marker:
         (
@@ -241,9 +245,63 @@ def _django_db_helper(
         "django_db_serialized_rollback" in request.fixturenames
     )
 
+    if transactional:
+        test_case_class = django.test.TransactionTestCase
+    else:
+        test_case_class = django.test.TestCase
+
+    _reset_sequences = reset_sequences
+    _serialized_rollback = serialized_rollback
+    _databases = databases
+    _available_apps = available_apps
+
+    class PytestDjangoTestCase(test_case_class):  # type: ignore[misc,valid-type]
+        reset_sequences = _reset_sequences
+        serialized_rollback = _serialized_rollback
+        if _databases is not None:
+            databases = _databases
+        if _available_apps is not None:
+            available_apps = _available_apps
+
+        # For non-transactional tests, skip executing `django.test.TestCase`'s
+        # `setUpClass`/`tearDownClass`, only execute the super class ones.
+        #
+        # `TestCase`'s class setup manages the `setUpTestData`/class-level
+        # transaction functionality. We don't use it; instead we (will) offer
+        # our own alternatives. So it only adds overhead, and does some things
+        # which conflict with our (planned) functionality, particularly, it
+        # closes all database connections in `tearDownClass` which inhibits
+        # wrapping tests in higher-scoped transactions.
+        #
+        # It's possible a new version of Django will add some unrelated
+        # functionality to these methods, in which case skipping them completely
+        # would not be desirable. Let's cross that bridge when we get there...
+        if not transactional:
+
+            @classmethod
+            def setUpClass(cls) -> None:
+                super(django.test.TestCase, cls).setUpClass()
+
+            @classmethod
+            def tearDownClass(cls) -> None:
+                super(django.test.TestCase, cls).tearDownClass()
+
+    yield PytestDjangoTestCase
+
+
+@pytest.fixture
+def _django_db_helper(
+    request: pytest.FixtureRequest,
+    django_db_setup: None,  # noqa: ARG001
+    django_db_blocker: DjangoDbBlocker,
+    django_testcase_class: type[django.test.TestCase],
+) -> Generator[None, None, None]:
+    if is_django_unittest(request):
+        yield
+        return
+
     with django_db_blocker.unblock():
-        import django.db
-        import django.test
+        django_testcase_class.setUpClass()
 
         if transactional:
             test_case_class = django.test.TransactionTestCase
@@ -294,13 +352,13 @@ def tearDownClass(cls) -> None:
             # this flag to say so.
             test_case._pre_setup()
 
-        yield
+        yield test_case
 
         test_case._post_teardown()
 
-        PytestDjangoTestCase.tearDownClass()
+        django_testcase_class.tearDownClass()
 
-        PytestDjangoTestCase.doClassCleanups()
+        django_testcase_class.doClassCleanups()
 
 
 def _django_db_signature(
@@ -370,6 +428,11 @@ def _set_suffix_to_test_databases(suffix: str) -> None:
 # ############### User visible fixtures ################
 
 
+@pytest.fixture(name="djt")
+def django_testcase(_django_db_helper: django.test.TestCase | None) -> django.test.TestCase | None:
+    return _django_db_helper
+
+
 @pytest.fixture
 def db(_django_db_helper: None) -> None:
     """Require a django test database.

pytest_django/plugin.py

@@ -42,6 +42,8 @@
     django_db_serialized_rollback,  # noqa: F401
     django_db_setup,  # noqa: F401
     django_db_use_migrations,  # noqa: F401
+    django_testcase,  # noqa: F401
+    django_testcase_class,  # noqa: F401
     django_user_model,  # noqa: F401
     django_username_field,  # noqa: F401
     live_server,  # noqa: F401

tests/test_asserts.py

@@ -8,8 +8,11 @@
 from collections.abc import Sequence
 from typing import cast
 
+import django.test
 import pytest
 
+from .helpers import DjangoPytester
+
 import pytest_django
 from pytest_django.asserts import __all__ as asserts_all
 
@@ -73,3 +76,61 @@ def test_sanity() -> None:
         pass
 
     assert assertContains.__doc__
+
+
+def test_fixture_assert(djt: django.test.TestCase) -> None:
+    djt.assertEqual("a", "a")  # noqa: PT009
+
+    with pytest.raises(AssertionError):
+        djt.assertXMLEqual("a" * 10_000, "a")
+
+
+class TestInternalDjangoAssert:
+    def test_fixture_assert(self, djt: django.test.TestCase) -> None:
+        assert djt != self
+        djt.assertEqual("a", "a")  # noqa: PT009
+        assert not hasattr(self, "assertEqual")
+
+        with pytest.raises(AssertionError):
+            djt.assertXMLEqual("a" * 10_000, "a")
+
+
+@pytest.mark.django_project(create_manage_py=True)
+def test_django_test_case_assert(django_pytester: DjangoPytester) -> None:
+    django_pytester.create_test_module(
+        """
+        import pytest
+        import django.test
+
+        class TestDjangoAssert(django.test.TestCase):
+            def test_fixture_assert(self, djt: django.test.TestCase) -> None:
+                assert False, "Cannot use the fixture"
+
+            def test_normal_assert(self) -> None:
+                self.assertEqual("a", "a")
+                with pytest.raises(AssertionError):
+                    self.assertXMLEqual("a" * 10_000, "a")
+        """
+    )
+    result = django_pytester.runpytest_subprocess()
+    result.assert_outcomes(failed=1, passed=1)
+    assert "missing 1 required positional argument: 'djt'" in result.stdout.str()
+
+
+@pytest.mark.django_project(create_manage_py=True)
+def test_unittest_assert(django_pytester: DjangoPytester) -> None:
+    django_pytester.create_test_module(
+        """
+        import unittest
+
+        class TestUnittestAssert(unittest.TestCase):
+            def test_fixture_assert(self, djt: unittest.TestCase) -> None:
+                assert False, "Cannot use the fixture"
+
+            def test_normal_assert(self) -> None:
+                self.assertEqual("a", "a")
+        """
+    )
+    result = django_pytester.runpytest_subprocess()
+    result.assert_outcomes(failed=1, passed=1)
+    assert "missing 1 required positional argument: 'djt'" in result.stdout.str()