Mockito 2 - LyonJug - 2017-01-26

Brice Dutheil
LyonJUG
2017-01-26

View Slide

Qui suis-je ?
Back to basics
Mockito 2
Nouvelles
features
Mockito 2
Changements
internes
Mockito 3
What’s next
Release
delivery
continuum

View Slide

Brice Dutheil
Développeur freelance

View Slide

Qui suis-je ?
Back to basics
Mockito 2
Nouvelles
features
Mockito 2
Changements
internes
Mockito 3
What’s next
Release
delivery
continuum

View Slide

Un simulacre
Une
mauvaise
plaisanterie
Un mock c’est

View Slide

Bien sûr
J’ai tous leurs goodies
Non
Vous pouvez répéter la question ?
Qui connait
Mockito ?

View Slide

Avec Mockito 1.x on avait déjà

View Slide

Les mocks

View Slide

IMethods a_lot_of_methods = mock(IMethods.class);
MethodsImpl i_m_a_partial_mock = spy(new MethodsImpl());

View Slide

Les stubs

View Slide

given(a_lot_of_methods.varargs("Am", "stram", "gram",
"Pic", "et", "pic", "et", "colégram",
"Bour", "et", "bour", "et", "ratatam",
"Am", "stram", "gram")).willReturn(42);
// actual tested code

View Slide

La vérification

View Slide

verify(a_lot_of_methods).varargs(any());

View Slide

Les annotations

View Slide

@Mock IMethods a_lot_of_methods;
@Spy MethodsImpl i_m_a_partial_mock = new MethodsImpl();

View Slide

Une intégration JUnit 4

View Slide

@RunWith(MockitoJUnitRunner.Silent.class)
public class WithARunnerTest {
}

View Slide

@RunWith(MockitoJUnitRunner.Silent.class)
public class WithARunnerTest {
}
public class WithARuleTest {
@Rule public MockitoRule rulez = MockitoJUnit.rule();
}

View Slide

Les utilitaires complémentaires

View Slide

ArgumentCaptor the_arg = ArgumentCaptor.forClass(Long.class);
verify(i_m_a_partial_mock).oneArg(the_arg.capture());

View Slide

"Am", "stram", "gram"))
.will(AdditionalAnswers.returnsArgAt(9));
ArgumentCaptor The_arg = ArgumentCaptor.forClass(Long.class);
verify(i_m_a_partial_mock).oneArg(The_arg.capture());
Pour les cas plus rares

View Slide

Qui suis-je ?
Back to basics
Mockito 2
Nouvelles
features
Mockito 2
Changements
internes
Mockito 3
What’s next
Release
delivery
continuum

View Slide

Java 8

View Slide

Mockito retourne
des valeurs par défaut pour certains types

View Slide

public Long returns_a_long() {
}
mock.returns_a_long() Retourne 0

View Slide

public Long returns_a_long() {
}
mock.returns_a_long()
public List returns_a_list() {
}
mock.returns_a_list() Retourne une collection vide

View Slide

Java 8 vient avec des nouveaux types

View Slide

public Optional returns_optional() {
}
mock.returns_optional()
public Stream returns_a_stream() {
}
mock.returns_a_stream()
Retourne Optional.empty()
Retourne une stream vide

View Slide

Mockito 2 est compilé avec Java 6
donc sans Stream et Optional

View Slide

Stream et Optional
ne sont donc pas disponible
dans l’API publique de Mockito

View Slide

L’API des matchers re-pensée
avec l’inférence de type

View Slide

String forBoolean(Boolean value);
when(mock.forBoolean(isNull())).thenReturn("ok");
String forInteger(Integer value);
when(mock.forInteger(notNull())).thenReturn("ok");
String forMap(Map map);
when(mock.forMap(anyMap())).thenReturn("ok");
String oneArg(CurrencyDescription value);
when(mock.oneArg(any())).thenReturn("$ USD");
when(mock.oneArg(any(EuroDescription.class))).thenReturn("€ EUR");
Java 8

View Slide

Avec Java 6 ou Java 7,
il est possible d’utiliser l’ancienne API

View Slide

when(mock.forBoolean(isNull())).thenReturn("ok");
when(mock.forInteger(notNull())).thenReturn("ok");
when(mock.forMap(anyMap())).thenReturn("ok");
when(mock.oneArg(any())).thenReturn("$ USD");
Java 8

View Slide

when(mock.forBoolean(isNull(Boolean.class))).thenReturn("ok");
when(mock.forInteger(notNull(Integer.class))).thenReturn("ok");
when(mock.forMap(anyMapOf(String.class, String.class))).thenReturn("2");
when(mock.oneArg((CurrencyDescription) any())).thenReturn("matched");
Java 7

View Slide

L’ancienne API est dépréciée
car elle n’a plus d’intérêt
avec l’inférence de type

View Slide

Pour faciliter la transition :
Utiliser la nouvelle API
avec des cast en Java 6/7

View Slide

when(mock.forBoolean((Boolean) isNull())).thenReturn("ok");
when(mock.forInteger((Integer) notNull())).thenReturn("ok");
when(mock.forMap((Map) anyMap())).thenReturn("ok");
when(mock.oneArg((CurrencyDescription) any())).thenReturn("$ USD");

View Slide

Votre IDE proposera de retirer
les instructions de cast
avec Java 8

View Slide

when(mock.forBoolean((Boolean) isNull())).thenReturn("ok");

View Slide

L’API publique
a été améliorée
pour profiter les lambdas

