2. Tests unitaires

Les tests unitaires sont une pratique essentielle dans le développement logiciel, y compris pour les développeurs data. Ils consistent à tester individuellement les plus petites parties d’un code, appelées « unités », pour s’assurer qu’elles fonctionnent correctement de manière isolée. Voici quelques raisons pour lesquelles les tests unitaires sont importants pour un développeur data :

  • validation du code : les tests unitaires permettent de vérifier que chaque fonction ou méthode produit le résultat attendu pour une entrée donnée. Cela est crucial pour s’assurer que les calculs, transformations de données, et autres opérations fonctionnent correctement ;

  • détection précoce des bugs : en écrivant des tests unitaires, les bugs peuvent être détectés tôt dans le cycle de développement, ce qui facilite leur correction et réduit le coût global du développement ;

  • refactoring : lorsque vous devez modifier ou optimiser du code existant, les tests unitaires permettent d’apporter des changements sans craindre de casser des fonctionnalités existantes ;

  • documentation : les tests unitaires servent également de documentation pour le code. Ils montrent comment les fonctions sont censées être utilisées et quels résultats sont attendus, ce qui peut être très utile pour les autres développeurs (ou pour vous-même dans le futur) ;

  • intégration continue : les tests unitaires sont souvent intégrés dans des pipelines d’intégration continue (CI), où ils sont exécutés automatiquement à chaque modification du code. Cela permet de s’assurer que les nouvelles modifications n’introduisent pas de régressions ;

  • qualité du code : écrire des tests unitaires encourage une meilleure conception du code, car il faut souvent structurer le code de manière modulaire pour qu’il soit testable. Cela peut conduire à un code plus propre et plus maintenable ;

  • collaboration : dans un environnement de travail collaboratif, les tests unitaires aident à s’assurer que le code de chacun fonctionne bien ensemble et respecte les attentes définies.

Pour un développeur data, les tests unitaires peuvent être appliqués à diverses tâches, telles que :

  • nettoyage des données : vérifier que les fonctions de nettoyage des données produisent les résultats attendus ;

  • transformation des données : s’assurer que les transformations appliquées aux données sont correctes ;

  • modèles de machine learning : tester les fonctions utilitaires utilisées pour préparer les données ou évaluer les modèles ;

  • requêtes SQL : vérifier que les requêtes SQL retournent les résultats attendus.

En résumé, les tests unitaires sont un outil puissant pour améliorer la qualité, la fiabilité et la maintenabilité du code, ce qui est particulièrement important dans le domaine de la science des données où la précision et la fiabilité des résultats sont cruciales.

2.1. unittest

unittest est un module intégré de Python qui fournit un ensemble d’outils pour écrire et exécuter des tests unitaires. Il est inspiré par le framework de test JUnit pour Java et est largement utilisé pour tester le code Python. Voici quelques points clés concernant unittest :

  • framework de test intégré : unittest est inclus dans la bibliothèque standard de Python, ce qui signifie qu’il est disponible sans installation supplémentaire. Cela le rend très accessible pour les développeurs Python ;

  • structure de test : unittest encourage une structure de test organisée. Les tests sont généralement écrits dans des classes qui héritent de unittest.TestCase. Chaque méthode de la classe qui commence par test_ est considérée comme un test à exécuter ;

  • assertions : unittest fournit une variété de méthodes d’assertion pour vérifier les conditions attendues dans les tests. Par exemple, assertEqual(), assertTrue(), assertFalse(), assertRaises(), etc ;

  • configuration et nettoyage : il permet de définir des méthodes de configuration (setUp) et de nettoyage (tearDown) qui sont exécutées avant et après chaque test. Cela est utile pour préparer l’environnement de test et le nettoyer après l’exécution des tests ;

  • gestion des exceptions : unittest permet de tester si un code lève une exception attendue avec assertRaises, ce qui est utile pour vérifier que les erreurs sont gérées correctement ;

  • exécution des tests : les tests peuvent être exécutés directement depuis la ligne de commande, ce qui facilite l’intégration avec des outils d’intégration continue ;

  • rapports de test : unittest fournit des rapports de test détaillés qui aident à identifier quels tests ont échoué et pourquoi, ce qui est crucial pour le débogage ;

  • extensibilité : bien que unittest soit puissant, il peut être étendu avec des bibliothèques tierces pour ajouter des fonctionnalités supplémentaires, comme des rapports plus détaillés ou des intégrations avec d’autres outils.

Voici un exemple simple de l’utilisation de unittest :

