Gestion des modèles non gérés dans Pytest-Django

Le défi de tester des modèles non gérés

Dans les projets Django, nous rencontrons occasionnellement des modèles non gérés, des modèles qui n'ont pas géré = True dans leurs méta-options. Ces modèles peuvent rendre les tests délicats, en particulier lorsque votre configuration de test implique un mélange de modèles gérés et non gérés ou plusieurs bases de données (par exemple, une avec des modèles gérés et une autre avec des modèles non gérés).

Cet article de blog explore les approches permettant de tester des modèles non gérés avec pytest-django, en mettant en évidence les avantages, les inconvénients et les solutions de contournement pour vous aider à gérer ces scénarios efficacement.

Approche 1 : marquer tous les modèles comme gérés

Un moyen simple de gérer les modèles non gérés pendant les tests consiste à les marquer temporairement comme gérés. Voici comment procéder :

# Add this to conftest.py
@pytest.hookimpl(tryfirst=True)
def pytest_runtestloop():
    from django.apps import apps
    unmanaged_models = []
    for app in apps.get_app_configs():
        unmanaged_models += [m for m in app.get_models()
                             if not m._meta.managed]
    for m in unmanaged_models:
        m._meta.managed = True

Remarque : pour que cette approche fonctionne, vous devez ajouter une option --no-migrations à vos paramètres pytest (ou pytest.ini)

Référence : Débordement de pile

Avantages :

• Simple à mettre en œuvre.

Inconvénients :

• Ignore les tests de migration, ce qui peut entraîner des problèmes lorsque plusieurs développeurs travaillent sur le même projet.

Approche 2 : créer manuellement des modèles non gérés

Vous pouvez également créer manuellement des modèles non gérés lors de la configuration du test. Cette approche garantit que les migrations sont testées :

@pytest.fixture(scope="session", autouse=True)
def django_db_setup(django_db_blocker, django_db_setup):
    with django_db_blocker.unblock():
        for _connection in connections.all():
            with _connection.schema_editor() as schema_editor:
                setup_unmanaged_models(_connection, schema_editor)
        yield

def setup_unmanaged_models(connection, schema_editor):
    from django.apps import apps

    unmanaged_models = [
        model for model in apps.get_models() if model._meta.managed is False
    ]
    for model in unmanaged_models:
        if model._meta.db_table in connection.introspection.table_names():
            schema_editor.delete_model(model)
        schema_editor.create_model(model)

Avantages :

• Teste les migrations dans le cadre de vos cas de test.

Inconvénients :

• Légèrement plus complexe.
• transaction=True ne fonctionne pas avec cette approche (discutée dans la section suivante).

Comprendre les tests transactionnels

Pytest-django fournit un accessoire de base de données : django_db et django_db(transaction=True). Voici en quoi ils diffèrent :

django_db : Annule les modifications à la fin d'un scénario de test, ce qui signifie qu'aucune validation réelle n'est effectuée dans la base de données.

django_db(transaction=True): Valide les modifications et tronque les tables de la base de données après chaque scénario de test. Étant donné que seuls les modèles gérés sont tronqués après chaque test, c'est la raison pour laquelle les modèles non gérés nécessitent un traitement spécial lors des tests transactionnels.

Exemple de cas de test

@pytest.mark.django_db
def test_example():
    # Test case logic here
    pass

@pytest.mark.django_db(transaction=True)
def test_transactional_example():
    # Test case logic here
    pass

Faire fonctionner les tests transactionnels avec des modèles non gérés

Étant donné que les tests transactionnels tronquent uniquement les modèles gérés, nous pouvons modifier les modèles non gérés pour qu'ils soient gérés pendant l'exécution du test. Cela garantit qu'ils sont inclus dans la troncature :

# Add this to conftest.py
@pytest.hookimpl(tryfirst=True)
def pytest_runtestloop():
    from django.apps import apps
    unmanaged_models = []
    for app in apps.get_app_configs():
        unmanaged_models += [m for m in app.get_models()
                             if not m._meta.managed]
    for m in unmanaged_models:
        m._meta.managed = True

Éviter transaction = True avec on_commit Hooks (si possible)

Dans les scénarios impliquant des hooks on_commit, vous pouvez éviter d'utiliser des tests transactionnels en capturant et en exécutant directement les rappels on_commit, en utilisant le luminaire django_capture_on_commit_callbacks de pytest-django(>= v.4.4) :

@pytest.fixture(scope="session", autouse=True)
def django_db_setup(django_db_blocker, django_db_setup):
    with django_db_blocker.unblock():
        for _connection in connections.all():
            with _connection.schema_editor() as schema_editor:
                setup_unmanaged_models(_connection, schema_editor)
        yield

def setup_unmanaged_models(connection, schema_editor):
    from django.apps import apps

    unmanaged_models = [
        model for model in apps.get_models() if model._meta.managed is False
    ]
    for model in unmanaged_models:
        if model._meta.db_table in connection.introspection.table_names():
            schema_editor.delete_model(model)
        schema_editor.create_model(model)

Références

• Documentation pytest-django
• Débordement de pile : tester des modèles non gérés

Avez-vous d'autres approches ou conseils pour gérer les modèles non gérés ? Partagez-les dans les commentaires ci-dessous !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!