Le test de mutation, ou mutation de programme, est une technique de test en boîte blanche qui aide les entreprises à développer une série de nouveaux contrôles logiciels tout en vérifiant les processus actuels d’un projet. Il s’agit d’une approche relativement nouvelle, qui garantit que les développeurs et les testeurs travaillent selon des normes élevées.
Le succès ou la qualité d’une application dépend de ses propres procédures d’assurance qualité. Il est donc essentiel que les organisations adoptent plus d’un type de technique de test.
L’apprentissage des tests de mutation pourrait aider les équipes de test à améliorer leurs compétences et leur répertoire général, ce qui leur permettrait d’accroître la fiabilité de ces contrôles. Le test de mutation est un processus complexe et sensible. Il est donc essentiel que les testeurs étudient de manière approfondie les avantages, les défis et les programmes de tiers qui peuvent garantir une mise en œuvre réussie.
Dans cet article, nous examinons les tests de mutation et la manière dont ils améliorent l’assurance qualité, ainsi que d’autres considérations essentielles pour les équipes de test de logiciels.
Qu’est-ce que le test de mutation dans les tests de logiciels ?
Dans le contexte des logiciels, les tests de mutation signifient qu’une équipe d’assurance qualité introduit délibérément des bogues – ou « mutations » – dans le code d’une application pour voir comment l’équipe réagit. L’objectif est de créer une erreur et de s’assurer que la suite de tests est capable d’identifier chaque modification de l’application.
Lorsqu’il modifie le code du programme, le testeur de mutation peut changer une expression vrai/faux, supprimer une instruction ou simplement modifier une valeur. Ces erreurs peuvent se manifester de différentes manières lors d’autres contrôles de logiciels ; elles sont toutes facilement détectables par une équipe de test compétente et expérimentée.
Les mutations elles-mêmes sont souvent très mineures, ce qui permet au testeur qui fait muter le code d’observer comment l’équipe découvre ces changements. Les changements significatifs seraient évidents même à un coup d’œil superficiel – les erreurs mineures sont donc généralement le meilleur moyen de s’assurer que l’entreprise utilise des pratiques de test robustes.
Cette technique examine spécifiquement l’efficacité des cas de test d’une équipe, c’est-à-dire les documents contenant les informations relatives aux tests. L’équipe peut également utiliser un logiciel d’automatisation tiers pour effectuer ces vérifications, auquel cas les tests de mutation examinent la capacité de cette plateforme à détecter les failles dans le code du programme.
1. Quand faut-il procéder à un test de mutation ?
L’objectif des tests de mutation étant de valider et d’améliorer les contrôles d’assurance qualité actuels, il est essentiel que les équipes effectuent ces tests dès le début de la phase d’essai. Cela signifie que si la suite de tests n’est pas en mesure d’identifier et de « tuer » les mutants, il reste suffisamment de temps pour apporter des changements radicaux, quelle que soit leur ampleur, aux procédures de test de l’organisation.
Comme il s’agit d’une méthode très polyvalente, les tests de mutation sont applicables à pratiquement tous les types de logiciels, qu’il s’agisse de programmes web, mobiles ou de bureau. Cette méthode fonctionne le mieux lors de la phase de test unitaire, qui examine les plus petits composants d’une application.
2. Quand il n’est pas nécessaire de procéder à un test de mutation
Il existe encore des scénarios dans lesquels la mutation et les tests généraux en boîte blanche ne sont pas appropriés pour un programme ; cela peut être dû à diverses raisons.
Par exemple, si les testeurs ne cherchent qu’à vérifier la boîte noire – dans ce cas, ils se concentreront plutôt sur l’interface pour cette session ou même sur l’ensemble de la phase de test.
Certaines entreprises considèrent que les tests en boîte blanche sont fastidieux et prennent beaucoup de temps, ce qui peut les amener à ne pas les réaliser. Des cas de test solides et bien vérifiés peuvent également permettre d’éviter les tests de mutation, car ils témoignent de la diligence et de l’engagement de l’équipe à respecter des procédures de test précises.
3. Qui participe à l’analyse des mutations ?
L’analyse des mutations joue un certain nombre de rôles différents, dont les suivants :
– Testeurs de mutations
Ils modifient le code en introduisant divers défauts mineurs afin de s’assurer que le processus de test fonctionne comme prévu. Ces testeurs sont généralement des membres préexistants de l’équipe d’assurance qualité.
– Testeurs d’applications
Ils vérifient régulièrement le code pour détecter d’éventuels problèmes, en identifiant et en corrigeant les mutations qu’ils trouvent. Ils effectuent des tests en boîte blanche pour détecter les erreurs de codage, mais utilisent également d’autres techniques.
– Développeurs d’applications
Ils conçoivent les caractéristiques du programme et écrivent le code initial. Ils corrigent également tous les problèmes détectés par les testeurs, afin de garantir la stabilité du logiciel avant sa mise sur le marché.
– Chefs de projet
Ils donnent des indications sur l’application et peuvent travailler avec les testeurs de mutations pour vérifier l’efficacité de leurs propres équipes. Ils garantissent des normes strictes à tous les stades du développement.
Que recherchons-nous avec les tests de mutation ?
Les tests de mutation se concentrent davantage sur les processus de test que sur l’application. À cette fin, il examine les points suivants :
1. Cas d’essai
Les cas de test sont des documents qui contiennent des informations détaillées sur chaque test, y compris les résultats que les testeurs attendent de chaque vérification. Des scénarios de test cohérents et précis permettent aux membres de l’équipe d’assurance qualité de se faire une idée de l’état de santé de l’application et de la manière dont ses performances répondent aux attentes de l’entreprise.
Les informations contenues dans ces cas de test peuvent déterminer la capacité d’un testeur à repérer certains défauts, y compris ceux induits par les tests de mutation.
2. Normes d’essai
Les tests de mutation examinent de près les procédures de test actuelles afin de s’assurer que les membres de l’équipe peuvent identifier les problèmes, même mineurs, susceptibles d’affecter la perception du logiciel par l’utilisateur.
La diligence et la compétence des testeurs pourraient même être les principaux facteurs évalués par une entreprise dans le cadre de ces contrôles. Sans une attention particulière aux détails à chaque étape, les testeurs pourraient passer à côté de graves mutations présentes dans le programme.
3. Unités individuelles de code
Les tests de mutation sont fréquents lors de la phase de test unitaire du développement. Il s’agit d’examiner les composants individuels afin de se concentrer sur chaque test, ce qui permet d’optimiser considérablement l’ensemble du processus en veillant à ce que les testeurs ne travaillent qu’avec les lignes de code pertinentes.
Comme les tests de mutation se situent souvent au début de la phase d’assurance qualité et qu’ils pourraient être le précurseur de tests à grande échelle, cette approche permet d’augmenter la vitesse sans compromettre la précision.
4. Mises à jour du programme
Les mises à jour de logiciels impliquent généralement de relancer le processus de test pour s’assurer qu’il n’y a pas de nouvelles erreurs et que les erreurs précédentes ne réapparaissent pas.
La répétition des tests de mutation est un élément clé de cette démarche et contribue à promouvoir des normes de test cohérentes après les changements majeurs apportés aux logiciels.
L’équipe chargée des tests peut considérer que des vérifications approfondies après mise à jour ne sont pas nécessaires, mais la mutation du code peut faire en sorte qu’elle comprenne l’importance des tests à chaque étape du développement.
5. Logiciel d’automatisation
Les entreprises effectuent également des tests de mutation afin d’inspecter leurs suites de tests automatisées et de s’assurer qu’elles sont en mesure de détecter les codes mutés, entre autres problèmes.
Si une application de test tierce est capable d’identifier les changements externes apportés à un programme et éventuellement de les corriger, cela signifie que l’organisation peut faire confiance au logiciel pour automatiser les tests.
Il est essentiel que les entreprises valident leur approche de l’automatisation, ce qui permet à chaque testeur d’avoir l’esprit tranquille.
6. Stratégie d’automatisation
La manière dont l’entreprise intègre l’automatisation dans ses processus est tout aussi importante que le logiciel qu’elle utilise ; par exemple, elle peut décider de mettre en œuvre l’ hyperautomatisation. Cela permet à l’entreprise de décider intelligemment des mutations et des tests logiciels à automatiser.
Sans une stratégie d’automatisation solide qui tienne compte de la diversité du code d’une application, certains tests peuvent être incompatibles avec l’automatisation, ce qui limite les capacités de la plateforme.
7. L’application
Bien que le test de mutation se concentre davantage sur l’équipe de test que sur l’application, il peut néanmoins mettre en évidence des informations importantes sur ce programme.
Par exemple, les tests de mutation montrent comment le logiciel réagit aux modifications de son code, et notamment s’il signale ces problèmes de la manière attendue par l’équipe.
Cette approche n’est pas une technique d’essai de logiciel, mais elle permet néanmoins d’obtenir des données intéressantes sur le fonctionnement interne de l’entreprise.
Cycle de vie des tests de mutation
Le cycle de vie habituel des tests de mutation est le suivant :
1. Analyse des besoins
La première étape du cycle de vie des tests de mutation consiste à déterminer exactement ce qui doit être validé et quels éléments du code de l’application bénéficieraient le plus de ces tests.
L’équipe peut s’entretenir avec les développeurs et les cadres pour déterminer leurs préoccupations et commencer à y répondre.
2. Planification des tests
Les testeurs commencent alors à développer les contrôles exacts qu’ils ont l’intention de mettre en œuvre – dans ce cas, les mutations qui offriront le meilleur aperçu.
Cette étape détermine la stratégie globale de test des mutations et la manière dont l’équipe va mettre en œuvre efficacement les mutations de code prévues.
3. Développement de cas de test
Les tests de mutation impliquent une documentation de test distincte, comprenant des informations sur le code muté et sur la manière dont les testeurs doivent résoudre le problème.
Une bonne tenue des registres permet de s’assurer que les tests se déroulent comme prévu et peut aider l’équipe à maintenir son engagement à respecter des normes de test élevées.
4. Configuration de l’environnement de test
Les testeurs s’assurent que l’application est prête à être modifiée et qu’ils disposent d’une procédure pour résoudre ces problèmes si les autres membres de l’équipe ne sont pas en mesure de les détecter.
Dans ce cadre, les testeurs de mutations établissent un serveur de test et l’utilisent comme canevas pour leurs mutations.
5. Exécution des tests
Après avoir terminé leurs préparatifs, les testeurs modifient le code de plusieurs composants de l’application ; ils attendent ensuite que d’autres testeurs remarquent et corrigent les problèmes.
Les testeurs de mutations et les testeurs d’applications doivent documenter ce processus de manière exhaustive afin de s’assurer que leurs enregistrements sont robustes.
6. Clôture du cycle d’essai
Une fois les tests terminés, les testeurs de mutations vérifient à nouveau que toutes les modifications qu’ils ont apportées ont été corrigées par les testeurs d’applications ou par eux-mêmes.
Ils clôturent ensuite le cycle de test et analysent les résultats, en discutant de la manière dont les testeurs ont réagi aux différentes erreurs et de leur capacité à les corriger.
7. Répétition des tests
Après avoir clôturé le cycle de test, il pourrait être nécessaire de le réactiver après de futures mises à jour du logiciel.
Chaque changement apporté à une application modifie sa fonctionnalité d’une manière ou d’une autre, ce qui entraîne de nouvelles possibilités dont l’équipe doit tenir compte afin de s’assurer que son processus de test est suffisamment méticuleux.
Avantages des tests de mutation
La réalisation de tests de mutation présente de nombreux avantages, notamment
1. Valide le processus de test
Le principal avantage des tests de mutation réside dans leur capacité à montrer comment les testeurs de l’entreprise abordent les logiciels – et leur aptitude à reconnaître les problèmes de codage. Cela permet également de s’assurer que les cas de test de l’équipe sont suffisamment complets et couvrent tous les tests nécessaires.
Les tests de mutation examinent l’ensemble de la procédure de test d’une organisation afin de garantir qu’elle fonctionne comme prévu.
2. Assurer une forte automatisation
Les tests de mutation permettent à une équipe de vérifier si sa plateforme d’automatisation des tests est en mesure d’identifier correctement les erreurs dans le code et de les traiter de la bonne manière.
Si ce logiciel ne parvient pas à les détecter, même après l’étalonnage nécessaire, il peut être utile de remplacer la plate-forme par une autre qui passe facilement ces tests.
3. Bonne couverture
Chaque processus de test de logiciel doit pouvoir couvrir l’ensemble de l’application afin de garantir que chaque aspect reçoive le niveau d’attention nécessaire.
Les testeurs de mutation peuvent modifier n’importe quelle partie du code d’un programme ; une bonne mise en œuvre permet à ces tests d’englober toutes les fonctionnalités majeures. Les testeurs apprennent ainsi à rechercher les problèmes dans l’ensemble de l’application.
4. Examine le code source
Comme les tests de mutation impliquent de travailler avec le code et d’apporter des modifications directes le cas échéant, cette méthode pourrait également mettre l’accent sur les scripts non optimisés présents dans l’application.
Les testeurs de logiciels ne peuvent autoriser le programme et effectuer leur série normale de tests que si le code du logiciel est adéquat ; ces vérifications permettent aux testeurs de mettre en évidence d’éventuels problèmes futurs.
5. Permet d’améliorer les logiciels
Les tests de mutation permettent de s’assurer que les processus de test de l’application sont adaptés aux exigences du programme.
Si une analyse de mutation révèle que l’équipe d’assurance qualité ne suit pas les bonnes procédures ou que les cas de test sont inadéquats, les testeurs peuvent s’efforcer d’améliorer la situation. Sans cette diligence raisonnable, l’organisation peut diffuser un produit défectueux sans s’en rendre compte.
6. Efficace pour différentes langues
Quel que soit le langage utilisé par une équipe de test pour son application, il existe des options logicielles qui peuvent offrir une analyse de mutation de haute qualité.
Cela inclut un certain nombre de caractéristiques de qualité de vie spécifiques à la langue, rationalisant les contrôles pour une plus grande fiabilité. Une approche personnalisée pour différentes langues améliore la qualité de chaque test individuel.
7. Des outils très accessibles
Un grand nombre des principales plateformes de mutation sont entièrement libres, ce qui signifie qu’elles offrent une plus grande personnalisation et une gamme complète de fonctionnalités gratuitement ou à des prix nettement inférieurs.
Avec moins d’obstacles que de nombreuses autres formes de test, la mutation de code est un moyen utile et pratique pour les entreprises d’évaluer, voire d’améliorer, leur approche de l’assurance qualité.
Les défis des tests de mutation
Ce processus s’accompagne également de nombreux défis, tels que :
1. Nécessite des connaissances en programmation
Pour que les testeurs puissent effectuer ces vérifications, ils doivent avoir une connaissance approfondie du programme et du code, ce qui complique la tâche des testeurs moins expérimentés.
Une entreprise ne peut tester un logiciel qu’en fonction des compétences existantes des testeurs, c’est-à-dire de leur capacité à modifier une application et à créer une erreur de codage corrigeable.
2. Ne convient pas aux tests boîte noire
Les tests « boîte noire » consistent principalement à examiner la partie frontale d’une application sans en inspecter le fonctionnement interne et le code – ce qui est effectivement incompatible avec les tests de mutation.
Par conséquent, ces contrôles ne sont utiles que pour certains tests par rapport à d’autres méthodes, dont beaucoup peuvent offrir une couverture bien plus large de l’ensemble de la phase de test.
3. La conception de tests de mutation prend beaucoup de temps
La mutation du code peut être un processus fastidieux car l’équipe doit trouver les composants individuels qui méritent d’être mutés. Le choix des mutations à effectuer peut lui-même prendre beaucoup de temps, ce qui peut s’avérer problématique lorsque d’autres types de tests attendent effectivement ces contrôles pour valider pleinement l’approche de l’entreprise en matière de tests.
4. Peut nécessiter de nombreuses mutations du code
Dans le même ordre d’idées, les projets complexes justifient naturellement un plus grand nombre de mutants afin de garantir une approche de test complète. Cela ajoute du temps à l’étape de mutation et peut impliquer de nombreuses modifications manuelles du code de l’application.
Sans un logiciel d’automatisation des tests de haute qualité avec des capacités de mutation de programme, il pourrait être difficile pour les testeurs de mettre cela en œuvre avec succès.
5. Les testeurs peuvent ne pas remarquer les erreurs
La principale préoccupation des testeurs de mutations et des chefs de projet lors de la mise en œuvre de ces contrôles est la possibilité que les testeurs de logiciels (manuels ou automatisés) ne remarquent tout simplement pas les problèmes.
Cela peut nécessiter une révision complète des procédures de test de l’entreprise, même si cela peut fournir aux testeurs des informations vitales sur les normes d’assurance qualité de l’entreprise.
6. Peut être gourmand en mémoire
Les tests de mutation nécessitent généralement une puissance de traitement élevée, mais cela peut dépendre de l’application utilisée par les testeurs.
Si l’organisation dispose d’un nombre limité de machines ou si ces appareils ont de faibles spécifications, ils pourraient avoir du mal à exécuter un trop grand nombre de mutations simultanées. Cela influe sur le nombre de contrôles qu’ils peuvent effectuer avant la fin de la phase de test.
7. Les rapports peuvent être denses en informations
Bien que cela dépende principalement de l’interface de l’outil de test de mutation d’une équipe, les rapports qu’ils génèrent peuvent être difficiles à analyser.
Cela signifie qu’il faut du temps pour les trier manuellement et trouver les bons résultats ; certains programmes permettent aux utilisateurs de personnaliser le processus d’établissement des rapports ; cela varie d’une application à l’autre.
Caractéristiques des tests de mutation
Les principales caractéristiques des tests de mutation efficaces sont les suivantes
1. L’exhaustivité de l’information
Ces contrôles couvrent tous les aspects importants du logiciel ; les entreprises disposant de ressources suffisantes peuvent même concevoir un test de mutation pour chaque cas de test normal.
Bien que le nombre exact dépende des capacités et des préférences de l’organisation, les tests de mutation efficaces couvrent un large éventail de caractéristiques codées.
2. Stratégique
Les mutations du programme doivent également suivre une structure claire et bien planifiée qui facilite les objectifs globaux de l’organisation en matière de tests.
Par exemple, les erreurs qu’ils produisent peuvent correspondre à des échecs de test réalistes, ce qui permet aux testeurs d’anticiper ces problèmes s’ils se produisent naturellement, améliorant ainsi de manière significative le processus de test de l’entreprise.
3. Constructif
L’objectif des tests de mutation est d’identifier les lacunes des tests, en montrant comment l’équipe pourrait améliorer ses vérifications et corriger les erreurs mineures au fur et à mesure qu’elles apparaissent.
Les testeurs de mutations doivent donner la priorité aux mutants « non valides » qui affectent la fonctionnalité du logiciel, ce qui permet d’améliorer plus clairement les tests dans l’ensemble du projet.
4. Préemptif
Ces contrôles servent à valider la stratégie globale de l’équipe, ce qui signifie que les tests de mutation sont plus efficaces aux premiers stades du développement.
Si les testeurs remarquent des failles importantes dans leur approche de l’assurance qualité, cela leur donne le temps nécessaire pour modifier leurs scénarios de test afin de s’assurer qu’ils sont adéquats.
5. Cohérent
Les tests de mutation effectués sur différentes itérations d’une application devraient donner des résultats cohérents, tout en ajoutant des vérifications supplémentaires pour tenir compte des modifications apportées au logiciel.
Les contrôles ultérieurs doivent faire l’objet de la même attention pour conserver leur efficacité – sans cette précision, les tests de mutation risquent de perdre de leur précision.
6. Subtil
Les tests de mutation visent à examiner la capacité de l’équipe d’assurance qualité à identifier les défauts du code par le biais de ses tests et de plates-formes tierces.
Cela signifie que les tests ne doivent pas être immédiatement évidents pour toute personne inspectant le logiciel ; l’objectif est d’examiner comment les testeurs réagissent à des problèmes de code mineurs.
7. La collaboration
Comme tout test de logiciel, la mutation de code est un processus qui nécessite généralement un travail d’équipe et de la communication pour garantir son succès. Le maintien d’une atmosphère de collaboration permet d’éviter les silos d’information, qui peuvent entraîner une mauvaise communication – cela garantit également que chaque testeur reste concentré sur les tâches à accomplir.
Types de tests de mutation
Les trois principaux types de tests de mutation sont les suivants
1. Mutation de valeur
Les mutations de valeur modifient directement les valeurs dans le code, en remplaçant un chiffre ou une lettre par un autre de manière à affecter la fonctionnalité de l’application.
Par exemple, le testeur pourrait modifier les paramètres exacts du programme, tels que les nombres auxquels il répond. Les testeurs de mutation peuvent cibler spécifiquement les valeurs constantes d’un logiciel, car elles restent toujours les mêmes pendant les opérations normales.
2. Mutation de décision
Les mutations décisionnelles modifient les opérateurs arithmétiques et logiques, changeant ainsi la façon dont l’application réagit à des situations spécifiques.
Par exemple, le remplacement d’un opérateur plus grand que (>) par un opérateur moins grand que (<) affecte naturellement la sortie du programme. Les testeurs peuvent également remplacer « ou » par « et » ou vice versa, ce qui modifie fondamentalement ce logiciel et la manière dont il interprète les informations fournies par d’autres testeurs et utilisateurs potentiels.
3. Mutation de déclaration
Les mutations d’énoncés modifient les énoncés réels du code, modifiant les règles qu’une application utilise pour prendre ses décisions. Les testeurs peuvent modifier le contenu de ces lignes, les dupliquer ou même les supprimer pour vérifier l’impact du programme mutant sur la fonctionnalité du logiciel.
Ces mutations modifient les éléments constitutifs d’un programme, en supprimant éventuellement des fonctions entières ou en les empêchant de fonctionner.
Dissiper la confusion
– Tests de mutation et tests de régression
Les tests de mutation et de régression sont tous deux des approches utiles pour tester les logiciels. La compréhension de chacune de ces techniques peut améliorer l’assurance qualité globale d’une entreprise.
1. Qu’est-ce que le test de régression ?
Le test de régression consiste pour les testeurs à examiner le logiciel entre les différentes itérations afin de s’assurer qu’il fonctionne toujours malgré les modifications apportées au code.
En l’absence de ces vérifications, des modifications même mineures peuvent entraîner des problèmes graves, voire la réapparition de bogues antérieurs. Cela nécessite généralement l’automatisation en raison de la nature complexe des nouveaux tests de chaque composant ; de nombreuses entreprises renoncent aux tests de régression pour cette raison.
Les testeurs peuvent effectuer ces contrôles sur des unités individuelles, des composants particuliers ou l’ensemble du produit – les tests exacts requis dépendent principalement du projet et de son ampleur.
2. Quelle est la différence entre les tests de mutation et de régression ?
Les tests de régression se concentrent principalement sur la vérification du programme et de sa fonctionnalité, tandis que la mutation du code s’intéresse plutôt à la manière dont les testeurs réagissent aux problèmes.
Le premier type de contrôle a lieu en grande partie après plusieurs itérations d’un programme, tandis que les contrôles de mutation peuvent avoir lieu à n’importe quel stade du développement, mais généralement dans les premières parties de la phase de test.
Les tests de régression et de mutation peuvent tous deux porter sur des unités de codage individuelles et sur la manière dont des modifications mineures peuvent entraîner des problèmes importants que les testeurs doivent s’efforcer de rectifier.
3. Conclusion : Tests de mutation et tests automatisés
L’automatisation est souvent un élément clé des tests de mutation en raison de l’ampleur des contrôles et des unités, ce qui la rend parfois vitale pour un processus de test réussi et complet.
Les entreprises utilisent généralement les mutations de code pour examiner leur plateforme d’automatisation tierce et la manière dont elle identifie les scripts problématiques.
La combinaison d’un catalogue complet de vérifications de mutations et d’un logiciel automatisé peut augmenter considérablement la couverture de l’entreprise et garantir des résultats plus solides.
Bien qu’il s’agisse de deux pratiques de test distinctes, elles ne doivent pas s’opposer l’une à l’autre. L’intégration de l’automatisation des processus robotiques, par exemple, peut renforcer la stratégie de test de mutation d’une entreprise.
De quoi avez-vous besoin pour commencer le test de mutation dans l’ingénierie logicielle ?
Les exigences habituelles pour un test de mutation complet sont les suivantes
1. Une stratégie d’essai claire
L’équipe chargée des tests doit établir une stratégie pour les tests de mutation, notamment en ce qui concerne les composants et les unités qu’il est le plus important d’examiner.
Par exemple, certains aspects du code peuvent être plus importants pour le succès et la fonctionnalité d’une application ; les testeurs doivent s’assurer qu’il y a suffisamment de mutations pour en tenir compte.
Le calendrier des tests de mutation de l’entreprise est également un élément essentiel, car il garantit que les testeurs disposent de suffisamment de temps pour étudier le code.
2. Pas de dérive du champ d’application
Même avec une stratégie complète définissant l’approche de l’entreprise en matière de tests de mutation, il est possible que le nombre de tests soit beaucoup plus élevé que nécessaire.
L’efficacité est primordiale tout au long de cette procédure, d’autant plus que d’autres étapes de test peuvent attendre que l’équipe trouve et élimine les mutations. Les testeurs doivent clairement définir leur champ d’application avant de commencer à modifier le code ; cela permet de s’assurer que tout est gérable dans un délai pratique.
3. Une documentation rigoureuse
Chaque processus de test bénéficie d’une documentation complète – souvent sous la forme de cas de test qui détaillent les vérifications individuelles et toutes les mutations pertinentes.
Cela illustre les progrès actuels de l’équipe à travers les tests, ce qui est particulièrement utile pour les managers et les dirigeants. Le fait de documenter chaque mutation du code permet également aux testeurs de conserver des informations claires sur les changements qu’ils effectuent.
Si l’équipe chargée de l’assurance qualité a du mal à trouver ces mutations lors des tests, ces documents servent effectivement de clé de réponse.
4. Testeurs qualifiés
Les testeurs qui modifient le code doivent avoir une connaissance approfondie du logiciel, y compris des nombreuses façons dont ils peuvent le modifier, voire le casser.
Les testeurs de mutations savent à peu près comment leurs changements affecteront l’application et comment les autres membres de l’équipe d’assurance qualité pourraient identifier le code mutant.
Cela nécessite généralement un bon niveau de connaissances en programmation. Pour que l’analyse des mutations soit efficace, les testeurs du logiciel doivent également avoir des compétences bien développées et de l’expérience en matière de tests.
5. Logiciel d’automatisation
Un logiciel d’automatisation tiers peut s’avérer nécessaire avant les tests de mutation en raison du nombre de vérifications que ce processus requiert souvent. C’est particulièrement vrai pour les applications complexes qui comportent davantage de code et de fonctions à examiner par l’équipe chargée de l’assurance qualité.
Les entreprises peuvent mettre en place ces contrôles spécifiquement pour tester la façon dont les logiciels d’automatisation réagissent aux erreurs de codage. Il peut s’agir d’un élément essentiel du processus d’évaluation de l’entreprise pour déterminer quels sont les programmes les plus utiles.
Processus de test de mutation
Les étapes habituelles suivies par les testeurs lors d’une analyse de mutation sont les suivantes :
1. Préparer les tests
La préparation est la première étape de tout processus de test. Il s’agit notamment de négocier les contrôles exacts à mettre en œuvre et d’obtenir les approbations nécessaires, notamment de la part des dirigeants de l’entreprise et des parties prenantes.
Les testeurs doivent développer ces contrôles de manière à respecter le calendrier du projet tout en couvrant chaque composant majeur. La planification de l’équipe peut déterminer l’efficacité des mutations du code.
2. Présenter les mutants et les défauts
Une fois les préparatifs terminés, l’équipe chargée des tests commence à modifier le code, en le faisant muter conformément à son plan afin d’introduire des failles spécifiques. Ces erreurs doivent être relativement mineures, car elles permettent aux testeurs d’évaluer la capacité du reste de l’équipe à identifier les problèmes de codage.
Les défauts mineurs peuvent également aider l’organisation à vérifier la sensibilité de son logiciel d’automatisation tiers.
3. Appliquer les cas de test
Les cas de test doivent tenir compte de tous les points de défaillance possibles dans une application – ce qui peut nécessiter une réécriture si le programme mutant est capable de fonctionner sans aucune erreur.
Les cas de test d’un programme représentent l’ensemble des vérifications effectuées par les testeurs ; chacun d’entre eux doit aider les testeurs à découvrir les mutations cachées et faire partie intégrante de la facilité d’utilisation de l’application.
4. Comparer les résultats
Après avoir ajouté des erreurs de mutation au programme et appliqué les cas de test de l’équipe, celle-ci doit comparer les résultats du programme original et du programme mutant.
L’espoir est que pour chaque vérification réussie dans l’original, il y aura également une erreur dans l’application mutante. Cela démontre les capacités des testeurs et des outils qu’ils utilisent.
5. Agir sur les différents résultats
Si les résultats du programme original et du programme mutant sont différents de ceux attendus par les testeurs, cela signifie que le scénario de test peut tuer avec succès le mutant en démontrant sa présence.
Les testeurs peuvent alors procéder en ayant confiance dans leur méthodologie et leur capacité à identifier les problèmes de codage. Aucune modification des cas de test n’est nécessaire pour ces tests particuliers.
6. Changer les boîtiers si nécessaire
Certaines mutations du code peuvent aboutir à des conclusions identiques dans les différents programmes, ce qui suggère que les cas de test ne sont pas en mesure de mettre en évidence toutes les erreurs possibles dans l’application.
Dans ce cas, le mutant reste « vivant » et peut continuer à affecter le logiciel d’une manière que les testeurs n’ont pas la possibilité d’aborder, ce qui conduit à la création de meilleurs cas de test.
Comment créer des programmes mutants
Les programmes mutants sont en fait identiques aux programmes originaux, à l’exception d’une modification mineure qui peut avoir un impact sur la fonctionnalité d’une application de façon minime mais perceptible.
Des cas de test complets et détaillés aident un testeur ou une suite logicielle à repérer ces changements et les défauts qui en résultent. Chaque cas vérifié par l’entreprise nécessite un programme original et un programme modifié, montrant les effets de chaque changement de manière isolée.
Les programmes reproduisent généralement des erreurs réalistes, telles que des fautes de frappe. Il est également important que les testeurs évitent les mutants « mort-nés » qui empêchent l’exécution de l’application – c’est trop évident pour les testeurs.
Que faut-il changer dans un programme mutant ?
Comme pour de nombreuses variables de test de logiciels, les modifications exactes apportées par les testeurs dépendent de l’application et de son code.
Trois catégories englobent la majorité des tests de mutation : les opérandes, les expressions et les instructions. La modification de l’un de ces éléments peut créer un programme mutant efficace – montrant comment les différentes valeurs ou règles affectent la logique même utilisée par un programme.
Ces catégories correspondent aux trois principaux types de mutations étudiées par les testeurs, à savoir les mutations de décision, les mutations de valeur et les mutations d’énoncé. Les modifications doivent être mineures et ne doivent pas empêcher totalement l’exécution d’un test.
Meilleures pratiques pour les tests de mutation
Lors de la réalisation de tests de mutation dans le cadre de tests de logiciels, certaines pratiques méritent d’être suivies afin de garantir des résultats probants :
1. Maximiser le score de mutation
Le score de mutation d’un programme est le pourcentage de mutants qu’une équipe ou une application peut identifier ou « tuer » avec succès.
Par exemple, si une série de tests de mutation comporte 40 mutants et que les testeurs en trouvent 36, le score de mutation est de 90 % – l’objectif de l’équipe est toujours d’obtenir un score de 100 %.
2. Choisir les mutants au hasard
Bien que cela puisse aider à donner la priorité à certains composants et à les tester de manière plus approfondie, il est également utile pour les testeurs de choisir au hasard les mutants à ajouter, en particulier dans un délai serré.
Tant que ces contrôles représentent tous les types de mutation importants, l’équipe chargée de l’assurance qualité peut valider sa stratégie globale de test des logiciels.
3. Limiter les changements
Les mutations du code doivent représenter des écarts mineurs par rapport au programme original, car cela illustre la probabilité qu’un testeur identifie certaines erreurs ; les problèmes de codage mineurs démontrent également la sensibilité de leur logiciel.
Il est essentiel que les testeurs de mutations trouvent un équilibre qui permette à ces changements mineurs de produire des défauts perceptibles.
4. Une mutation par programme
Les tests de mutation examinent les cas de test individuels de manière isolée afin d’en vérifier l’exhaustivité. Pour ce faire, chaque programme muté ne doit comporter qu’une seule modification par rapport à l’original.
Les programmes comportant plusieurs mutations peuvent ne pas être en mesure de s’associer efficacement à des cas de test ; les mutations peuvent entrer en conflit les unes avec les autres.
5. Examiner attentivement les logiciels d’automatisation
Les entreprises ont souvent recours à la mutation de code pour valider l’utilisation par l’équipe d’un logiciel d’automatisation et s’assurer qu’il est capable d’identifier les erreurs aussi efficacement qu’un testeur humain.
Cela signifie que le choix de la bonne plateforme d’automatisation peut être un élément important, tout comme la possibilité d’intégrer l’automatisation des processus robotiques.
6. Utiliser le développement piloté par les tests
Le développement piloté par les tests (TDD) est une technique spécifique qui prend en compte les exigences en matière de tests à chaque étape du développement.
Cela permet de s’assurer que les cas de test sont entièrement compatibles avec le logiciel – ce qui lui permet de passer facilement les tests de mutation et de créer un meilleur programme qui se synchronise avec les processus d’assurance de la qualité.
Types de résultats d’un test de mutation
Les tests de mutation génèrent plusieurs résultats, notamment
1. Programme mutant
Les programmes mutants sont le résultat naturel de ces vérifications ; les testeurs les créent pour refléter leurs cas de test actuels et les problèmes qu’ils contribuent à détecter. Les programmes ne s’écartent généralement de leur équivalent original que sur un point mineur mais significatif, afin de garantir une plus grande fiabilité.
2. Mutant vivant ou mort
Après les tests, une mutation est soit « tuée », soit « vivante » – cela signifie simplement que le testeur (ou son logiciel) a réussi ou non à identifier un problème de codage.
Si le mutant reste en vie, les cas de test pourraient nécessiter de sérieuses modifications.
3. Cas de test de mutation
L’équipe chargée de l’assurance qualité utilise des cas de test distincts, spécifiques aux mutations, qui enregistrent des informations sur leurs programmes mutants.
Cela permet à l’équipe de disposer de dossiers complets pour chaque contrôle ; ces documents contiennent des détails sur les mutations et leurs effets sur le programme.
4. Score de mutation
L’objectif final de tout test de mutation est d’atteindre un score de mutation de 100 %, les procédures de test de l’entreprise permettant de localiser et de tuer tous les mutants. Si ce n’est pas le cas, cela signifie que les cas de test et les processus généraux doivent être améliorés afin d’identifier les codes problématiques.
Exemples de tests de mutation
Voici trois exemples de tests de mutation :
1. Exemple de mutation de valeur
Les mutations de valeur impliquent la modification d’une constante ou d’un paramètre qui peut potentiellement modifier les limites du programme. Par exemple, le logiciel d’une caisse automatique peut utiliser le poids d’un produit alimentaire pour en déterminer le prix.
Les testeurs pourraient modifier le code de ce programme pour changer les paramètres de poids, ce qui rendrait les aliments beaucoup plus chers par once ou par livre. Le testeur ou la plate-forme de test doit être en mesure d’identifier les effets des différentes valeurs sur le programme.
Comme cette erreur modifie l’une des principales fonctionnalités du logiciel, les scénarios de test doivent la détecter et alerter l’équipe.
2. Exemple de mutation décisionnelle
Les mutations de décision impliquent la modification d’un opérateur arithmétique ou logique, l’inversion ou toute autre modification de la manière dont cette application réagit à l’entrée de l’utilisateur. Pour reprendre l’exemple d’une caisse automatique, ces machines peuvent signaler un article dont le poids est anormalement élevé, éventuellement en raison d’une erreur de l’utilisateur.
Le code de la machine pourrait le faire par le biais d’une décision du type « si (a>b) » – « b » reflétant le poids attendu et « a » correspondant au poids réel. L’équipe peut transformer cela en « if (a≤b) », ce qui modifie la façon dont la caisse réagit ; elle signale l’article même s’il a le poids escompté.
3. Exemple de mutation de déclaration
Les mutations de déclarations impliquent la modification d’une règle ou d’une sortie, ce qui peut aller jusqu’à la suppression pure et simple de déclarations dans l’application. Ces mutations peuvent être plus perceptibles que d’autres, en fonction de la fréquence de la déclaration en question ; il est essentiel que les testeurs choisissent judicieusement la déclaration.
Par exemple, un distributeur automatique de billets peut afficher un avertissement si un utilisateur tente d’acheter un article dont l’âge est limité. Sans la déclaration correspondante, la machine peut se bloquer ou permettre à n’importe quel client d’acheter n’importe quel article.
En modifiant la déclaration et en la signalant à l’équipe, les testeurs peuvent vérifier que leur approche tient compte de ces problèmes.
Types d’erreurs et de bogues détectés par le test de mutation
Les tests de mutation révèlent principalement des problèmes dans le processus de test lui-même. Dans cette optique, voici une série de problèmes que ces contrôles peuvent aider à identifier :
1. Cas de test peu clairs
Si l’analyse de mutation révèle un faible score de mutation (ou même un score inférieur à 100 %), cela signifie que les scénarios de test de l’équipe ne sont pas en mesure de prendre en compte toutes les failles possibles susceptibles d’affecter une application.
Elles peuvent ne pas être suffisamment spécifiques ou larges pour répondre aux besoins de l’équipe. Ces documents doivent couvrir toutes les possibilités que l’équipe peut rencontrer en testant le logiciel pour en garantir la fiabilité.
2. Équipe de test non formée
Les tests de mutation peuvent également illustrer les capacités de l’équipe, notamment sa capacité à identifier personnellement les mutations et autres défauts. S’ils ne parviennent pas à localiser les mutants dans l’ensemble des programmes malgré des cas de test clairs et détaillés, c’est peut-être parce que les testeurs n’ont pas appliqué ces cas correctement.
Les programmes mutants peuvent présenter des problèmes tout au long du processus de test – cela peut également concerner des testeurs non qualifiés ou non formés.
3. Logiciel de test inadéquat
Si une entreprise utilise ces contrôles pour inspecter sa propre plateforme de test, elle pourrait découvrir que le logiciel ne peut pas identifier ou tuer avec précision le code mutant.
L’entreprise peut réagir en examinant d’autres choix jusqu’à ce qu’elle en trouve un qui soit compatible avec ses cas types. Si le logiciel d’automatisation ne parvient pas à trouver le code problématique, il aura probablement du mal à identifier les autres problèmes qui affectent le logiciel.
4. Code non optimisé
Les tests de mutation peuvent révéler des problèmes déjà présents dans le logiciel. Par exemple, les testeurs peuvent essayer de modifier le code mais découvrir eux-mêmes des défauts critiques.
Il s’agit là d’une autre perspective importante du programme, qui montre que la mutation du code offre des avantages au-delà du processus de test. Plus les testeurs examinent ce code, de quelque manière que ce soit, plus l’équipe peut découvrir et résoudre de problèmes au cours de la phase de test.
Mesures du test de mutation commune
Les principaux paramètres utilisés par les tests de mutation sont les suivants :
1. Mutants tués
Il s’agit du nombre de mutants que les testeurs ou le logiciel ont pu identifier, en signalant leur existence afin que le personnel puisse détecter des défauts mineurs tels que ceux-ci.
Le nombre de mutants tués par les testeurs dépend de la force de leurs cas de test.
2. Mutants vivants
Les mutants vivants sont ceux que le testeur ou le logiciel ne parvient pas à identifier, ce qui montre les lacunes éventuelles de la stratégie d’assurance qualité de l’équipe. Dans ce cas, les testeurs doivent recalibrer leur processus et leurs scénarios de test pour tenir compte de ces mutants et les éliminer lors des prochaines vérifications.
3. Mutants valides
Cette mesure détermine le nombre de mutations que le programme a pu inclure avec succès sans qu’une erreur d’exécution ne vienne annuler le test et son efficacité.
Les mutants valides sont ceux que le testeur et le logiciel d’automatisation peuvent examiner, car les mutations sont relativement mineures.
4. Mutants non valides
Des mutations importantes peuvent affecter l’application au point de rendre les tests peu pratiques, voire impossibles. Il est donc utile de savoir combien de mutants « non valides » sont présents dans le programme muté.
L’identification de ces mutations permet aux testeurs de les modifier, voire de les supprimer, afin de s’assurer que les contrôles ne portent que sur des mutations valides.
5. Total des mutants
Le nombre de mutations, indépendamment de leur validité, est une autre mesure que les testeurs suivent ; cela leur permet de surveiller les mutants et d’enregistrer leur état.
Comme chaque mutation fait généralement l’objet d’un test distinct, le total sert également à comptabiliser le nombre de mutations globales du code.
6. Score de mutation
La mesure la plus utile pour l’analyse des mutations est généralement le score de mutation, qui est en fait le pourcentage de mutants valides que le testeur ou la suite d’automatisation a pu détecter.
Toute détection inférieure à 100 % peut être le signe d’une procédure d’essai incorrecte.
7 erreurs et pièges dans l’implémentation des tests mutants
Le test de mutation est un processus complexe que les entreprises doivent mettre en œuvre de manière judicieuse afin d’éviter des problèmes ou des erreurs graves. Voici sept pièges que les testeurs doivent s’efforcer d’éviter lorsqu’ils effectuent des tests de mutation :
1. Mauvaise mise à l’échelle de la mutation
L’échelle est un élément important à prendre en compte lors de l’analyse des mutations, car ce processus a pour but de s’assurer que les testeurs identifient les défauts mineurs d’une application. Si la mutation est trop évidente pour les testeurs, cela peut ne pas être un moyen efficace de vérifier leur capacité à remarquer ou à contrer les problèmes logiciels.
2. Mutations invalides ou vivantes
Même à l’échelle appropriée, de nombreuses mutations n’offrent qu’une efficacité limitée – par exemple, si elles ne conduisent pas à une défaillance ou si elles entraînent un problème qui empêche l’application de fonctionner.
Les testeurs doivent être attentifs à la manière dont toute modification du codage peut affecter l’ensemble du logiciel.
3. Cas de test incompatibles
Les cas de test et les mutations doivent s’associer parfaitement pour garantir des tests cohérents et harmonieux. Lorsqu’elle décide des mutations à ajouter ou même lorsqu’elle conçoit les cas de test initiaux, l’équipe d’assurance qualité peut s’efforcer de garantir que ces mutations s’imbriquent les unes dans les autres et conduisent à des tests plus fluides dans l’ensemble.
4. Délais et calendriers
Les phases de test sont plus ou moins longues, mais elles doivent toujours respecter les délais internes de l’entreprise. Les entreprises qui ne planifient pas correctement leurs tests de mutation risquent de ne pas pouvoir achever le processus à temps.
Avant qu’un projet n’atteigne la phase de test, l’équipe doit s’assurer que le calendrier des tests est suffisamment complet.
5. Couverture de test inadéquate
Les entreprises peuvent choisir de mettre en œuvre leur code de mutations de manière aléatoire, mais il est important qu’il couvre un large éventail de questions.
Pour s’assurer que les testeurs et le logiciel peuvent détecter tous les types de mutants, les vérifications doivent inclure au minimum plusieurs mutations de valeurs, de décisions et d’instructions.
6. Utilisation de mutants pour tester le logiciel
Bien que les tests de mutation offrent une nouvelle perspective sur une application, les équipes ne doivent utiliser cette méthode que pour vérifier leur propre processus de test. L’entreprise doit comprendre les capacités et les limites exactes des tests de mutation ; cette technique ne peut réussir qu’en complément d’autres contrôles logiciels.
7. Trop de mutants
Il est primordial que les entreprises assurent une large couverture des tests, mais elles risquent de mettre en œuvre trop de mutants dans le processus. Chaque programme de mutation nécessite une puissance de calcul importante, ce qui limite le nombre de programmes qu’une organisation peut mener simultanément.
L’exécution d’un trop grand nombre de mutations peut également rendre plus difficile le respect des délais d’exécution des tests.
Liste de contrôle, conseils et astuces pour les tests de mutation
Il existe un certain nombre de conseils supplémentaires qui pourraient aider toute équipe à améliorer le succès de son processus de test de mutation :
1. Vérifier la compatibilité du langage de programmation
Les outils de test de mutation, qu’ils soient gratuits ou payants, sont généralement spécialisés dans un langage de codage. Il est donc important que les testeurs choisissent un outil compatible avec l’application et la plateforme de test du logiciel.
L’équipe de test doit étudier de nombreuses options afin de s’assurer qu’elle utilise un programme adapté à son budget et à son langage de codage préféré.
2. Répartir judicieusement les tests
Les différents membres de l’équipe de test examineront probablement des aspects différents de l’application, généralement en fonction de leurs forces et faiblesses spécifiques et de leur expérience globale.
Lorsque l’équipe attribue des tests de mutation à chaque testeur, elle doit garder cela à l’esprit pour se faire une idée de leur compétence ; cela indique dans quelle mesure les tests ultérieurs se dérouleront.
3. Choisir les fautes avec soin
Si une itération récente du logiciel présentait un bogue impliquant une valeur ou une déclaration, il peut être utile de le reproduire et d’examiner comment l’équipe ou le programme réagit.
Cela permet de garantir la pérennité de l’application et d’illustrer la capacité de l’équipe à détecter les erreurs antérieures si elles se reproduisent – il s’agit là d’un élément clé des tests de régression.
4. Maximiser la puissance de calcul
Comme les contrôles de mutation peuvent nécessiter beaucoup de puissance de calcul, il est utile d’exploiter au maximum le matériel de l’entreprise.
Par exemple, si certaines machines ont des spécifications plus strictes, il peut être utile d’exécuter les mutants sur ces appareils. Cela permet à l’entreprise d’éviter les retards importants que des machines plus lentes pourraient entraîner.
5. Ne pas rejeter les mutations vivantes
Même avec un calendrier strict, les testeurs doivent s’efforcer de modifier et d’élargir leurs scénarios de test afin de lutter contre les mutants qui survivent au processus.
Bien que ces erreurs puissent sembler insignifiantes si le logiciel ou le testeur ne les découvre pas, elles n’en représentent pas moins une incapacité des cas de test à identifier tous les problèmes de codage.
6. Étudier un nouveau logiciel d’automatisation
Si les cas de test de l’équipe sont suffisamment détaillés mais que leur suite de tests automatisés ne peut pas les utiliser avec succès pour identifier chaque mutation, ils pourraient bénéficier d’un logiciel différent.
Il existe de nombreuses plateformes gratuites et payantes, et les entreprises doivent vérifier chaque option pour s’assurer qu’elles disposent du logiciel qui convient le mieux à leurs cas de test à long terme.
7. Synchroniser chaque processus de test
La collaboration est un élément essentiel de toute stratégie de test – elle permet de s’assurer que chaque processus peut facilement s’intégrer comme le souhaite l’équipe.
Par exemple, l’équipe chargée des tests pourrait élaborer ses scénarios de test en tenant compte des mutations afin de garantir un niveau de compatibilité plus élevé, ce qui permettrait aux testeurs de valider plus facilement leur stratégie.
8. Utiliser les tests unitaires
Les tests unitaires permettent à l’équipe chargée de l’assurance qualité d’inspecter des morceaux de code de manière isolée, ce qui simplifie considérablement les tests et facilite l’identification des problèmes par les équipes.
Cette combinaison peut s’avérer particulièrement utile si les testeurs sont préoccupés par les délais, ce qui leur donne l’occasion de simplifier leurs vérifications et d’améliorer la couverture globale, ce qui permet d’obtenir des tests logiciels beaucoup plus solides.
9. Rédiger des cas de test détaillés
Les cas de test de mutation doivent contenir des informations adéquates sur le mutant et son effet sur le programme, ainsi que sur la manière dont l’équipe ou la plate-forme de test a localisé ces fautes.
En fournissant autant de détails que possible, un testeur peut valider personnellement le cas de test et s’assurer que l’équipe sait exactement comment garantir le bon déroulement des tests.
5 meilleurs outils de test de mutation
Il existe une large gamme d’outils qui peuvent aider les entreprises à répondre à leurs besoins en matière de tests de mutation. Comme c’est souvent le cas avec les applications de test de logiciels, les prix et les fonctionnalités varient d’une plateforme à l’autre, ce qui fait qu’il est essentiel que les organisations choisissent celle qui répond le mieux à leurs besoins.
Certains de ces programmes pourraient offrir des contreparties gratuites ou être entièrement libres, bien qu’il soit généralement nécessaire de payer pour bénéficier d’une plus grande commodité.
Dans cette optique, voici les cinq meilleurs outils pour les tests de mutation.
1. Stryker
Stryker se spécialise dans la mutation JavaScript, rationalisant ce processus de manière significative afin de garantir l’absence de faux positifs et de réduire la quantité globale d’efforts que les testeurs devraient autrement déployer pour tous les contrôles de mutation.
La plateforme Stryker évalue intelligemment le logiciel et utilise les informations qu’elle recueille pour déterminer les chaînes ou les segments de code qui bénéficieraient d’une mutation. Cette application est accompagnée d’un rapporteur en texte clair qui fournit un résumé du mutant, y compris si Stryker a pu le tuer.
2. PITest
PITest est un choix très populaire dans le monde entier en raison de sa capacité à modifier le code byte de Java et à effectuer des milliers de mutations par seconde. Cette application utilise les données relatives à la couverture des cas de test pour déterminer instantanément les tests susceptibles de tuer un mutant.
Il n’exécute que les tests dont il sait qu’ils seront pertinents, ce qui limite la puissance de calcul que cette procédure consomme habituellement. PITest est également compatible avec la plupart des formes du plugin de test unitaire Surefire, mais peut avoir du mal à gérer efficacement les dépendances des ordres de test.
3. Assurer++
Insure++ possède de nombreuses capacités de test, notamment l’analyse des mutations, qui permet à la plateforme de repérer les ambiguïtés d’un programme. Contrairement aux tests de mutation conventionnels, Insure++ renonce à générer des mutants défectueux et crée à la place des mutations fonctionnellement équivalentes qui correspondent au code source du projet.
Il s’agit d’éviter les hypothèses implicites qui peuvent limiter par inadvertance le processus d’essai et ne pas refléter des environnements d’essai réalistes. Comme son nom l’indique, la plateforme est principalement compatible avec les programmes C++, et toutes les fonctionnalités sont calibrées pour ce langage.
4. Le bric-à-brac
Cette application se spécialise dans le cadre JavaScript JUnit, avec des indicateurs visuels complets sur la façon dont le code réagit à l’analyse de mutation. Jumble est une plateforme open source qui fonctionne dans le byte-code des applications Java afin de réduire la durée de chaque cycle de test.
Les applications similaires qui utilisent exclusivement le code source d’un programme peuvent parfois prendre plus de temps pour effectuer ces contrôles en raison de leur processus de recompilation.
Jumble utilise également des heuristiques pour optimiser encore davantage les tests de mutation, ce qui simplifie les tests ultérieurs.
5. MutPy
MutPy prend en charge les tests de mutation pour les applications basées sur Python, offrant une prise en charge complète des mutations d’ordre élevé ainsi qu’une analyse complète de la couverture. L’interface de ce programme est facile à utiliser lors de l’étape de sortie, qui montre clairement aux utilisateurs tous les détails essentiels des tests de mutation de l’équipe.
MutPy offre de nombreux choix sur mesure pour les testeurs – ce qui leur permet de calibrer ce logiciel spécifiquement en fonction de leurs besoins. La plateforme utilise des arbres syntaxiques abstraits qui fournissent une structure claire du code source de l’application, ce qui donne aux testeurs une plus grande confiance dans leurs mutations.
Conclusion
La mutation de code s’applique à presque tous les processus de test de logiciels et offre un certain nombre d’avantages évidents aux entreprises qui mettent en œuvre cette technique, en particulier au début de la phase d’assurance de la qualité.
Aucune méthodologie n’est exempte de difficultés ; il est donc impératif que les organisations considèrent judicieusement les avantages de l’analyse de mutation tout en veillant à ce qu’elle s’inscrive dans leur calendrier habituel de développement de logiciels.
Ces mutations donnent aux équipes de test la possibilité d’examiner leur propre approche et de déterminer son efficacité pour localiser et rectifier les erreurs dans le code source. Cette technique est particulièrement compatible avec les procédures d’automatisation, permettant aux entreprises de valider le logiciel auquel elles confient leurs contrôles.
Les tests de mutation offrent aux équipes d’assurance qualité un moyen complet de mieux comprendre leurs propres processus et logiciels, y compris les problèmes qu’elles ne parviendraient pas à détecter autrement.
Il est donc essentiel que les équipes de test étudient de près cette technique pour déterminer si elle correspond aux besoins de l’organisation, et notamment si l’outil de mutation qu’elles choisissent est entièrement compatible avec leur langage de programmation. Le logiciel de test automatisé ZAPTEST présente de nombreuses caractéristiques qui lui permettent de passer les tests de mutation, garantissant ainsi aux équipes une confiance totale dans ses capacités.
Les versions Free et Enterprise offrent toutes deux un processus de test de haute qualité qui peut facilement s’adapter aux mutations du code.
FAQ et ressources
1. Les meilleurs cours sur les tests de mutation
Les cours en ligne peuvent aider les testeurs débutants à apprendre les bases de la mutation de code ou à renforcer les compétences préexistantes des membres expérimentés du personnel chargé de l’assurance qualité. Les leçons générales sur les tests de logiciels peuvent également offrir de nombreux avantages aux testeurs. Les meilleurs cours en ligne pour les testeurs de mutations sont les suivants :
– L’article de PluralSight intitulé « Mutation Testing in Java with PITest » (Test de mutation en Java avec PITest) examine spécifiquement la manière de modifier le code Java et les avantages de cette approche pour les processus pratiques de test de logiciels.
– Le cours « The Complete 2023 Software Testing Bootcamp » d’Udemy est un cours particulièrement à jour qui illustre tous les composants clés des tests de logiciels, y compris les tests en boîte blanche.
– Le cours d’Alison intitulé « Software Testing – Condition Coverage and Mutation Testing Strategies » est gratuit et examine de près la manière de mettre en œuvre judicieusement les tests de mutation.
– Le cours « Unit Testing Fundamentals » de PluralSight explore les avantages et les caractéristiques des tests unitaires, afin de s’assurer que les étudiants comprennent le processus exact d’écriture de tests unitaires solides.
– Le cours « Introduction to Unit Testing » d’Udemy est un autre cours gratuit qui présente clairement les tests unitaires ainsi que l’importance des stratégies de développement pilotées par les tests.
2. Quelles sont les 5 principales questions d’entretien sur le test de mutation ?
Les entreprises peuvent poser un certain nombre de questions aux candidats lors d’un entretien afin de vérifier leur expérience ou leur compréhension des tests de mutation et de leurs principes fondamentaux. Cela permet à une entreprise de s’assurer qu’elle engage un testeur qualifié capable d’aborder facilement différents scénarios liés à la mutation.
Les questions exactes varient, mais il peut s’agir de demander leur propre avis ou des exemples de leurs compétences en matière de mutation de code.
Les cinq principales questions d’entretien concernant les tests de mutation sont les suivantes
– Quels sont les outils de test de mutation que vous avez déjà utilisés, le cas échéant ? Quelles étaient les principales caractéristiques de ce logiciel ?
– Lorsque vous procédez à une mutation de code, comment feriez-vous pour assurer un équilibre sain entre la vitesse et la profondeur des tests ?
– Dans quelles situations l’analyse des mutations est-elle impossible ? Comment inspecteriez-vous la procédure de test dans ces scénarios ?
– Si une mutation de valeur parvient à survivre au processus de test, quelle serait votre ligne de conduite pour éviter qu’elle ne se reproduise ?
– Quelles informations incluriez-vous dans un cas de test de mutation afin de garantir que vos collègues disposent des données dont ils ont besoin ?
3. Meilleurs tutoriels YouTube sur les tests de mutation
Des tutoriels gratuits, des webinaires et d’autres vidéos sont disponibles sur YouTube pour aider les testeurs à mieux comprendre les tests de mutation. Voici quelques-unes des vidéos et séries les plus utiles sur le sujet :
– Software Testing’s « Mutation Testing for Programs », qui fournit des exemples pratiques de la manière dont la mutation de code aide les programmes, ainsi que la manière d’écrire des cas de test approfondis.
– Test de mutation de Devoxx : Did my test break my code ? », qui examine comment l’analyse de mutation améliore les procédures de test globales pour tous les types de projets logiciels.
– La conférence « Kill All Mutants ! Intro to Mutation Testing », qui étudie comment les suites de tests peuvent bénéficier de la mutation du code et des défauts qu’elle contribue à créer.
– GOTO Conferences’ ‘Mutation Testing in Python’, qui examine spécifiquement comment les applications basées sur Python peuvent appliquer l’analyse de mutation pour atteindre des objectifs de test spécifiques.
– L’article de Diego Pacheco intitulé « Java Mutation Testing With PITest », qui illustre de manière similaire les logiciels JavaScript utilisant la mutation de code – en mettant l’accent sur le programme de mutation PITest.
4. Comment maintenir les tests de mutation ?
La combinaison de l’analyse des mutations avec des tests de régression et d’autres stratégies à long terme permet aux entreprises de garantir un niveau élevé d’assurance qualité, même après la publication.
Les mises à jour ultérieures peuvent entraîner des modifications du code qui nécessitent des contrôles supplémentaires. Les tests de mutation montrent que le logiciel d’automatisation et les testeurs sont cohérents entre les différentes versions du même logiciel, ce qui ré-authentifie leur approche particulière.
Les nouvelles fonctions nécessitent de nouveaux cas de test, en particulier si ces fonctions interagissent avec des cas de test préexistants.
En outre, l’utilisation du développement piloté par les tests permet aux membres de l’équipe de planifier la longévité du logiciel et de tester sa compatibilité dans le cadre de son propre cycle de développement.
