unit-testing - système - test de validation




Qu'est-ce qu'un test unitaire, un test d'intégration, un test de fumée, un test de régression? (14)

LES TESTS DE RÉGRESSION-

"Un test de régression ré-exécute les tests précédents sur le logiciel modifié pour s'assurer que les modifications apportées au logiciel actuel n'affectent pas la fonctionnalité du logiciel existant."

Qu'est-ce qu'un test unitaire, un test d'intégration, un test de fumée, un test de régression et quelles sont les différences entre eux? Et quels outils puis-je utiliser pour chacun d'entre eux?

Par exemple, j'utilise JUnit et NUnit pour les tests unitaires et les tests d'intégration. Existe-t-il des outils de test de fumée ou de test de régression?


Il y a eu un grand détail de la différence entre les différentes techniques de test. Cela dit, très peu a touché aux outils de test de fumée ou de régression.

Habituellement, il y a quelques cadres couplés avec le langage / cadre qui a été utilisé pour développer l'application. Ayant développé Angular, le rapporteur pourrait être un bon choix, car le concombre Java ou l'arquillien pourrait être un autre choix. Dans tous les plus de langages / cadres, plus vous avez de choix. Ou est-ce ?.

J'ai personnellement cru en un langage déclaratif qui convient à tous les langages et platofrm tous ensemble pour les tests de bout en bout.

Endly est le premier framework de test et d'automatisation de bout en bout entièrement déclaratif, il peut être utilisé pour n'importe quel test dans n'importe quelle langue.


Les tests de fumée et de santé mentale sont tous deux effectués après la construction d'un logiciel pour déterminer s'il faut commencer les tests. La santé peut ou peut ne pas être exécutée après un test de fumée. Ils peuvent être exécutés séparément ou en même temps - la santé mentale étant immédiatement après la fumée.

Parce que le test de santé mentale est plus approfondi et prend plus de temps, dans la plupart des cas, il vaut la peine d'être automatisé.

Le test de fumée ne prend généralement pas plus de 5-30 minutes pour l'exécution. Il est plus général: il vérifie un petit nombre de fonctionnalités de base de l'ensemble du système, afin de vérifier que la stabilité du logiciel est suffisante pour des tests ultérieurs et qu'il n'y a pas de problèmes, bloquant la réalisation des cas de test planifiés.

Les tests de santé sont plus détaillés que la fumée et peuvent durer de 15 minutes à une journée entière, selon l'échelle de la nouvelle construction. Il s'agit d'un type de test d'acceptation plus spécialisé, effectué après la progression ou le re-test. Il vérifie les caractéristiques de base de certaines nouvelles fonctionnalités et / ou corrections de bogues ainsi que certaines de leurs fonctionnalités, afin de vérifier qu'elles fonctionnent selon la logique opérationnelle requise, avant que les tests de régression puissent être exécutés à plus grande échelle.


Quelques bonnes réponses déjà mais je voudrais encore les affiner:

Les tests unitaires sont la seule forme de test de boîte blanche ici. Les autres sont des tests en boîte noire. Le test de boîte blanche signifie que vous connaissez l'entrée, vous connaissez les rouages ​​internes du mécanisme et pouvez l'inspecter et connaître la sortie. Avec le test de boîte noire, vous ne savez que ce que l'entrée est et quelle devrait être la sortie.

Il est donc clair que le test unitaire est le seul test de boîte blanche ici.

  • Les tests unitaires testent des morceaux de code spécifiques. Habituellement des méthodes.
  • Les tests d'intégration testent si votre nouveau composant logiciel peut s'intégrer avec tout le reste.
  • Les tests de régression. Ce test est fait pour s'assurer que vous n'avez rien cassé. Tout ce qui avait l'habitude de fonctionner devrait encore fonctionner.
  • Le test de fumée est fait comme un test rapide pour s'assurer que tout va bien avant de participer aux tests les plus vigoureux.

