Comment tester en « mode agile » ?

18 05 2009

Comme promis aux nombreux lecteurs m’ayant fais la demande, je vous présente cet article traitant des tests en mode agile. Il s’agit d’une vulgarisation et je tente de vous présenter les principes et points importants à prendre en compte.

SCRUM, XT programming et autres acronymes du même acabit sont légions depuis quelques années et sont très en vogue parmi les développeurs. En fait il s’agit de développer le plus rapidement possible quelques fonctionnalités et de mettre tout aussi rapidement en production (d’où le terme de sprint que nous verrons plus tard) !

Et le test me direz-vous ?

Les activités de tests sont bien entendu réduits à au maximum… mais… il faut savoir qu’il y a une méthodologie spécifique concernant les activités de tests et qui s’insère naturellement et simplement en mode agile.

En premier lieu je passe en revue les deux méthodes de développements les plus connues dans le mode agile. En effet, elles représentent la majorité des projets de ce type (nos chers développeurs les préfèrent aussi). Il s’agit du SCRUM et de l’eXtreme Programing.

Méthode SCRUM :
La définition du mode agile est en partie basée sur la remarque suivante : « … L’approche course de relais pour le développement de produits…peut être en conflit avec les objectifs de vitesse et de flexibilité maximum. A l’inverse, une approche holistique comme au rugby— quand une équipe essaie d’avancer en restant unie, en se passant le ballon de main en main— peut mieux servir les exigences de compétitivité d’aujourd’hui ». Hirotaka Takeuchi et Ikujiro Nonaka, “The New New Product Development Game”, Harvard Business Review, Janvier 1986.

Ainsi le SCRUM est un processus agile qui permet de produire la plus « grande valeur métier » dans la durée la plus courte. Du code est produit à chaque sprint (toutes les 2 à 4 semaines).

Le métier (les utilisateurs par exemple) définit les priorités. L’équipe de développeur s’organise elle-même pour déterminer la meilleure façon de produire les exigences (ou backlog) les plus prioritaires.

Et à chaque fin de sprint, tout le monde peut voir fonctionner le produit courant et décider soit de le livrer dans l’état, soit de continuer à l’améliorer pendant un sprint supplémentaire.

Les grands principes du SCRUM :

  • Equipe responsable, en auto-organisation
  • Avancement du produit / code par une série de « sprints » de 5 jours maximum
  • Exigences définies comme des éléments d’une liste appelée « backlog du produit »
  • Pas de prescription de pratiques d’ingénierie
  • Utilisation de règles génériques permettant de créer un environnement agile pour un projet

eXtreme programming :
En 2001, aux États-Unis, dix-sept acteurs clés du développement logiciel se sont réunies pour débattre de leurs méthodes respectives, dites méthodes agiles. Les plus connus d’entre eux étaient :

  • Ward Cunningham l’inventeur du Wiki via WikiWikiWeb
  • Kent Beck, père de l’extreme programming et cofondateur de JUnit
  • Ken Schwaber et Jeff Sutherland, fondateurs de SCRUM
  • Jim Highsmith, prônant l’ASD
  • Alistair Cockburn pour la méthode Crystal clear
  • Martin Fowler et Dave Thomas
  • Arie van Bennekum pour DSDM (Dynamic System Development Method) la version anglaise du RAD (Développement rapide d’applications).

Ces nombreux experts réussirent à extraire de leur méthodes respectives des critères pour définir une nouvelle façon des développer des logiciels. De cette réunion devait émerger le Manifeste Agile, considéré comme la définition du développement agile et de ses principes.

Ainsi leurs conclusions furent :

Principales causes identifiées de l’échec des projets :

  • Mauvaise compréhension du besoin : 51%
  • Estimation et planification déficiente : 48%
  • Technologies mal maîtrisées : 45%

Méthodes classiques trop lourdes :

  • Manque de réactivité
  • Excès de documentation

But : produire un logiciel de qualité en respectant les délais et le budget grâce à un ensemble de pratiques efficaces poussées à l’extrême.

Dans la pratique les choses sont bien différentes… En effet, les délais et budgets sont à peine respectés (comme dans les projets en mode classique – processus en V et autres) et la qualité est inconnue de la plupart des développeurs.

