Annotations Mockito de base

2.1 Annotation @Mock

Il existe deux façons de travailler avec des objets fictifs dans Mockito. La première consiste à créer un objet entièrement virtuel , la seconde consiste à envelopper un objet existant dans un wrapper. Commençons par le premier.

Pour créer un objet entièrement virtuel, vous devez écrire le code :

ClassName variable name = Mockito.mock(ClassName.class);

Créons une classe ArrayList factice à titre d'exemple :

@ExtendWith(MockitoExtension.class)
class MockTest {
    @Test
    public void whenNotUseMockAnnotation_thenCorrect() {
        List mockList = Mockito.mock(ArrayList.class);
        //these methods won't do anything - they are stubs
        mockList.add("one");
        mockList.add("two");
    }
}

Dans cet exemple, nous créons une fausse ArrayList et stockons une référence à celle-ci dans la variable mockList. Les méthodes de cet objet ne font rien.

Soit dit en passant, ce code peut être écrit encore plus court, car il existe une annotation spéciale pour cela @Mock.

@ExtendWith(MockitoExtension.class)
class MockTest {
    @Mock
    List mockList;

    @Test
    public void whenNotUseMockAnnotation_thenCorrect() {
        //these methods won't do anything - they are stubs
        mockList.add("one");
        mockList.add("two");
    }
}

Dans le second cas, MockitoExtensionil analysera le code de classe lui-même et créera les stubs nécessaires. Vous n'avez pas besoin d'appeler la méthode Mockito.mock(). Une annotation et l'objet virtuel est prêt. Beauté.

2.2 Annotation @Espion

Le deuxième type d'objets important dans Mockito sont des wrappers sur des objets existants. Ils permettent, d'une part, d'utiliser des classes existantes, et d'autre part, d'intercepter les appels à toutes les méthodes et variables de tels objets : pour corriger leur travail si nécessaire. Ils sont utilisés aussi souvent que les objets Mock.

Pour créer un wrapper sur un objet, vous devez écrire le code :

ClassName variable name = Mockito.spy(an object);

Un exemple avec un wrapper autour de la classe ArrayList :

@ExtendWith(MockitoExtension.class)
class SpyTest {
    @Test
    public void whenMockAnnotation() {
        List<String> mockList = Mockito.spy(new ArrayList<String>());
        //these methods will work!
        mockList.add("one");
        mockList.add("two");
    }
}

Dans sa forme la plus simple, un appel à un objet wrapper redirige simplement les appels vers l'objet d'origine, la référence à laquelle il garde à l'intérieur de lui-même . Tout fonctionnera comme avec l'objet d'origine.

Vous pouvez également créer un wrapper en utilisant l'annotation - @Spy.

@ExtendWith(MockitoExtension.class)
class SpyTest {
    @Spy
    List mockList = new ArrayList<String>();

    @Test
    public void whenMockAnnotation() {
        // these methods will work!
        mockList.add("one");
        mockList.add("two");
    }
}

Ces deux exemples de code sont équivalents.