Programmation serveur Python : tests étendus avec Django-test-plus

Python est un langage de programmation de haut niveau largement utilisé dans divers domaines, tels que le développement de sites Web, la science des données, l'apprentissage automatique, etc. Parmi eux, le développement de sites Web est l’un des domaines d’application importants de Python. En Python, il existe de nombreux frameworks Web qui peuvent être utilisés pour développer des applications Web, parmi lesquels Django est le plus populaire.

Django est un framework Web efficace et facile à utiliser qui fournit de nombreuses fonctionnalités et outils pour créer rapidement des applications Web. L'un d'eux est Django-Test-Plus, un outil de test étendu pour les applications Django qui facilite l'écriture et la gestion des tests par les développeurs. Dans cet article, nous présenterons comment utiliser Django-Test-Plus pour des tests étendus afin de nous aider à mieux développer des applications Python et Django.

1. Qu'est-ce que Django-Test-Plus ?

Django-Test-Plus est un outil de test étendu pour les applications Django. Il fournit de nombreuses fonctionnalités et outils utiles pour aider les développeurs à rédiger et gérer des tests plus facilement. Certaines des fonctionnalités clés incluent :

1. Remplissez des formulaires avec des champs à choix multiples
2. Ajoutez des formulaires à des ensembles de formulaires imbriqués et testez-les
3. Raccourcis pour générer des données de test
4. Prise en charge des tests de modèles de traduction multilingues
5. Division de la base de données d'heure et de date prise en charge des tests
6. Prend en charge les compagnons de test TestClient et LiveServerTestCase
7. Prend en charge les tests de l'API JSON
8. Fournit d'autres fonctions auxiliaires de test utiles

2.

Avant d'utiliser Django-Test-Plus pour les tests d'extensions, nous devons d'abord l'installer. Il peut être installé en ligne de commande en exécutant la commande suivante :

pip install django-test-plus

Une fois l'installation terminée, nous pouvons l'ajouter au paramètre INSTALLED_APPS de notre projet Django comme ceci :

# settings.py 

INSTALLED_APPS = [
    # 我们的其他应用程序
    # ...
    'test_plus',
]

Nous sommes maintenant prêts à commencer à utiliser Django- Test -Plus fait l'objet de tests étendus.

3. Comment utiliser Django-Test-Plus ?

Ci-dessous, nous présenterons comment utiliser certaines fonctionnalités de Django-Test-Plus pour écrire du code de test.

1. Remplissez le formulaire avec des champs à choix multiples

Pendant le processus de test, nous devons tester si la validation du formulaire est correcte. Django-Test-Plus fournit un moyen pratique de tester des formulaires avec plusieurs champs de sélection. Par exemple, disons que nous avons un formulaire appelé « ExampleForm » dans notre application, qui possède un MultiChoiceField appelé « colors » qui contient des options de couleur (rouge, vert et bleu). En utilisant Django-Test-Plus, nous pouvons remplir le formulaire via :

from django import forms

class ExampleForm(forms.Form):
    colors = forms.MultipleChoiceField(choices=[
        ('red', '红色'),
        ('green', '绿色'),
        ('blue', '蓝色'),
    ])

class ExampleFormTest(TestCase):
    def test_form_valid(self):
        form_data = {
            'colors': ['red', 'green'],
            # 添加其他表单字段
            # ...
        }
        form = ExampleForm(data=form_data)
        self.assertTrue(form.is_valid())

Notez que nous pouvons remplir le formulaire en passant simplement les données du MultiChoiceField au formulaire. Cela peut rendre le code de test plus propre et réduire la quantité de code en double.

2. Ajoutez des formulaires aux ensembles de formulaires imbriqués et testez-les

Dans Django, vous pouvez utiliser des ensembles de formulaires imbriqués pour collecter et traiter des données de formulaire complexes. Lors des tests, nous devons tester si ces formulaires sont validés et traités correctement. En utilisant Django-Test-Plus, nous pouvons facilement ajouter des formulaires à des ensembles de formulaires imbriqués et tester leur validation et leur traitement. Par exemple, disons que nous avons un formulaire principal appelé « ParentForm » dans notre application, qui possède un InlineFormSet appelé « enfants ». Dans cet exemple, nous ajouterons un formulaire enfant appelé "ChildForm" qui sera associé au formulaire parent. En utilisant Django-Test-Plus, nous pouvons ajouter des formulaires aux ensembles de formulaires imbriqués via :

from django.forms import inlineformset_factory

class ChildForm(forms.Form):
    name = forms.CharField()
    age = forms.IntegerField()

class ParentForm(forms.Form):
    #添加其他表单字段
    #...
    children = inlineformset_factory(
        Parent, Child, form=ChildForm,
        fields=['name', 'age'],
        extra=1,
    )

class ParentFormTest(TestCase):
    def test_form_valid(self):
        form_data = {
            #添加主表单数据
            #...
            'children-TOTAL_FORMS': '1',
            'children-INITIAL_FORMS': '0',
            'children-0-name': 'Alice',
            'children-0-age': '12',
        }
        form = ParentForm(data=form_data)
        self.assertTrue(form.is_valid())

