Test de l'unité automatisé, test d'intégration ou test d'acceptation
TDD et tests unitaires semblent être le grand rave pour le moment. Mais il est vraiment utile que d'autres formes de tests automatisés?
Intuitivement, je devinerais que les tests d'intégration automatisés sont beaucoup plus utiles que les tests unitaires. D'après mon expérience, la plupart des bugs semblent être dans l'interaction entre les modules, et pas tant la logique réelle (habituelle limitée) de chaque unité. Les régressions sont également souvent arrivées en raison de la modification des interfaces entre les modules (et modifiés pré-conditions.)
Suis-je mal comprendre quelque chose, ou pourquoi les tests d'unité se concentrent-ils autant de concentrations par rapport aux tests d'intégration? C'est simplement parce qu'il est supposé que les tests d'intégration sont quelque chose que vous avez et que les tests unitaires sont la prochaine chose que nous devons apprendre à appliquer en tant que développeurs?
Ou peut-être que des tests unitaires donnent simplement le plus grand gain par rapport à la complexité de l'automatiser?
Quelles-tu d'expérience avec les tests d'unité automatisés, les tests d'intégration automatisés et les tests d'acceptation automatisés et dans votre expérience ce qui a donné le meilleur retour sur investissement? Et pourquoi?
Si vous deviez choisir une seule forme de test pour être automatisé sur votre prochain projet, ce qui serait-ce?
Merci d'avance.
Tous les types d'essais sont très importants et garantissent différents aspects du système. Donc, pour travailler en arrière, "si je devais choisir un type de test ..." Je ne le ferais pas. Le test unitaire me fournit des commentaires différents que des tests d'intégration ou des tests interactifs par une personne.
Voici le type/avantage des tests que nous faisons:
- Tests unitaires - garantit que les unités effectuent des travaux comme nous nous attendons à ce qu'ils soient. Nous testons les contrats de fournisseur et de consommation pour chaque interface - et cela est assez facile à automatiser. Nous vérifions également nos conditions limites, etc.
- Tests d'intégration - garantit que les unités travaillent ensemble de concert. Ceci est principalement pour tester notre conception. Si quelque chose se casse ici, nous devons ajuster nos tests de l'unité pour vous assurer que cela ne se reproduise pas.
- Test du système - Assure que le système répond aux exigences/spécifications. Habituellement, les gens font ce type de test.
- Test d'acceptation - Le client fait cela pour vérifier que le produit final fait ce qui est annoncé.
Test optionnel mais recommandé:
- Essais d'expérience utilisateur: pendant que nous obtenons des commentaires décents à partir des tests du système, les personnes à partir de la prévisualisation du client Certaines pré-versions peuvent vraiment aider à déterminer si nous devons changer les choses avant qu'il ne soit trop tard.
Juste pour comprendre pourquoi les tests unitaires ont un avantage sur les tests d'intégration, vous devez comprendre les tests supplémentaires de la magnitude dont vous auriez besoin pour être exhaustif. Pour chaque résultat possible pour l'unité A, il faut un test. La même chose pour l'unité B. Maintenant, si elles travaillent ensemble pour une solution plus complète, le nombre de tests est combinatoire. En bref, pour tester chaque permutation d'interaction entre unité A et unité B, vous avez besoin de tests * B. Ajouter une unité C et le nombre de tests pour le trio seraient * b * c.
C'est là que le concept d'interfaces et de frontières d'objet devient très important. Les interfaces représentent un certain contrat. AnMiddor d'une interface convient qu'il se comportera d'une certaine manière. De même, A consommateur d'une interface convient qu'il utilisera la mise en œuvre d'une certaine manière. En écrivant un test qui collecte chaque classe qui implémente une interface, vous pouvez facilement tester que chaque mise en œuvre observe les contrats d'interface. C'est la moitié de l'équation. L'autre moitié est de tester le côté de la consommation - ce qui est là où des objets masculins viennent jouer. La moquure est configurée pour s'assurer que les interactions sont toujours en sécurité. À ce stade, tout ce qui est nécessaire est quelques tests d'intégration afin de nous assurer que nous avons les contrats de mise en œuvre/consommateurs corrects.
Ce sont des outils différents avec des objectifs différents:
Le test de l'unité est un outil de conception (TDD) et une prérequis presque pour le refactoring.
Les tests d'intégration sont parfaits pour visualiser la progression du projet, ainsi que pour éviter les bugs de régression.
Le point à retenir est que vous ne pouvez pas vraiment concevoir avec des tests d'intégration, et vous ne trouverez pas de régressions avec des tests unitaires.
Le meilleur retour sur investissement est généralement le premier test qui peut trouver ce type de bogue.
Les tests unitaires doivent trouver la plupart des bugs qui sont juste dans une méthode, ou peut-être un composant. Il trouve des bugs qui peuvent généralement être fixés en quelques minutes, avec au total des temps de tour autour de moins d'une heure. des tests très bon marché, des bugs très bon marché pour trouver et corriger! Si ces bugs ont fait dans les tests d'intégration, de demi-tour pourrait être plus comme une journée (séries de tests se produisent souvent la nuit), en supposant que le bogue ne soit pas obturée par un autre bogue; plus il y a probablement plus de bugs introduits depuis un autre code a été écrit contre le code bogué initial; ainsi que tous les refontes auront un impact plus des morceaux de code. De plus, en laissant plus d'insectes par des moyens ayant trait à beaucoup d'autres séries de tests avant le test d'intégration peut être complétée. les tests unitaires pauvres est souvent au cœur des longues, onéreuses, coûteux cycles d'intégration de test. tests unitaires peut réduire de moitié le temps Skipping de développement, mais les tests prendra 3 à 4 fois plus longtemps au moins, l'ensemble du projet doublera en longueur, et vous aurez encore moins bonne qualité que si vous unité testée IME.
Les tests d'intégration est généralement le premier test réel qui peut trouver des bogues d'intégration (bien que les processus d'examen peuvent trouver quelques bugs avant que le logiciel est écrit, ou avant que le code va à l'essai). Vous voulez trouver ces bugs avant de commencer à montrer le logiciel à l'utilisateur ou à la libération, car la correction des bugs au dernier moment (ou chaud fixation!) Est très cher. Vous ne pouvez pas trouver les bogues plus tôt, quand ils seraient moins chers pour fixer, car vous avez besoin des composants de travail multiples pour intégrer (par définition). Les tests d'intégration se ralentit quand les bugs qui ont rien à voir avec des pièces en interaction (comme les fautes de frappe mineures) doivent être résolus avant de l'essai plus intéressant peut même commencer.
Les tests d'acceptation des utilisateurs est en vous assurant que le logiciel fait ce que le client veut (bien que le client a l'espérons impliqué tout le temps, pour réduire le risque de trouver un énorme écart entre les attentes et les logiciels droit réel à la fin du projet - très cher !). Au moment où vous arrivez à ce stade de test, vous devriez vraiment croire que la plupart des bugs dans votre produit, par rapport aux spécifications au moins, ont déjà été trouvés. les tests d'acceptation des utilisateurs est plus de faire que les produits fits les besoins du client que de faire en sorte qu'il n'y a pas de bugs par rapport aux spécifications.
Si je ne vais automatiser un type de test, il serait des tests unitaires. Les tests d'intégration peut se faire manuellement et ont été faites de cette façon par de nombreuses grandes entreprises depuis des années. Il est plus de temps à faire manuellement un travail qui pourrait être fait par un ordinateur et plus, et beaucoup plus cher pour la plupart des projets, sans parler ennuyeux et sujette aux erreurs, mais il peut être fait. tests d'acceptation de l'utilisateur sont souvent manuel, car les utilisateurs ne savent souvent pas comment automatiser leurs tests tout en testant ce qu'ils se soucient. Les tests unitaires DOIVENT être automatisés. Vous devez être en mesure d'exécuter tous les tests unitaires en quelques secondes à la demande aussi souvent que toutes les quelques minutes. Les humains ne peuvent pas même se rapprocher des tests manuels. Sans oublier que les tests unitaires sont dans le code, et ne peuvent être exécutées sans les appeler par le code, à savoir les automatiser. -Tests unitaires est tout simplement impossible manuellement.
Une chose à garder à l'esprit est que c'est un forum principalement pour les développeurs, pas testeurs. Les tests d'intégration est principalement mis en œuvre par les testeurs. Les tests unitaires sont mis en œuvre par les développeurs. Bien entendu, les développeurs parlent plus sur les tests unitaires que d'autres types de tests. Cela ne veut pas dire qu'ils ne pensent pas d'autres tests est important. Cela signifie simplement qu'ils ne sont pas réellement faire (ou le faire moins souvent).
J'ai l'impression que les tests d'acceptation sont KING dans ce scénario.
Si un COMMIT casse des tests d'acceptation, il doit être réglé.
Les tests d'acceptation vous indiquent où se trouve votre logiciel, les tests unitaires ne le font pas.
Par conséquent, les tests unitaires peuvent fournir un très faux sens de la sécurité.
La question n'est pas telle que ce qui est plus important, comme ce qui peut être automatisé et courir rapidement.
Les tests d'unités montrent si un petit composant est adapté à un objectif particulier et est généralement petit et rapide à courir. Être petit, ils sont généralement raisonnablement faciles à automatiser.
Les tests d'intégration montrent si les composants fonctionnent ensemble. Ils sont généralement beaucoup plus grands et peuvent ne pas être faciles à automatiser. Ils peuvent prendre plus de temps à courir. Il y a de la valeur pour pouvoir les exécuter automatiquement, mais c'est une tâche plus grande et elle ne sera pas courante aussi souvent.
Les tests d'acceptation montrent si un projet est acceptable ou non. Ceci est normalement impossible d'automatiser complètement (bien que des tests automatisés puissent jouer une pièce), car il est normalement impossible de clouer les exigences exactes et complètes dans une affaire formelle moins compliquée que le code source lui-même. Les tests d'acceptation incluent généralement les utilisateurs potentiels qui font des choses avec le système et observant que les résultats sont satisfaisants à tous égards, ce qui est normalement partiellement subjectif. Étant donné que les tests d'acceptation sont généralement exécutés une fois (différents clients voudront normalement effectuer leurs propres tests d'acceptation distincts), il ne vaut pas l'automatisation.