Qu'est-ce que les tests unitaires?

je ne suis pas en désaccord avec Dan (bien que le meilleur choix est peut être tout simplement de ne pas répondre)...mais...

Unit testing est le processus d'écriture de code pour tester le comportement et la fonctionnalité de votre système.

évidemment, les tests améliorent la qualité de votre code, mais ce n'est qu'un avantage superficiel des tests unitaires. Les avantages réels sont les suivants:

1. facilitent la modification de la mise en œuvre technique tout en assurant vous ne changez pas le comportement (refactoring). Le code correctement testé par l'unité peut être remanié/nettoyé de façon agressive avec peu de chance de casser quoi que ce soit sans le remarquer.
2. donne confiance aux développeurs en ajoutant un comportement ou en faisant des corrections.
3. Documentez votre code
4. indique les zones de votre code qui sont étroitement couplées. Il est difficile d'établir un code d'essai unitaire étroitement couplé
5. fournit un moyen d'utiliser votre API et cherchez les difficultés dès le début
6. indique des méthodes et des classes qui ne sont pas très cohérentes

vous devriez faire un test unitaire parce que c'est dans votre intérêt de fournir un produit maintenable et de qualité à votre client.

je vous suggère de l'utiliser pour n'importe quel système, ou partie d'un système, qui modèle le comportement réel. En d'autres termes, il est particulièrement bien adapté au développement des entreprises. Je ne voudrais pas l'utiliser pour jeter/programmes utilitaires. Je ne l'utiliserais pas pour les parties d'un système qui posent problème au test (L'assurance-chômage est un exemple courant, mais ce n'est pas toujours le cas)

le plus grand écueil est que les développeurs testent une unité trop grande, ou ils considèrent une méthode une unité. Cela est particulièrement vrai si vous ne comprenez pas Inversion du contrôle - dans ce cas, les tests de votre unité se transformeront toujours en test d'intégration de bout en bout. L'essai unitaire devrait tester l'individu les comportements - et la plupart des méthodes ont de nombreux comportements.

