Quelle est la pertinence des tests unitaires dans un environnement «Release early release souvent»?

Au cours de la dernière année, j'ai orienté mon équipe vers le mode de développement à libération anticipée (AKA: Rapid Application Development, not Agile). Pour plus d'informations sur la manière dont nous fermons la génération, voir ma réponse ici: Un moyen simple d'améliorer la qualité de la version dans l'environnement RAD

Lorsque nous avons adopté RAD, les gens étaient assez indépendants et faisaient d'abord des tests unitaires; les tests intégrés ont eu lieu beaucoup plus tard dans le processus. C'était un processus naturel pour eux sans beaucoup d'application formelle. Maintenant, la situation est assez différente:

1. La plate-forme entière est bien intégrée avec les versions / versions établies fonctionnant côté client sans aucun point chaud.

2. De nouvelles exigences en matière de fonctionnalités continuent d'arriver et nous les construisons progressivement au fur et à mesure.

3. La dynamique globale du système est très importante car si des groupes de développement indépendants peuvent suivre correctement les processus, des échecs majeurs sont survenus en raison de circonstances compliquées et non évidentes.

4. De nombreuses parties du système impliquent de nouveaux algorithmes et des entrées de recherche, de sorte que les défis (et donc le mécanisme de test) ne sont pas toujours prévus correctement, comme les tests de fonctionnalités dans un logiciel bien défini.

Récemment, j'essayais d'avoir une meilleure image globale pour voir si nous avions besoin d'une amélioration des processus. Quand je me suis assis avec mon équipe, beaucoup d'entre eux ont rechigné: "Nous ne faisons plus de tests unitaires!" tandis que d'autres pensaient que nous ne devrions pas commencer maintenant car cela ne sera jamais efficace.

Les tests unitaires sont-ils utiles dans un système relativement mature? Faut-il au moins peser la portée du test en fonction de la maturité des unités? Les tests unitaires ralentiront-ils le rythme de développement? Est-il nécessaire d'évaluer les tests unitaires d'une manière différente?

Quelles sont les meilleures pratiques de test pour une plate-forme mature dans un environnement de mise à jour anticipée?

Les tests unitaires ne visent pas principalement à trouver des bogues - ils visent à garantir que la prochaine version de votre système est aussi stable que la version précédente. Plus votre cycle de publication est court, plus il est important que vous puissiez exécuter ces tests automatiquement au lieu de les faire manuellement.

Bien sûr, si vous avez un système avec des parties indépendantes et que vous ne travailliez entre deux versions que sur une petite partie du système, vous pouvez probablement omettre certains tests unitaires qui concernent d'autres parties du système. Mais vous devez certainement utiliser (et étendre) les tests unitaires pour les pièces sur lesquelles vous travaillez.

Une autre chose est que lorsqu'un système se développe, il y aura de plus en plus besoin de tests d' intégration supplémentaires - mais cela ne signifie pas que vous aurez besoin de moins de tests unitaires.

La vraie question derrière la vôtre est peut-être différente. Est-il devenu plus difficile d'écrire des tests unitaires depuis que votre système est devenu de plus en plus gros? Vos tests "unitaires" sont-ils vraiment des tests unitaires, ou ne testent-ils plus les choses isolément? Cela peut être dû au fait qu'ils dépendent de parties inférieures du système qui se sont stabilisées au fil du temps.

Ces choses se produisent parce que les développeurs ont tendance à réutiliser les bibliothèques et le code existants en les référençant directement. Cela a souvent pour effet d'écrire des tests unitaires plus difficiles, car ils doivent souvent fournir un environnement plus complexe et davantage de données de test. Si tel est votre problème, vous devriez en apprendre davantage sur les concepts clés de l' injection de dépendance et du principe de ségrégation d'interface , qui peuvent vous aider à rendre le code plus testable unitaire.

Vous devriez envisager d'examiner le développement piloté par les tests, où les tests sont conçus en premier et décrire comment le nouveau code fonctionnera une fois écrit. Vous faites ensuite passer les tests.

D'après mon expérience, cela a tendance à rendre le code plus léger et mieux pensé, en particulier pour les bibliothèques, et c'est une partie exécutable de la spécification (ce qui signifie que ce sera toujours une documentation correcte).

Cela dit, les tests existants sont utilisés pour s'assurer que le code fonctionne toujours comme prévu. Il peut intercepter la rupture de code et vous permettre de vous assurer que le code tiers fonctionne toujours comme prévu lors de la mise à niveau.

Comme suggéré par Doc Brown et Thorbjørn Ravn Andersen , un environnement de version précoce peut souvent bénéficier encore plus de bons tests unitaires et d'un développement piloté par les tests qu'un environnement avec de longs cycles de version.

Si vous avez un bon système d' intégration continue en place et des tests qui représentent bien la fonctionnalité, vous avez une bonne idée à tout moment de ce qui fonctionne (car les tests pour cette fonctionnalité passent) et ce qui n'a pas encore été implémenté ( car il n'y a pas de test pour cette fonctionnalité).