View Slide

given(mock.returns_a_long()).willAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
// custom code ...
return something;
}
});
Mockito 1.x et
Mockito 2.x

View Slide

@Override
// custom code ...
return something;
}
});
given(mock.returns_a_long()).willAnswer(invocation -> /* custom code ... */);
Mockito 1.x

View Slide

@Override
// custom code ...
return something;
}
});
given(mock.returns_a_long()).willAnswer(invocation -> /* custom code ... */);
Représente
une invocation sur le mock

View Slide

import static org.mockito.AdditionalAnswers.answer;
given(mock.returns_a_long("a", "b", "c")).will(answer((arg0, arg1, arg2) -> 0));
Mockito 2.x

View Slide

Arguments
de la méthode

View Slide

Answer
qui extrait les arguments
de l’invocation

View Slide


View Slide

Avec Mockito 3 ce travail ira plus loin

View Slide

Java 8 permet d’écrire du code concret dans
les méthodes d’interface
connues sous le nom default methods

View Slide

Le comportement par défaut de Mockito 2
est de stubber ces méthodes

View Slide

@Mock private Consumer consumer1;

View Slide

@Test
public void working_with_default_methods() {
consumer1.andThen(consumer2)
.accept("hi");
}

View Slide

@Test
.accept("hi");
verify(consumer1).accept("hi");
}

View Slide

@Test
.accept("hi");
}
NullPointerException

View Slide

@Test
.accept("hi");
}
Retourne null

View Slide

@Test
.accept("hi");
}
default method

View Slide

@Test
.accept("hi");
}
default method
default Consumer andThen(Consumer super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}

View Slide

À ce jour les mocks d’interface
n’invoquent pas
le comportement concret des default methods

View Slide

Un spy est un mock partiel.
Par défaut invoque les méthodes concrètes
mais
permet de modifier le comportement

View Slide

Créer un spy à partir
de classes abstraites ou d’interfaces
est maintenant possible

View Slide

Consumer consumer1 = spy(Consumer.class);
.accept("hi");

View Slide

.accept("hi");
Code concret de andThen exécuté

View Slide

Qualité

View Slide

La pratique du TDD
permet de maintenir
la qualité du code de production

View Slide

Qu’en est-il du code de test ?

View Slide

public class Tested {
private Dep1 dep1;
private Dep2 dep2;
private Dep3 dep3;
public void behavior() {
dep1.sub_behaviour();
}
}

View Slide

@Mock private Dep1 dep1;
@InjectMocks Tested tested;
@Test
public void should_behave_in_that_case() {
given(dep1.sub_behaviour()).willReturn("A");
tested.behavior();
//...
}

View Slide

private Dep1 dep1;
private Dep2 dep2;
private Dep3 dep3;
}
}
Feature supprimée

View Slide

private Dep3 dep3;
}
}

View Slide

[MockitoHint] QualityTest.should_behave_in_that_case (see javadoc for MockitoHint):
[MockitoHint] 1. Unused -> at QualityTest.should_behave_in_that_case(QualityTest.java:22)
[MockitoHint] 2. Unused -> at QualityTest.should_behave_in_that_case(QualityTest.java:23)

View Slide

@Test
tested.behavior();
//...
}

View Slide

@Rule public MockitoRule rulez = MockitoJUnit.rule()
.silent();
@Test
tested.behavior();
//...
}
Éteint les warnings
dans la console

View Slide

.strictness(STRICT_STUBS);
@Test
tested.behavior();
//...
}
Fait échouer le test

View Slide

.strictness(STRICT_STUBS);
@Test
tested.behavior();
//...
}
Possiblement le défaut
dans Mockito 3

View Slide

org.mockito.exceptions.misusing.UnnecessaryStubbingException:
Unnecessary stubbings detected.
Clean & maintainable test code requires zero unnecessary code.
Following stubbings are unnecessary (click to navigate to relevant line of
code):
1. -> at QualityTest.should_behave_in_that_case(QualityTest.java:23)
2. -> at QualityTest.should_behave_in_that_case(QualityTest.java:24)
Please remove unnecessary stubbings or use 'silent' option. More info: javadoc
for UnnecessaryStubbingException class.

View Slide

Le runner MockitoJunitRunner est
stricte par défaut.
Changeable avec
MockitoJUnitRunner.Silent

View Slide

Plugins

View Slide

L’extensibilité et la facilité de configuration
existent depuis longtemps.

View Slide

Le tout premier mécanisme consiste
à créer dans ses sources une classe
org.mockito.configuration.MockitoConfiguration

View Slide

Lorsque Mockito identifie
cette classe dans le classpath,
il tient compte des nouveaux réglages

View Slide

package org.mockito.configuration;

View Slide

public class MockitoConfiguration {
}

View Slide

public class MockitoConfiguration implements IMockitoConfiguration {
}

View Slide

public class MockitoConfiguration implements IMockitoConfiguration {
@Override public Answer getDefaultAnswer() {
return ...;
}
@Override public AnnotationEngine getAnnotationEngine() {
return ...;
}
@Override public boolean cleansStackTrace() {
return ...;
}
@Override public boolean enableClassCache() {
return ...;
}
}

View Slide

public class MockitoConfiguration extends DefaultMockitoConfiguration
implements IMockitoConfiguration {
@Override public Answer getDefaultAnswer() {
return ...;
}
@Override public AnnotationEngine getAnnotationEngine() {
return ...;
}
return ...;
}
return ...;
}
}

