Description

Méthodes Agiles, ingénierie et test logiciel

Durée : 28 heures
Modalités techniques d’évaluation : Évaluation des connaissances par QCM, évaluation des compétences au travers de travaux pratiques et de cas d’études. Contrôle de l’acquisition des connaissances et des compétences pendant la formation par le formateur.
Moyens pédagogiques : Apports théoriques réalisés en classe et complétés par de nombreux travaux pratiques permettent aux participants de disposer d’une expérience concrète. A l’issue des sessions magistrales, réalisation de cas d’études tutorés.

Objectifs :

  • Comprendre la philosophie et les règles d’ingénierie logicielle en agile
  • Mettre en œuvre des tests unitaires avec un framework de test
  • Implémenter une solution en Test Driven Development en Java
  • Appliquer des techniques pour refactorer un code à risque
  • Utiliser des doubles de tests pour simuler un comportement
  • Automatiser un scénario de tests fonctionnels

Programme:

Introduction

  • Pratiques d’ingénierie logicielle et méthodes Agiles.
  • Le développement incrémental et itératif.
  • L’équipe Agile. Scrum et XP.

Réflexion collective
Partage d’expérience et échanges autour des pratiques d’ingénierie et de test logiciel.

Les tests agiles

  • Définition et périmètre des tests agiles.
  • Cycle de développement : origine du TDD (Test Driven Development), ATDD, TDR, les types de tests…

Les tests développeurs

  • Définition et objectifs : les patterns basiques XUnit.
  • Principe des tests unitaires automatisés.
  • Règles de simplicité : règle des « 3 A » (Arrange, Act, Assert).
  • Mise en œuvre de tests unitaires avec JUnit, le framework de test en Java.
  • Lanceur de tests (TestRunner).
  • Les méthodes d’Assertions.

Le TDD, développement guidé par les tests

  • Le cycle de développement.
  • Le principe du TDD : « test first », « tester, coder, refactorer ».
  • TDD et pratiques agiles (XP) : l’intégration continue, le Pair Programming.
  • Démonstration du TDD sur un cas concret.

Etude de cas
Implémentation d’une solution en TDD, écriture des tests Junit.

« Refactoring », le remaniement de code

  • Principes du refactoring.
  • Réduire l’apparition de la dette technique, rendre le code compréhensible.
  • Comment identifier le code à risque ? La notion de « Code Smells », signes de danger potentiel.
  • Les principales opérations de refactoring.
  • Rappel sur les Design Patterns.

Travaux pratiques
Refactoring de code à risque.

Isolation des tests

  • Les doubles de test, leur utilisation.
  • Le « Mock Object » pour vérifier certaines hypothèses.
  • Le « Fake », pour la simulation.
  • Le « Stub » : fournir une réponse prédéfinie à un appel.

Travaux pratiques
Utilisation de double de tests.

Le test comme cahier des charges, la notion d’ATDD

  • Les principes et avantages de l’ATDD.
  • Du scénario au test de recette.
  • Combiner ATDD, BDD et TDD.
  • Les outils (Fitnesse, Cucumber…).

Etude de cas
Rédaction et automatisation de scénarios de tests.