Test unitaire: Il est toujours effectué par le développeur après le développement afin de déterminer les problèmes rencontrés par les tests avant de répondre aux exigences d'assurance qualité.

Tests d'intégration: Cela signifie que le testeur doit vérifier la vérification du module par rapport au sous-module lorsque certaines données / sorties de fonction sont connectées à un module vers un autre module. Ou dans votre système si vous utilisez un outil tiers qui utilise vos données système pour intégrer.

Test de fumée: testeur effectué pour vérifier le système pour les tests de haut niveau et essayer de détecter le bug de blocage avant que les modifications ou le code ne soient mis en ligne.

Test de régression: Le testeur a effectué une régression pour la vérification de la fonctionnalité existante en raison des changements mis en œuvre dans le système pour une nouvelle amélioration ou des changements dans le système.


Test unitaire: Vérification de ce composant particulier (c'est-à-dire, classe) fonctions créées ou modifiées telles que conçues. Ce test peut être manuel ou automatisé mais ne dépasse pas la limite du composant.

Test d'intégration: Vérification que l'interaction de composants particuliers fonctionne comme prévu. Les tests d'intégration peuvent être effectués au niveau de l'unité ou au niveau du système. Ces tests peuvent être manuels ou automatisés.

Test de régression: vérification que les nouveaux défauts ne sont pas introduits dans le code existant. Ces tests peuvent être manuels ou automatisés.

En fonction de votre SDLC (cascade, rup, agile, etc), des tests particuliers peuvent être réalisés en "phases" ou peuvent tous être réalisés, plus ou moins, en même temps. Par exemple, les tests unitaires peuvent être limités aux développeurs qui transmettent ensuite le code aux testeurs pour des tests d'intégration et de régression. Cependant, une autre approche pourrait impliquer que les développeurs effectuent des tests unitaires et un certain niveau d'intégration et de tests de régression (en utilisant une approche TDD avec une intégration continue et des tests unitaires et de régression automatisés).


Tests unitaires: - les tests unitaires sont généralement réalisés par les développeurs, où les testeurs évoluent en partie dans ce type de test où les tests sont effectués unité par unité. Dans java Junit, les cas de test peuvent également être testés pour savoir si le code écrit est parfaitement conçu ou non.

Test d'intégration: - Ce type de test est possible après les tests unitaires lorsque tous / certains composants sont intégrés. Ce type de test s'assurera que lorsque les composants sont intégrés, ils affectent les capacités fonctionnelles de chacun ou les fonctionnalistes.

Test de fumée: - Ce type de test est effectué au dernier moment lorsque le système est intégré avec succès et prêt à fonctionner sur le serveur de production. Ce type de test garantit que toutes les fonctionnalités importantes du début à la fin fonctionnent correctement et que le système est prêt à être déployé sur le serveur de production.

Test de régression: - Ce type de test est important pour vérifier que les défauts involontaires / indésirables ne sont pas présents dans le système lorsque le développeur a corrigé certains problèmes. Ce test permet également de s'assurer que tous les bogues ont été résolus avec succès et pour cette raison, aucun autre problème n'est survenu.


Tout le monde aura des définitions légèrement différentes, et il y a souvent des zones grises. Toutefois:

  • Test unitaire: est-ce que ce petit un peu (aussi isolé que possible) fonctionne?
  • Test d'intégration: ces deux composants (ou plus) fonctionnent-ils ensemble?
  • Test de fumée: est-ce que tout ce système (aussi proche que possible d'un système de production) s'accouple assez bien? (Sommes-nous raisonnablement confiants qu'il ne créera pas de trou noir?)
  • Test de régression: avons-nous par inadvertance réintroduit les bugs que nous avions précédemment corrigés?

Une nouvelle catégorie de test dont je viens de prendre connaissance est la suivante:

Test des Canaries

Un test Canary est un test automatisé non destructif qui est exécuté régulièrement dans un environnement LIVE , de sorte que si jamais il échoue, quelque chose de vraiment grave est arrivé.

Les exemples pourraient être:

  • Les données qui ne devraient être disponibles que dans DEV / TEST sont apparues dans LIVE.
  • Un processus d'arrière-plan n'a pas pu s'exécuter
  • Un utilisateur peut-il se connecter?

Le test de fumée a déjà été expliqué ici et est simple. Le test de régression est soumis à un test d'intégration.

Les tests automatisés peuvent être divisés en seulement 2.

Test unitaire et test d'intégration. (c'est tout ce qui compte)

J'appellerais utiliser l'expression «long test» (LT) pour tous les tests comme le test d'intégration, le test fonctionnel, le test de régression, le test UI, etc. Et le test unitaire comme «test court».

Un exemple de LT pourrait être le chargement automatique d'une page Web, la connexion au compte et l'achat d'un livre. Si le test réussit, il est plus probable qu'il s'exécute sur le site en direct de la même manière (d'où la référence «mieux dormir»). Long = distance entre la page Web (début) et la base de données (fin).

Et voici un excellent article sur les avantages des tests d'intégration (test long) par rapport aux tests unitaires


Réponse de l'un des meilleurs sites Web pour les techniques de test de logiciels:

Types de tests de logiciels - Liste complète Cliquez ici

C'est une description assez longue, je ne vais pas la coller ici: mais cela peut être utile pour quelqu'un qui veut connaître toutes les techniques de test.

J'espère que ça va être utile :)


Tests unitaires:

Le test unitaire est un processus de développement logiciel dans lequel les plus petites parties testables d'une application, appelées unités, sont examinées individuellement et indépendamment pour un fonctionnement correct. Les tests unitaires sont souvent automatisés mais ils peuvent également être effectués manuellement.

Tests d'intégration:

(parfois appelé intégration et test, abréviation I & T) est la phase dans les tests de logiciels dans lequel les modules logiciels individuels sont combinés et testés en tant que groupe. Cela se produit après les tests unitaires et avant les tests de validation.

Test du système:

est le plus souvent le test final pour vérifier que le système à livrer répond aux spécifications et à son objectif.

Test de régression:

après avoir implémenté de nouvelles fonctionnalités ou corrections de bugs, vous revérifiez des scénarios qui ont fonctionné dans le passé. Ici, vous couvrez la possibilité dans laquelle vos nouvelles fonctionnalités cassent les fonctionnalités existantes.

Test de fumée:

L'objectif n'est pas de réaliser des tests exhaustifs, mais de vérifier que les fonctionnalités critiques du système fonctionnent correctement. Par exemple un test de fumée typique serait - Vérifiez que l'application se lance avec succès, Vérifiez que l'interface graphique est sensible, etc.


  • Tests d'intégration: le test d'intégration est l'intégration de l'autre élément
  • Test de fumée: Test de fumée est également connu sous le nom de test de version de construction. Test de fumée est le processus de test initial exercé pour vérifier si le logiciel sous test est prêt / stable pour d'autres tests.
  • Tests de régression: les tests de régression sont des tests répétés. Si un nouveau logiciel est effectué dans un autre module ou non.
  • Test unitaire: Il s'agit d'un test de boîte blanche. Seuls les développeurs y participent

  • Test unitaire : un test automatique pour tester le fonctionnement interne d'une classe. Ce devrait être un test autonome qui n'est pas lié à d'autres ressources.
  • Test d'intégration : un test automatique effectué sur un environnement, similaire aux tests unitaires mais avec des ressources externes (db, accès disque)
  • Test de régression : après avoir implémenté de nouvelles fonctionnalités ou corrections de bugs, vous revérifiez des scénarios qui ont fonctionné dans le passé. Ici, vous couvrez la possibilité dans laquelle vos nouvelles fonctionnalités cassent les fonctionnalités existantes.
  • Test de fumée : premiers tests sur lesquels les testeurs peuvent conclure s'ils continueront les tests.






definition