View Slide

public class MockitoConfiguration extends DefaultMockitoConfiguration
implements IMockitoConfiguration {
return ...;
}
return ...;
}
}

View Slide

Demande de Google (Jessie Wilson),
pour permettre à Mockito de fonctionner
sur la VM Dalvik

View Slide

Un nouveau mécanisme de plugins
à été introduit en version 1.9.5

View Slide

Création de l’interface MockMaker

View Slide

Charge la classe du plugin
déclaré dans le fichier
mockito-extensions/org.mockito.plugins.MockMaker

View Slide

Fonctionnement similaire au
ServiceLoader

View Slide

Pourquoi ne pas utiliser ServiceLoader ?

View Slide

Machines will
replace humans

View Slide

Ajouté dans le niveau d’API 9 (~2011)

View Slide

Ajouté dans le niveau d’API 9 (~2011)
Utilise dans le dossier META-INF
hors il est supprimé à la création de
l’APK

View Slide

Mockito 2 étends le nombre de plugins
Interfaces dans org.mockito.plugins

View Slide

MockMaker, génère un mock

View Slide

InstantiatorProvider, instancie un mock

View Slide

AnnotationEngine, gère les annotations

View Slide

StackTraceCleanerProvider,
néttoie les stack traces

View Slide

StackTraceCleanerProvider,
néttoie les stack traces
PluginSwitch, gère l’activation d’un plugin externe

View Slide

Exemple :
Ajouter la gestion de l’annotation @Dummy

View Slide

/**
* Serves as a marker for dummy mocks, when processed creates
* a mock using {@code Mcokito.mock(FieldType.class)}
*/
public @interface Dummy { }

View Slide

/**
* Serves as a marker for dummy mocks, when processed creates
* a mock using {@code Mcokito.mock(FieldType.class)}
*/
public @interface Dummy { }
@Dummy Dependency just_for_compilation;

View Slide

public class DummyAnnotationEngine implements AnnotationEngine {
@Override
public void process(Class> clazz, Object testInstance) {
}
}

View Slide

@Override
testInstance.getClass().getDeclaredFields()
}
}

View Slide

@Override
Arrays.stream(testInstance.getClass().getDeclaredFields())
}
}

View Slide

@Override
.filter(field -> field.isAnnotationPresent(Dummy.class))
}
}

View Slide

@Override
.forEach(field -> {
});
}
}

View Slide

@Override
.forEach(field -> {
field.set(testInstance, Mockito.mock(field.getType()));
});
}
}

View Slide

@Override
.forEach(field -> {
field.setAccessible(true);
});
}
}

View Slide

@Override
.forEach(field -> {
try {
} catch (Exception e) {
}
});
}
}

View Slide

@Override
.forEach(field -> {
try {
throw new IllegalStateException(format("Could not
initialize @Dummy field '%s'", field.getName()), e);
}
});
}
}

View Slide

mockito-extensions/org.mockito.plugins.AnnotationEngine

View Slide

mockito-extensions/org.mockito.plugins.AnnotationEngine
my.package.DummyAnnotationEngine

View Slide

Ce processeur d’annotation
remplace
le processeur par défaut

View Slide

Les annotations @Mock, @Spy, etc.
sont ignorées

View Slide

Astuce temporaire

View Slide

@Override
.forEach(field -> {
try {
}
});
}
}

View Slide

AnnotationEngine internalEngine = new InjectingAnnotationEngine();
@Override
.forEach(field -> {
try {
}
});
}
}

View Slide

@Override
.forEach(field -> {
try {
}
});
internalEngine.process(clazz, testInstance);
}
}
Invoque le processeur interne

View Slide

@Override
internalEngine.process(clazz, testInstance);
}
}
API interne

View Slide

Une évolution de l’API publique
permettra d’obtenir
le plugin par défaut de Mockito

View Slide

Android

View Slide

Un robot
humanoïde
Un OS pour
mobile
Qui connait
Android ?

View Slide

Android Studio permet d’écrire
deux types de test

View Slide

Les tests qui vont tourner sur une VM java
Usuellement hotspot

View Slide

Les tests qui vont tourner sur un émulateur
Ou un device

View Slide

View Slide

Ces deux packages de tests
ont chacun leur scopes de dépendances

View Slide

testCompile pour les tests
qui vont tourner sur la VM java

View Slide

androidTestCompile pour les tests
qui vont tourner sur l’émulateur / le device

View Slide

dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
exclude group: 'com.android.support', module: 'support-annotations'
})
compile 'com.android.support:appcompat-v7:25.1.0'
// ...
testCompile 'junit:junit:4.12'
// ...
}

View Slide

dependencies {
})
// ...
testCompile 'org.mockito:mockito-core:2.+'
// ...
}

View Slide

dependencies {
})
// ...
androidTestCompile 'org.mockito:mockito-core:2.+'
androidTestCompile 'com.linkedin.dexmaker:dexmaker-mockito:2.2.0'
// ...
}

View Slide

dependencies {
})
// ...
// ...
}
dexmaker a été repris par linkedin
Et mis à jour pour fonctionner avec Mockito 2

View Slide

Depuis la version 2.6.1 nous avons une
alternative à dexmaker :
mockito-android

View Slide

Celle-ci est basée sur bytebuddy-android.

View Slide

dependencies {
})
// ...
// ...
}

View Slide

dependencies {
})
// ...
androidTestCompile 'org.mockito:mockito-android:2.6.+'
// ...
}

