Testez votre projet Python

Commençons par une définition formelle. Les tests d'intégration sont destinés à vérifier les combinaisons de différentes unités de code, leurs interactions et la manière dont les sous-systèmes s'unissent en un système commun.

Par exemple, lorsque nous testons les fonctionnalités de connexion et d'inscription dans une application web, nous les considérons comme des unités distinctes. Si nous vérifions la possibilité de se connecter après qu'un utilisateur s’est inscrit sur l’application, nous vérifions l'intégration entre ces deux fonctionnalités. Évidemment, ces fonctionnalités distinctes ont été vérifiées par des tests unitaires au préalable.

Les tests d'intégration et les tests unitaires sont deux niveaux de tests logiciels, où :

• les tests unitaires vérifient une unité de code, comme une méthode ou une classe ;

• les tests d'intégration vérifient la combinaison de plusieurs composants, par exemple deux classes ou deux fonctionnalités distinctes qui vont interagir ensemble.

Les tests unitaires impliquent de vérifier séparément les plus petites parties fonctionnelles du code. Les tests d'intégration vont plus loin : nous recherchons les erreurs qui se produisent lorsque les unités de code commencent à interagir. Le fait que les unités aient réussi les tests aux étapes précédentes ne garantit pas qu'elles fonctionneront bien ensemble.

Nous savons bien à quel point un code peut être imprévisible, même s'il semble parfaitement écrit. Les tests d'intégration permettent de diviser le code en blocs constitués de plusieurs unités, et de vérifier progressivement les parties du logiciel avant de les assembler en un système complet.

Écrivez un test d’intégration avec Pytest

Vous n’allez pas être dépaysé dans la mise en place des tests d’intégration, car nous allons utiliser, comme pour les tests unitaires, le framework Pytest. En effet, ce framework nous fournit l’ensemble des outils nécessaires pour effectuer nos tests.

Je vous propose de reprendre notre super projet OC-commerce afin d’écrire notre test d’intégration. Nous allons vérifier dans ce test que la combinaison des services d’inscription et de connexion fonctionnent bien ensemble. C’est-à-dire qu’à la suite de son inscription, un utilisateur pourra bien se connecter sur l’application.

Vous allez tout d’abord créer un packageintegration_testsdans l’arborescence de test.

Ensuite, vous allez créer un premier module de test qui contiendra les tests concernant les composants liés d’authentification, que nous nommeronstest_authentification.py.

Comme pour les tests unitaires, nous allons implémenter notre test d’intégration à l’aide d’une fonction. Vous utiliserez ensuite le client pour effectuer toutes les manipulations sur votre application. Enfin, les assertions pourront vérifier et valider le scénario.

import pytest

from pytest_django.asserts import assertTemplateUsed
from django.urls import reverse, resolve
from django.test import Client
from django.contrib import auth
from django.contrib.auth.views import LoginView

@pytest.mark.django_db
def test_login_route():

    client = Client()

 #Inscrire un utilisateur à l’aide de la vue `signup`afin de l’enregistrer dans la base de données
    credentials = {
        'first_name': 'Test',
        'last_name': 'User',
        'username': 'TestUser',
        'email': 'testuser@testing.com',
        'password1': 'TestPassword',
        'password2': 'TestPassword'
    }
    temp_user = client.post(reverse('signup'), credentials)

    #Connecter cet utilisateur avec la vue `login`
    response = client.post(reverse('login'), {'username': 'TestUser', 'password': 'TestPassword'})

    #Vérifier que la redirection vers la page d’accueil est effectuée
    assert response.status_code == 302
    assert response.url == reverse('home')

    #Vérifier que l’utilisateur est bien authentifié 
    user = auth.get_user(client)
    assert user.is_authenticated

Grâce à la vérification de la redirection et de l’authentification de l’utilisateur, nous pouvons confirmer que la combinaison de ces deux fonctionnalités est validée par un test d’intégration.

À vous de jouer !

Je vous propose de reprendre le code source du projet Django afin de vous entraîner à la mise en place de tests d’intégration. N’oubliez pas, tout d’abord, d’identifier les différents composants à tester et d’enrichir votre plan de test avec les tests d’intégration.

Votre mission :

• Ajoutez au plan de test les scénarios des tests d’intégration.

• Créez la suite de tests sur l’ensemble du projet :

  • redirection vers la page de connexion pour l’ensemble des fonctionnalités nécessitant une session ;

  • affichage du profil d’un utilisateur connecté ;

  • ajout d’un produit en favori ;

  • suppression d’un produit en favori ;

  • déconnexion d’un utilisateur connecté.

Retrouvez une proposition de correction sur GitHub !

En résumé

• Les tests d'intégration déterminent si les unités logicielles développées indépendamment fonctionnent correctement lorsqu'elles sont connectées les unes aux autres. 

• Pour implémenter un test d’intégration, nous :

  • écrivons une fonction qui contiendra le scénario ;

  • utilisons un client pour effectuer les manipulations sur le programme ;

  • ajoutons des assertions qui vérifieront le scénario de test.

Grâce aux tests d’intégration, vous avez pu vérifier l'interaction des différents composants de l’application. Voyons ensuite comment tester le parcours utilisateur grâce aux tests fonctionnels.