Qu'est-ce que le test des singes et des gorilles ? Exemples, Différence

⚡ Résumé intelligent

Les tests de type « singe » consistent à injecter des données aléatoires et non planifiées dans une application en cours d'exécution et à observer si elle survit ; ainsi, les plantages, les blocages et les états non gérés sont mis en évidence bien avant qu'un cas de test prédéfini n'ait été écrit.

  • ???? Idée centrale : Des clics, des frappes au clavier et des gestes aléatoires permettent de sonder le système à la recherche de points de défaillance plutôt que de résultats attendus.
  • (I.e. Contraste avec le gorille : Les tests de type « gorille » consistent à tester un module de manière répétée, tandis que les tests de type « singe » parcourent l'ensemble de l'application.
  • 🧠 Trois niveaux : Les singes stupides, intelligents et brillants diffèrent par leur niveau de connaissance du système testé.
  • Compromis honnête : Peu coûteux et rapide à utiliser, mais les défauts sont difficiles à reproduire et la couverture ne peut être garantie.
  • Outillage: Android UI/Application Exerciser Monkey, MonkeyRunner et des outils similaires génèrent automatiquement des flux d'événements.
  • (I.e. Meilleure coupe : Des versions préliminaires, des interfaces interactives et des tests de stabilité, toujours associés à des tests scriptés et exploratoires.

Comparaison des tests de singes et des tests de gorilles dans les tests logiciels

Qu'est-ce que le test du singe ?

Tests sur les singes Le test empirique est une technique de test logiciel où le testeur saisit des données aléatoires dans une application, sans scénarios de test prédéfinis, et observe son comportement, notamment la détection de plantages. Son objectif est de déceler les bogues et les erreurs par une interaction expérimentale et non scénarisée.

Ce nom provient d'une image simple, illustrée ci-dessous.

Le testeur joue le rôle du singe en saisissant des données aléatoires lors des tests sur les singes.

  • Dans les tests de type « singe », le testeur (et parfois le développeur) est traité comme le « singe ».
  • Si un singe utilisait un ordinateur, il effectuerait des tâches au hasard, sans comprendre le système.
  • De la même manière, le testeur applique des entrées aléatoires au système testé afin de trouver des bogues sans prédéfinir aucun cas de test.
  • Dans certains cas, les tests sur les singes visent à tests unitaires or Tests d'interface graphique.

Qu’est-ce que le test Gorilla ?

Tests de gorilles est une technique de test logiciel dans laquelle un module du programme est testé de manière répétée pour confirmer qu'il fonctionne correctement et ne contient aucun défaut.

Un même module peut être exécuté une centaine de fois, voire plus, exactement de la même manière ; c’est pourquoi le test gorille est aussi appelé « test de frustration ». Le test singe répartit les tests aléatoirement dans l’application ; le test gorille se concentre sur un seul point jusqu’à ce qu’il y ait une défaillance ou que sa robustesse soit démontrée.

Types de tests sur les singes

Les tests de type « singe » sont divisés en catégories selon le niveau de connaissance du système par le testeur. Le diagramme ci-dessous résume les trois types.

Types de tests sur les singes : stupides, intelligents et brillants

  • Singe stupide : Le testeur n'a aucune idée du système ni de son fonctionnement, et rien ne garantit la validité des données saisies.
  • Singe intelligent : Le testeur a une idée précise du système, de son objectif et de ses fonctionnalités, il navigue à travers celui-ci et fournit des entrées valides.
  • Singe brillant : Le testeur travaille à partir du comportement réel des utilisateurs et peut indiquer où les défauts sont susceptibles d'apparaître.

Tests sur les singes vs tests sur les gorilles vs tests ad hoc

Tests sur des singes, tests sur des gorilles et tests ad hoc Elles partagent un côté spontané, ce qui explique pourquoi on les confond souvent. Les deux tableaux ci-dessous permettent de les distinguer.

Tests sur les singes vs tests sur les gorilles

Test de singe Test de gorille
Exécuté de manière aléatoire, sans cas de test prédéfinis. Ni prédéfinies ni aléatoires — les mêmes vérifications sont simplement répétées.
Effectué sur l'ensemble du système et pouvant impliquer de nombreux cas de test. Effectué sur quelques modules sélectionnés avec un nombre limité de cas de test.
L'objectif est de vérifier s'il y a eu une panne du système. L'objectif est de vérifier si le module fonctionne correctement.

Tests empiriques vs tests ad hoc

Test de singe Tests ad hoc
Exécuté de manière aléatoire, sans cas de test prédéfinis. Exécuté sans planification ni documentation, donc aucun cas de test ni spécification des exigences système n'est préparé.
Les testeurs peuvent ignorer ce qu'est le système ou à quoi il sert. Le testeur doit bien comprendre le système avant le début des tests.
L'objectif est de vérifier s'il y a eu une panne du système. L'objectif est de diviser le système en sous-parties de manière aléatoire et de vérifier leur fonctionnalité.

Avantages et inconvénients des tests sur les singes

Puisque cette technique privilégie la rapidité à la planification, ses avantages et ses inconvénients découlent de la même propriété.

Avantages des tests sur les singes

  • Nouveaux types d'insectes : Le testeur est libre de travailler en dehors des scénarios préalablement définis, ce qui permet de faire émerger des erreurs auxquelles personne n'avait pensé pour le script.
  • Facile à exécuter : L'application d'actions aléatoires à des données aléatoires est un moyen rapide de mettre le système à l'épreuve.
  • Less personnes qualifiées : Les tests sur les singes peuvent souvent être réalisés sans testeurs très expérimentés.
  • Less cher: Sa mise en place et son exécution nécessitent des dépenses considérablement moindres qu'une suite logicielle scriptée.

Inconvénients des tests sur les singes

  • Les bogues peuvent être difficiles à reproduire : Étant donné que les entrées sont aléatoires, il peut être impossible de reproduire une panne sans une graine enregistrée.
  • Less précision: Le testeur ne peut pas définir un scénario exact et ne peut garantir l'exactitude de ce qui a été couvert.
  • L'expertise technique reste utile : Pour que les résultats soient pertinents, les testeurs doivent avoir une bonne connaissance du domaine.
  • Lent par rapport au rendement : Les cycles de production peuvent se poursuivre longtemps tout en ne révélant que peu de défauts, laissant ainsi des failles dans le système.

Comment réaliser des tests avec des singes

Les tests sur singes deviennent beaucoup plus efficaces lorsqu'un outil les pilote, et ils peuvent être exécutés contre Android Il s'agit de développer des applications de bureau et des applications web. Le processus général est le suivant :

  1. Enregistrez l'application testée auprès de l'outil ou du serveur dédié qui l'exécutera.
  2. Préparez les références et la configuration dont l'outil a besoin pour construire une suite de tests.
  3. Exécutez la suite de tests générée.
  4. Laissez l'outil écrire son journal — le fichier journal « test du singe » enregistre chaque événement généré et ses résultats.
  5. Laissez l'exécution se poursuivre jusqu'à ce que le système atteigne un point de défaillance, auquel cas l'action fautive est enregistrée dans le journal.
  6. Partagez le rapport avec l'équipe responsable et conservez les données de test pour référence ultérieure.

Conservez tous les journaux d'événements. Une exécution aléatoire n'est utile ultérieurement que si la séquence d'événements et la graine qui l'a produite ont été sauvegardées. gestion des défauts peut relier le plantage à une entrée reproductible.

Outils de test Monkey

Les tests de type « singe » sont généralement automatisés, car une machine peut générer des milliers d'événements là où une personne n'en produit que quelques dizaines. Les options couramment utilisées sont :

  • Singe d'exercice d'interface utilisateur/d'application : un outil en ligne de commande intégré à Android qui court dans le adb shell et envoie des flux pseudo-aléatoires d'événements utilisateur, tels que des tapotements, des gestes et des frappes de touches, ainsi que des événements au niveau du système, à un appareil ou à un émulateur.
  • SingeRunner : un séparé Python API Il permet de piloter des périphériques et des émulateurs depuis un poste de travail, en envoyant des commandes spécifiques et en prenant des captures d'écran. Malgré son nom, il ne s'agit pas du même outil que l'outil de simulation d'exercices « exercise monkey ».
  • UI Automator et Appium: général test mobile des frameworks pouvant être programmés pour déclencher des séquences d'événements semi-aléatoires lors d'une compilation.
  • Outils de fuzzing tels que AFL : la même idée d'entrée aléatoire appliquée aux données plutôt qu'aux gestes, qui est traitée dans test de fuzz.

Les outils de support pour les tests automatisés sont moins nombreux que pour les tests scriptés. tests d'automatisationLa plupart des équipes combinent donc un générateur d'événements générique avec leur framework existant plutôt que d'acheter un produit dédié.

Quand utiliser les tests de singes

Les tests sur des singes trouvent leur place dans des situations spécifiques plutôt que comme un substitut général aux tests planifiés.

Utilisez-le quand :

  • Une version préliminaire nécessite un test de stabilité peu coûteux avant même l'existence de cas de test formels.
  • L'interface est hautement interactive — jeux, outils de dessin, lecteurs multimédias — et le comportement réel des utilisateurs est difficile à prévoir.
  • Vous voulez un bain ou stress Exécuter un processus qui recherche les plantages, les fuites de mémoire et les états non gérés pendant de nombreuses heures.
  • Une version a passé les contrôles prévus par le script et vous souhaitez une analyse indépendante pour tout ce que le script n'a jamais touché.

Évitez-le lorsque :

  • Vous avez besoin de preuves reproductibles qu'une exigence est satisfaite — c'est le rôle d'une preuve écrite cas de test.
  • La version est tellement instable que chaque exécution plante immédiatement, ce qui masque tout le reste suite à la première défaillance.
  • Le temps presse, car une recherche aléatoire ne garantit rien.

En pratique, les meilleurs résultats sont obtenus en combinant différentes approches : les tests scriptés couvrent les flux connus, tests exploratoires Il explore délibérément l'inconnu, et les tests sur les singes s'attaquent à tout ce que tous deux supposaient ne jamais voir arriver.

FAQ

Le nom emprunte l'image du singe à l'infini : un singe tapant au hasard sur des touches pendant suffisamment longtemps finit par produire quelque chose de significatif. Appliquée au logiciel, l'entrée aléatoire finit par atteindre des états que le concepteur n'avait pas anticipés.

Les tests exploratoires sont délibérés : le chercheur formule une hypothèse, l’explore et l’adapte. Les tests sur les singes sont, par définition, non dirigés. L’un repose sur le jugement, l’autre sur le volume et le hasard.

Elles partagent le principe d'entrée aléatoire, mais diffèrent par leur objectif. Les tests de type « monkey testing » consistent à déclencher des interactions utilisateur avec une interface. Le fuzzing, quant à lui, alimente des analyseurs syntaxiques et des API avec des données malformées, généralement dans le but de détecter des failles de sécurité.

Chaos Monkey relève de l'ingénierie du chaos : il désactive aléatoirement des services ou perturbe l'infrastructure pour tester sa résilience. L'idée commune est l'aléatoire, mais la cible est la plateforme d'exécution, et non l'interface utilisateur.

Les modèles peuvent orienter le flux d'événements vers les parcours empruntés par les utilisateurs réels, transformant ainsi un comportement rudimentaire en un comportement plus intelligent. Ils regroupent également les journaux d'incidents dupliqués et hiérarchisent les défaillances aléatoires qui nécessitent l'attention prioritaire d'un développeur.

Copilote GitHub L'infrastructure est rapidement mise en place : générateurs d'événements, gestion des initialisations, analyseurs de journaux et scripts de gestion des incidents. La stratégie d'aléatoire et les critères de réussite doivent encore être définis par un testeur.

Les indicateurs utiles comprennent le nombre de plantages pour mille actions générées, le nombre de défauts uniques détectés, la couverture de code atteinte pendant l'exécution et le temps avant la première défaillance. Il est préférable d'analyser leur évolution sur plusieurs versions plutôt que de se baser sur une seule exécution.

Enregistrez la graine aléatoire et le journal des événements. Les outils qui acceptent une graine reproduiront la séquence à l'identique, ce qui permettra de circonscrire l'échec à un cas court et reproductible et de le signaler comme un défaut normal.

Résumez cet article avec :