import unittest

class TestStringMethods(unittest.TestCase):

    def setUp(self):
        # Code de configuration qui sera exécuté avant chaque test
        pass

    def test_upper(self):
        self.assertEqual('foo'.upper(), 'FOO')

    def test_isupper(self):
        self.assertTrue('FOO'.isupper())
        self.assertFalse('Foo'.isupper())

    def test_split(self):
        s = 'hello world'
        self.assertEqual(s.split(), ['hello', 'world'])
        with self.assertRaises(TypeError):
            s.split(2)

    def tearDown(self):
        # Code de nettoyage qui sera exécuté après chaque test
        pass

if __name__ == '__main__':
    unittest.main()

unittest est un outil puissant pour écrire des tests unitaires en Python. Il est particulièrement utile pour les projets de grande envergure où la fiabilité et la maintenabilité du code sont cruciales. Bien qu’il existe d’autres frameworks de test plus performants pour Python, unittest présente l’avantage d’être intégré à la bibliothèque standard.

Lisez le tutoriel Python’s unittest: Writing Unit Tests for Your Code pour comprendre la philosophie du test, acquérir le vocabulaire nécessaire et pouvoir replacer d’autres frameworks de test dans leur contexte. En première lecture, si vous pouvez vous passer de reproduire les interactions, il est cependant essentiel de bien comprendre la structure des tests. Cette compréhension est indispensable pour la suite.

2.2. pytest

pytest est le framework de test à privilégier pour Python. Il est souvent préféré pour sa simplicité, sa flexibilité et ses fonctionnalités avancées comme les fixtures et les plugins. Il est particulièrement apprécié pour les projets où la rapidité de développement et la facilité de maintenance des tests sont importantes. Voici quelques avantages clés de l’utilisation de pytest par rapport à d’autres frameworks de test comme unittest :

  • simplicité et facilité d’utilisation : pytest permet d’écrire des tests très simplement et avec moins de code boilerplate que unittest. Par exemple, vous n’avez pas besoin de créer des classes qui héritent d’une classe de test. Vous pouvez simplement écrire des fonctions ;

  • découverte automatique des tests : pytest découvre automatiquement les tests dans votre projet sans avoir besoin de configuration complexe. Il suffit d’exécuter pytest dans le terminal, et il trouvera et exécutera tous les tests dans les fichiers dont les noms correspondent au modèle test_*.py ou *_test.py ;

  • assertions puissantes : pytest utilise les assertions standard de Python, mais fournit des messages d’erreur très détaillés et utiles lorsque les assertions échouent. Cela facilite le débogage des tests ;

  • plugins et extensibilité : pytest dispose d’un riche écosystème de plugins qui peuvent être utilisés pour étendre ses fonctionnalités. Par exemple, pytest-cov pour mesurer la couverture de code, pytest-xdist pour exécuter les tests en parallèle, et bien d’autres ;

  • fixtures : pytest introduit le concept de « fixtures », qui sont des fonctions utilisées pour fournir des données de test ou des objets aux tests. Les fixtures permettent de gérer les dépendances des tests de manière élégante et réutilisable ;

  • paramétrage des tests : avec pytest, il est facile de paramétrer les tests pour exécuter la même fonction de test avec différentes entrées. Cela se fait avec le décorateur @pytest.mark.parametrize ;

  • support pour les tests fonctionnels et d’intégration : bien que pytest soit excellent pour les tests unitaires, il est également bien adapté pour les tests fonctionnels et d’intégration, ce qui en fait un outil polyvalent pour tous vos besoins de test ;

  • communauté active : pytest bénéficie d’une communauté active et grandissante, ce qui signifie que vous pouvez trouver beaucoup de ressources, de tutoriels et de soutien en ligne.

Voici un exemple simple de l’utilisation de pytest.

# content of test_sample.py
def func(x):
    return x + 1

def test_answer():
    assert func(3) == 4

Pour exécuter le test, utilisez simplement la commande suivante dans le terminal

$ pytest test_sample.py

pytest est un outil puissant et flexible pour le test en Python, qui peut rendre le processus de test plus simple et plus efficace. Sa facilité d’utilisation, combinée à ses fonctionnalités avancées, en fait une solution efficace.

Suivez très attentivement le tutoriel Effective Python Testing With pytest. Il débute par une référence à unittest ce qui vous permettra de mettre les deux frameworks en perspective.

2.3. Application

Utiliser pytest pour ajouter des tests aux fonctions écrites pour le Test technique.