Pourquoi les gens détestent les tests unitaires et comment ramener l'amour

Nous avons créé le Parasoft Jtest Assistant de test unitaire pour rendre les tests unitaires plus efficaces car nous savons à quel point c'est important mais à quel point cela peut prendre du temps.

Il est bien établi que tests unitaires est une bonne pratique de développement de base. Dans le même temps, ici chez Parasoft, nous entendons de nombreuses histoires de clients concernant la couverture insuffisante des tests unitaires de leur code.

Alors pourquoi l'écart entre les meilleures pratiques et la réalité ?

Examinons certaines des causes de la faible couverture des tests unitaires et comment surmonter ces obstacles grâce à l'automatisation logicielle.

Pourquoi faire des tests unitaires, de toute façon ?

La plupart des équipes de développement conviendront que les tests unitaires sont précieux. Une bonne suite de tests unitaires fournit un filet de sécurité au développement d'applications, permettant aux équipes d'accélérer le développement Agile tout en atténuant le risque que des défauts se glissent dans les étapes ultérieures du pipeline.

J'irais plus loin et dirais que le processus de création d'un test unitaire logiciel est une activité bénéfique en soi, aidant le développeur à regarder son code sous un angle différent, en faisant essentiellement une révision de code supplémentaire.

Lors de l'écriture d'un test unitaire, vous passez en revue l'interface de la fonctionnalité d'un point de vue externe, en profitant des questions posées comme ci-dessous.

• Comment mon code sera-t-il utilisé ? Poser cette question peut conduire à une interface simplifiée et à un moindre coût de maintenance du code.
• Que se passe-t-il si j'obtiens des données invalides ? Cette question peut aboutir à un code plus robuste et réutilisable.

Nos équipes de développement chez Parasoft ont découvert de nombreux problèmes dans le code en cours de développement lors de l'écriture de tests unitaires pour ce code.

Où les intentions de grands tests unitaires échouent

En règle générale, les équipes de développement effectuent un minimum de tests unitaires ou les ignorent complètement. Cela est souvent dû à une combinaison des deux situations suivantes.

1. La pression pour fournir de plus en plus de fonctionnalités.
2. La complexité et la nature fastidieuse de la création de tests unitaires de valeur.

Raisons de l'adoption limitée des tests unitaires

Cela se décompose en certaines raisons courantes citées par les développeurs qui limitent l'adoption des tests unitaires en tant que pratique de développement de base.

• Il y a beaucoup de codage manuel impliqué. Parfois même plus que nécessaire pour mettre en œuvre une fonctionnalité ou une amélioration spécifique.
• Il est difficile de comprendre, d'initialiser et/ou d'isoler les dépendances de l'unité testée.
• La définition d'assertions appropriées prend du temps et nécessite souvent des cycles d'exécution et d'ajustement manuel de tests ou de conjectures intelligentes.
• Ce n'est tout simplement pas si intéressant. Les développeurs ne veulent pas se sentir comme des testeurs, ils veulent passer du temps à fournir plus de fonctionnalités.

Outils d'aide aux tests unitaires

Il existe plusieurs outils actuellement disponibles qui peuvent aider avec les tests unitaires.

• Les frameworks de test unitaire et d'assertion fournissent des formats d'exécution standardisés, tels que JUnit, pour une intégration transparente dans l'infrastructure CI (Jenkins, Azure DevOps, Bamboo, TeamCity).
• Les IDE aident à la création de code de test (IntelliJ, Eclipse).
• Les frameworks moqueurs isolent le code de ses dépendances (Mockito).
• Les outils de couverture de code offrent une certaine visibilité sur le code exécuté (JaCoCo, Emma, ​​Cobertura, Clover).
• Les débogueurs permettent aux développeurs de surveiller et d'inspecter l'exécution étape par étape d'un test individuel.

Points douloureux coûteux des tests unitaires

Bien que ces outils soient utiles, ils ne traitent pas les raisons pour lesquelles les développeurs ne font pas suffisamment de tests unitaires. Les développeurs trouvent encore de nombreux points faibles qui rendent les tests unitaires coûteux, tels que les suivants :

• L'IDE aide à créer un squelette pour le test unitaire, mais pas de contenu. Le développeur doit encore ajouter beaucoup de code pour créer un test en cours d'exécution.

• Les frameworks moqueurs nécessitent une quantité importante de codage manuel pour instancier et configurer, ainsi que la connaissance de la façon de les utiliser correctement.
• Les assertions doivent être définies manuellement et des tests doivent être exécutés pour voir si les valeurs correctes ont été affirmées.
• Les outils de couverture fournissent un aperçu du code couvert par un test exécuté, mais ils ne fournissent aucun aperçu du comportement d'exécution du test.
• Les débogueurs peuvent être utilisés pour un test individuel mais ne s'adaptent pas pour surveiller une exécution de test entière.