le plus grand malentendu est que les programmeurs ne devraient pas tester. Seuls les mauvais ou les programmeurs paresseux croient cela. Le type qui construit votre toit ne devrait-il pas le tester? Le médecin qui remplace une valve cardiaque ne devrait-il pas tester la nouvelle valve? Seul un programmeur peut tester que son code fait ce qu'il avait l'intention de faire (QA peut tester les cas de bordures - comment le code se comporte quand on lui dit de faire des choses que le programmeur n'avait pas l'intention de faire, et le client peut faire test d'acceptation-le code fait-il ce que le client a payé pour qu'il fasse?

la principale différence des tests unitaires, par opposition à" juste ouvrir un nouveau projet et tester ce code spécifique "est que c'est automatisé , donc répétable .

Si vous testez votre code manuellement, il peut vous convaincre que le code fonctionne parfaitement - dans son état actuel . Mais qu'en est-il une semaine plus tard, quand vous y avez apporté une légère modification? Êtes-vous prêt à tester de nouveau par la main chaque fois que quelque chose change dans votre code? Très probablement pas: - (

mais si vous pouvez exécuter vos tests à tout moment, en un seul clic, exactement de la même manière, en quelques secondes , alors ils will vous montrer immédiatement chaque fois que quelque chose est cassé. Et si vous intégrez également les tests de l'unité dans votre processus de construction automatisé, ils vous avertiront des bogues, même dans les cas où un le changement a cassé quelque chose dans une partie éloignée de la base de codes - quand il ne vous viendrait même pas à l'esprit qu'il y a un besoin de retester cette fonctionnalité particulière.

C'est le principal avantage des essais unitaires par rapport aux essais manuels. Mais attendez, il y a plus:

• tests unitaires raccourcir considérablement la boucle de rétroaction du développement : avec un département de test séparé, il peut vous prendre des semaines pour savoir qu'il y a un bug dans votre code, par lequel le temps que vous avez déjà oublié une grande partie du contexte, ainsi il peut vous prendre des heures pour trouver et corriger le bug; OTOH avec des tests unitaires, le cycle de rétroaction est mesurée en secondes, et le processus de correction de bug est typiquement le long des lignes d'un "oh sh*t, j'ai oublié de vérifier cette condition ici": -)
• tests unitaires efficacement document (votre compréhension de l') le comportement de votre code
• unité d'essai vous oblige à réévaluer vos choix de conception, ce qui se traduit par conception plus simple et plus propre

les cadres de test unitaires, à leur tour, rendent facile pour vous d'écrire et exécuter vos tests.

je n'ai jamais été enseigné tests unitaires à l'université, et il m'a fallu un certain temps pour "obtenir". J'ai lu à ce sujet, j'ai dit "Ah, d'accord, les tests automatisés, ça pourrait être cool je suppose", et puis j'ai oublié.

il a fallu un peu plus de temps avant que je comprenne vraiment le point: disons que vous travaillez sur un grand système et vous écrivez un petit module. Il compile, vous mettre à l'épreuve, il fonctionne très bien, de passer à la tâche suivante. Neuf mois plus tard et deux versions plus tard quelqu'un d'autre fait un changement à quelque apparemment partie sans rapport du programme, et il casse le module. Pire, ils testent leurs modifications, et leur code fonctionne, mais ils ne testent pas votre module; enfer, ils peuvent même ne pas savoir votre module existe .

et maintenant vous avez un problème: code cassé est dans le coffre et personne ne sait même. Le meilleur cas est un testeur interne le trouve avant de vous expédier, mais la fixation du code que tard dans le jeu est cher. Et si aucun testeur trouve...Eh bien, cela peut devenir très cher en effet.

la solution est un essai unitaire. Ils vont attraper des problèmes quand vous écrivez le code - ce qui est très bien - mais vous auriez pu le faire à la main. La vraie récompense est qu'ils vont attraper des problèmes neuf mois plus tard dans la ligne quand vous travaillez maintenant sur un projet complètement différent, mais un stagiaire d'été pense qu'il aura l'air plus tidier si ces paramètres étaient dans l'ordre alphabétique - et puis le test de l'unité que vous avez écrit il y a longtemps échoue, et quelqu'un jette des choses au stagiaire jusqu'à ce qu'il change l'ordre des paramètres en arrière. C'est le" pourquoi " des tests unitaires. :- )

sur les avantages philosophiques des tests unitaires et de la TDD voici quelques-uns d'entre eux des observations "légères" qui m'ont frappé sur mes premiers pas provisoires sur la voie de la TDD enlightenment (aucune originale ou nécessairement nouvelles)...

1. TDD ne signifie pas que vous devez écrire deux fois la quantité de code. Le code de Test est généralement assez rapide et indolore à écrire et est un élément clé de votre processus de conception et critique.

2. TDD vous aide à réaliser quand arrêter le codage! Vos tests vous donnent confiance que vous avez fait assez pour le moment et peut arrêter de peaufiner et passer à la chose suivante.

3. les essais et le code travaillent ensemble pour obtenir un meilleur code. Votre code pourrait être mauvais / buggy. Votre TEST pourrait être mauvais / buggy. En TDD vous misez sur les chances D'être mauvais / buggy être assez faible. Souvent son le test qui doit être réparé, mais c'est encore un bon résultat.

4. TDD aide à coder la constipation. Tu sais ce sentiment que tu as tant de choses à faire Tu Sais à peine par où commencer? C'est vendredi après-midi, si vous attendez encore quelques heures... TDD vous permet d'étoffer très rapidement ce que vous pensez que vous devez faire, et obtient votre codage se déplaçant rapidement. Aussi, comme les rats de laboratoire, je pense que nous répondons tous à ce grand feu vert et travaillons plus dur pour le voir à nouveau!

5. dans la même veine, ces types de designers peuvent voir sur quoi ils travaillent. Ils peuvent se promener pour une pause jus / cigarette / iphone et revenir à un moniteur qui leur donne immédiatement un signal visuel quant à l'endroit où ils se sont rendus. TDD nous donne quelque chose de similaire. C'est plus facile de voir où on en est quand la vie intervient...

6. je pense que C'est Fowler qui a dit: "les tests imparfaits, courir fréquemment, sont beaucoup mieux que parfait des tests qui ne sont jamais écrits". J'interprète ceci comme me donnant la permission d'écrire des tests là où je pense qu'ils seront les plus utiles même si le reste de ma couverture de code est tristement incomplet.

7. TDD aide dans toutes sortes de façons surprenantes en bas de la ligne. De bons tests unitaires peuvent aider à documenter ce que quelque chose est censé faire, ils peuvent vous aider à migrer le code d'un projet à l'autre et vous donner un sentiment injustifié de supériorité sur votre non-collègues de tests :)

