[JAVA] Changements dans Mockito 2

À propos des changements dans Mockito 2. Le contenu est destiné aux utilisateurs de Mockito 1.

À propos de la politique de publication

Politique de publication modifiée a été ajoutée le 2017/04. Auparavant, il était publié avec chaque correctif, mais maintenant, seules les versions importantes (essentiellement mises à jour des versions majeures / mineures) seront fournies par le référentiel central JCenter / Maven.

Changements depuis Mockito 1

Les principaux changements et fonctions supplémentaires sont décrits ci-dessous. Pour plus d'informations, voir Wiki, Notes de version /blob/release/2.x/doc/release-notes/official.md) et [Mockito's Javadoc](https://javadoc.io/page/org.mockito/mockito-core/latest/org/mockito/ Veuillez vérifier Mockito.html # 0).

Vous pouvez maintenant vous moquer des classes / méthodes finales

Mockito 1 requis Power Mock, mais à partir de Mockito 2, il est possible de se moquer de ceux-ci en activant le fabricant de simulation en ligne. .. La classe de Kotlin, qui est finalement spécifiée par défaut, utilise également plug-in kotlin-allopen. Vous pouvez vous moquer sans l'utiliser.

Pour activer cette fonctionnalité, préparez le fichier MockMaker suivant dans le répertoire des ressources de test.

text:app/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

mock-maker-inline

Vous pouvez également spécifier l'artefact mockito-inline au lieu de mockito-core.

build.gradle

dependencies {
    //testCompile "org.mockito:mockito-core:+"
    testCompile "org.mockito:mockito-inline:+"
}

Cependant, cet artefact est transitoire jusqu'à ce que la fonctionnalité devienne la valeur par défaut et peut être supprimée ultérieurement.

Cette fonctionnalité est fournie par un fabricant de simulation appelé InlineByteBuddyMockMaker, mais pour cette classe [@ Incubating](https://javadoc.io/page/org.mockito/mockito-core/latest/org/mockito/Incubating .html) Annoté. L'annotation @ Incubating est ajoutée à la nouvelle API et indique que nous attendons les commentaires des utilisateurs. Veuillez noter que l'API peut changer (même si je pense que c'est rare) en fonction des commentaires.

Notez que la moquerie des méthodes statiques et des constructeurs n'est pas prise en charge, donc si vous voulez vous moquer d'eux, vous aurez toujours besoin de PowerMock.

Une bibliothèque pour les appareils Android a été préparée

Auparavant, il fallait Dexmaker, mais Mockito 2.6 fournit désormais une bibliothèque pour les appareils Android. Vous pouvez utiliser Mockito sur votre appareil Android en spécifiant mockito-android comme bibliothèque de portée androidTestCompile.

build.gradle

dependencies {
    androidTestCompile "org.mockito:mockito-android:+"
}

mockito-android vous permet de simuler des classes privées de package qui n'étaient pas possibles avec Dexmaker.

Notez que vous ne pouvez pas vous moquer des classes / méthodes finales avec cet artefact. (Le fabricant de maquette en ligne mentionné ci-dessus n'est pas non plus compatible avec Android) À ce sujet, bien que ce soit mon travail, nous fournissons une bibliothèque appelée DexOpener qui réalise la moquerie des classes / méthodes finales sur les terminaux Android. Veuillez l'essayer si vous le souhaitez.

ArgumentMatcher peut maintenant être écrit dans des expressions lambda

Dans Mockito 1, ArgumentMatcher était une classe abstraite. Maintenant que Mockito 2 est devenu une interface de type SAM, vous pouvez utiliser des expressions lambda avec ʻargThat (ArgumentMatcher) `.

any (Class) ne correspond plus à null

ʻAny () et ʻany (Class) ʻ sont maintenant des méthodes clairement distinctes. ʻAny () correspond à n'importe quel argument, y compris null, mais ʻany (Class)` ne correspond pas à null.

En outre, la classe dans laquelle ces méthodes sont définies a été modifiée de Matchers à ArgumentMatchers.

Le système anyXxx () ne correspond plus à null

Les matchers de séries AnyXxx () tels que ʻanyString () et ʻanyList () ne correspondent plus à null.

anyObject () / anyVararg () est obsolète

Mockito 2 utilise ʻany () `.

Ajouter nullable (classe)

Nullable (Class) a été ajouté comme méthode très similaire à ʻisA (Class) . nullable (Class)correspond à null ou à un argument du type spécifié, mais ʻisA (Class)ne correspond pas à null.

La classe fictive est maintenant annotée avec la classe cible

Par exemple, si la classe cible est

@Foo
class Bar { ... }

La classe fictive est également donnée «@ Foo».

Bar mock = mock(Bar.class);
assertTrue(mock.getClass().isAnnotationPresent(Foo.class));

La rigueur a été introduite

À partir de Mockito 2.3, la classe Strictness a été introduite.

--LENIENT (Mockito 1 par défaut, le plus lâche) --WARN (Mockito 2 par défaut) --STRICT_STUBS (Mockito 3 sera la valeur par défaut, le plus difficile)

Il existe trois modes, vous pouvez lever une exception sur la façon d'utiliser le simulacre et vous pouvez générer un message d'indication.

Aussi pour MockitoJUnitRunner

--MockitoJUnitRunner.Silent (équivalent à LENIENT) --MockitoJUnitRunner.Strict (équivalent à WARN, équivalent à MockitoJUnitRunner) --MockitoJUnitRunner.StrictStubs (équivalent à STRICT_STUBS)

Trois classes ont été ajoutées.

Un exemple d'utilisation est présenté ci-dessous.

public class MyTest {

    @Rule
    public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);

    @Mock
    Foo foo;

    @Test
    public void test() {
        when(foo.bar()).thenReturn("test");
    }

    class Foo {
        String bar() {
            return "";
        }
    }

}

La méthode test () ci-dessus n'utilise pas le jeu de simulation dans la clause when. L'exécution de ce test lève une exception UnnispensStubbingException.

Si vous remplacez STRICT_STUBS dans le code ci-dessus par WARN, aucune erreur ne se produira, mais le conseil suivant sera envoyé à la console.

[MockitoHint] MyTest.test (see javadoc for MockitoHint):
[MockitoHint] 1. Unused -> at com.example.MyTest.test(MyTest.java:22)

Si vous le changez en «LENIENT», aucune erreur ne se produira et aucun message ne sera émis.

L'équipe Mockito [Fortement recommandé] d'utiliser STRICT_STUBS (https://javadoc.io/page/org.mockito/mockito-core/latest/org/mockito/quality/Strictness.html#STRICT_STUBS" )est.

Veuillez noter que la classe Strictness est annotée avec @ Incubating.

Présentation de la session Mockito

À partir de Mockito 2.7, Mockito Session est fourni pour les environnements où MockitoJUnitRunner / MockitoRule ne peut pas être utilisé. Si vous utilisez MockitoAnnotations # initMocks (Object) pour générer la maquette, vous pouvez la remplacer par MockitoSession.

L'utilisation est indiquée ci-dessous.

private MockitoSession session;

@Before
public void setUp() {
    session = Mockito.mockitoSession().initMocks(this).startMocking();
}

@After
public void tearDown() {
    session.finishMocking();
}

Si vous faites ce qui précède, la vérification selon le mode de Strictness sera effectuée au moment de finishMocking ().

Utilisez la méthode strictness (Strictness) pour changer de Strictness.

session = Mockito.mockitoSession()
    .initMocks(this)
    .strictness(Strictness.WARN)
    .startMocking();

La valeur par défaut pour Strictness est STRICT_STUBS, qui est un mode plus strict que WARN dans MockitoJUnitRunner / MockitoRule.

Veuillez noter que MockitoSession est également annoté avec «@ Incubating».

c'est tout.