View Slide

Mieux que dexmaker
mais il y a encore des améliorations

View Slide

Classes finales

View Slide

Mockito 1 limité aux classes non finale

View Slide

Mockito 2 introduit
un mockmaker expérimental
pour les classes finales

View Slide

mock-maker-inline

View Slide

public final class FinalClass {
public String foo() {
return "foo";
}
}

View Slide

return "foo";
}
}
FinalClass finalClass = mock(FinalClass.class);
given(finalClass.foo()).willReturn("bar");

View Slide

return "foo";
}
}
assertThat(proxy.foo()).isEqualTo("bar");

View Slide

return "foo";
}
}
assertThat(proxy.foo()).isEqualTo("bar");
My Life List
…
[✔ ] Mocking final

View Slide

Même avec les classes du JDK !
À quelques exceptions près Class, String, …

View Slide

Attention !

View Slide

Toujours questionner
s’il est sage de mocker
un type qui n’est pas sous notre contrôle

View Slide

Vous ne voulez pas mocker
Pattern, classe finale,
son comportement change entre chaque JDK

View Slide

Vous ne voulez pas mocker
HashMap, classe non finale,
son comportement change entre chaque JDK

View Slide

Sur votre CI vos tests peuvent être verts
mais
le code exécuté en production peut être erroné

View Slide

Qui suis-je ?
Back to basics
Mockito 2
Nouvelles
features
Mockito 2
Changements
internes
Mockito 3
What’s next
Release
delivery
continuum

View Slide

Un doudou
pour les bébés
Le remplaçant
de CGLIB
Qu’est-ce que
byte-buddy ?

View Slide

CGLIB de facto standard
nous faisait défaut sur de nombreux points

View Slide

Bridge method, annotations, generics,
permgen leak, aucun mainteneurs, CVS, etc.

View Slide

Après des mois à coder et étudier les
alternatives,
http://stackoverflow.com/questions/2261947/are-there-alternatives-to-cglib/9823788#9823788

View Slide

Après des mois à coder et étudier les
alternatives, Rafael nous a proposé
sa librairie : byte-buddy
http://stackoverflow.com/questions/2261947/are-there-alternatives-to-cglib/9823788#9823788

View Slide

Le mock maker de mockito 1 est
basé sur CGLIB

View Slide

ByteBuddy a une API basé sur des builders

View Slide

… relativement avancée, elle demande
un certain niveau de connaissances sur la JVM

View Slide

… relativement avancée, elle demande
un certain niveau de connaissance sur la JVM
Mais pas autant que ASM

View Slide

DynamicType.Builder builder =
byteBuddy.subclass(features.mockedType)
.name(nameFor(features.mockedType))
.ignoreAlso(isGroovyMethod())
.annotateType(features.mockedType.getAnnotations())
.implement(new ArrayList(features.interfaces))
.method(matcher)
.intercept(to(DispatcherDefaultingToRealMethod.class))
.transform(withModifiers(SynchronizationState.PLAIN, Visibility.PUBLIC))
.attribute(INCLUDING_RECEIVER)
.method(isHashCode())
.intercept(to(MockMethodInterceptor.ForHashCode.class))
.method(isEquals())
.intercept(to(MockMethodInterceptor.ForEquals.class))
.serialVersionUid(42L)
.defineField("mockitoInterceptor", MockMethodInterceptor.class, PRIVATE)
.implement(MockAccess.class)
.intercept(FieldAccessor.ofBeanProperty());
if (features.serializableMode == SerializableMode.ACROSS_CLASSLOADERS) {
builder = builder.implement(CrossClassLoaderSerializableMock.class)
.intercept(to(MockMethodInterceptor.ForWriteReplace.class));
}
if (readReplace != null) {
builder = builder.defineMethod("readObject", void.class, Visibility.PRIVATE)
.withParameters(ObjectInputStream.class)
.throwing(ClassNotFoundException.class, IOException.class)
.intercept(readReplace);
}
return builder.make()
.load(new MultipleParentClassLoader.Builder()
.append(features.mockedType)
.append(features.interfaces)
.append(currentThread().getContextClassLoader())
.append(MockAccess.class, DispatcherDefaultingToRealMethod.class)
.append(MockMethodInterceptor.class,
MockMethodInterceptor.ForHashCode.class,

View Slide

.method(matcher)
.method(isEquals())
}
}
Configuration de la classe

View Slide

.method(matcher)
.method(isEquals())
}
}
Configuration de la classe
Configuration du classloader
pour le chargement de la
classe du mock

View Slide

Comment Mockito créé ses mocks ?

View Slide

.method(matcher)
.method(isEquals())
.defineField("mockitoInterceptor", MockMethodInterceptor.class, Visibility.PRIVATE)
Type de modification :
Sous classe

View Slide

.method(matcher)
.method(isEquals())
Défini le nom qualifié
Packages signés, etc.

View Slide

.method(matcher)
.method(isEquals())
Le nom de la classe contiendra :
MockitoMock

View Slide

.method(matcher)
.method(isEquals())
On ne mocke pas les méthodes
générées par groovy

View Slide

.method(matcher)
.method(isEquals())
Copie les annotations
du type mocké

View Slide

.method(matcher)
.method(isEquals())
Extra interfaces

View Slide

.method(matcher)
.method(isEquals())
Quelle méthode à
intercepter
(toutes par défaut)

View Slide

.method(matcher)
.method(isEquals())
Type du callback
Dispatcher : Classe
mockito annotée