Cette présentation est une excellente introduction à toute la délicieuse bonté de test implique.

je voudrais vous recommander le livre xUnit Testing Patterns de Gerard Meszaros. Il est grand, mais est une grande ressource sur le test de l'unité. Voici un lien vers son site web où il discute les bases de tests unitaires. http://xunitpatterns.com/XUnitBasics.html

c'est mon avis. Je dirais que le test à l'unité est la pratique d'écrire des tests logiciels pour vérifier que votre vrai logiciel fait ce qu'il est censé faire. Cela a commencé avec jUnit dans le monde de Java et est devenu une meilleure pratique en PHP aussi bien avec SimpleTest et phpUnit . C'est une pratique de base de la programmation extrême et vous aide à être sûr que votre logiciel fonctionne toujours comme prévu après l'édition. Si vous avez suffisamment de couverture de test, vous pouvez effectuer un remaniement majeur, corriger des bogues ou ajouter des fonctionnalités rapidement avec beaucoup moins de crainte d'introduire d'autres problèmes.

c'est le plus efficace lorsque tous les tests unitaires peuvent être exécutés automatiquement.

"151900920 de tests Unitaires, est généralement associé avec OO développement. L'idée de base est de créer un script qui configure l'environnement de votre code puis l'exerce; vous écrivez des assertions, spécifiez la sortie prévue que vous devriez recevoir puis exécutez votre script de test en utilisant un framework comme ceux mentionnés ci-dessus.

le framework exécutera tous les tests par rapport à votre code puis rapportera le succès ou l'échec de chaque test. phpUnit est exécuté à partir de la ligne de commande Linux par défaut, bien qu'il existe des interfaces HTTP pour cela. SimpleTest est basé sur le web par nature et est beaucoup plus facile de se mettre en marche, IMO. En combinaison avec xDebug, phpUnit peut vous fournir des statistiques automatisées pour la couverture du code que certaines personnes trouvent très utile.

certaines équipes écrivent des hooks à partir de leur dépôt subversion afin que les tests unitaires soient exécutés automatiquement chaque fois que vous propagez des modifications.

C'est une bonne pratique de garder vos tests unitaires dans le même référentiel que votre demande.

j'utilise des tests unitaires pour gagner du temps.

lors de la construction de la logique d'affaires (ou de l'accès aux données) fonctionnalité de test peut souvent impliquer de taper des choses dans un grand nombre d'écrans qui peut ou ne peut pas être terminé encore. L'automatisation de ces tests permet de gagner du temps.

pour moi, les essais unitaires sont une sorte de harnais d'essai modularisé. Il y a habituellement au moins un test par fonction publique. J'écris des tests supplémentaires pour couvrir divers comportements.

tous les cas spéciaux auxquels vous avez pensé lors de l'élaboration du code peuvent être enregistrés dans le code dans les tests unitaires. Les tests unitaires également devenir une source d'exemples sur la façon d'utiliser le code.

il est beaucoup plus rapide pour moi de découvrir que mon nouveau code casse quelque chose dans mes tests de l'unité puis de vérifier le code et d'avoir un développeur front-end trouver un problème.

