Tâche: Implémenter un test de développeur
Cette tâche décrit la manière de créer un ensemble de tests pour valider que le composant fonctionne correctement avant de procéder à un test plus formel sur le composant.
Disciplines: Implémentation
Objet
  • Implémenter un ou plusieurs tests permettant de valider des composants logiciels individuels par le biais d'une exécution physique
  • Développer des tests pouvant être exécutés conjointement avec d'autres tests dans le cadre d'une infrastructure de test plus importante
Relations
Etapes
Affiner la portée et identifier les tests
Objet :  Identifier le composant testé et définir un ensemble de tests intéressants pour l'itération en cours

Dans un environnement formel, les composants et les tests qui doivent être développés sont spécifiés dans l'artefact de conception du test, ce qui rend cette étape facultative. Il existe d'autres cas où les tests du développeur sont dictés en fonction de demandes de changements, de débogages, de décisions d'implémentation nécessitant d'être validées, de tests de sous-système avec uniquement le modèle de conception comme entrée. Pour chacun de ces cas :

  • définissez l'objectif : validation de l'interface sous-système/composant, validation de l'implémentation, reproduction d'un incident
  • définissez la portée : sous-système, composant, groupe de composants
  • définissez le type et les détails du test : fonctionnel, structurel, conditions préalables, conditions postérieures, invariants, entrée/sortie et conditions d'exécution, points d'observation/contrôle, actions de nettoyage
  • décidez de la durée de vie du test ; par exemple, un test spécialement conçu pour résoudre un incident pourra être bref, en revanche, un test mettant en pratique les interfaces externes aura la même durée de vie que le composant testé
Sélectionner la technique d'implémentation appropriée
Objet :  Déterminer la technique appropriée pour implémenter le test

Il existe différentes techniques disponibles pour implémenter un test, mais on peut les regrouper en deux catégories principales : le test manuel et le test automatisé. La plupart des tests des développeurs sont implémentés à l'aide de techniques de test automatisées :

  • tests programmés, utilisant soit le même environnement et les mêmes techniques de programmation que le composant testé, soit des outils et des langages de programmation complexes (par exemple les langages de script : tcl, basés sur un interpréteur de commandes, etc.)
  • tests enregistrés ou capturés, développés à l'aide d'outils d'automatisation de test qui capturent les interactions entre le composant testé et le reste du système et produisent les tests de base
  • tests générés : certains aspects du test, relatifs à la procédure ou aux données de test, peuvent être automatiquement générés à l'aide d'outils d'automatisation de test plus complexes
Bien que l'approche la plus classique est le "test programmé", dans certains cas - pour le test de l'interface utilisateur par exemple, le moyen le plus efficace de mener un test est la méthode manuelle, en suivant une séquence d'instructions capturées sous la forme d'une description textuelle.
Implémenter le test
Objet :  Implémenter les tests identifiés dans l'étape ou la tâche de définition

Implémentez tous les éléments définis dans la première étape. Détaillez et spécifiez clairement les conditions préalables à l'environnement de test et les étapes permettant de conduire le composant testé jusqu'à l'état où le ou les tests peuvent être menés. Identifiez les étapes de nettoyage à suivre pour restaurer l'environnement à son état d'origine. Faites particulièrement attention aux points d'observation/contrôle, dans la mesure où ces aspects peuvent nécessiter l'implémentation d'une prise en charge dans le composant testé.

Etablir des ensembles de données externes
Objet :  Créer et conserver des données, stockées à l'extérieur du test, utilisées par le test lors de son exécution

Dans la plupart des cas, le fait de découpler les données de test du test conduit à une solution plus facile à gérer. Si la durée de vie du test est très brève, le codage en dur des données au sein du test peut s'avérer plus efficace, mais s'il est nécessaire de procéder à de nombreux cycles d'exécution de test utilisant différents ensembles de données, la méthode la plus simple est de les stocker de manière externe. Il existe d'autres avantages dans le fait de découpler les données de test du test :

  • plusieurs tests peuvent utiliser le même ensemble de données
  • facilité de modification et/ou de multiplication
  • possibilité de contrôler la logique de branchement conditionnel au sein du test
Vérifier l'implémentation du test
Objet :  Vérifier le fonctionnement correct du test

Testez le test. Vérifiez la configuration de l'environnement et les instructions de nettoyage. Exécutez le test, observez son comportement et réglez les incidents du test. Si le test a une durée de vie élevée, demandez à une personne ayant une connaissance moins approfondie de l'environnement de test de l'exécuter afin de vérifier qu'il existe suffisamment d'informations de support. Révisez le test avec d'autres personnes de l'équipe de développement et d'autres parties intéressées.

Gérer les relations de traçabilité
Objet :  Permettre l'analyse d'impact et la génération de rapports d'évaluation sur l'élément tracé

En fonction du niveau de formalité, il est possible que vous soyez obligé de gérer les relations de traçabilité. Dans ce cas, utilisez les exigences de traçabilité mises en évidence dans le plan de test afin de mettre à jour les relations de traçabilité, si nécessaire.


Plus d'informations