Normalement, avec mockito, je vais faire quelque chose comme:
Mockito.when(myObject.myFunction(myParameter)).thenReturn(myResult);
Est-il possible de faire quelque chose dans le sens de
myParameter.setProperty("value");
Mockito.when(myObject.myFunction(myParameter)).thenReturn("myResult");
myParameter.setProperty("otherValue");
Mockito.when(myObject.myFunction(myParameter)).thenReturn("otherResult");
Donc, plutôt que de simplement utiliser le paramètre pour déterminer le résultat. Il utilise une valeur d'une propriété à l'intérieur du paramètre pour déterminer le résultat.
donc quand le code est exécuté, il se comporte comme si
public void myTestMethod(MyParameter myParameter,MyObject myObject){
myParameter.setProperty("value");
System.out.println(myObject.myFunction(myParameter));// outputs myResult
myParameter.setProperty("otherValue");
System.out.println(myObject.myFunction(myParameter));// outputs otherResult
}
solution actuelle, espérons que quelque chose de mieux peut être suggéré.
private class MyObjectMatcher extends ArgumentMatcher<MyObject> {
private final String compareValue;
public ApplicationContextMatcher(String compareValue) {
this.compareValue= compareValue;
}
@Override
public boolean matches(Object argument) {
MyObject item= (MyObject) argument;
if(compareValue!= null){
if (item != null) {
return compareValue.equals(item.getMyParameter());
}
}else {
return item == null || item.getMyParameter() == null;
}
return false;
}
}
public void initMock(MyObject myObject){
MyObjectMatcher valueMatcher = new MyObjectMatcher("value");
MyObjectMatcher otherValueMatcher = new MyObjectMatcher("otherValue");
Mockito.when(myObject.myFunction(Matchers.argThat(valueMatcher))).thenReturn("myResult");
Mockito.when(myObject.myFunction(Matchers.argThat(otherValueMatcher))).thenReturn("otherResult");
}
Voici une façon de le faire. Ceci utilise un objet Answer
pour vérifier la valeur de la propriété.
@RunWith(MockitoJUnitRunner.class)
public class MyTestClass {
private String theProperty;
@Mock private MyClass mockObject;
@Before
public void setUp() {
when(mockObject.myMethod(anyString())).thenAnswer(
new Answer<String>(){
@Override
public String answer(InvocationOnMock invocation){
if ("value".equals(theProperty)){
return "result";
}
else if("otherValue".equals(theProperty)) {
return "otherResult";
}
return theProperty;
}});
}
}
Il existe une syntaxe alternative, que je préfère en réalité, qui permettra d'obtenir exactement la même chose. À vous de choisir l’un de ceux-ci. Ceci est juste la méthode setUp
- le reste de la classe de test devrait être le même que ci-dessus.
@Before
public void setUp() {
doAnswer(new Answer<String>(){
@Override
public String answer(InvocationOnMock invocation){
if ("value".equals(theProperty)){
return "result";
}
else if("otherValue".equals(theProperty)) {
return "otherResult";
}
return theProperty;
}}).when(mockObject).myMethod(anyString());
}
En Java 8, c'est encore plus simple que tout ce qui précède:
when(mockObject.myMethod(anyString()))
.thenAnswer(invocation ->
invocation.getArgumentAt(0, String.class));
Oui, vous pouvez utiliser un correcteur d’arguments personnalisé.
Voir le javadoc de Matchers
pour plus de détails et plus précisément ArgumentMatcher
.
Voici comment cela ressemblerait à Kotlin avec mockito-kotlin library.
mock<Resources> {
on {
mockObject.myMethod(any())
} doAnswer {
"Here is the value: ${it.arguments[0]}"
}
}