Pour l'accès aux données de test j'essaie d'écrire des tests qui n'ont pas de changer ou nettoyer après eux-mêmes.

les tests unitaires ne vont pas être en mesure de résoudre toutes les exigences de test. Ils seront en mesure d'économiser du temps de développement et de tester les parties centrales de l'application.

bibliothèques comme NUnit , xUnit ou JUnit sont juste obligatoires si vous voulez développer vos projets en utilisant le TDD approche popularisée par Kent Beck:

vous pouvez lire Introduction to Test Driven Development (TDD) ou le livre de Kent Beck Test Driven Development: By Example .

alors, si vous voulez être sûr que vos tests couvrent une "bonne" partie de votre code, vous pouvez utiliser des logiciels comme NCover , JCover , PartCover ou n'importe quoi d'autre. Ils vous diront le pourcentage de couverture de votre code. Selon votre niveau d'expertise au TDD, vous saurez si vous l'avez assez bien pratiqué:)

Unité de test est sur le code d'écriture qui teste votre code d'application.

la Unité partie du nom concerne l'intention de tester de petites unités de code (une méthode par exemple) à la fois.

xUnit est là pour aider avec ce test - ils sont des cadres qui aident avec cela. Une partie de cela sont des coureurs de test automatisés qui vous disent ce que le test échoue et ceux qui passent.

ils ont également installations pour mettre en place le code commun dont vous avez besoin dans chaque test avant la main et le détruire lorsque tous les tests ont terminé.

vous pouvez avoir un test pour vérifier qu'une exception attendue a été lancée, sans avoir à écrire le bloc d'essai entier vous-même.

je pense que le point que vous ne comprenez pas est que les cadres d'essai d'unité comme NUnit (et similaires) vous aideront dans automating small to medium-sized tests. Habituellement , vous pouvez exécuter les tests dans une interface graphique (c'est le cas avec NUnit , par exemple) en cliquant simplement sur un bouton et puis - espérons - le-voir la barre de progression rester vert. S'il devient rouge, le framework vous montre quel test a échoué et ce qui a mal tourné. Dans une unité normale test, vous utilisez souvent des assertions, par exemple Assert.AreEqual(expectedValue, actualValue, "some description") - donc si les deux valeurs sont inégales, vous verrez une erreur disant"une certaine description: expected mais était ".

ainsi, comme une conclusion Unité de test rendra les tests plus rapide et beaucoup plus confortable pour les développeurs. Vous pouvez exécuter tous les tests unitaires avant d'engager un nouveau code afin de ne pas briser le processus de construction d'autres développeurs sur le même projet.

Utiliser Testivus . Tout ce que vous devez savoir, c'est juste là :)

Unité de test est une pratique pour s'assurer que la fonction ou le module que vous allez mettre en œuvre va se comporter comme prévu (exigences) et aussi pour s'assurer comment il se comporte dans des scénarios comme les conditions limites, et entrée invalide.

xUnit , NUnit , mbUnit , etc. sont des outils qui vous aident à écrire les tests.

de l'Unité de test est le test d'une unité de code (par exemple, une fonction unique) sans la nécessité pour l'infrastructure de l'unité de code s'appuie sur. c'est à dire de le tester dans l'isolement.

si, par exemple, la fonction que vous testez se connecte à une base de données et fait une mise à jour, dans un test unitaire, vous pourriez ne pas vouloir faire cette mise à jour. Vous s'il s'agissait d'un test d'intégration, mais dans ce cas, il ne l'est pas.

ainsi un test unitaire exercerait fonctionnalité incluse dans la" fonction " que vous testez sans effets secondaires de la mise à jour de la base de données.

dites que votre fonction a récupéré quelques chiffres d'une base de données et a ensuite effectué un calcul d'écart-type. De quoi êtes-vous en train de tester, ici? L'écart-type est-il calculé correctement ou les données sont-elles retournées de la base de données?

dans un test unitaire, vous voulez juste tester que l'écart-type est calculé correctement. Dans un test d'intégration vous voulez tester le calcul de l'écart-type et l'extraction de la base de données.

développement basé sur les tests A en quelque sorte pris plus de temps que le terme test unitaire. En tant qu'ancien, je mentionnerai la définition plus générale de cette notion.

essai à L'Unité signifie également l'essai d'un seul composant dans un système plus grand. Ce composant unique pourrait être une dll, exe, bibliothèque de classe, etc. Il peut même s'agir d'un système unique dans une application multi-systèmes. Donc finalement, le test unitaire finit par être le test de ce que vous voulez appeler un morceau unique d'un système plus grand.

vous passerez ensuite aux tests intégrés ou systèmes en testant comment tous les composants fonctionnent ensemble.

tout d'abord, qu'il s'agisse d'Essais unitaires ou de tout autre type d'essais automatisés (intégration, charge, essai de L'IU, etc.).), la principale différence par rapport à ce que vous suggérez est qu'il est automatisé, reproductible et il ne nécessite pas de ressources humaines pour être consommé (= personne n'a à effectuer les tests, ils fonctionnent généralement à une pression d'un bouton).

