it-swarm-fr.com

Test de l'unité Newbie Team doit tester un appareil

Je travaille avec une nouvelle équipe qui n'a toujours pas fait de test unitaire. Mon objectif est que l'équipe a finalement emploie TDD (développement axé sur les tests) comme processus naturel. Mais puisque TDD est un tel changement d'esprit radical pour une équipe de test non unitaire, je pensais que je voudrais simplement commencer par écrire des tests d'unité après le codage.

Quelqu'un at-il été dans une situation similaire? Qu'est-ce qu'un moyen efficace d'obtenir une équipe d'être à l'aise avec TDD quand ils n'ont pas fait de test unitaire? Cela a-t-il un sens de le faire dans quelques étapes? Ou devrions-nous plonger et faire face à toutes les douleurs de croissance à la fois ??

ÉDITER

Juste pour clarification, il n'y a personne sur l'équipe (autre que moi) qui a une exposition/expérience de test de l'unité. Et nous prévoyons d'utiliser les fonctionnalités de test de l'unité intégrées à Visual Studio.

38
Walter

Pratique sur les bugs/défauts existants.

C'est une situation très difficile. Je ne suis jamais allé jusqu'à TDD de rien auparavant, mais dans mon expérience, d'obtenir une équipe de passer d'aucun test d'unité pour les écrire de manière proactive a été une approche très "une étape à la fois".

Tout d'abord, procurez-leur des tests d'unité d'écriture à l'aise et de connaître vraiment ce qu'ils sont et leurs avantages. Pour mes équipes, il est préférable d'écrire des tests d'unité pour les bugs existants. Les bugs actuels dans les systèmes ont deux éléments dont vous avez besoin pour apprendre aux personnes à écrire des tests de l'unité:

  1. une condition préalable attendue et postcondition
  2. un résultat qui n'est actuellement pas ce qui est attendu et viole cette préconditionnement/postcontion

Cela donne aux membres des exemples de pratique très concrète. Ils peuvent écrire un test avant de corriger le bogue, de sorte qu'il échoue. Ensuite, ils peuvent corriger le code de sorte qu'il passe et corrige le bogue. Une fois qu'ils sont à l'aise avec cela, vous pouvez les obtenir le reste du chemin afin qu'ils puissent écrire des tests d'unité sans code haut avant, puis écrivez le nouveau code pour obtenir leurs tests.

Je pense que l'astuce est de leur donner quelque chose à pratiquer où il existe une méthode claire pré/post-conditions. Si les conditions requises pour les méthodes sont floues, il est difficile pour les personnes TDD même expérimentées de savoir exactement où commencer. Prenez-le un pas à l'heure et vous y arriverez. Bonne chance!

38
Ryan Hayes

J'ai réussi à convaincre toute ma compagnie de passer à TDD. Ce n'était pas facile, mais c'était la peine d'être effort: la qualité du code est montée après la transition, et personne n'imagine maintenant de retourner dans les horribles temps de codage de cow-boy.

  1. Expliquer, expliquer, expliquer. Vous ne voulez pas que votre équipe écrit des tests. Vous voulez que votre équipe veuillez Pour écrire des tests. Cela signifie qu'ils devraient bien comprendre pourquoi Ils devraient le faire, quels sont les avantages et comment cela rendra beaucoup plus facile leur travail. rouge, vert, refacteur, écrit un test de régression comme une preuve qu'un bogue a été corrigé, etc. Vous devez les convaincre tout ce qui est logique avant de leur demander d'écrire n'importe quel code.

  2. Allez pour la vraie chose (premiers tests, puis code). Écrire des tests après que le code n'a guère de sens, car vous ne saurez jamais si elles fonctionnent réellement (et les gens écrivent des cas de test de buggy). Mon intuition est que la quantité d'effort que vous devez aller de aucun test to tests d'abord est beaucoup moins que ce que vous devez faire de la forme Aucun test via code d'abord to Tests d'abord, vous pouvez aussi bien sauter l'étape moyenne.

  3. Commencez par des tests de régression. Celles-ci sont assez simples à comprendre et ils donnent une gratification instantanée. Bien entendu, cela suppose que le code est correctement modularisé et facilement testable. Sinon, ignorez cette étape.

  4. Prenez des petits pas. TDD prend un certain temps pour s'habituer et peut être frustrant au début. Essayez d'introduire des tests dans un nouveau projet ou composant, idéalement: quelque chose qui n'est pas très important. Vous souhaitez éviter à tout prix la situation lorsqu'il y a quelque chose de vraiment important d'être fait très rapidement et que les programmeurs estiment que TDD se met à la hauteur.

  5. Lorsque l'équipe commence à être à l'aise, toutes les nouvelles fonctionnalités sont-elles écrites de manière TDD. Cela dépend de la taille de votre projet, mais après un certain temps, vous devriez avoir une très bonne couverture, avec seulement une partie héritage Parties de votre projet écrit à l'ancienne.

  6. À ce stade, l'équipe doit déjà comprendre et embrasser TDD, et le héritage Stufft (non TDD) devrait être considéré comme difficile et gênant de travailler avec. Obtenez-le refactored: la plupart des collons le feront avec plaisir.

