FAQ Tests Consultez toutes les FAQ

1
2
3
4
5
<dependency> 
    <groupId>org.mockito</groupId> 
    <artifactId>mockito-all</artifactId> 
    <version>X.X.X</version> 
</dependency>

1
2
import static org.mockito.Mockito.*; 
ClasseAMocker objetMock = mock(ClasseAMocker.class)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/** 
 * Class programmeVoiture 
 * La classe à tester unitairement 
 * @author ok.Idriss 
 */ 
public class ProgrammeVoiture(){ 
    // Objet persistance qui sera lié par le principe d'injection de dépendances 
    private IPersistanceModeleVoiture persistance; 
  
    /** Méthodes à tester */ 
  
    /** 
     * Rechercher une liste de modèles en fonction de la marque 
     * @param String marque 
     * @return List<ModeleVoiture> tous les modèles en base appartenant à cette marque 
     */ 
    public List<ModeleVoiture> rechercherVoitureParMarque(String marque){ 
        CritereRerchercheModeleVoiture citere = new CritereRerchercheModeleVoiture(); 
        critere.setMarqueModele(marque); 
        return persistance.searchModeleVoiture(critere); 
    } 
  
    /** 
     * Rechercher un modèle de voiture via son id en base 
     * @param Long id 
     * @return ModeleVoiture résultat correspondant à la recherche 
     */ 
    public ModeleVoiture rechercherVoitureParId(Long id){ 
        try { 
            return persistance.searchModeleVoitureById(id); 
        } catch (TooMuchResultException e){ 
            System.out.println(« Trop de résultats avec le même id, revoyez la structure de votre table ! »); 
            return null; 
        } 
    } 
  
    /** 
     * Enregistrer un modèle valorisé à partir d'un formulaire de création/modification 
     * Doit mettre à jour en base le modèle ou l'ajouter dans le cas ou il n'existe pas 
     * @param ModeleVoiture modele 
     */ 
    public boolean enregisterModeleVoiture(ModeleVoiture modele){ 
        try{ 
            if (null != modele.getId()){ 
                persistance.updateModeleVoiture(modele); 
            } else { 
                persistance.addModeleVoiture(modele); 
            } 
        } catch (ErreurPersistance e){ 
            System.out.println ("Erreur : " + e.getMessage); 
        } 
    } 
  
    /** Getters et setters */ 
    public IPersistanceModeleVoiture getPersistance() { 
        return persistance; 
    } 
  