En résumé, la création d'un test unitaire nécessite encore beaucoup d'efforts manuels, longs et souvent abrutissants avant même que vous n'ayez commencé à ajouter une logique métier à un test.

La solution? Nous avons créé un assistant !

Pour créer un outil pour vous aider à contourner ces points faibles, nous nous sommes tournés vers l'automatisation des tests logiciels (bien sûr). L'assistant de test unitaire (UTA) de Parasoft Jtest est disponible pour vous aider à créer un test unitaire entièrement fonctionnel en un clic.

Les tests créés avec Parasoft Jtest sont des JUnits "réguliers", mais avec tout le travail banal effectué pour vous. Parasoft Jtest configure le cadre de test, instancie les objets, configure les simulations pour les objets appropriés et les appels de méthode utilisés par la méthode testée, et ajoute des assertions pour les valeurs qui changent dans les objets testés. Ces JUnits peuvent être exécutés dans le cadre de votre flux de travail CI standard de la même manière que vos tests existants.

Parasoft Jtest prend en charge les workflows de création de test suivants :

• Création assistée par outil de tests unitaires pour le code nouvellement développé.
• Génération en masse de tests unitaires pour le code hérité.
• Génération ciblée de tests unitaires pour couvrir des blocs de code spécifiques non couverts.

Création de tests unitaires assistée par outil pour le code nouvellement développé

Les développeurs peuvent choisir de générer plusieurs cas de test avec une initialisation d'objet et des simulations entièrement configurées pour couvrir toutes les branches de leur méthode testée. Alternativement, s'ils veulent plus de contrôle sur le code généré, ils peuvent construire le test petit à petit en utilisant des actions Parasoft Jtest ciblées.

Assistant de test unitaire de Parasoft Jtest se spécialise dans un flux de travail assisté en fournissant des actions qui effectuent les actions suivantes :

• Créez des squelettes de test qui appellent la méthode testée avec tous les objets initialisés.
• Identifiez les appels de méthode qui peuvent être simulés pour mieux isoler le code testé, avec des correctifs rapides pour générer le code simulé.
• Créez des assertions pour les valeurs d'objet qui changent pendant l'exécution du test et qui doivent être affirmées.
• Trouvez les tests qui ne sont pas nettoyés après avoir eux-mêmes créé un environnement de test potentiellement instable (en raison de l'utilisation de threads, de fichiers externes, de champs statiques ou de propriétés système).

Génération de tests unitaires en masse pour le code hérité

De nombreuses équipes conservent encore des bases de code héritées avec beaucoup de code non testé. Cela devient un risque commercial lorsque des modifications doivent être apportées à ce code.

Parasoft Jtest permet à un développeur de générer des suites de tests pour des projets, des packages et des classes entiers afin de créer rapidement un ensemble de tests fournissant couverture élevée du code existant. Les tests peuvent être optimisés pour produire la couverture la plus élevée avec un ensemble minimal de cas de test ou pour produire une couverture légèrement inférieure avec une suite de tests plus stable et plus maintenable.

Génération de tests unitaires ciblés pour couvrir des blocs de code non couverts spécifiques

Souvent, certains tests existent pour une base de code, mais pas assez de tests pour couvrir toutes les conditions. Les flux principaux sont testés, mais les cas extrêmes ou les conditions d'erreur ne sont pas testés.

Parasoft Jtest montre visuellement quels blocs de code sont testés et lesquels ne le sont pas et fournit des actions spécifiques au contexte pour créer un cas de test qui couvre spécifiquement une ligne de code non couverte spécifiée. Cette action crée un cas de test qui initialise tous les objets et simule avec des valeurs spécifiques nécessaires pour forcer le test à exécuter la ligne de code donnée.

Réduire le temps de test unitaire

Nous avons créé l'assistant de test unitaire de Parasoft Jtest pour rendre les tests unitaires plus efficaces car, en tant qu'organisation spécialisée dans l'automatisation intelligente des tests, nous savons que les tests unitaires sont une étape essentielle dans la création de logiciels sûrs, sécurisés, fiables et de haute qualité.

Depuis que nous avons lancé Parasoft Jtest avec l'assistant de test unitaire, les clients nous ont dit que Parasoft Jtest réduisait jusqu'à 50 % le temps qu'il leur fallait pour créer et maintenir des tests unitaires. J'espère que vous l'essayerez et partagerez votre expérience avec Parasoft Jtest pour réduire considérablement le temps nécessaire à la création et à la maintenance de vos tests unitaires.