En fin de compte les problèmes concernant les tests sont les mêmes sur tout les projets. Le principal étant la non connaissance des bonnes pratiques de tests par les chefs de projets (ou scrumMaster) et les développeurs (ou CoWboyZ).

Ainsi le mode agile possède aussi quelques bonnes pratiques à mettre en œuvre et faire respecter par les ScrumMaster et autres chefs de projet. Voici celles que j’ai apprises et optimisées lors de mes missions.

Ci-dessous le processus de développement logiciel en mode agile :

image1_agile

On constate que le processus fonctionne un peu comme un sous-marin, avec des compartiments devant rester étanches, sous peine de ne plus respecter le processus…

  • Ainsi, les métiers définissent leurs besoins et exigences, ils les communiquent au chef de produit
  • Le chef de produit en fais une synthèse et en propose une priorisation au chef de projet (ou ScrumMaster)
  • Ensuite, le chef de projet les prends en compte et détermine les exigences (ou backlogs) qui seront développés par son / ses équipes « agiles ».
  • Sachant que les users métiers ne doivent parler qu’uniquement au chef de produit et que celui-ci est le seul à parler avec le chef de projet
  • Enfin, les développeurs et testeurs ne peuvent pas parler avec les users ni les chefs de produit

Ce mode de « communication en mode étanche » a été préconisé à l’époque afin d’assurer la tranquillité de l’équipe de développement et s’assurer que ceux-ci ne seraient pas dérangés. Ainsi, les créateurs du mode agile crurent assurer en partie par ce biais le respect des délais et des budgets.

Mais, les effets pervers de ce mode étanche sont :

  • Pas ou peu de cahier des charges / spécifications en entrée des développements
  • Les besoins et exigences des utilisateurs sont filtrés et surtout réinterprétés par trois personnes différentes ayant chacun des priorités et objectifs différents
  • Pas de traçabilité des exigences
  • Des effets de ralentissements ou « d’à peu près » car quand un développeur a une question sur une fonctionnalité à coder, il ne peut la poser qu’au chef de projet qui demandera au chef de produit qui demander aux utilisateurs. La réponse (si la question a bien été posée) prendra le chemin en sens inverse…
  • Les testeurs non presque pas de documentation et doivent souvent attendre la fin du  deuxième sprint pour avoir une certaine visibilité sur ce qu’il y aura à tester

Finissons cette description du processus logiciel en mode agile par la communication au sein de l’équipe agile.

  • En début de chaque sprint (tous les lundis donc car un sprint = 5 jours) il y a une réunion de démarrage qui doit aborder le planning, les outils, etc.
  • Pendant les sprints il y a une réunion quotidienne ne devant pas avoir lieu dans une salle (ceci reste un mystère pour moi j’avoue) mais plutôt dans un lieu incongru et très bruyant comme la salle à café ou équivalent. Cette réunion ne doit pas dépasser 15 minutes (avec des questions comme : les problèmes rencontrés, etc.)
  • Le reste de la communication est assurée par les « Instant Messenger » comme MSN et équivalent (même si les développeurs et testeurs sont dans le même bureau, ce qui est hallucinant à vivre je vous l’avoue !)

Synthèse des fondamentaux de l’agile :

  • Sprint et itérations très courts
  • Une équipe ne communiquant que par son scrumMaster
  • Spécifications « rédigées » pendant les sprints
  • Pas de plan de tests – scripts « one shot »

Ci-dessous le séquencement d’un projet agile :

image2_agile

Au sein d’un projet il y a plusieurs releases. Chaque release est composé de plusieurs sprint. Tous les 3 ou 4 sprints une release / package est construite par les développeurs (en 1 journée grand maximum). Puis, le package doit-être mis en production. Si vous avez lus mes articles précédents vous constaterez bien vite qu’il manque une étape importante avant la mise en production… (Roulement de tambour… suspens…), il s’agit des tests avant la mise en production. Comme :

  • Les tests de performance
  • Les tests d’exploitabilité
  • Les tests d’installations
  • Les tests de MEP à blanc, etc.

Bonnes pratiques :

  • Mettre en place une machine d’intégration continue qui assurera la « récolte » des développements, leurs sauvegardes et leurs versions
  • Prévoir, définir et mettre en œuvre les tests devant valider les packages :
  • Souvent cette étape se résume à un combat pour l’imposer auprès des chefs de projet qui trouve que les tests ne font pas partie du mode agile et ralentissent le processus. Ces mêmes chefs de projet qui subitement changent d’avis après des mises en production sans tests préalable… C’est ce que l’on appel l’expérience par l’échec.

image3_agile
Détaillons les activités de tests dans le mode agile en prenant un exemple concret :

Dans le schéma ci-dessus j’ai modélisé une release comportant uniquement deux sprints, une étape de packaging et la mise en production (MEP).

Itération 1 – Planning du sprint 1 (ou S1) :

  • Lundi 2 février au matin : réunion de démarrage (1 heure maximum – A). Le scrumMaster explique aux 3 développeurs et au testeur unique les backlogs (B) devant être développés et testés
  • Lundi 2 au vendredi 6 février matin les développeurs on les tâches suivantes :
  • Prise de connaissance des backlogs fourni par le scrumMaster
  • Développements (codage en Java – C) des backlogs (et des classes de tests bien entendu) :
  • + Tests unitaires (D) en utilisant Junit et Javadoc au sein du framework Eclipse
  • Chaque les développeurs « commit » leurs bouts de code. Ce code est pris en charge dans le processus d’intégration continue (E)
  • Lundi 2 au vendredi 6 février matin le testeur a les tâches suivantes :
  • Prise de connaissance des backlogs
  • Lecture des rapports de tests générés par Junit
  • Création des scripts de tests (sous Selenium – F)
  • Vendredi 6 février après-midi :
  • Le scrumMaster décide lors de la réunion matinale quotidienne de mettre fin au sprint 1 (S1) ce vendredi en fin de journée car il estime que les objectifs ont été atteints. Il envoi un mail pour en prévenir le chef de produit.

Planning du sprint 2 (S2) :

  • Lundi 9 au 13 février matin : réunion de démarrage (1 heure maximum). Le scrumMaster explique aux 3 développeurs et au testeur unique les backlogs devant être développés et testés
  • Lundi 9 au 13 février matin les développeurs on les tâches suivantes :
  • Prise de connaissance des backlogs fourni par le scrumMaster
    Développements (codage en Java) des backlogs (et des classes de tests bien entendu) :
    + Tests unitaires en utilisant Junit et Javadoc au sein du framework Eclipse
    Chaque les développeurs « commit » leurs bouts de code. Ce code est pris en charge dans le processus d’intégration continue
  • Lundi 9 au vendredi 13 février matin le testeur a les tâches suivantes :
    Prise de connaissance des backlogs S2
    Lecture des rapports de tests générés par Junit du S2
    Création des scripts de tests (sous Selenium) pour le S2
    + Le testeur doit aussi faire en parallèle (dès le lundi après la réunion) :
    Lancement et surveillance des scripts du S1 (H)
    Remontée des anomalies sur les backlog du S1 au scrumMaster (uniquement à lui – qui est juge et partie sur la décision de corriger ou pas les anomalies remontées par le testeur – G)
  • Vendredi 13 février après-midi :
    Le scrumMaster décide lors de la réunion matinale quotidienne de mettre fin au sprint 2 (S2) ce vendredi en fin de journée car il estime que les objectifs ont été atteints. Il envoi un mail pour en prévenir le chef de produit et indique qu’une mise en production est possible sans problème
    La MEP est effectué par un des développeurs. Juste avant de partir en week-end il lance l’installation en étant sur à 100% que tout se déroulera bien (I)

Fin de l’itération 1

J

Voici donc le fonctionnement typique d’une équipe agile classique. Suivant vos expériences, vous vous apercevrez qu’il y a de nombreuses erreurs de jugement et de très importants manques aux niveaux des tests !

Je vais lister ci-dessous les bonnes pratiques pouvant être mises en œuvre dans un projet agile. Sachant que ces bonnes pratiques devront être présentées et défendues auprès du scrumMaster, par le testeur.

L’intervention des bonnes pratiques est signalées par une lettre dans le planning ci-dessus et expliquées en détails ci-dessous :

image4_agile

Lien vers l’article traitant des tests unitaires.


Actions

Information

One response

1 02 2012
killertom3

Énormément de conneries, l’auteur ne maîtrise absolument pas le sujet et présente comme étant agiles des pratiques qui ne le sont absolument pas !

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s




%d blogueurs aiment cette page :