    public void setPersistance(IPersistanceModeleVoiture persistance) { 
        this.persistance = persistance; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/** 
 * Objet persistant 
 * @author ok.Idriss 
 */ 
public class ModeleVoiture{ 
    private Long id; 
    private String libelle; 
    private String marque; 
    private Long nbKilometres; 
    private Long age; 
  
    /** Getters et setters */ 
  
    public Long getId() { 
        return id; 
    } 
    public void setId(Long id) { 
        this.id = id; 
    } 
    public String getLibelle() { 
        return libelle; 
    } 
    public void setLibelle(String libelle) { 
        this.libelle = libelle; 
    } 
    public String getMarque() { 
        return marque; 
    } 
    public void setMarque(String marque) { 
        this.marque = marque; 
    } 
    public Long getNbKilometres() { 
        return nbKilometres; 
    } 
    public void setNbKilometres(Long nbKilometres) { 
        this.nbKilometres = nbKilometres; 
    } 
    public Long getAge() { 
        return age; 
    } 
    public void setAge(Long age) { 
        this.age = age; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/** 
 * Interface IPersistanceModeleVoiture 
 * Signatures des méthodes permettant l'interaction des objets à persister et la base de données 
 * @author ok.Idriss 
 */ 
public interface IPersistanceModeleVoiture { 
    /** 
     * Rechercher une liste de modèles de voiture en base de données à partir de critères 
     * @param CritereRerchercheModeleVoiture critere de recherche 
     * @return List<ModeleVoiture> liste de résultats correspondant à la recherche 
     */ 
    public List<ModeleVoiture> searchModeleVoiture(CritereRerchercheModeleVoiture critere); 
  
    /** 
     * Rechercher un modèle de voiture via son id en base 
     * @param Long id 
     * @return ModeleVoiture résultat correspondant à la recherche 
     * @throws TooMuchResultException lorsque la recherche correspond à plusieurs résultats 
     */ 
    public ModeleVoiture searchModeleVoitureById(Long id) throws TooMuchResultException; 
  
    /** 
     * Persister une instance de ModeleVoiture en base de données 
     * @param ModeleVoiture modele instance à persister en base 
     * @return boolean true si l'insertion s'est bien passée sinon false 
     * @throws ErreurPersistance en cas d'erreur 
     */ 
    public boolean addModeleVoiture(ModeleVoiture modele) throws ErreurPersistance; 
  
    /** 
     * Mettre à jour une instance de ModeleVoiture en base de données 
     * @param ModeleVoiture modele instance à modifier en base 
     * @return boolean true si la mise à jour s'est bien passée sinon false 
     * @throws ErreurPersistance en cas d'erreur 
     */ 
    public boolean updateModeleVoiture(ModeleVoiture modele) throws ErreurPersistance; 
  
    /** 
     * Supprimer une instance de ModeleVoiture en base de données 
     * @param ModeleVoiture modele instance à supprimer en base 
     * @return boolean true si la suppression s'est bien passée sinon false 
     * @throws ErreurPersistance en cas d'erreur 
     */ 
    public boolean deleteModeleVoiture(ModeleVoiture modele) throws ErreurPersistance; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/** 
 * Class CritereRerchercheModeleVoiture 
 * Critères de recherche d'un modèle de voiture 
 * @author ok.Idriss 
 */ 
public class CritereRerchercheModeleVoiture{ 
    private String libelleModele; 
    private String marqueModele; 
  
    /** Getters et setters */ 
  
    public String getLibelleModele() { 
        return libelleModele; 
    } 
  
    public void setLibelleModele(String libelleModele) { 
        this.libelleModele = libelleModele; 
    } 
  
    public String getMarqueModele() { 
        return marqueModele; 
    } 
  
    public void setMarqueModele(String marqueModele) { 
        this.marqueModele = marqueModele; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import org.junit.Before;  
import static org.mockito.Mockito.*; 
  
/** 
 * Class ProgrammeVoitureTest 
 * Tests unitaires de la classe ProgrammeVoiture 
 * @author ok.Idriss 
 */ 
public class ProgrammeVoitureTest(){ 
    private ProgrammeVoiture programme; 
    private IPersistanceModeleVoiture persistanceMock; 
  
    /** 
     * Création du mock de la persistance et injection dans l'instance de la classe à tester 
     * @throws Exception 
     */ 
    @Before  
    public void setUp() throws Exception {  
        programme = new ProgrammeVoiture(); 
  
        // Création du mock 
        persistanceMock = mock(IPersistanceModeleVoiture.class); 
  
        // Injection du mock en lieu et place d'une réelle implémentation de IPersistanceModeleVoiture 
        programme.setPersistance(persistanceMock); 
    } 
}

1
2
3
4
5
6
import static org.mockito.Mockito.*;  
import static org.mockito.Matchers.*; 
  
when(objetMock.methode(any(ClassArgument.class))).thenReturn(objetResultat); 
when(objetMock.methode(eq(valeurArgument))).thenReturn(objetResultat); 
when(objetMock.methode(valeurArgument)).thenReturn(objetResultat);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import org.junit.Before;   
import org.junit.Test;   
  
import static org.junit.Assert.*; 
import static org.mockito.Mockito.*;  
import static org.mockito.Matchers.*; 
  
/**  
 * Class ProgrammeVoitureTest  
 * Tests unitaires de la classe ProgrammeVoiture  
 * @author ok.Idriss  
 */  
public class ProgrammeVoitureTest(){  
    private ProgrammeVoiture programme;  
    private IPersistanceModeleVoiture persistanceMock;  
  
    /** Jeu de données */ 
    private ModeleVoiture modeleTest; 
    Long idExistant = 1L; 
    Long idInexistant = 2L; 
    String libelleTest = "Clio"; 
    String marqueTest = "Renault"; 
    List<ModeleVoiture> listTest; 
  
    /**  
     * Création du mock de la persistance et injection dans l'instance de la classe à tester  
     * @throws Exception  
     */  
    @Before   
    public void setUp() throws Exception {   
        programme = new ProgrammeVoiture();  
  
        // Création du mock  
        persistanceMock = mock(IPersistanceModeleVoiture.class);  
  
        // Injection du mock en lieu et place d'une réelle implémentation de IPersistanceModeleVoiture  
        programme.setPersistance(persistanceMock);  
  
        // Initialisation du jeu de données 
        modeleTest = new ModeleVoiture(); 
        modele.setMarque(marqueTest); 
        modele.setLibelle(libelleTest); 
        modele.setId(idExistant); 
        listTest.add(modeleTest); 
    }  
  
    @Test 
    public final void testRechercherVoitureParId(){ 
        // Lorsque l'on appelera la méthode searchModeleVoitureById avec comme paramètre "1", le mock retournera modeleTest 
        when(persistanceMock.searchModeleVoitureById(idExistant)).thenReturn(modeleTest); 
  
        // l'id existe en base (tel qu'est défini le mock) 
        // on vérifie qu'on renvoie bien le résultat retourné par la persistance 
        ModeleVoiture result = programme.rechercherVoitureParId(idExistant); 
        assertNotNull(result); 
        assertEquals(idExistant, result.getId()); 
        assertEquals(libelleTest, result.getLibelle()); 
        assertEquals(marqueTest, result.getMarque()); 
  
        // L'id n'existe pas en base 
        // on vérifie que l'on renvoie bien null dans ce cas-là 
        result = programme.rechercherVoitureParId(idInexistant); 
        assertNull(result); 
    } 
  
    @Test 
    public final void testRechercherVoitureParMarque(){ 
        // Renverra toujours le même résultat 
        // Le matcher any() contrairement au matcher eq() (utilisé implicitement dans le test du dessus) 
        // permet de renvoyer le résultat quelque soit l'instance de la classe spécifiée en paramètre 
        when(persistanceMock.searchModeleVoiture(any(CritereRerchercheModeleVoiture.class))).thenReturn(listTest); 
  
        List<ModeleVoiture> lstResult = programme.rechercherVoitureParMarque("Renault"); 
        assertNotNull(lstResult); 
        assertFalse(lstResult.isEmpty()); 
  
        // Ici aussi on aura malgré tout un résultat 
        lstResult = programme.rechercherVoitureParMarque("Peugeot"); 
        assertNotNull(lstResult); 
        assertFalse(lstResult.isEmpty()); 
    } 
}

1
2
3
4
5
6
import static org.mockito.Mockito.*;   
import static org.mockito.Matchers.*;  
  
verify(objetMock).methode(valeurArgument); 
verify(objetMock).methode(eq(valeurArgument)); 
verify(objetMock).methode(any(ClassArgument.class));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import org.junit.Before;   
import org.junit.Test; 
import static org.mockito.Mockito.*;  
  
/**  
 * Class ProgrammeVoitureTest  
 * Tests unitaires de la classe ProgrammeVoiture  
 * @author ok.Idriss  
 */  
public class ProgrammeVoitureTest(){  
    private ProgrammeVoiture programme;  
    private IPersistanceModeleVoiture persistanceMock;  
  
    /**  
     * Création du mock de la persistance et injection dans l'instance de la classe à tester  
     * @throws Exception  
     */  
    @Before   
    public void setUp() throws Exception {   
        programme = new ProgrammeVoiture();  
  
        // Création du mock  
        persistanceMock = mock(IPersistanceModeleVoiture.class);  
  
        // Injection du mock en lieu et place d'une réelle implémentation de IPersistanceModeleVoiture  
        programme.setPersistance(persistanceMock);  
    }  
  
    @Test 
    public final void testEnregisterModeleVoiture_Creation(){ 
    	// Instance sans id 
    	ModeleVoiture modele = new ModeleVoiture(); 
    	modele.setLibelle("libelle test"); 
  
    	programme.enregisterModeleVoiture(modele); 
  
    	// assertion => on a bien appelé la méthode addModeleVoiture avec comme paramètre modele 
    	verify(persistanceMock).addModeleVoiture(modele); 
    } 
  
    @Test 
    public final void testEnregisterModeleVoiture_Modification(){ 
    	// Instance avec id 
    	ModeleVoiture modele = new ModeleVoiture(); 
    	modele.setLibelle("libelle test"); 
    	modele.setId(1L); 
  
    	programme.enregisterModeleVoiture(modele); 
  
    	// assertion => on a bien appelé la méthode updateModeleVoiture avec comme paramètre modele 
    	verify(persistanceMock).updateModeleVoiture(modele); 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
@RunWith(MockitoJUnitRunner.class) 
public class MaClasseDeTest{ 
    @Mock 
    ObjetMock mock; 
  
    @Spy 
    ObjetSpy spy; 
  
    @Captor 
    ArgumentCaptor<ArgumentAVerifier> captor; 
}

1
2
3
ObjetMock mock = mock(ObjetMock.class); 
ObjetSpy = spy(ObjetSpy.class); 
ArgumentCaptor<ArgumentAVerifier> captor = ArgumentCaptor.forClass(ArgumentAVerifier.class);

MockitoAnnotations.initMocks(this);

1
2
3
4
5
6
7
8
9
import org.mockito.ArgumentCaptor; 
import static org.mockito.Mockito.*; 
import static org.mockito.Matchers.*; 
  
ArgumentCaptor<ObjetParametreAVerifier> captor = ArgumentCaptor.forClass(ObjetParametreAVerifier.class); 
verify(ObjetMock).methodeAVerifier(eq(valeur), captor.capture()); 
  
ObjetParametreAVerifier objetAVerifier = captor.getValue(); 
// assertions sur les méthodes de objetAVerifier

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
import org.junit.Before;   
import org.junit.Test; 
import static org.mockito.Mockito.*;  
import static org.mockito.Matchers.*; 
import org.mockito.ArgumentCaptor; 
  
/**  
 * Class ProgrammeVoitureTest  
 * Tests unitaires de la classe ProgrammeVoiture  
 * @author ok.Idriss  
 */  
public class ProgrammeVoitureTest(){  
    private ProgrammeVoiture programme;  
    private IPersistanceModeleVoiture persistanceMock;  
  
    /**  
     * Création du mock de la persistance et injection dans l'instance de la classe à tester  
     * @throws Exception  
     */  
    @Before   
    public void setUp() throws Exception {   
        programme = new ProgrammeVoiture();  
  
        // Création du mock  
        persistanceMock = mock(IPersistanceModeleVoiture.class);  
  
        // Injection du mock en lieu et place d'une réelle implémentation de IPersistanceModeleVoiture  
        programme.setPersistance(persistanceMock);  
    }  
  
    @Test 
    public final void testEnregisterModeleVoiture_Creation(){ 
        // Captor 
        ArgumentCaptor<ModeleVoiture> captor = ArgumentCaptor.forClass(ModeleVoiture .class);  
  
    	// Instance sans id 
    	ModeleVoiture modele = new ModeleVoiture(); 
    	modele.setLibelle("libelle test"); 
  
    	programme.enregisterModeleVoiture(modele); 
  
    	// assertions 
    	verify(persistanceMock).addModeleVoiture(captor); 
        assertEquals("libelle test", captor.getValue().getLibelle()); 
    } 
  
    @Test 
    public final void testEnregisterModeleVoiture_Modification(){ 
        // Captor 
        ArgumentCaptor<ModeleVoiture> captor = ArgumentCaptor.forClass(ModeleVoiture .class);  
  
    	// Instance avec id 
    	ModeleVoiture modele = new ModeleVoiture(); 
    	modele.setLibelle("libelle test"); 
    	modele.setId(1L); 
  
    	programme.enregisterModeleVoiture(modele); 
  
    	// assertions 
    	verify(persistanceMock).updateModeleVoiture(captor); 
        assertEquals("libelle test", captor.getValue().getLibelle()); 
    } 
}

1
2
@Captor 
ArgumentCaptor<List<String>> captor;

1
2
3
import static org.mockito.Mockito.*;  
  
ObjetSpy spy = spy(ObjetSpy.class);

1
2
3
4
5
6
7
8
9
10
11
12
@RunWith(MockitoJUnitRunner.class)  
public class MyControllerTest {  
    @Mock  
    MyService serviceMock;  
  
    // Injection de dépendances : la classe MyController qui a un attribut de type « MyService » va être instanciée automatiquement avec comme instance de « MyService » le mock au-dessus 
    @InjectMocks 
    @Spy // on peut aussi déclarer le controller comme Spy pour faire des asserts dessus 
    MyController controller; 
  
    // ... 
}