je suis allé à une présentation sur les tests unitaires à FoxForward 2007 et on m'a dit de ne jamais tester les unités qui fonctionnent avec des données. Après tout, si vous testez les données en direct, les résultats sont imprévisibles, et si vous ne testez pas les données en direct, vous ne testez pas réellement le code que vous avez écrit. Malheureusement, c'est la plupart des codes que je fais ces jours-ci. :- )

j'ai fait un essai à TDD récemment quand j'écrivais une routine pour sauver et restaurer les paramètres. Tout d'abord, j'ai vérifié que j' pourrait créer l'objet de stockage. Puis, qu'il y avait la méthode que j'avais besoin d'appeler. Alors, que je pouvais l'appeler. Ensuite, je pourrais passer les paramètres. Ensuite, je pourrais lui passer des paramètres spécifiques. Et ainsi de suite, jusqu'à ce que je vérifie enfin qu'il sauvegarderait le paramètre spécifié, me permette de le modifier, puis de le restaurer, pour plusieurs syntaxes différentes.

Je ne suis pas arrivé à la fin, parce que j'avais besoin-de-la-routine-maintenant-dammit, mais c'était un bon exercice.

Que faites-vous si on vous donne un tas de merde et semblent comme vous êtes coincé dans un état perpétuel de nettoyage que vous savez avec l'ajout de toute nouvelle fonctionnalité ou code peut briser l'ensemble actuel parce que le logiciel actuel est comme un château de cartes?

Comment faire des tests unitaires alors?

vous commencez petit. Le projet dans lequel je suis entré n'a pas été testé jusqu'à il y a quelques mois. Quand la couverture était si faible, nous choisirions simplement un fichier qui n'avait pas de couverture et cliquions "ajouter des tests".

en ce moment nous sommes à plus de 40%, et nous avons réussi à arracher la plupart des fruits bas de gamme.

(la meilleure partie est que même à ce faible niveau de couverture, nous avons déjà rencontré de nombreuses instances du code faisant la mauvaise chose, et les tests l'ont attrapé. C'est une énorme motivation pour pousser les gens à ajouter plus de tests.)

cette réponse explique pourquoi vous devriez faire des tests à l'unité.

---

les 3 vidéos ci-dessous couvrent la mise à l'essai de l'unité en javascript, mais les principes généraux s'appliquent à la plupart des langues.

Test d'Unité: Minutes Maintenant Économiser des Heures plus Tard - Eric Mann - https://www.youtube.com/watch?v=_UmmaPe8Bzc

JS Tests Unitaires (très bonne) - https://www.youtube.com/watch?v=-IYqgx8JxlU

Writing Testable JavaScript - https://www.youtube.com/watch?v=OzjogCFO4Zo

---

