This is an old revision of the document!
Table of Contents
Tests d'intégration et conception en autonomie
Ce TD vise
- à vous apprendre à mettre en place des tests d'intégration
- à concevoir une petite application à plusieurs en prévoyant les tests d'intégration.
- Soyez itératif, faîtes en sorte de toujours avoir un code qui tourne.
- Ne trainez pas non plus !
Partie 1 : Tutoriel EasyMock (1h grand maximum)
Si vous dépassez le temps passez à la suite et revenez dessus plus tard. L'énoncé suivant est issu du “getting started” de easyMock mis à jour pour travailler avec junit 5 et voir un peu plus de choses.
- Voici le .jar dont vous avez besoin pour avoir accès à l'environnement EasyMock.
- Voici l'interface dont dépendent vos codes, mais que vous ne devez pas implémenter.
public interface Collaborator { // if the document already exists, a "AlreadyAdded" exception is thrown. // if the document fails to be added, false is return. public boolean documentAdded(String title) throws AlreadyAdded ; public void documentRemoved(String title) ; }
Et l'exception associée :
public class AlreadyAdded extends Exception { }
- Voici vos codes (donc vous pouvez bien sûr les modifier si vous le voulez) et donc il s'agit bien de la classe à tester
public class ClassTested { public static final String COPY = "_copy"; private Collaborator listener; private HashMap<String, String> documents = new HashMap<>(); public void setListener(Collaborator listener) { this.listener = listener; } public void addDocument(String title, String document) { try { if (listener.documentAdded(title) ) documents.put(title, document); } catch (AlreadyAdded e) { documents.put(title+COPY, document); } } public void removeDocument(String title) { listener.documentRemoved(title); } public Collaborator getListener() { return listener; } public boolean isContained(String key) { return documents.containsKey(key); } }
- Voici un début de tests.
- Remarquez la construction du mock (5.a)
import static org.easymock.EasyMock.*; import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; import org.easymock.EasyMockSupport; import org.easymock.Mock; import org.easymock.TestSubject; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; public class ExampleTest extends EasyMockSupport { @TestSubject private ClassTested classUnderTest = new ClassTested(); // 2 @Mock private Collaborator mock; // 1 @BeforeEach public void setUp() { //5.a mock = mock(Collaborator.class); classUnderTest = new ClassTested(); classUnderTest.setListener(mock); }
- Vous pouvez l'exécuter il ne se passe rien (il n'y a aucun test
)
- Ajoutez un test.
@Test public void testRemoveNonExistingDocument() { // This call should not lead to any notification // of the Mock Object replay(mock); // 6.b classUnderTest.removeDocument("Does not exist"); }
- Il échoue en effet on enregistre (6.b) que le mock ne reçoit aucun message alors que là il a reçu un message. Vous devrez donc avoir l'erreur suivante
java.lang.AssertionError: Unexpected method call Collaborator.documentRemoved("Does not exist"):...
- Ajoutez un test, cette fois-ci juste :
- On déclare le message que doit recevoir le mock (7.a)
- On enregistre (7.b)
- On lance le test sur notre code (7.c)
- On explicite la vérification (réalisée par défaut) (7.d)
@Test public void testRemoveNonExistingDocument2() { mock.documentRemoved("Does not exist"); //7.a replay(mock); //7.b classUnderTest.removeDocument("Does not exist"); //7.c verify(mock); //7.d }
- Ajoutez un test, mais cette fois-ci nous explicitons la valeur de retour attendue et nous créons deux mocks pour nous assurer qu'il n'y a pas d'effets secondaires
@Test public void testAddDocument() throws AlreadyAdded { //Initialisation Collaborator firstCollaborator = mock(Collaborator.class);//construction de mock Collaborator secondCollaborator = mock(Collaborator.class);//construction de mock, il ne sera pas utilisé classUnderTest.setListener(firstCollaborator); //// expect document addition expect(firstCollaborator.documentAdded("New Document")).andReturn(true); //On attend que le mock réponde True ! replayAll(); //on enregistre le comportement de tous les Mocks classUnderTest.addDocument("New Document", "content"); assertTrue(classUnderTest.isContained("New Document")); //on vérifie que NOS codes se comportent correctement verifyAll(); //On vérifie le comportement de tous les mocks }
- Ajoutez un test, mais cette fois-ci nous attendons pour valeur de retour false
@Test public void testFailingAddDocument() throws AlreadyAdded { //Initialisation Collaborator firstCollaborator = mock(Collaborator.class); Collaborator secondCollaborator = mock(Collaborator.class); classUnderTest.setListener(firstCollaborator); //// expect document addition expect(firstCollaborator.documentAdded("New Document")).andReturn(false); replayAll(); classUnderTest.addDocument("New Document", "content"); assertFalse(classUnderTest.isContained("New Document")); verifyAll(); }
- et enfin nous testons une levée d'exception
@Test public void testDuplicationWhenAddingDocument() throws AlreadyAdded { //Initialisation Collaborator firstCollaborator = mock(Collaborator.class); Collaborator secondCollaborator = mock(Collaborator.class); classUnderTest.setListener(firstCollaborator); //// expect document addition expect(firstCollaborator.documentAdded("New Document")).andThrow(new AlreadyAdded()); replayAll(); classUnderTest.addDocument("New Document", "content"); assertTrue(classUnderTest.isContained("New Document"+ClassTested.COPY)); verifyAll(); }
Cela conclut la partie tutorielle. A présent, vous devriez savoir créer vous même des tests d'intégration.
Partie 2 : Un jeu de Quizz
Vous devez réaliser en groupe de X étudiants un jeu de quizz dont voici la spécification.
Spécification
- V0 : Version de base
- En tant que joueur, je veux répondre à une question du quizz
- Si j'ai la bonne réponse je gagne 1pt
- Si je n'ai pas la bonne réponse, la bonne réponse m'est donnée.
- La vérification de la réponse ne dépend pas des minuscules ou majuscules
- ex :
- “Quelle est la capitale de la France”, je réponds PARIS, le jeu me félicite et m'annonce que j'ai gagné 1 pt
- “Quelle est la capitale de l'Espagne”, je réponds madrid … j'ai gagné 1 pt
- “Quelle est la capitale de l'Érythrée”, je réponds Assab, le jeu m'annonce que la bonne réponse est Asmara, je n'ai pas gagné de points
- En tant que joueur, je veux jouer une partie de quizz, de façon à m'amuser en vérifiant mes connaissances.
Modélisation
Exigences
Un groupe a proposé l'an dernier les interfaces suivantes.
public interface GameInterface { void startGame(); boolean isNotOver(); String nextQuestion(); boolean setCurrentUserAnswer(String answer); String getRightAnswer(); int getPoints(); }
public interface QuizInterface { public String getQuestion(int currentQuestionNumber) ; public boolean isGoodAnswer(int currentQuestionNumber, String answer); public String getAnswer(int currentQuestionNumber); public int size(); public void addQuestion(QuestionInterface q1); }
public interface QuestionInterface { String getAnswer(); String getQuestion(); boolean isGoodAnswer(String answer); }
Voici un code pour tester un jeu.
package quizzPK; import java.util.Scanner; public class mainTestGame { public static void main(String[] args) { Scanner sc = new Scanner(System.in); QuizInterface quiz = new Quiz(); QuestionInterface q1 = new Question("Capitale de la France ?", "Paris"); QuestionInterface q2 = new Question("Capitale de l'Allemagne ?", "Berlin"); QuestionInterface q3 = new Question("Capitale de l'Italie", "Rome"); quiz.addQuestion(q1); quiz.addQuestion(q2); quiz.addQuestion(q3); GameInterface game = new Game(quiz); game.startGame(); while (game.isNotOver()) { System.out.println(game.nextQuestion() + " : ") ; String answer = sc.nextLine(); boolean valid = game.setCurrentUserAnswer(answer); if (!valid ) { System.out.println("You failed, the correct answer is : " + game.getRightAnswer() ); } else System.out.println("Well done ! "); } System.out.println("Score : " + game.getPoints()); } }
A Faire
- Modélisez par groupe de 2 ou 3 étudiants, le jeu
- En particulier, intéressez-vous aux interactions entre les classes.
- Une fois que vous êtes d'accord, vous passez à la suite
- Développez séparément
- Etudiant 1 : Développez la classe
Game
sans développer la classeQuiz
.- Tester votre classe
Game
en utilisant des Mocks.
- Etudiant 2 : Développez la classe
Quizz
sans développer la classeQuestion
.- Tester votre classe
Quizz
en utilisant des Mocks
- Intégrez vos codes.
L'essentiel n'est pas d'atteindre cette ultime étape. Mais davantage d'apprendre à écrire des tests d'intégration.
A faire
- Conception : V0 (Environ 1/2 heure intense)
- Conseils
- Concevez l'application V0 à deux (i.e. UC, Classes, un diagramme de séquence pour analyser le déroulement d'une partie est conseillé, MAIS ne faîtes que ce qui vous paraît vraiment utile)
- Partagez le travail à réaliser
- Prévoyez les tests à réaliser pour chacune des histoires, vous pouvez même faire du TDD
- Enrichissez les histoires si besoin pour être sûrs de savoir les tester.
Sauvegardez une copie de votre conception quelle qu'elle soit : photo ou autre. Vous utiliserez cette conception pour faire le point à la fin entre votre travail initial et la réalisation. Vous ne serez pas noté dessus, vous devez apprendre à vous évaluer.
- Vous pouvez à partir de là choisir de focaliser sur une histoire ou de traiter plusieurs histoires en même temps.
- Développement : V0
- Développez le jeu en testant chacun individuellement vos classes et en utilisant les mocks pour les interactions.
- Intégration : V0
- Mettez vos codes en commun
- Testez une histoire et vérifier que vous pouvez dire qu'elle est terminée, c'est à dire que tous les tests passent.
- Faîtes les tests sur toutes les histoires, soyez itératif.
Faîtes une copie de votre architecture;
- vous la comparerez avec la précédente et la suivante. Il s'agit ici pour vous de
- déterminer si vous aviez fait des erreurs ou des incomplétudes,
- déterminer si vous saurez faire mieux la prochaine fois ou non, qu'avez-vous appris éventuellement?
- identifier les points que vous aimeriez améliorer (liste des TODO dans le code, le modèle, l'architecture).
- V1 : Choisissez une extension, complétez éventuellement les histoires et allez jusqu'au code correspondant.
reprendre la question précédente.
- Si vous êtes ici et que vous en avez envie ajoutez une autre extension.
Quelques trucs utiles
Pour Interroger vous pouvez utiliser:
import javax.swing.JOptionPane; .... String m = JOptionPane.showInputDialog("Anyone there?"); System.out.println(m); // juste pour expliquer ici JOptionPane.showMessageDialog(null, "A oui, il y a quelqu'un");
A RENDRE
- Document
- faisant état de vos réponses aux points
; les derniers modèles seront considérés pour l'évaluation de l'architecture.
- d'une image de la couverture de tests finale
- Précisez les extensions réalisées.
- Des codes et tests associés.
Rendus au plus tard le lundi 19 novembre à 18h45 sous http://jalon.unice.fr/cours/blay/Cours-blay-20150930110548/BoiteDepot-blay-20181113101132476393?mode_etudiant=true&tab=deposit
Voici le document qui sera utilisé pour l'évaluation (il peut encore changer) : https://goo.gl/forms/PmNPOPcurIKJLlo32