View Slide

.method(matcher)
.method(isEquals())
Copie les annotations
de la méthode

View Slide

.method(matcher)
.method(isEquals())
hashCode / equals
ne sont pas mockable

View Slide

.method(matcher)
.method(isEquals())
La réponse à la grande
question

View Slide

.method(matcher)
.method(isEquals())
Champs et accesseurs
de l’intercepteur mockito

View Slide

Comment Mockito intercepte les appels ?

View Slide

public static class DispatcherDefaultingToRealMethod {
@SuppressWarnings("unused")
@RuntimeType
@BindingPriority(BindingPriority.DEFAULT * 2)
public static Object interceptSuperCallable(@This Object mock,
@FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
@Origin Method invokedMethod,
@AllArguments Object[] arguments,
@SuperCall(serializableProxy= true) Callable> superCall) throws Throwable {
if (interceptor == null) {
return superCall.call();
}
return interceptor.doIntercept(
mock,
invokedMethod,
arguments,
new InterceptedInvocation.SuperMethod.FromCallable(superCall)
);
}
@RuntimeType
public static Object interceptAbstract(@This Object mock,
@StubValue Object stubValue,
@AllArguments Object[] arguments) throws Throwable {
return stubValue;

View Slide

@RuntimeType
}
mock,
invokedMethod,
arguments,
);
}
@RuntimeType
Appelé lorsqu’une invocation à lieu

View Slide

@RuntimeType
@FieldValue("mockitoInterceptor") MockMethodInterceptor intercep
@SuperCall(serializableProxy= true) Callable> superCall) thro
Throwable {
}
mock,
invokedMethod,
arguments,
);
}
@RuntimeType
Indique à byte-buddy les éléments qui
nous intéressent

View Slide

@RuntimeType
}
mock,
invokedMethod,
arguments,
);
}
@RuntimeType
Garde, appelle la méthode concrète de
l’objet

View Slide

@RuntimeType
}
mock,
invokedMethod,
arguments,
);
}
@RuntimeType
Invoque la logique interne de Mockito

View Slide

// ...
public static Object interceptSuperCallable(...) Callable> superCall) throws Throwable { ... }
@RuntimeType
return stubValue;
}
mock,
invokedMethod,
arguments,
InterceptedInvocation.SuperMethod.IsIllegal.INSTANCE
);
}
}
Callback utilisé pour les méthodes
abstraites

View Slide

// ...
public static Object interceptSuperCallable(...) Callable> superCall) throws Throwable { ... }
@RuntimeType
return stubValue;
}
mock,
invokedMethod,
arguments,
InterceptedInvocation.SuperMethod.IsIllegal.INSTANCE
);
}
}
Invoque la logique interne de Mockito

View Slide

Au final la stratégie de création
est de créer une sous classe

View Slide

Ensuite la classe du mock
sera instanciée par Objenesis

View Slide

C mock = mock(C.class);

View Slide

Type à
mocker

View Slide

Type à
mocker
Classe
du mock
extends

View Slide

Le modifier final
n’autorise pas
d’étendre la hiérarchie

View Slide

Comment autoriser
les mocks des classes finales ?

View Slide

Powermock ?

View Slide

@RunWith(PowerMockRunner.class)
@PrepareForTest({C.class})

View Slide

Classe
finale

View Slide

Classloader PowerMock
Classe
finale
Nouveau
classloader

View Slide

010010111010…
Reload la
classe
Classe
finale
Nouveau
classloader

View Slide

010010111010…
Reload la
classe
Classe
finale
Supprime
final
Nouveau
classloader

View Slide

010010111010…
Reload la
classe
Classe
finale
Supprime
final
Classe C
définalisé
Classe
du mock
extends
Nouveau
classloader

View Slide

Powermock recharge les classes du test
dans un classloader qui retire final.

View Slide

Introduction du mock
de classes finales avec Mockito 2

View Slide

Pas de classloader, on utilise un agent !

View Slide

L’agent est auto installé par byte-buddy
Certaines VM non supportées

View Slide

Classe
finale
Mockito +
mock-maker-inline

View Slide

JVM C mock = mock(C.class);
Classe
finale

View Slide

JVM
Installe l’agent
Classe
finale
Agent mockito

View Slide

static {
try {
try {
instrumentation = ByteBuddyAgent.install();
if (!instrumentation.isRetransformClassesSupported()) {
throw new IllegalStateException(...);
}
JarFile boot = createMockitoMethodDispatcherBootstrapJar();
instrumentation.appendToBootstrapClassLoaderSearch(boot);
checkBootstrapJarInjection();
} catch (IOException ioe) {
throw new IllegalStateException(..., ioe);
}
} catch (Throwable throwable) {
instrumentation = null;
initializationError = throwable;
}
INSTRUMENTATION = instrumentation;
INITIALIZATION_ERROR = initializationError;

View Slide

static {
try {
try {
}
}
}
Installation de l’agent

View Slide

static {
try {
try {
}
}
}
Injecte le dispatcher mockito
sur le classpath de bootstrap
de la VM

View Slide

Classe
finale
Agent mockito

View Slide

Classe
finale
Agent mockito
Transforme / instrumente
la classe
Indique à l’agent de
modifier C

View Slide

Classe
finale
Agent mockito
Ajoute l’intercepteur mockito
dans la classe C

View Slide

@Override
public Class extends T> mockClass(MockFeatures features) {
boolean subclassingRequired = !features.interfaces.isEmpty()
|| features.serializableMode != SerializableMode.NONE
|| Modifier.isAbstract(features.mockedType.getModifiers());
checkSupportedCombination(subclassingRequired, features);
synchronized (this) {
triggerRetransformation(features);
}
return subclassingRequired ?
subclassEngine.mockClass(features) :
features.mockedType;
}

View Slide

@Override
}
}
Certaines fonctionnalités
de mockito ne fonctionnent pas
dans ce mode.

