Is it possible to run a django pytest that has access to multiple databases, without executing the test against each database?

I have a Django project in which I'm trying to add a second database, however I'm having a hard time getting my existing test suite to cooperate.
I'm utilizing django==3.2.16, pytest==6.2.2 along with pytest-django==4.3.0.

I seem to be running into two problems:

I'm seeing tests fail with an error like such

AssertionError: Database queries to 'second' are not allowed in this test. Add 'second' to pytest_django.fixtures._django_db_fixture_helper.<locals>.PytestDjangoTestCase.databases to ensure proper test isolation and silence this failure.

From what I've found through issues and documentation is that I can do something like this to configure the test to have permission to the second db

pytestmark = pytest.mark.django_db(databases=['default', 'second'])

By having this at the top of my test file, it seems all the tests within have access to 'second', but this comes with the side effect that the test is now run TWICE, on each of the databases.

[gw0] [  2%] PASSED src/app/tests/test_some_stuff.py::test_case_1
[gw0] [  2%] ERROR src/app/tests/test_some_stuff.py::test_case_1

That is not the behaviour I'm looking for. I need the test to be run once, with access to both databases, and I can't seem to find an existing solution for this.

I just seem to be going in circles here...if I specify just one db the test fails because it doesn't have permission to access the second db. If I specify both, the first run succeeds and the other run fails. Is there a way I can just throw out the second run or something?

Yes, it's definitely possible to run a single test with access to both databases without having it run twice. When you specify multiple databases with pytest.mark.django_db(databases=['default', 'second']), pytest-django will by default run the test for each database. But you can disable this behavior with a simple setting.

Path 1

You should be able to achieve the desired behavior by making the following changes:

1. Configure pytest to not run tests for each database

   Update your pytest configuration (usually pytest.ini or pyproject.toml) with the following:

   [pytest]
   django_find_project = false
   addopts = --ds=myproject.settings
   databases = default second
   multi_db = true
   

   By setting multi_db = true, you allow Django to set up both databases for each test that uses the database, without running the test separately for each database.

2. Add the pytestmark to your test file

   You've already done this, but just for clarity:

   pytestmark = pytest.mark.django_db(databases=['default', 'second'])
   

   This mark tells pytest-django that the test should be set up with access to both the default and second databases.

With these configurations, the test should be run only once, but it will have access to both the default and second databases.

Path 2

1. Create a custom pytest marker:

   You can define a custom marker in your pytest configuration. Add this to your pytest.ini:

   [pytest]
   markers =
       dual_db: mark test as using both default and secondary databases
   

2. Use the marker in your tests:

   Mark the tests that need to use both databases with the new custom marker:

   @pytest.mark.dual_db
   def test_some_function():
       # your test code here
   

3. Customize Database Handling in conftest.py:

   Add a file named conftest.py at the top level of your tests folder (if it doesn't already exist). Use it to customize pytest's behavior for tests marked with the custom dual_db marker:

   import pytest
   from pytest_django.fixtures import _django_db_fixture_helper
   
   @pytest.hookimpl(tryfirst=True)
   def pytest_collection_modifyitems(items):
       for item in items:
           if item.get_closest_marker(name="dual_db"):
               # Attach databases to the test
               setattr(item, 'databases', ['default', 'second'])
   
   @pytest.fixture(autouse=True)
   def enable_db_access_for_dual_db(request):
       marker = request.node.get_closest_marker(name="dual_db")
       if marker:
           _django_db_fixture_helper(request, ['default', 'second'])
   

   This code will customize the test collection phase to check for tests marked with dual_db, and then it will set the databases attribute for those tests, allowing them to access both databases. The fixture enable_db_access_for_dual_db is automatically used for all tests because of the autouse=True argument and ensures that both databases are accessible.

With this setup, your tests marked with @pytest.mark.dual_db should only run once, but they'll have access to both databases.