" maintenant je suis en train d'apprendre sur le sujet donc je ne suis peut-être pas à 100% correct et il y a plus que ce que je décris ici, mais ma compréhension de base des tests unitaires est que vous écrivez un certain code de test (qui est maintenu séparé de votre code principal) qui appelle un fonction dans votre code principal avec entrée (arguments) que la fonction exige et le code vérifie ensuite s'il obtient en arrière une valeur de retour valide. S'il récupère une valeur valide, le framework de test unitaire que vous utilisez pour exécuter les tests affiche un feu vert (tout est bon) si la valeur n'est pas valide, Vous obtenez un feu rouge et vous pouvez alors corriger le problème immédiatement avant de lancer le nouveau code en production, sans test, vous n'avez peut-être pas saisi l'erreur.

donc vous écrire des tests pour vous code actuel et créer le code pour qu'il passe le test. Des mois plus tard, vous ou quelqu'un d'autre devez modifier la fonction dans votre code principal, parce que plus tôt, vous aviez déjà écrit le code de test pour cette fonction que vous exécutez maintenant à nouveau et le test peut échouer parce que le codeur introduit une erreur de logique dans la fonction ou retourner quelque chose de complètement différent de ce que cette fonction est censée retourner. De nouveau sans le tester en place d'erreur pourrait être difficile à traquer comme il peut éventuellement affecter d'autres codes et passent inaperçus.

---

aussi le fait que vous ayez un programme informatique qui tourne à travers votre code et le teste au lieu de le faire manuellement dans le navigateur page par page permet de gagner du temps (test unitaire pour javascript). Disons que vous modifiez une fonction qui est utilisée par certains script sur une page web et il fonctionne très bien pour sa nouvelle destination. Mais, disons aussi pour des raisons d'arguments qu'il y a une autre fonction que vous avez ailleurs dans votre code qui dépend de cette nouvelle fonction modifiée pour qu'elle fonctionne correctement. Cette fonction dépendante peut maintenant arrêter de fonctionner en raison des changements que vous avez faits à la première fonction, mais sans tests en place qui sont exécutés automatiquement par votre ordinateur, vous ne remarquerez pas qu'il y a un problème avec cette fonction jusqu'à ce qu'elle soit réellement exécutée et vous aurez à naviguer manuellement vers une page web qui comprend le script qui exécute le fonction dépendante, seulement alors vous remarquez qu'il y a un bug à cause du changement que vous avez fait à la première fonction.

pour répéter, avoir des tests qui sont exécutés tout en développant votre application attrapera ce genre de problèmes que vous codez. Ne pas avoir les tests en place, vous auriez à passer manuellement à travers toute votre application et même alors il peut être difficile de repérer le bogue, naïvement vous l'envoyez dans la production et après un certain temps un utilisateur gentil vous envoie un rapport de bogue (ce qui ne sera pas aussi bon que vos messages d'erreur dans un cadre de test).

---

c'est assez déroutant quand vous entendez parler du sujet pour la première fois et que vous vous dites: ne suis-je pas déjà en train de tester mon code? Et le code que vous avez écrit fonctionne comme prévu: "pourquoi ai-je besoin d'un autre cadre?"... Oui, vous êtes déjà en train de tester votre code, mais un ordinateur est meilleur pour le faire. Vous avez juste à écrire assez de bons tests pour une fonction / Unité de code une fois et le reste est pris en charge pour vous par le puissant cpu au lieu de vous avoir à vérifier manuellement que tout votre code fonctionne toujours lorsque vous faites un changement à votre code.

en outre, vous ne devez pas tester votre code si vous ne le voulez pas, mais il paie au fur et à mesure que votre base de code/projet commence à grossir au fur et à mesure que les chances d'introduire des bogues augmentent.

Unit-testing et TDD en général vous permet d'avoir des cycles de rétroaction plus courts sur le logiciel que vous écrivez. Au lieu d'avoir une grande phase de test à la toute fin de l'implémentation, vous testez progressivement tout ce que vous écrivez. Cela augmente considérablement la qualité du code, comme vous le voyez immédiatement, là où vous pourriez avoir des bogues.