Exactement ce que sont les tests d'intégration - par rapport à l'unité
Je commence à utiliser les tests unitaires dans mes projets et j'écris des tests qui testent au niveau méthode/fonction.
Je comprends cela et cela a du sens.
Mais, qu'est-ce qu'un test d'intégration? D'après ce que j'ai lu, il déplace la portée des tests pour tester les fonctionnalités plus grandes d'une application.
Cela implique que j'écris une nouvelle suite de tests pour tester des choses plus importantes telles que (sur un site de commerce électronique) la fonctionnalité de paiement, la fonctionnalité de connexion utilisateur, la fonctionnalité de panier. Alors ici, j'aurais écrit 3 tests d'intégration?
Est-ce exact - sinon, quelqu'un peut-il expliquer ce que cela signifie?.
De plus, le test d'intégration implique-t-il l'interface utilisateur (contexte d'application Web ici) et emploierait Selenium pour l'automatisation. Ou les tests d'intégration sont-ils toujours au niveau du code mais relient-ils les classes de différence et les zones du code?.
Considérons une méthode comme celle-ci PerformPayment(double amount, PaymentService service);
Un test unitaire serait un test dans lequel vous créez une maquette pour l'argument service.
Un test d'intégration serait un test dans lequel vous utilisez un service externe réel afin de tester si ce service répond correctement à vos données d'entrée.
Les tests unitaires sont des tests que le code testé est à l'intérieur de la classe réelle. Les autres dépendances de cette classe sont moquées ou ignorées, car le focus est de tester le code à l'intérieur de la classe.
Les tests d'intégration sont des tests qui impliquent l'accès au disque, le service d'application et/ou les infrastructures à partir de l'application cible . Les tests d'intégration s'exécutent isolés d'un autre service externe.
Je vais vous donner un exemple. Vous disposez d'une application Spring et vous avez effectué de nombreux tests unitaires pour garantir le bon fonctionnement de la logique métier. Parfait. Mais quel genre de tests vous devez garantir:
- Votre service d'application peut démarrer
- Votre entité de base de données est correctement mappée
- Vous disposez de toutes les annotations nécessaires fonctionnant comme prévu
- Votre filtre fonctionne correctement
- Votre API accepte une sorte de données
- Votre fonctionnalité principale est vraiment fonctionne dans le scénario de base
- Votre requête de base de données fonctionne comme prévu
- Etc...
Cela ne peut pas être fait avec des tests unitaires mais vous, en tant que développeur, devez garantir que tout fonctionne aussi. C'est l'objectif des tests d'intégration.
Le scénario idéal est les tests d'intégration exécutés indépendamment des autres systèmes externes que l'application utilise dans un environnement de production. Vous pouvez accomplir cela en utilisant les appels Wiremock for Rest, une base de données mémoire comme H2, des beans moqueurs de certaines classes spécifiques qui appellent des systèmes externes, etc.
Un peu de curiosité, Maven dispose d'un plugin spécifique pour les tests d'intégration: le maven failsafe plugin, qui exécutent les classes de test dont le nom se termine par [~ # ~] it [~ # ~] . Exemple: UserIT.Java.
La confusion sur la signification du test d'intégration
Certaines personnes comprennent le "test d'intégration" comme un test impliquant "l'intégration" à d'autres systèmes externes que le système utilise actuellement. Ce type de tests ne peut être effectué que dans un environnement où vous avez tous les systèmes opérationnels pour vous assister. Rien de faux, rien de moqué.
Ce n'est peut-être qu'un problème de dénomination, mais nous manquons de tests (ce que je comprends comme des tests d'intégration) qui répondent à la nécessité des éléments décrits ci-dessus. Au contraire, nous sautons pour une définition des tests unitaires (classe de test uniquement) à un test "d'intégration" (l'ensemble des systèmes réels). Alors, qu'est-ce qui se trouve au milieu sinon les tests d'intégration?
Vous pouvez en savoir plus sur cette confusion sur cet article par Martin Fowler. Il sépare le terme "tests d'intégration" sur deux sens: les tests d'intégration "large" et "étroit":
tests d'intégration étroite
- exercer uniquement la partie du code dans mon service qui parle à un service distinct
- utilise des tests doubles de ces services, en cours ou à distance
- se composent donc de nombreux tests de portée étroite, souvent pas plus étendus qu'un test unitaire (et généralement exécutés avec le même cadre de test que celui utilisé pour les tests unitaires)
tests d'intégration larges
- nécessitent des versions en direct de tous les services, nécessitant un environnement de test et un accès réseau substantiels
- exercer des chemins de code à travers tous les services, pas seulement le code responsable des interactions
Le test unitaire est l'endroit où vous testez votre logique métier au sein d'une classe ou d'un morceau de code. Par exemple, si vous testez qu'une section particulière de votre méthode doit appeler un référentiel, votre test unitaire vérifiera que la méthode de l'interface qui appelle le référentiel est appelée le nombre correct de fois que vous attendez, sinon elle échoue le test.
Les tests d'intégration, d'autre part, testent que le comportement réel du service ou du référentiel (base de données) est correct. Il vérifie que sur la base des données que vous transmettez, vous récupérez les résultats attendus. Cela correspond à vos tests unitaires afin que vous sachiez quelles données vous devez récupérer et ce qu'il fait avec ces données.
Voici quelques contraintes qu'un bon test unitaire satisfait. Répondre à ces contraintes exigeait également un bon code testable.
- Pas d'E/S - disque ou réseau
- Une seule assertion (si elles sont multiples, elles devraient être des variations mineures les unes des autres)
- N'exerce pas (couvre) beaucoup plus de code de production que ce qu'il affirme
Ces contraintes ne s'appliquent généralement pas aux tests d'intégration.
Pour autant que je vois, les tests Selenium devraient être dans une autre suite de tests. Ces tests sont le test le plus fragile de la nature même si vous les écrivez correctement. Ici, vous pouvez utiliser Specflow ou un autre type de spécification par exemple. Vous pouvez peut-être appeler ces tests des tests d'acceptation. Ils s'adressent également aux développeurs et aux experts commerciaux. Les tests d'intégration ou de module n'utilisent normalement pas d'interface utilisateur. Les tests d'intégration exercent certaines classes qui fonctionnent ensemble. Ce sont des tests de niveau inférieur à ceux du sélénium, et un peu plus faciles à entretenir. Ces tests sont réservés aux développeurs.