Quel est le bon équilibre entre le test unitaire et le test fonctionnel dans une application Web typique?

https://stackoverflow.com/questions/312904

10-07-2019
|

Question

Les tests unitaires sont moins coûteux à écrire et à maintenir, mais ils ne couvrent pas tous les scénarios. Quel est le bon équilibre entre eux?

La solution

J'aime Le quadrant de Brian Marick sur les tests automatisés où les distinctions sont opposées aux entreprises et aux technologies, et prennent en charge la programmation par rapport aux produits critiques.

Avec ce cadre, la question de l'équilibre devient, de quoi ai-je besoin maintenant?

Autres conseils

il est important de faire la distinction entre l’intention et la portée de ces deux types de tests:

un test unitaire teste généralement une fonctionnalité spécifique au niveau du module / de la classe , par exemple create-X, update-Y, foo-the-bar, compact-the-whizbang, etc. Une classe peut avoir plusieurs tests unitaires
un test fonctionnel , également appelé "test d'acceptation", teste généralement un scénario de cas d'utilisation depuis l'interface la plus externe jusqu'à la fin du traitement, par exemple: de l'interface utilisateur à la base de données et inversement, du processus d'entrée à l'utilitaire de notification, etc.

Ces deux types de tests ne sont pas interchangeables et sont en général disjoints . Donc, l'idée de trouver un «équilibre» entre eux n'a aucun sens. Vous avez besoin d'eux ou vous n'en avez pas.

si vous parlez de la facilité de codage de chaque type de test dans votre framework de test, la question est différente - mais l'utilisation du framework (par exemple, NUnit par rapport à un utilisateur-bot) ne modifie pas le type / nature du test.

le meilleur "solde", en général, consisterait à effectuer un test unitaire de la confiance et de l’exhaustivité et un test fonctionnel à l’acceptation du client

Je suis d'accord avec Steven Lowe sur le fait qu'il n'y a pas de compromis entre les tests unitaires et les tests fonctionnels, car ils sont utilisés à des fins très différentes.

Les tests unitaires concernent la vérification de la méthode et du type, ainsi que le test de régression. Les tests fonctionnels concernent les tests fonctionnels, de scénario et de faisabilité. À mon avis, il n'y a presque pas de chevauchement,

Si cela peut vous aider, voici mes catégories de tests.

Les développeurs partent de l'intérieur et travaillent vers l'extérieur, en se concentrant sur le code:

Assertions - Vérification du flux de données et des structures
Débogueur - vérifie le flux de code et les données
Test unitaire - vérifiez chaque fonction
Test d'intégration - vérification des sous-systèmes
Test du système - vérification de la fonctionnalité
Tests de régression - vérifiez que les défauts restent fixes
Tests de sécurité - vérifiez que le système ne peut pas être pénétré facilement.

Les testeurs commencent par l’extérieur et travaillent vers l’intérieur, en se concentrant sur les fonctionnalités:

Tests d'acceptation - vérifiez les exigences de l'utilisateur final
Tests de scénario - vérification de situations réelles
Tests globaux - vérification des entrées possibles
Tests de régression - vérifiez que les défauts restent fixes
Tests d'utilisabilité - vérifiez que le système est facile à utiliser
Tests de sécurité - Vérifiez que le système ne peut pas être pénétré facilement
Couverture de code - test du code non modifié
Compatibilité - avec les versions précédentes
Vous recherchez des bizarreries et des bords rugueux.

Les utilisateurs finaux travaillent de l'extérieur et ont généralement peu d'attention:

Tests d'acceptation - vérifiez les exigences de l'utilisateur final
Tests de scénario - vérification de situations réelles
Tests d'utilisabilité - vérifiez que le système est facile à utiliser
Vous recherchez des bizarreries et des bords rugueux.

Sur l'application sur laquelle je travaille en ce moment, il existe probablement 10: 1 unités pour les tests fonctionnels. Les tests unitaires fonctionnent simplement comme la récupération d’entités depuis une base de données, les tests de gestion des erreurs pour la connectivité base / réseau, etc. Ces opérations s’effectuent très rapidement, voire moins, et sont effectuées quotidiennement par les développeurs.

moins de tests fonctionnels ont tendance à être une approche d’évier de cuisine - une commande complète par l’utilisateur, etc. ont tendance à couvrir le domaine des affaires. Il faut des semaines pour exécuter ces tâches et généralement pour finaliser un cycle de publication.

