Pytest-django: एकाधिक डेटाबेस के साथ परीक्षणों के बीच समर्थन सफाई

क्या आप अपने पैच किए गए संस्करण का उपयोग करके एक उदाहरण परीक्षण दे सकते हैं जो दो डेटाबेस का उपयोग करता है? मुझे लगता है कि यह समझने में मदद करेगा कि कितने डेटाबेस का उपयोग किया जाता है और आपको दूसरे पर नियंत्रण की आवश्यकता होती है और फिर multi_db को सत्य पर सेट करना।

DATABASES = {
    'default': {
        'ENGINE'   : 'django.db.backends.sqlite3',
        'NAME'     : 'default.db',
    },
    'operations': {
        'ENGINE'   : 'django.db.backends.sqlite3',
        'NAME'     : 'operations.db',
    },
}

मेरे अधिकांश/सभी मॉडल दूसरे डेटाबेस "ऑपरेशंस" से जुड़े हैं। मेरा मानना ​​​​है कि Django का टेस्टकेस डिफ़ॉल्ट डीबी पर लेनदेन को सही ढंग से फ्लश करेगा, लेकिन अन्य नहीं जब तक multi_db=True ।

यहां कुछ नमूना परीक्षण दिए गए हैं:

from collection.models import Foo

def test_one(db):
    Foo.objects.create()
    assert Foo.objects.count() == 1

def test_two(db):
    assert Foo.objects.count() == 0

ऊपर वर्णित मेरे पैच किए गए db स्थिरता के साथ आउटपुट यहां दिया गया है:

$ py.test multi_db_test/ -vv
======================================= test session starts =======================================
platform linux2 -- Python 2.7.2 -- py-1.4.20 -- pytest-2.5.2 -- bin/python
plugins: django
collected 2 items

multi_db_test/test_foo.py:3: test_one PASSED
multi_db_test/test_foo.py:7: test_two PASSED

==================================== 2 passed in 5.75 seconds =====================================

यहाँ pytest_django के अपने db स्थिरता के साथ आउटपुट है:

$ py.test multi_db_test/ -vv
======================================= test session starts =======================================
platform linux2 -- Python 2.7.2 -- py-1.4.20 -- pytest-2.5.2 -- bin/python
plugins: django
collected 2 items

multi_db_test/test_foo.py:3: test_one PASSED
multi_db_test/test_foo.py:7: test_two FAILED

============================================ FAILURES =============================================
____________________________________________ test_two _____________________________________________

db = None

    def test_two(db):
>       assert Foo.objects.count() == 0
E       assert 1 == 0
E        +  where 1 = <bound method Manager.count of <django.db.models.manager.Manager object at 0x3cd0890>>()
E        +    where <bound method Manager.count of <django.db.models.manager.Manager object at 0x3cd0890>> = <django.db.models.manager.Manager object at 0x3cd0890>.count
E        +      where <django.db.models.manager.Manager object at 0x3cd0890> = Foo.objects

multi_db_test/test_foo.py:8: AssertionError
=============================== 1 failed, 1 passed in 5.85 seconds ===============================

तो एक त्वरित रूप से ऐसा लगता है कि multi_db स्थिरता और pytest.mark.django_db(multi=True) एक एपीआई के रूप में काम कर सकता है? किसी और के पास कोई बेहतर विचार है?

यह वाजिब लगता है। मेरे पास निश्चित रूप से अन्य विचार नहीं हैं, बेहतर या अन्यथा।

नमस्कार। क्या इस मुद्दे के अलावा multi_db समर्थन के बारे में कोई चर्चा है? डॉक्स का कहना है कि किसी को संपर्क करना चाहिए लेकिन इस पर वर्तमान स्थिति क्या है?

@slafs इसके अलावा बहु डेटाबेस समर्थन के लिए बहुत अधिक चर्चा/अनुरोध नहीं हुए हैं।

multi_db=True को पास करना बहुत आसान होगा, लेकिन इसके लिए हमें कुछ प्रकार के परीक्षणों की भी आवश्यकता है, इसलिए हमें द्वितीयक डेटाबेस सेट अप की भी आवश्यकता है। अगर कोई इस पर काम करने को तैयार है, तो यह बहुत अच्छा होगा :)

मैं शुरुआती पोस्ट में वर्कअराउंड @ftobia उल्लेखों का उपयोग कर रहा हूं, लेकिन 1.7 से Django 1.8.4 में अपग्रेड करने के बाद इसने काम करना बंद कर दिया।

एक इंस्टेंस विशेषता के बजाय multi_db वर्ग विशेषता के लिए कोड हैंडलिंग सेटअप/टियरडाउन लुक बनाने के लिए Django परिवर्तन था।

