Vérifier la valeur d’atsortingbut d’object avec mockito

J’ai un appel de méthode que je veux me moquer de mockito. Pour commencer, j’ai créé et injecté une instance d’un object sur lequel la méthode sera appelée. Mon but est de vérifier l’un des objects dans l’appel à la méthode.

Est-ce que mockito vous permet d’affirmer ou de vérifier l’object et ses atsortingbuts lorsque la méthode simulée est appelée?

Exemple

Mockito.verify(mockedObject) .someMethodOnMockedObject( Mockito.anyObject()) 

Au lieu de faire anyObject() je veux vérifier que cet object d’argument contient des champs particuliers

 Mockito.verify(mockedObject) .someMethodOnMockedObject( Mockito.**compareWithThisObject()**) 

La nouvelle fonctionnalité ajoutée à Mockito rend cela encore plus facile,

 ArgumentCaptor argument = ArgumentCaptor.forClass(Person.class); verify(mock).doSomething(argument.capture()); assertEquals("John", argument.getValue().getName()); 

Regardez la documentation de Mockito

Une autre possibilité, si vous ne souhaitez pas utiliser ArgumentCaptor (par exemple, parce que vous utilisez également le stubbing), consiste à utiliser Hamcrest Matchers en combinaison avec Mockito.

 import org.mockito.Mockito import org.hamcrest.Matchers ... Mockito.verify(mockedObject).someMethodOnMockedObject(Mockito.argThat( Matchers.hasProperty("propertyName", desiredValue))); 

Je pense que le moyen le plus simple de vérifier un object argument est d’utiliser la méthode refEq :

 Mockito.verify(mockedObject).someMethodOnMockedObject(Matchers.refEq(objectToCompareWith)); 

Il peut être utilisé même si l’object n’implémente pas equals() , car la reflection est utilisée. Si vous ne voulez pas comparer certains champs, ajoutez simplement leurs noms comme arguments pour refEq .

http://sites.google.com/a/pintailconsultingllc.com/java/argument-matching-with-mockito

Ce lien fournit un exemple de travail. J’ai pu le résoudre avec la même stratégie.

Ceci est une réponse basée sur la réponse de iraSenthil mais avec une annotation ( Captor ). A mon avis, cela présente des avantages:

  • c’est plus court
  • c’est plus facile à lire
  • il peut gérer des génériques sans avertissements

Exemple:

 @RunWith(MockitoJUnitRunner.class) public class SomeTest{ @Captor private ArgumentCaptor> captor; //... @Test public void shouldTestArgsVals() { //... verify(mockedObject).someMethodOnMockedObject(captor.capture()); assertThat(captor.getValue().getXXX(), is("expected")); } } 

Si vous utilisez Java 8, vous pouvez utiliser des expressions Lambda pour correspondre.

 import java.util.Optional; import java.util.function.Predicate; import org.hamcrest.BaseMatcher; import org.hamcrest.Description; public class LambdaMatcher extends BaseMatcher { private final Predicate matcher; private final Optional description; public LambdaMatcher(Predicate matcher) { this(matcher, null); } public LambdaMatcher(Predicate matcher, Ssortingng description) { this.matcher = matcher; this.description = Optional.ofNullable(description); } @SuppressWarnings("unchecked") @Override public boolean matches(Object argument) { return matcher.test((T) argument); } @Override public void describeTo(Description description) { this.description.ifPresent(description::appendText); } } 

Exemple d’appel

 @Test public void canFindEmployee() { Employee employee = new Employee("John"); company.addEmployee(employee); verify(mockedDal).registerEmployee(argThat(new LambdaMatcher<>(e -> e.getName() .equals(employee.getName())))); } 

Plus d’infos: http://source.coveo.com/2014/10/01/java8-mockito/

Les solutions ci-dessus n’ont pas vraiment fonctionné dans mon cas. Je n’ai pas pu utiliser ArgumentCaptor car la méthode a été appelée plusieurs fois et que je devais valider chacun d’eux. Un simple Matcher avec “argThat” a fait l’affaire facilement.

Matcher personnalisé

 // custom matcher private class PolygonMatcher extends ArgumentMatcher { private int fillColor; public PolygonMatcher(int fillColor) { this.fillColor = fillColor; } @Override public boolean matches(Object argument) { if (!(argument instanceof PolygonOptions)) return false; PolygonOptions arg = (PolygonOptions)argument; return Color.red(arg.getFillColor()) == Color.red(fillColor) && Color.green(arg.getFillColor()) == Color.green(fillColor) && Color.blue(arg.getFillColor()) == Color.blue(fillColor); } } 

Test Runner

 // do setup work setup // 3 light green polygons int green = getContext().getResources().getColor(R.color.dmb_rx_bucket1); verify(map, times(3)).addPolygon(argThat(new PolygonMatcher(green))); // 1 medium yellow polygons int yellow = getContext().getResources().getColor(R.color.dmb_rx_bucket4); verify(map, times(1)).addPolygon(argThat(new PolygonMatcher(yellow))); // 3 red polygons int orange = getContext().getResources().getColor(R.color.dmb_rx_bucket5); verify(map, times(3)).addPolygon(argThat(new PolygonMatcher(orange))); // 2 red polygons int red = getContext().getResources().getColor(R.color.dmb_rx_bucket7); verify(map, times(2)).addPolygon(argThat(new PolygonMatcher(red))); 

Vous pouvez vous référer à ce qui suit:

 Mockito.verify(mockedObject).someMethodOnMockedObject(eq(desiredObject)) 

Cela permettra de vérifier si la méthode de mockedObject est appelée avec parameterObjected comme paramètre.

Le javadoc pour refEq a mentionné que le contrôle de l’égalité est superficiel! Vous pouvez trouver plus de détails sur le lien ci-dessous:

[ https://static.javadoc.io/org.mockito/mockito-core/2.2.29/org/mockito/ArgumentMatchers.html#refEq ( T,%20java.lang.Ssortingng…)] <

Le problème de “l’égalité peu profonde” ne peut pas être contrôlé lorsque vous utilisez d’autres classes qui n’implémentent pas la méthode .equals (), la classe “DefaultMongoTypeMapper” est un exemple où la méthode .equals () n’est pas implémentée.

org.springframework.beans.factory.support propose une méthode qui peut générer une définition de bean au lieu de créer une instance de l’object, et peut être utilisée pour supprimer les échecs de comparaison.

  genericBeanDefinition(DefaultMongoTypeMapper.class) .setScope(SCOPE_SINGLETON) .setAutowireMode(AUTOWIRE_CONSTRUCTOR) .setLazyInit(false) .addConstructorArgValue(null) .getBeanDefinition() 

** “La définition du bean est seulement une description du bean, pas un bean lui-même. Les descriptions du bean implémentent correctement equals () et hashCode (), donc plutôt que de créer un nouveau DefaultMongoTypeMapper (), nous fournissons une définition devrait en créer un ”

Dans votre exemple, vous pouvez faire quelque chose comme ça

 Mockito.verify(mockedObject) .doSoething(genericBeanDefinition(YourClass.class).setA("a") .getBeanDefinition());