Mon projet actuel couvre environ 60% de la couverture des tests unitaires et toutes les user stories ont une couverture joyeuse des user stories des tests au sélénium. Certaines ont une couverture supplémentaire.

Nous discutons constamment de cela: y a-t-il vraiment un intérêt à repousser la couverture par tests unitaires de scénarios de plus en plus absurdes pour une couverture beaucoup plus élevée?

L’argument avancé est que l’expansion des tests au sélénium augmente la couverture de tests sur les éléments ayant une valeur commerciale. Le client se soucie-t-il vraiment des cas de coins de tests unitaires qui peuvent échouer?

Lorsque vous maîtrisez les tests de sélénium, le coût de la rédaction de nouveaux tests avec une valeur commerciale diminue. Pour nous, ils sont aussi simples que des tests unitaires.

Le coût d'exécution est un autre problème. Nous avons un petit groupe de boîtes exécutant ces tests tout le temps.

Nous avons donc tendance à préférer les tests sur le Web, probablement parce que nous avons réussi à les écrire et qu’ils fournissent une valeur commerciale indéniable.

À l’origine, j’ai été fortement enclin à préférer les tests unitaires aux tests fonctionnels / de réception en raison du facteur de coût initial des tests de réception. Cependant, au fil du temps, j'ai changé de philosophie et je suis désormais un ardent défenseur du choix des tests d'acceptation, dans la mesure du possible, et de l'utilisation de tests unitaires uniquement lorsque les tests d'acceptation ne répondent pas à mes besoins.

La raison d'être du choix de l'acceptation sur les tests unitaires est la même que celle de code SOLID . Votre implémentation devrait pouvoir changer radicalement avec le refactoring, etc., mais tous les cas d’affaires - tests d’acceptation - devraient pouvoir rester inchangés et prouver un comportement de système acceptable (tests réussis). Avec les tests unitaires, il existe souvent un couplage fort naturel entre test et code d'implémentation. Bien que ce soit un code de test, il faut tout de même éviter le code et le couplage fort. En choisissant des tests d'acceptation, vous êtes souvent plongé dans la spirale du succès pour créer des API dissociées bien planifiées et consommables, permettant ainsi à votre implémentation de changer en arrière-plan sans que vos tests changent. De plus, vos idées concernant l'implémentation des développeurs correspondent aux idées concernant le comportement du système d'entreprise. En fin de compte, je trouve que tout cela est meilleur pour les affaires et pour la satisfaction du codeur.

D'un point de vue théorique, je me demande souvent si un morceau de code ne peut pas être testé via un test d'acceptation, pourquoi ce morceau de code devrait-il exister? IE - si cela ne fait pas partie d’un scénario commercial valide, ce code ajoute-t-il de la valeur ou est-il actuellement et restera-t-il uniquement un coût?

De plus, si vous commentez / documentez bien vos tests d'acceptation, ces commentaires / documents sont généralement la langue la plus récente et la plus précise du système. Ils vous permettront généralement d'éviter d'autres méthodes de documentation moins valables. Les tests unitaires ne se prêtent pas à cette forme de "terme commercial". communication.

Enfin, je n’ai pas formé ce point de vue uniquement à partir de mon développement personnel. Il a fait ses preuves avec deux ou trois équipes de projet différentes dans mon groupe "très corporate". environnement de travail.

JB http://jb-brown.blogspot.com

Les tests doivent être rapides et permettre de localiser les problèmes. Les tests unitaires vous permettent de le faire en ne testant que le module en question. Cependant, des tests fonctionnels / d'intégration / d'acceptation peuvent être effectués de manière suffisamment rapide dans la plupart des scénarios Web.

J'ai lu un jour qu'un test unitaire était une "exigence relative à l'exécutable", ce qui me paraissait parfaitement logique. Si votre test ne vise pas à prouver une exigence métier, il ne sert à rien. Si vous avez des exigences détaillées (et qu’il s’agit du test à l’acide), vous rédigerez un certain nombre de tests unitaires afin d’exercer chaque scénario possible, ce qui garantira l’intégrité de vos algorithmes et de votre logique de structure de données. Si vous testez quelque chose qui n'est pas une exigence mais que vous savez forcément être vrai pour que le test réussisse, il est plus que probable qu'il manque des exigences.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow