samedi 27 juillet 2013

Given-When-Then comme pratique agile

Certains frameworks de test fonctionnel orientés vers BDD (Behaviour-Driven Development) implémentent nativement la séparation des étapes d'un test selon ce schéma :
Given / Étant donné [un contexte]
When / Quand [certains événements surviennent]
Then / Alors [on obtient les résultats attendus]
Given - When - Then

Par exemple, JBehave le propose dans son système d'annotations (@Given, @When, @Then), afin de composer l'écriture d'un "story test" en Java.

Mais ces mots-clés peuvent servir également à bien identifier les étapes à l'intérieur d'autres types de tests : unitaires ou d'intégration, avec JUnit par exemple. En effet, les annotations de JUnit ne sont pas toujours suffisantes : @Before (préparation), @Test (exécution + vérification) et @After (nettoyage) correspondent au cycle ci-dessous.

Tester en 4 étapes
Or, dans un test JUnit, rien ne distingue les étapes "Quand" et "Alors", sinon l'ordre d'écriture. De plus, quand une classe de test comporte plusieurs méthodes @Test, il est souvent nécessaire d'y ajouter quelques lignes supplémentaires pour finir la préparation du contexte ("Étant donné").

En tant que pratique, Given-When-Then a l'avantage de donner un guide pour mieux structurer son cas de test, d'inciter à n'écrire qu'un cas par méthode de test, ainsi que d'améliorer la lisibilité du code.



De manière à en généraliser l'usage, quoi de mieux que de l'intégrer directement dans son IDE ?

Avec Eclipse IDE, dans le menu "Windows / Preferences" :
  • accéder au sujet "Java / Editor / Templates",
  • créer un nouveau template en cliquant sur "New",
  • configurer le template comme ci-dessous :
  • dans votre méthode de test, taper tout ou partie de "givenwhenthen" et laisser l’auto-complétion faire le reste.
Il est aussi possible d'importer un template, en cliquant sur le bouton "Import" et en sélectionnant ce fichier.

Liens :

samedi 3 novembre 2012

Etats des objets Hibernate (poster)

Ce poster comprend :
  • La définition des états Hibernate : objets volatiles ("transient"), persistants et détachés.
  • L'effet des opérations supportées par la session Hibernate lors des transitions d'état.
  • Des extraits de code montrant où peuvent intervenir les états entre les différentes couches d'une application 3-tiers (couche de présentation, couche de service et couche de persistance).
Poster
États des objets Hibernate
Liens :

samedi 29 septembre 2012

Lister les ports ouverts dans un batch

Quelques commandes utiles

  • Afficher la date : date /t, ou bien : echo %date%
  • Afficher l'heure : time /t, ou bien : echo %time%
  • Afficher toutes les connexions TCP actives, avec le nom du programme impliqué dans la création de chaque connexion et ports ouverts, les adresses et les ports étant affichés au format numérique : netstat -bon
  • Lancer une nouvelle instance de l'interpréteur de commande Windows, avec fermeture en fin d'exécution : cmd /C

Le tout dans un batch :

echo off

set dateTime=%date%T%time%
set output=netstat-report.txt

(
    echo %dateTime%
    cmd /C netstat -bon
) > %output%

Les résultats peuvent ensuite être lus dans le fichier "netstat-report.txt".
Remarque : Si l'utilitaire netstat n'est pas exécuté avec cmd, le fichier de rapport ne contiendra pas la sortie de netstat.

Liens :

dimanche 22 juillet 2012

User Story ou Use Case ?

Entre User Story et Use Case, la différence ou la séparation est parfois confuse, et il me paraît intéressant de bien situer les deux en terme de similitudes, de spécificités et de complémentarité. Pour rappel, voici quelques définitions utiles se rapportant au sujet des user stories et des use cases, avant de les comparer.


Définition d'une Feature :
Une feature est un service fourni par le système, observable de l'extérieur, qui répond à un besoin, et dont la description se situe à un niveau tel que toutes les parties prenantes comprennent facilement ce dont il s'agit.
On emploie également dans le domaine de l'ingénierie des exigences les termes suivants : theme, epic, minimal marketable feature (MMF).
Exemples d'atelier pour identifier les features :
  • Product Box / Boîte du Produit
  • Remember the Future / Souvenir du Futur
Définition d'une User Story (ou histoire utilisateur) :
Une user story est une fonctionnalité élémentaire décrite du point de vue de l'utilisateur. Elle apporte de la valeur à l'utilisateur et peut être réalisée en moins d'une itération de deux semaines, c'est-à-dire quelques jours tout au plus. Les US sont obtenues par la décomposition des features. L'écriture d'une US s'appuie sur la formalisation suivante :
En tant que <rôle>, je peux <action>, afin de <justification>.

User Story : matrice Rôle - Fonctionnalité - Bénéfice
User Story : matrice Rôle - Fonctionnalité - Bénéfice
Avec 3 attributs récurrents :
  • un rôle,
  • une action : le but fonctionnel,
  • une justification (parfois facultative, car elle peut être évidente),
  • la plus-value métier, représentant le bénéfice que va tirer l'utilisateur de la user story,
  • le coût en story points, c'est-à-dire l'estimation de l'effort nécessaire à la réalisation de la user story.
Et éventuellement des attributs complémentaires :
  • une priorité déduite de la plus-value métier et du coût,
  • La fréquence d'utilisation de la US par le rôle : plus grande est la fréquence d'utilisation, plus important sera le soin apporté aux tests (tests unitaires, d'intégration, de charge, etc).
  • Des informations complémentaires : texte, schéma, diagramme.
Et toujours les tests d'acceptation (story tests) associés à la US : en fin d'itération, la US est considérée finie seulement si tous les tests d'acceptation sont validés. Les tests d'acceptation, ou conditions de satisfaction, ont eux-mêmes leur formalisme :
Étant donné... <pré-condition : état du système>
Quand... <événement : acteur + action>
Alors... <résultat observable de l'extérieur>
[Et... <autre résultat observable>]


Définition d'un Use Case (ou cas d'utilisation) :
Un use case est une description des interactions qui vont permettre à l'acteur d'atteindre son objectif en utilisant le système. Les interactions sont regroupées en scénarii. Un acteur est une entité décrite par son rôle, ses besoins et ses capacités.
Rédaction d'un cas d'utilisation :
  • Fiche récapitulative :
    • Titre,
    • Identifiant,
    • Acteurs,
    • Description.
  • Préconditions
  • Post-conditions
  • Scénario principal : séquence d'étapes ordonnées dans le temps (3 à 9 étapes).
  • Scénarii alternatifs éventuels : variations / exceptions, cas d'erreur et leur gestion.
Un cas d'utilisation ne doit pas se réduire à l'IHM, ce qui masquerait les interactions du système avec d'autres acteurs que l'utilisateur final.
Le diagramme des cas d'utilisation comprend :
  • un ou des acteurs, représentés par des pictogrammes humanoïdes,
  • des cas d'utilisation, représentés par des ellipses,
  • des relations, représentées par des traits :
    • relations simples (trait continu), 
    • inclusions (traits pointillés terminés par une flèche et stéréotype "includes"),
    • extensions (traits pointillés terminés par une flèche et stéréotype "extends"),
    • généralisations (ou spécialisations, ou héritages) (trait continu terminé par une flèche triangulaire).


Qu'il s'agisse de User Story ou de Use Case, les deux techniques servent à appréhender les besoins des utilisateurs en terme d'interaction avec un système, mais leurs manières de le faire divergent en de nombreuses occasions.


User StoryUse Case
FinalitéEn association avec les tests d'acceptation, rédiger les exigences fonctionnelles du point de vue de l'utilisateur.
Faciliter l'estimation et la planification : les US décomposées peuvent être planifiées dans des itérations différentes.
Comme éléments du backlog de produit, les US sont orientées vers la gestion et le suivi des projets.
Seulement recueillir l'expression des besoins et rédiger les spécifications détaillées des exigences fonctionnelles sous forme de processus métier.
TraçabilitéUS conservée dans le Backlog de produit.UC conservé dans le document des spécifications fonctionnelles.
GranularitéFine : une fonctionnalité élémentaire. Une US peut être une partie d'un UC : tout ou partie d'un scénario, ou éclatée dans plusieurs scénarii.
Implémentée et testée en moins d'une itération.
Grande : une macro-fonctionnalité qui en réunit de plus petites.
Implémenté et testé en une ou plusieurs itérations.
FormalismePhrase composée de 3 attributs : rôle ("qui ?"), action ("quoi ?"), justification ("pourquoi ?"), et complétée par des tests d'acceptation.Le formalisme est défini par UML.
Scénarii constitués d'une séquence d'actions ou d'événements. Répondent à "qui ?" et "quoi ?".
Les UC sont regroupés dans un diagramme des cas d'utilisation.
ExpressionDescription brève, facile à comprendre, dans le langage de tous les jours ou du métier (mais sans jargon technique).Quantité importante d'informations, dans le langage spécifique de l'utilisateur final ou de l'expert du domaine métier.
(Une demi-page pour un UC court, jusqu'à 2 pages pour un long)
EffortÉmergence rapide des exigences.
Facile à écrire avec ou par des utilisateurs ou des clients.
Les UC nécessitent un long travail d'analyse et de formalisation, afin de décrire un système entier et pensé dans son intégralité.
ComplétudeLes tests d'acceptation fournissent les conditions de satisfaction sous forme de scénarii courts pour valider une US.Le scénario principal décrit le comportement nominal. Pour le reste, les scénarii alternatifs et d'erreur viennent combler les manques.
MaintenabilitéFacile à maintenir, car le format est synthétique.Difficile à maintenir, car le format implique un contenu très conséquent. De plus, les UC mélangent les interactions et les règles métier, ce qui pose problème quand les besoins évoluent.
FocusValeur métier pour l'utilisateur final.Interactions entre l'utilisateur final et le système.
Visibilité du contexte globalDifficile de lier les US les unes aux autres. Une partie du contexte est fournie par les features et la vision du produit.Les scénarii montrent l'enchaînement temporel des actions.
Culture de travailAdaptée au travail collaboratif et à des échanges de proximité. Favorable à l'émergence de débats et à la négociation.Adapté à des échanges distants et contractuels.
TestsLes US contiennent déjà les tests d'acceptation à réaliser pendant les développements, puis lors de la démonstration pour la validation avec le Product Owner. Cf. ATDD.Les UC permettent de préparer les tests de recette, car les scénarii donnent les parcours à réaliser au cours des tests fonctionnels. Mais ils n'indiquent pas les critères d'acceptation pour statuer.
Relation avec d'autres méthodesTechnique issue de l'eXtreme Programming et associée aux méthodes agiles.Technique associée au Processus Unifié.
Auteur de référenceMike CohnAlistair Cockburn

Ainsi, on constate déjà un certain nombre d'impacts selon le choix qui sera fait entre User Story et Use Case :
  • Impact sur la vision du produit :
    • Les US expliquent ce que doit faire un système, mais aussi pourquoi. Les US sont regroupées au travers des features dont elles sont issues.
    • Les UC expliquent bien ce que doit faire un système, mais pas pourquoi il le fait. Les UC sont liés entre eux par le diagramme des cas d'utilisation, et leurs scénarii relient les fonctionnalités entre elles.
  • Impact sur les cycles des livraisons :
    • Cycle court avec les US et livraison au plus tôt de leur plus-value métier pour un retour sur investissement plus tôt et plus rapide ;
    • Livraisons plus espacées avec les UC.
  • Impact sur le processus de développement :
    • Longue phase de spécification avec les UC suivie de phases distinctes définies par le processus (RUP, cycle en V ou cascade) ;
    • Réalisation par petits périmètres fonctionnels, qui autorise un transfert continu et opportuniste de la connaissance métier vers l'équipe de développement, une collaboration entre toutes les parties prenantes à chaque itération, ainsi qu'un retour rapide du ressenti utilisateur permettant d'éventuels changements au plus tôt (et donc à moindre coût).
  • Impact sur la validation ou recette :
    • Les critères sont connus avant les développements avec les US, ce qui permet de limiter les interprétations ;
    • Les critères sont exprimés après les développements avec les UC seuls comme exigences, ce qui nécessite une deuxième interprétation des exigences à la rédaction du cahier de recette, potentiellement différente, et donc une maintenance corrective accrue.

En revanche, il existe une complémentarité entre user story et use case, entre la vision du produit et la visibilité du contexte global. Dans la mesure où il serait possible de construire le scénario principal d'un cas d'utilisation sur une seule histoire utilisateur, on pourrait tirer parti d'un diagramme des cas d'utilisation reprenant différents items du backlog de produit.

Liens :

dimanche 15 avril 2012

[Scrum] Casting du Product Owner


Dans un projet en mode Scrum, un bon PO, hors la définition du rôle et les aptitudes requises, doit tendre à satisfaire quelques critères que voici :
  1. Être un visionnaire : Le PO porte le projet, c'est-à-dire que sa contribution devrait aider le projet à devenir un succès et guider l'équipe vers les objectifs à atteindre. Pour cela, il se sent directement concerné par la réussite ou l'échec du projet. En cas de difficultés rencontrées, il devrait agir et prendre des décisions qui relèvent de son périmètre. C'est donc l'opposition entre engagement et implication qui revient : "Engagé, je me sens concerné et je réagis ; alors qu'impliqué seulement, je me contente d'observer."
  2. Maîtriser les aspects financiers du projet : Le PO connait bien les aspects financiers du projet, et devrait être capable de prioriser entre délai, périmètre et coûts. Par exemple, si le délai et le périmètre sont fortement contraints tandis que le budget est plus souple, l'équipe pourrait avoir besoin de faire intervenir ou de consulter des experts ponctuellement pour asseoir ou parvenir à une dynamique gagnante.
  3. Voir Scrum aussi comme un état d'esprit, pas simplement comme une méthode alternative, en adhérant aux valeurs et aux principes véhiculés par l'Agilité.
Liens :