@ftobia के कार्य-आसपास को निम्नलिखित में बदलना मेरे लिए

case = TestCase(methodName='__init__')
case.__class__.multi_db = True
case._pre_setup()
request.addfinalizer(case._post_teardown)
request.addfinalizer(_django_cursor_wrapper.disable)

+1:+1:

यह हमें Django टेस्ट रनर से pytest पर स्विच करने से रोक रहा है।

यहाँ डिफ़ॉल्ट रूप से django_case.multi_db = True का उपयोग क्यों न करें https://github.com/pytest-dev/pytest-django/blob/master/pytest_django/fixtures.py#L107 ?

+1

+1

मुझे लगता है कि django_db मार्कर पर मार्कर होने से मैं अच्छा एपीआई पसंद करूंगा:

@pytest.mark.django_db(transactional=True, multi_db=True)
def test_a():
    pass

कार्यान्वयन अपेक्षाकृत reset_sequences (पीआर #308) या serialized_rollback (पीआर #353) के समान होना चाहिए।

"मुश्किल" भाग कई डेटाबेस रखने के लिए pytest-django के आंतरिक परीक्षण सूट में सुधार करना होगा।

अगर कोई इसमें काम करना चाहता है तो मैं निश्चित रूप से इसकी समीक्षा करूंगा और इसे मर्ज करने में मदद करूंगा। पीआर पर काम करना शुरू करने के लिए स्वतंत्र महसूस करें यदि यह ऐसा कुछ है जो आपके लिए दिलचस्प होगा!

https://github.com/pytest-dev/pytest-django/pull/397#issuecomment -261987751 पर कुछ टिप्पणियां छोड़ दीं, और एक पीआर बनाया, जो इसे सामान्य तरीके से बदलने की अनुमति देगा: https://github। com/pytest-dev/pytest-django/pull/431.

अस्थायी समाधान की तलाश करने वालों के लिए multi_db सक्षम करने का एक अन्य विकल्प। इसे conftest.py . में डालें

def pytest_sessionstart(session):
    from django.test import TransactionTestCase
    TransactionTestCase.multi_db = True

कामकाज की तलाश में किसी और के लिए, ध्यान दें कि multi_db Django 2.2 में बहिष्कृत किया गया था। मेरे लिए काम करने वाला प्रतिस्थापन है:

TransactionTestCase.databases = set(settings.DATABASES.keys())

@jcushman क्या आप अपने द्वारा उपयोग किए गए पूर्ण स्थिरता या कोड स्निपेट को साझा करना चाहते हैं?

जो भी कारण के लिए, pytest_sessionstart() हमारे आधार में conftest.py कुछ भी नहीं कर रहा था। मानक पाइटेस्ट monkeypatch सामान के साथ #342 से एक पृष्ठ लिया और हमारे बहु-डेटाबेस उपयोग के लिए निम्नलिखित पर पहुंचे:

# OPTION 1: Function fixture; must be included with tests
@pytest.fixture
def django_db_multiple(monkeypatch, request, settings):
    """
    Ensure all test functions using Django test cases have multiple database
    support. This is mostly/only so that Django will wrap ALL database use with
    atomic blocks like it does for DEFAULT_DB_ALIAS.

    https://github.com/django/django/blob/master/django/test/testcases.py#L903
    https://github.com/pytest-dev/pytest-django/issues/76
    """
    from django.test import TestCase
    from django.test import TransactionTestCase

    db_keys = set(settings.DATABASES.keys())

    monkeypatch.setattr(TestCase, 'databases', db_keys)
    monkeypatch.setattr(TransactionTestCase, 'databases', db_keys)

@pytest.mark.django_db
def test_some_test(django_db_multiple):
    pass

# OPTION 2: Session fixture
@pytest.fixture(autouse=True, scope='session')
def django_db_multiple():
    """
    Ensure all test functions using Django test cases have multiple database
    support. This is mostly/only so that Django will wrap ALL database use with
    atomic blocks like it does for DEFAULT_DB_ALIAS.

    https://github.com/django/django/blob/master/django/test/testcases.py#L903
    https://github.com/pytest-dev/pytest-django/issues/76
    https://github.com/pytest-dev/pytest/issues/1872
    """
    from _pytest.monkeypatch import MonkeyPatch
    from django.test import TestCase
    from django.test import TransactionTestCase
    from django.conf import settings

    db_keys = set(settings.DATABASES.keys())

    monkeypatch = MonkeyPatch()
    monkeypatch.setattr(TestCase, 'databases', db_keys)
    monkeypatch.setattr(TransactionTestCase, 'databases', db_keys)

    yield monkeypatch

    monkeypatch.undo()

_संपादित करें: हम एक सत्र स्थिरता में चले गए।_

सबसे पहले Django परीक्षण मामलों में स्विच करके pytest महाशक्तियों को ढीला नहीं करने के लिए, मैंने इस बदसूरत (अभी तक काम कर रहे!) हैक के लिए pytest-django आंतरिक की प्रतिलिपि बनाई और पैच किया:

from typing import Optional, Type, TypeVar

import pytest
from django.test import TransactionTestCase
from pytest_django.django_compat import is_django_unittest

TestCase = TypeVar('TestCase', bound=TransactionTestCase)


def _django_db_fixture_helper(
    request, django_db_blocker, transactional: bool = False, reset_sequences: bool = False,
) -> Optional[Type[TestCase]]:
    if is_django_unittest(request):
        return None

    if not transactional and 'live_server' in request.fixturenames:
        # Do nothing, we get called with transactional=True, too.
        return None

    django_db_blocker.unblock()
    request.addfinalizer(django_db_blocker.restore)

    if transactional:
        from django.test import TransactionTestCase as DjangoTestCase  # noqa: WPS433

        if reset_sequences:

            class ResetSequenceTestCase(DjangoTestCase):  # noqa: WPS431
                reset_sequences = True

            DjangoTestCase = ResetSequenceTestCase  # type: ignore[misc] # noqa: N806
    else:
        from django.test import TestCase as DjangoTestCase  # type: ignore[no-redef] # noqa: WPS433

    return DjangoTestCase  # type: ignore[return-value]


@pytest.fixture()
def db_case(request, django_db_setup, django_db_blocker):
    """Require a django test database.

    This database will be setup with the default fixtures and will have
    the transaction management disabled. At the end of the test the outer
    transaction that wraps the test itself will be rolled back to undo any
    changes to the database (in case the backend supports transactions).
    This is more limited than the ``transactional_db`` resource but
    faster.

    If multiple database fixtures are requested, they take precedence
    over each other in the following order (the last one wins): ``db``,
    ``transactional_db``, ``django_db_reset_sequences``.
    """
    if 'django_db_reset_sequences' in request.fixturenames:
        request.getfixturevalue('django_db_reset_sequences')
    if (
        'transactional_db' in request.fixturenames
        or 'live_server' in request.fixturenames
    ):
        request.getfixturevalue('transactional_db')
    else:
        django_case: Optional[Type[TransactionTestCase]] = _django_db_fixture_helper(
            request, django_db_blocker, transactional=False,
        )

        def factory(dbs=None):  # noqa: WPS430
            if django_case is None:
                return
            CaseType: Type[TransactionTestCase] = django_case  # noqa: N806
            if dbs is not None:
                class DatabasesSetTestCase(  # noqa: WPS431
                    CaseType,  # type: ignore[valid-type, misc]
                ):
                    databases = dbs
                CaseType = DatabasesSetTestCase  # noqa: N806
            test_case: TransactionTestCase = CaseType(methodName='__init__')
            test_case._pre_setup()  # type: ignore[attr-defined] # noqa: WPS437
            request.addfinalizer(
                test_case._post_teardown,  # type: ignore[attr-defined] # noqa: WPS437
            )

        return factory

इसके साथ कोई कुछ इस तरह उपयोग कर सकता है:

class TestCase(object):

    def test_ok(
        self,
        db_case,
        ...
    ):
        db_case(dbs=('non_default_db_alias',))

इसका उपयोग db स्थिरता या pytest.mark.django_db चिह्न के बजाय किया जाना चाहिए।

@jcushman क्या आप अपने द्वारा उपयोग किए गए पूर्ण स्थिरता या कोड स्निपेट को साझा करना चाहते हैं?

अगर कोई और इसमें टकराएगा तो जवाब जोड़ना।

आपको नीचे दिए गए कोड को conftest.py में जोड़ना होगा। यह स्थिरता स्वचालित रूप से उठाई जाती है इसलिए इसे किसी परीक्षण में जोड़ने की आवश्यकता नहीं है।

`` `पीई
def pytest_sessionstart (सत्र):
django.test आयात से TransactionTestCase

TransactionTestCase.databases = set(settings.DATABASES.keys())

````

इसलिए मेरा मानना ​​है कि यह मुद्दा उचित बहु-डीबी समर्थन के लिए नीचे आता है। मैं इस मुद्दे को उसके डुप्लिकेट के रूप में बंद कर दूंगा।