TDD (Test Driven Developement) et refactoring

TDD et Refactoring

Walid
Skouri

Plan
• Introduction
• L’eXtreme Programming
• Les bases du TDD
• Les tests unitaires
• Le refactoring

Introduction
• Introduction
• L’eXtreme Programming
• Les bases du TDD
• Le refactoring

Introduction
• Les démarches traditionnelles

– spécification > conception > réalisation > validation

– Concentre la plupart des décision au début d’un projet

– Les client réalisent que leurs besoins ont changé

Introduction
Accepter ce changment
• C’est une composante incontournable de
tout projet

• Approche XP

XP
L’idée

• Réduction significative de la durée du cycle
de développement:
– Réduction du temps entre :
• L’implémentation d’une fonctionnalité
• Mise en production d’une nouvelle version du logiciel

XP
Comment
• On ne fait de conception que pour les fonctionnalités
existantes, pas pour les fonctionnalités futures:
– On ne fait de généralisations dans la conception que lorsque
des besoins concrets se font sentir.
– On n'introduit pas d'optimisations si elles ne sont pas
demandées par le client.
• Priorité :
– Travail actuel bien fait : Code testé, simple, lisible et sans
duplication

XP
Principaux éléments de fonctionnement de XP

• Cycles itératifs pilotés par le client : Le projet progresse au rythme d'itérations
très courtes, dont le contenu fonctionnel est déterminé par le client.
• Travail d'équipe auto-organisé : L'équipe travaille réellement... en équipe. Les
développeurs organisent eux-mêmes leur travail, interviennent sur l'ensemble du
code, travaillent systématiquement en binômes, et synchronisent leurs
développements plusieurs fois par jour.
• Programmation pilotée par les tests : les développeurs écrivent des test
automatiques pour chaque portion de code qu'ils conçoivent, et ils s'appuient sur
ces tests pour affiner et améliorer sans cesse la conception de l'application sans
craindre de régression.

XP
Le coût des changements

Traditionnel

Coût des
changement
s

XP

Temps

XP
Les valeurs de XP
• Communication : XP favorise le contact humain, la communication directe, plutôt que le cloisonnement
des activités et les échanges de courriers électroniques ou de documents formels. Les développeurs
travaillent directement avec la maîtrise d'ouvrage, les testeurs sont intégrés à l'équipe de développement,
etc.

• Feedback : qu'il s'agisse d'itérations courtes, de livraisons fréquentes, de travail en binômes ou de tests
automatiques exécutés en permanence, la plupart des pratiques XP sont conçues pour donner un
maximum de feedback sur le déroulement du projet afin de corriger la trajectoire au plus tôt. En particulier,
les points de début d'itération offrent à l'équipe le moyen de prendre du recul sur son fonctionnement et de
l'améliorer sans cesse au fil des itérations.

• Simplicité : XP relève le défi suivant : « que pouvons-nous arrêter de faire tout en continuant à créer
efficacement un logiciel qui réponde aux besoins réels du client ? ». Cette recherche de simplification
touche le processus lui-même, mais aussi l'outil fabriqué (la mécanique de planification incite le client à
focaliser les efforts sur les fonctions prioritaires) ou encore la conception de l'application (guidée par un
principe de « You ain't gonna need it »).

Les bases du TDD
Tests au début du développement

Ecriture des Ecriture du
tests code
Tests
Commencer Fini
échoués

Les bases du TDD
Développements pilotés par les tests

Code Tests
propre échoués

Refactoring

Tous les
tests
réussis

Les bases du TDD
Recommandations

• Ne jamais écrire de code sans avoir de
tests qui échouent
• Les tests doivent être représentatifs des
spécifications

Les tests unitaires
• Il permettent

– De contrôler et conserver la qualité du produit tout
au long du projet
– De se focaliser sur l’amélioration du code, plutôt
que sur les bugs
– D’améliorer la productivité de l’équipe en
automatisant un maximum de tâches redondantes
et ennuyantes

Les tests unitaires
Testabilité du code

• Privilégier la composition à l’héritage
• Isoler les dépendances
• Injecter les dépendances

Les tests unitaires
• Privilégier la composition à l’héritage

Héritage Composition
class Fruit { class Fruit {
//... } //... }
class Apple extends Fruit { class Apple {
//... } private Fruit fruit = new Fruit(); //... }

– L’héritage permet à la sous classe d’heriter toutes les fonctionnalité
– La composition permet une solution plus flexible et réutilisable
– Exemple: Permet d’instancier le l’objet composite avec différentes implémentations

Les tests unitaires

Injection de dépendance
• Se rapporte à la fourniture d'une dépendance
externe à un composant logiciel.
• Formes d’injection de dépendance
– interface injection
– setter injection
– constructor injection

Les tests unitaires

Injection du constructeur
public class ImportantClass { public class ImportantClass {
IFoo foo; IFoo foo;
public ImportantClass() public ImportantClass(IFoo foo) {
{ this.foo = foo;
this.foo = new }
EnterpriseFoo();
void doReallyImportantStuff() {
}
this.foo.bar();
void doReallyImportantStuff() {
this.foo.bar(); }
} }
}

Refactoring
C’est quoi?

• C’est une technique de restructuration du
code existant: modifier sa structure sans
changer son comportement externe

• Ensemble de petites modifications dans le
but d’améliorer le code

Refactoring
C’est quoi?

• Chaque transformation (ou Refactoring) ne
modifie qu’une petite partie du code mais un
ensemble de transformations peut produire un
changement significatif

• Le système se doit de toujours fonctionner suite
à chaque refactoring. Eviter les régressions.

Refactoring
Pourquoi?

• Améliorer la structure du logiciel

• Rendre le code plus lisible et maintenable

• Faciliter les futurs changements

• Plus de flexibilité

• Augmenter la réutilisabilité

• Faciliter la recherche de bugs

Refactoring
Quand?

• Code dupliqué

• Longues méthodes

• Longues liste de paramètres

• Nommage inapproprié

TDD (Test Driven Developement) et refactoring

Contenu connexe

Tendances (20)

Similaire à TDD (Test Driven Developement) et refactoring (20)

Plus de neuros (20)

TDD (Test Driven Developement) et refactoring