Quelques autres points importants:

  • Assurez-vous d'utiliser le meilleur cadre de test disponible. Il sera beaucoup plus difficile de convaincre les gens de faire TDD s'ils doivent interagir avec une bibliothèque mal écrite.

  • Assurez-vous que les tests sont faciles à exécuter et ne prenez pas beaucoup de temps pour terminer (ou tricher, par exemple en utilisant une DB en mémoire pour les tests).

  • Configurez un logiciel d'intégration continue, de sorte que les tests brisés se trouvent immédiatement.

34
Ryszard Szopa

Une façon de se mettre à l'aise avec TDD est d'écrire d'abord des tests d'intégration. Introduisez des joints de test et des tests d'unités réels plus tard.

Le problème avec l'écriture des tests d'unité après le codage est que le code peut ne pas nécessairement être conçu pour être testable. Vous devrez peut-être faire du refactoring ou peut-être de re-conception pour introduire les joints de test. Mais Comment pouvez-vous refactuer ou ré-concevoir en toute sécurité si vous n'avez aucune couverture de test de quelque nature que ce soit?

Les tests d'intégration peuvent vous donner cette couverture initialement. Chaque fois que vous avez une régression ou un problème de production, corrigez-le dans le code et couvrez ce code avec un test. Une fois que vous avez suffisamment d'un filet de sécurité fourni par de tels tests, vous pouvez introduire des tests d'unité de composants et/ou de classes isolés de votre système plus finement grainé.

19
azheglov

TDD est très difficile à mettre en œuvre et n'est pas toujours la meilleure option pour chaque équipe de développement. Dans mon emploi précédent, l'équipe était fortement concentrée sur TDD. Notre modèle de développement était entièrement TDD à l'aide de l'approche Agile Development.Sting a été effectuée via des tests d'unité Visual Studio.

Si un développeur n'a pas écrit de tests unitaires pour sa fonctionnalité, ils seraient en difficulté avec le plomb technique. En outre, si quelqu'un enregistre une construction cassée ou des tests unitaires, le développeur devra résoudre tous les problèmes et ajouter un montant de 1 $ au bocal de l'équipe.

4
Nickz

Juste une petite chose à ajouter, visualisez le processus. Rendre les tests d'intégration continue automatiquement et recherchez la couverture de code. Énumérez les modules testés les plus complets sur une base de bord que tout le monde peut voir. Cela devrait faire venir la compétition d'équipe.

3
Fredrik

Je suis allé d'aucune expérience junit directement à TDD et l'expérience a rendu la valeur de TDD incomparablement apparente. Je suis devenu tellement reconnaissant pour les tests de l'unité que je suis rapidement devenu un évangéliste pour l'approche

2
Ray

Je suis sur des équipes qui n'ont pas fait de test unitaire, mais il a été introduit et est devenu presque courant d'avoir des tests maintenant. Je suggérerais d'explorer à quel point votre équipe comprend-elle les bases des tests unitaires ainsi que sur les outils que vous souhaitez apporter ici?

Dans mon cas, il apportait une Nunit pour certains code .NET qui constituait un mélange de logique commerciale, d'interface utilisateur et de fonctionnalité arrière. Je suggérerais de voir s'il y a des gens qui sont plus volontaires de vouloir y arriver plus que d'autres afin que quelques personnes de l'équipe l'obtiennent et que cela puisse se répandre un peu plus que le côté retournement où vous essayez d'obtenir tout le monde sauter à ce sujet. En obtenant un peu pour le faire d'abord, cela permet une formation continue de sorte que ceux qui le ramassent peuvent être testés quant à la façon dont ils peuvent l'apprendre à quelqu'un d'autre.

Un autre point est d'envisager d'apporter à ceux qui ont plus d'expertise pour essayer de le montrer dans une certaine mesure. Les travaux de pensée ont été apportés là où je travaille pour nous montrer des choses que certaines d'entre elles ont été largement adoptées et que d'autres parties ne sont pas nombreuses, mais je pense que cela serait vrai dans la plupart des endroits.

0
JB King