View Slide

@Override
}
}
Instrumente la classe

View Slide

@Override
}
}
Invoque
instrumentation.retransformClasses(types);

View Slide

@Override
}
}
Si la classe n’est pas finale :
créé une sous-classe / implémentation

View Slide

@Override
public byte[] transform(ClassLoader loader,
String className,
Class> classBeingRedefined,
ProtectionDomain protectionDomain,
byte[] classfileBuffer) throws IllegalClassFormatException {
if (classBeingRedefined == null
|| !mocked.contains(classBeingRedefined)
|| EXCLUDES.contains(classBeingRedefined)) {
return null;
} else {
try {
return byteBuddy.redefine(classBeingRedefined,
ClassFileLocator.Simple.of(classBeingRedefined.getName(),
classfileBuffer))
.visit(new ParameterWritingVisitorWrapper(classBeingRedefined))
.visit(Advice.withCustomMapping()
.bind(MockMethodAdvice.Identifier.class, identifier)
.to(MockMethodAdvice.class).on(isVirtual()
.and(not(isBridge().or(isHashCode()).or(isEquals()).or(isDefaultFinalizer())))
.and(not(isDeclaredBy(nameStartsWith("java.")).and(isPackagePrivate())))))
.to(MockMethodAdvice.ForHashCode.class).on(isHashCode()))
.to(MockMethodAdvice.ForEquals.class).on(isEquals()))
.make()
.getBytes();
java.lang.instrumentation.ClassFileTransformer

View Slide

@Override
String className,
return null;
} else {
try {
classfileBuffer))
.make()
.getBytes();
Est-ce que le type doit / peut
être modifié ?

View Slide

@Override
String className,
return null;
} else {
try {
classfileBuffer))
.make()
.getBytes();
Instructions de
transformation

View Slide

classfileBuffer))
.and(not(isBridge().or(isHashCode())
.or(isEquals())
.or(isDefaultFinalizer())))
.and(not(isDeclaredBy(nameStartsWith("java."))
.and(isPackagePrivate())))))
.make()
.getBytes();
Indique à l’agent byte-buddy
ou trouver le bytecode
de la classe à modifier

View Slide

classfileBuffer))
.or(isEquals())
.make()
.getBytes();
API basé sur des visiteurs,
comme ASM

View Slide

classfileBuffer))
.or(isEquals())
.make()
.getBytes();
Ré-insère le nom des
paramètres
Java 8 : -parameters

View Slide

classfileBuffer))
.or(isEquals())
.make()
.getBytes();
Instrumente les
méthodes mockables

View Slide

classfileBuffer))
.or(isEquals())
.make()
.getBytes();
Donc pas
● le constructeur
● les méthodes privées
hashcode / equals
● les bridges
… entre autres

View Slide

classfileBuffer))
.or(isEquals())
.make()
.getBytes();
Instrumente
de manière spécifique
les méthodes
hashcode / equals

View Slide

classfileBuffer))
.or(isEquals())
.make()
.getBytes();
Renvoie le bytecode de la
classe instrumentée

View Slide

Qui suis-je ?
Back to basics
Mockito 2
Nouvelles
features
Mockito 2
Changements
internes
Release
delivery
continuum
Mockito 3
What’s next

View Slide

À la recherche
d’un modèle de livraison / déploiement
continu

View Slide

Tous les projets doivent délivrer.

View Slide

Quelle stratégie ?

View Slide

Quelle stratégie ?
À quelle cadence ?

View Slide

Quelle stratégie ?
À quelle cadence ?
Sur quel canal ?

View Slide

Quelle stratégie ?
À quelle cadence ?
Sur quel canal ?
Pour quels utilisateurs ?

View Slide

Dur dans un projet business

View Slide

Dur dans un projet open source

View Slide

Mockito a été actif lors des itérations
pour la version 1

View Slide

Puis une très longue période sans release

View Slide

Raisons multiples :
Santé

View Slide

Raisons multiples :
Santé Job

View Slide

Raisons multiples :
Santé Job Temps

View Slide

Raisons multiples :
Santé Job Temps Autres

View Slide

Comment être indépendant
de la personne
qui possède les identifiants ?

View Slide

Nous avons écrit un bot
chargé de faire des releases
et de les déployer

View Slide

Comment ça fonctionne ?

View Slide

git push upstream
✓ Not skipped
✓ Releasable branch ?
✓ Not a PR
✓ Previous and current jar
are different
[release/2.x] $ release/2.x

View Slide