En ajoutant des formulaires aux ensembles de formulaires imbriqués, nous pouvons plus facilement tester des applications avec des données de formulaire complexes.

3. Raccourci pour générer des données de test

Pendant le processus de test, nous devons générer fréquemment des données de test. En utilisant Django-Test-Plus, nous pouvons utiliser des générateurs rapides pour générer des données de test. Par exemple, disons que nous avons un modèle appelé « ExampleModel » qui a un CharField appelé « name ». Nous pouvons utiliser le générateur rapide de Django-Test-Plus pour générer des données de test :

from test_plus import TestCase

from myapp.models import ExampleModel

class ExampleModelTest(TestCase):
    def setUp(self):
        self.example = self.make(ExampleModel, name='example')

    def test_model(self):
        self.assertEqual(self.example.name, 'example')

Notez que nous utilisons la méthode make pour générer l'exemple d'objet modèle et lui transmettre la valeur du nom. Cela facilite la génération de données de test, ce qui permet d'obtenir un code de test plus propre.

4. Prise en charge des tests de modèles de traduction multilingues

Dans Django, vous pouvez utiliser des modèles de traduction multilingues pour prendre en charge plusieurs langues. Au cours du processus de test, nous devons tester si le modèle de traduction multilingue est correct. En utilisant Django-Test-Plus, nous pouvons facilement tester des modèles de traduction multilingues. Par exemple, disons que nous avons un modèle traduit dans notre application qui contient une chaîne nommée « exemple ». Nous pouvons utiliser Django-Test-Plus pour tester s'il a été traduit correctement :

from django.test import override_settings

class ExampleTemplateTest(TestCase):
    @override_settings(LANGUAGE_CODE='en')
    def test_example_template_en(self):
        response = self.client.get(reverse('example'))
        self.assertContains(response, 'example')

    @override_settings(LANGUAGE_CODE='zh_cn')
    def test_example_template_zh_cn(self):
        response = self.client.get(reverse('example'))
        self.assertContains(response, '例子')

Notez que lors des tests nous utilisons override_settings pour modifier le code de langue et basculer entre les deux langues. Cela nous permet de tester plus librement les modèles de traduction multilingues.

5. 支持TestClient和LiveServerTestCase的测试伴侣

在Django中，可以使用TestClient和LiveServerTestCase来测试Web应用程序。Django-Test-Plus提供了与这些测试工具一起使用的测试伴侣，以使测试更轻松。例如，假设我们有一个名为“ExampleView”的视图，我们想测试它是否正确或者如何处理HTTP GET请求。我们可以使用Django-Test-Plus中的测试伴侣来测试：

from test_plus import APITestCase

from myapp.views import ExampleView

class ExampleViewTest(APITestCase):
    def setUp(self):
        self.view = ExampleView.as_view()

    def test_view(self):
        response = self.get('myapp:example')
        self.assertEqual(response.status_code, 200)

通过使用测试伴侣，我们可以更方便地使用TestClient和LiveServerTestCase来测试Web应用程序。

6. 支持JSON API测试

在Django中，可以使用Django Rest Framework（DRF）来构建JSON API。在测试过程中，我们需要测试这些API的验证和处理。使用Django-Test-Plus，我们可以轻松地测试JSON API。例如，假设我们有一个名为“ExampleAPIView”的视图，它使用DRF构建了JSON API。我们可以使用Django-Test-Plus来测试它是否正确或者如何处理HTTP GET请求：

from test_plus import APITestCase

from myapp.views import ExampleAPIView

class ExampleAPIViewTest(APITestCase):
    def setUp(self):
        self.view = ExampleAPIView.as_view()

    def test_view(self):
        response = self.get('myapp:example_api')
        self.assertEqual(response.status_code, 200)

通过使用Django-Test-Plus，我们可以更轻松地使用DRF测试JSON API，并使测试代码更加简洁。

7. 提供了一些其他有用的测试辅助函数

除了上述功能外，Django-Test-Plus还提供了许多其他有用的测试辅助函数。如下所示：

1. assert_contains：断言响应包含指定的内容
2. assert_not_contains：断言响应不包含指定内容
3. assert_redirects：断言响应为重定向
4. assert_template_used：断言视图使用了指定的模板
5. assert_form_error：测试表单验证错误
6. assert_messages_contains：测试消息中包含指定内容
7. assert_messages_not_contains：测试消息中不包含指定内容
8. assert_select_related：测试查询结果中是否使用了select_related

通过使用这些其他有用的测试辅助函数，我们可以更轻松地编写测试代码，并使测试代码更加简洁。

四、总结

在本文中，我们介绍了Django-Test-Plus，它是一个用于Django应用程序的扩展测试工具。我们详细介绍了它的功能和用法，并给出了一些示例代码。通过使用Django-Test-Plus，我们可以更轻松地编写和管理测试，并使测试代码更加简洁。如果您正在开发Python和Django应用程序，并想要更好地进行测试，那么我建议您尝试使用Django-Test-Plus。

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!