Quelle est la différence entre les tests unitaires, fonctionnels, d'acceptation et d'intégration? [fermé]

L'important est que vous sachiez ce que ces termes signifient pour vos collègues. Différents groupes auront des définitions légèrement différentes de ce qu'ils signifient lorsqu'ils disent des tests "complets de bout en bout", par exemple.

Je suis tombé récemment sur le système de nommage de Google pour leurs tests, et je l'aime plutôt-ils contournent les arguments en utilisant simplement Small, Medium et Large. Pour décider dans quelle catégorie un test s'inscrit, ils examinent quelques facteurs-combien de temps faut-il pour s'exécuter, y a-t-il Accès le réseau, base de données, système de fichiers, systèmes externes et ainsi de suite.

Http://googletesting.blogspot.com/2010/12/test-sizes.html

J'imagine que la différence entre Petit, Moyen et grand pour votre lieu de travail actuel pourrait varier de Google.

Cependant, il ne s'agit pas seulement de portée, mais de but. Le point de Mark sur les différentes perspectives pour les tests, par exemple programmeur vs client / utilisateur final, est vraiment important.

Http://martinfowler.com/articles/microservice-testing/

Le billet de blog de Martin Fowler parle de stratégies pour tester le code (en particulier dans une architecture de micro-services), mais la plupart s'applique à n'importe quelle application.

Je vais citer de sa diapositive de résumé:

• tests unitaires-exercer les plus petits morceaux de logiciels testables dans l'application pour déterminer si elles se comportent comme prévu.
• tests D'intégration-vérifier la communication chemins et interactions entre les composants pour détecter les défauts d'interface.
• tests de composants-limiter la portée du logiciel exercé à une partie du système testé, en manipulant le système à travers interfaces de code internes et utilisation de doubles de test pour isoler le code en vertu de test à partir d'autres composants.
• tests de contrat-vérifier les interactions à la limite d'un service externe affirmant qu'il répond au contrat attendu par un consommateur service.
• tests de bout en bout-vérifier qu'un système répond aux exigences externes et atteint ses objectifs, en testant l'ensemble du système, à partir de de bout en bout.

Unit Testing - comme son nom l'indique, cette méthode teste au niveau de l'objet. Les composants logiciels individuels sont testés pour toute erreur. La connaissance du programme est nécessaire pour ce test et les codes de test sont créés pour vérifier si le logiciel se comporte comme il est prévu.

les Tests Fonctionnels - Est effectuée sans aucune connaissance du fonctionnement interne du système. Le testeur va essayer d'utiliser le système en suivant les exigences, en fournissant différents entrées et test des sorties générées. Ce test est également connu sous le nom de test en boîte fermée ou boîte noire.

Test D'acceptation - Il s'agit du dernier test effectué avant la remise du logiciel au client. Il est effectué pour s'assurer que le logiciel développé répond à toutes les exigences du client. Il existe deux types de tests d'acceptation - l'un qui est effectué par les membres de l'équipe de développement, connu sous le nom de tests d'acceptation interne (test Alpha), et le d'autres, qui est effectuée par le client ou l'utilisateur final connu sous le nom (Bêta test)

Integration Testing - les modules individuels déjà soumis à des tests unitaires sont intégrés les uns aux autres. Généralement les deux approches sont suivies :

1) De Haut En Bas
2) Bottom-Up

C'est très simple.

1. Tests unitaires: il s'agit des tests effectués par les développeurs qui ont des connaissances en codage. Ce test est effectué à la phase de codage et fait partie des tests en boîte blanche. Quand un logiciel vient pour le développement, il est développé dans le morceau de code ou des tranches de code connu comme une unité. Et les tests individuels de ces unités appelées tests unitaires effectués par les développeurs pour découvrir une sorte d'erreurs humaines comme l'absence de couverture de déclaration etc..

2. Test fonctionnel: ce test est effectué à la phase de test (QA) et fait partie des tests de boîte noire. L'exécution réelle des cas de test précédemment écrits. Ce test est fait par les testeurs, ils trouvent le résultat réel de toute fonctionnalité dans le site et comparent ce résultat au résultat attendu. S'ils ont trouvé une disparité, c'est un bug.

3. Essais D'acceptation: savoir comme UAT. Et cela effectivement fait par le testeur ainsi que les développeurs, équipe de gestion, auteur, écrivains, et tous ceux qui sont impliqués dans ce projet. Pour s'assurer que le projet est enfin prêt à être livré avec des bugs gratuits.

4. Tests D'intégration: les unités de code (expliquées au point 1) sont intégrées les unes aux autres pour compléter le projet. Ces unités de codes peuvent être écrites dans une technologie de codage différente ou peuvent être de version différente de sorte que ce test est effectué par les développeurs pour s'assurer que toutes les unités du code sont compatibles avec d'autres et il n'y a aucune question de l'intégration.

Quelques idées (relativement) récentes contre les moqueries excessives et pures test unitaire:

• https://www.simple-talk.com/dotnet/.net-framework/are-unit-tests-overused/
• http://googletesting.blogspot.com/2013/05/testing-on-toilet-dont-overuse-mocks.html
• http://codebetter.com/iancooper/2011/10/06/avoid-testing-implementation-details-test-behaviours/
• http://cdunn2001.blogspot.com/2014/04/the-evil-unit-test.html
• http://www.jacopretorius.net/2012/01/test-behavior-not-implementation.html
• Pourquoi La plupart des tests unitaires sont des déchets

Test unitaire: le test d'un module individuel ou d'un composant indépendant dans une application est connu pour être un test unitaire, le test unitaire sera effectué par le développeur.

Test D'intégration: combinant tous les modules et tester l'application pour vérifier la communication et le flux de données entre les modules fonctionnent correctement ou non, ce test également effectué par les développeurs.

Funcional test vérification de la fonctionnalité individuelle d'une application est dire tests fonctionnels

Tests D'acceptation ce test est effectué par l'utilisateur final ou le client , que l'application de construction soit conforme aux exigences du client et aux spécifications du client, ce qui est connu pour être des tests d'acceptation

Je vais vous expliquer cela avec un exemple pratique et pas de trucs théoriques:

Un développeur écrit le code. Aucune interface graphique n'est encore implémentée. Le test à ce niveau, vérifie que les fonctions fonctionnent correctement et les types de données sont corrects. Cette phase de test est appelée test unitaire.

Lorsqu'une interface graphique est développée et que l'application est affectée à un testeur, il vérifie les exigences métier avec un client et exécute les différents scénarios. Ceci est appelé le test fonctionnel. Ici, nous mappent les exigences du client avec des flux d'application.

Test D'intégration: disons que notre application comporte deux modules: RH et Finance. Le module RH a été livré et testé précédemment. Maintenant Finances est élaboré et est disponible pour tester. Les fonctionnalités interdépendantes sont également disponibles maintenant, donc dans cette phase, vous allez tester les points de communication entre les deux et vérifier qu'ils fonctionnent comme demandé dans les exigences.

Le test de régression est une autre phase importante, qui est fait après tout nouveau développement ou corrections de bugs. Son but est de vérifier les fonctions de travail antérieures.