✓ Not skipped
✗ Releasable branch ?
git push upstream
[feature_#73] $ feature_#73

View Slide

✓ Not skipped
✓ Releasable branch ?
✓ Not a PR
✓ Previous and current jar
are different
release/2.x
PR #73 → release/2.x

View Slide

Ce bot et cette configuration de déploiements
réponds aux questions suivantes

View Slide

Comment délivrer
aux utilisateurs qui subissent un bug ?

View Slide

Comment délivrer
aux utilisateurs les nouveautés ?

View Slide

Comment garantir
que les scripts fonctionnent encore ?

View Slide

Comment favoriser le feedback sur un
développement en cours ?

View Slide

Il y a cependant des problèmes

View Slide

Comment être garantir la compatibilité ?

View Slide

Les revues de code ont permi

View Slide

d’identifier des bugs

View Slide

d’identifier des bugs
de (re) designer des APIs

View Slide

La fatigue des mises à jour
pour les utilisateurs
Marre de changer mon pom / gradle

View Slide

Ces questions ont été vivement
débattues dans le ticket #618

View Slide

Nous souhaitons améliorer
notre pipeline de delivery

View Slide

Qui suis-je ?
Back to basics
Mockito 2
Nouvelles
features
Mockito 2
Changements
internes
Mockito 3
What’s next
Release
delivery
continuum

View Slide

Compilation avec Java 8
Accès aux types du JDK 8

View Slide

Réflexion sur une API basée sur les lambdas

View Slide

Amélioration du support JDK 9

View Slide

Contrainte sur ASM 6

View Slide

Contrainte sur ASM 6
Problème avec Jigsaw

View Slide

Dépréciation de when / then
au profit de given / will

View Slide

Qui suis-je ?
Back to basics
Mockito 2
Nouvelles
features
Mockito 2
Changements
internes
Mockito 3
What’s next
Release
delivery
continuum

View Slide

???
https://speakerdeck.com/bric3/mockito-2-lyonjug-2017-01-26

View Slide

https://cdn1.macworld.co.uk/cmsdata/features/3608274/Terminalicon2_thumb800.png
http://www.wpclipart.com/cartoon/signs/more_signs/warning_slippery.png.html
https://crackberry.com/sites/crackberry.com/files/styles/large/public/topic_images/2013/ANDROID.png
https://kotlinlang.org/assets/images/open-graph/kotlin_250x250.png
https://raw.githubusercontent.com/JetBrains/intellij-community/master/platform/icons/src/nodes/class.svg
https://raw.githubusercontent.com/JetBrains/intellij-community/master/platform/icons/src/fileTypes/text.svg
https://image.freepik.com/free-icon/chronometer-quarter-hour-logistics_318-36128.jpg
http://www.freeiconspng.com/free-images/direction-icon-png-4697
http://downloadicons.net/ekg-icon-87666
https://www.pinterest.com/pin/369084131932258329/
Git, Jetbrains, Travis, Gradle, RxJava, Devoxx France, Cassandra, Kafka, Oracle Java
Image sources

View Slide

Retiré

View Slide

1. Qui suis-je ?
2. Back to basics
a. Do you know mockito ? yes / no
b. Do you know what is a mock ? yes / no
3. Nouvelles features de Mockito 2
a. Premier support de Java 8
b. Meilleur support des generics
c. Qualité / Strict mocking
d. API entre Java 6 et Java 8
e. Mockito.framework() / listeners
f. Plugins
g. Android support
h. Classes finales
i. Kotlin
4. Changements internes de Mockito 2
a. Bytebuddy (incompatibilité avec PowerMock)
b. Mocking des classes finales
5. Release model
a. Continuous delivery continuum
6. Pour Mockito 3
a. Extensions du support Java 8
b. Java 9 ready, dans les faits dépends de ASM6
c. Simplicity
d. BDD api only ?

View Slide

Qui suis-je ?
Back to basics
Mockito 2
Nouvelles
features
Mockito 2
Changements
internes
Release
model
Mockito 3
What’s next

View Slide

Framework

View Slide

Autre nouveauté
La mise en place d’une API publique
autour du fonctionnement de Mockito

View Slide

La plupart des API publiques
sont réparties dans les classes
du package org.mockito

View Slide

Mockito / BDDMockito
@Mock / @Spy / @InjectMocks
ArgumentMatchers / AdditionalMatchers
Answers / AdditionalAnswers

View Slide

L’outillage publique JUnit est
dans org.mockito.junit

View Slide

Comment ouvrir l’API interne de Mockito ?

View Slide

Mise en place de Mockito.framework()

View Slide

Pour l’instant limité à
l’ajout / retrait de listener

View Slide

Un listener doit
implémenter une sous-interface
de MockitoListener

View Slide

Exemple :
lister les créations de mocks
avec MockCreationListener

View Slide

Mockito.framework().addListener(...);

View Slide

Mockito.framework().addListener(new MockCreationListener());

View Slide

Mockito.framework().addListener(new MockCreationListener() {
@Override
public void onMockCreated(Object mock, MockCreationSettings settings) {
}
});

View Slide

@Override
System.out.println("new mock created '" + mock + "'");
}
});

View Slide

@Override
System.out.println("new mock created '" + mock + "'");
}
});
...
Mockito.mock(AwesomeType.class);

View Slide

new mock created 'Mock for AwesomeType, hashCode: 370869802'

View Slide

Cas plus concret :
Tracker les mocks qui forcent la sérialisation

View Slide

Mockito.mock(AwesomeType.class, Mockito.withSettings()
.serializable());
Mockito.mock(AwesomeType.class, Mockito.withSettings()
.serializable(ACROSS_CLASSLOADERS));
Force le mock à supporter la sérialisation

View Slide

Créer une rule JUnit
empêchant
la création de mock serializable

View Slide

@ClassRule
public static TestRule trackSerializableMock = new ScreamOnSerializableMock();

View Slide

public class ScreamOnSerializableMock implements TestRule {
@Override
public Statement apply(Statement base, Description description) {
return ...;
}
}

View Slide

@Override
return new Statement() {
@Override
public void evaluate() throws Throwable {
base.evaluate();
}
};
}
}

View Slide

@Override
MockCreationListener listener = new SerializableMockCreationListener();
@Override
base.evaluate();
}
};
}
}

View Slide

@Override
@Override
Mockito.framework().addListener(listener);
base.evaluate();
}
};
}
}

View Slide

@Override
@Override
base.evaluate();
}
};
}
}
Ajoute le listener pour la méthode de test

View Slide

@Override
@Override
try {
base.evaluate();
} finally {
Mockito.framework().removeListener(listener);
}
}
};
}
}
Important supprimer le listener

View Slide

Le listener enregistré
peut réagir aux évènements de
création de mock

View Slide

class SerializableMockCreationListener implements MockCreationListener {
@Override
}
}

View Slide

@Override
if(settings.isSerializable()) {
}
}
}

View Slide

@Override
if(settings.isSerializable()) {
String msg = format("serializable mock created '%s', with mode=%s",
mock,
settings.getSerializableMode());
System.out.println(msg);
throw new ProgrammerError(msg);
}
}
}

View Slide

VerificationListener
permet de réagir
sur chaque appel à verify

View Slide

En fonction des besoins
d’autres listeners seront ajoutés

View Slide

Mockito.framework()

View Slide

Kotlin

View Slide

Pour certains usages
Mocker une classe finale peut-être utile

View Slide

Kotlin compile les classes
avec le modifier final

View Slide

class PassengerNameRecord {
fun isExpired(): Boolean {
return ...
}
}

View Slide

class PassengerNameRecord {
fun isExpired(): Boolean {
return ...
}
}
Classe finale

View Slide

class PassengerNameRecordTest {
@Mock
val pnr = PassengerNameRecord()
@Rule @JvmField
public val rulez = MockitoJUnit.rule();
@Test
fun should_behave_like_that() {
...
}
}

View Slide

org.mockito.exceptions.base.MockitoException:
Cannot mock/spy class com.github.bric3.PassengerNameRecord
Mockito cannot mock/spy because :
- final class

View Slide

mock-maker-inline

View Slide

View Slide

Matchers Mockito peuvent retourner null

View Slide

Matchers Mockito peuvent retourner null
Option : utiliser github.com/nhaarman/mockito-kotlin
verify(myClass).setItems(argThat { size == 42 })

View Slide

CGLIB mockmaker

View Slide

Enhancer enhancer = new Enhancer();
Class>[] allMockedTypes = prepend(mockedType, interfaces);
enhancer.setClassLoader(SearchingClassLoader.combineLoadersOf(allMockedTypes));
enhancer.setUseFactory(true);
if (mockedType.isInterface()) {
enhancer.setSuperclass(Object.class);
enhancer.setInterfaces(allMockedTypes);
} else {
enhancer.setSuperclass(mockedType);
enhancer.setInterfaces(interfaces);
}
enhancer.setCallbackTypes(new Class[]{MethodInterceptor.class, NoOp.class});
enhancer.setCallbackFilter(IGNORE_BRIDGE_METHODS);
if (mockedType.getSigners() != null) {
enhancer.setNamingPolicy(NAMING_POLICY_THAT_ALLOWS_IMPOSTERISATION_OF_CLASSES_IN_SIGNED_PACKAGES);
} else {
enhancer.setNamingPolicy(MockitoNamingPolicy.INSTANCE);
}
enhancer.setSerialVersionUID(42L);
try {
return enhancer.createClass();
} catch (CodeGenerationException e) {
// propagate with meaningful message
}
Configuration
de CGLIB
pour créer
la classe du mock

View Slide

} else {
}
} else {
}
try {
}
Instance du créateur de classe de CGLIB

View Slide

} else {
}
} else {
}
try {
}
Mocked type + extra interfaces

View Slide

} else {
}
} else {
}
try {
}
Classloader chargé trouvé les bon
classloader pour chaque type

View Slide

} else {
}
} else {
}
try {
}
Équivalent de @PostConstruct

View Slide

} else {
}
} else {
}
try {
Hack pour gérer
les mocks de classes
ou les mocks d’interfaces

View Slide

} else {
}
} else {
}
try {
}
Type du callback
que Mockito doit
implémenter
Type de callback
NoOp

View Slide

} else {
}
} else {
}
try {
}
CGLIB ne gère pas
les bridge méthodes

View Slide

} else {
}
enhancer.setNamingPolicy(
NAMING_POLICY_THAT_ALLOWS_IMPOSTERISATION_OF_CLASSES_IN_SIGNED_PACKAGES);
} else {
}
try {
Gestion du nommage pour les
packages signés.
Par exemple java.util

View Slide

} else {
}
enhancer.setNamingPolicy(
NAMING_POLICY_THAT_ALLOWS_IMPOSTERISATION_OF_CLASSES_IN_SIGNED_PACKAGES);
} else {
}
try {
Le nom de la classe contiendra
EnhancedByMockitoWithCGLIB

View Slide

} else {
}
} else {
}
try {
}
Génère le bytecode
et charge la classe dans
SearchingClassLoader

View Slide

Mockito 2 - LyonJug - 2017-01-26

Mockito 2 - LyonJug - 2017-01-26

Brice Dutheil

More Decks by Brice Dutheil

Other Decks in Programming

Featured

Transcript