Перевірте значення атрибута об'єкта за допомогою mockito

У мене є виклик методу, який я хочу знущатися з mockito. Для початку я створив і ввів екземпляр об'єкта, за яким буде викликаний метод. Моя мета - перевірити один із об'єктів у виклику методу.

Чи є спосіб, що mockito дозволяє стверджувати або перевіряти об'єкт і його атрибути, коли викликається метод макету?

приклад

Mockito.verify(mockedObject)
       .someMethodOnMockedObject(
              Mockito.<SomeObjectAsArgument>anyObject())

Замість того, щоб робити, anyObject()я хочу перевірити, чи об'єкт аргументу містить деякі конкретні поля

Mockito.verify(mockedObject)
       .someMethodOnMockedObject(
              Mockito.<SomeObjectAsArgument>**compareWithThisObject()**)

Нова функція, додана до Mockito, робить це ще простіше,

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

Погляньте на документацію Mockito

У випадку, коли існує більше ніж один параметр, і потрібне захоплення лише одного парамуму, використовуйте інші ArgumentMatchers, щоб обернути решту аргументів:

verify(mock).doSomething(eq(someValue), eq(someOtherValue), argument.capture());
assertEquals("John", argument.getValue().getName());

Я думаю, що найпростішим способом перевірки об’єкта аргументу є використання refEqметоду:

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

Він може бути використаний, навіть якщо об'єкт не реалізує equals(), оскільки використовується рефлексія. Якщо ви не хочете порівнювати деякі поля, просто додайте їх імена як аргументи refEq.

Ще одна можливість, якщо ви не хочете використовувати ArgumentCaptor(наприклад, тому що ви також використовуєте заглушку), - це використовувати Hamcrest Matchers у поєднанні з Mockito.

import org.mockito.Mockito
import org.hamcrest.Matchers
...

Mockito.verify(mockedObject).someMethodOnMockedObject(MockitoHamcrest.argThat(
    Matchers.<SomeObjectAsArgument>hasProperty("propertyName", desiredValue)));

Це відповідь, заснована на відповіді iraSenthil, але з анотацією ( Captor ). На мою думку, це має деякі переваги:

• це коротше
• легше читати
• він може обробляти дженерики без попереджень

Приклад:

@RunWith(MockitoJUnitRunner.class)
public class SomeTest{

    @Captor
    private ArgumentCaptor<List<SomeType>> captor;

    //...

    @Test 
    public void shouldTestArgsVals() {
        //...
        verify(mockedObject).someMethodOnMockedObject(captor.capture());

        assertThat(captor.getValue().getXXX(), is("expected"));
    }
}

Якщо ви використовуєте Java 8, ви можете використовувати вирази Lambda, щоб відповідати.

import java.util.Optional;
import java.util.function.Predicate;

import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;

public class LambdaMatcher<T> extends BaseMatcher<T>
{
    private final Predicate<T> matcher;
    private final Optional<String> description;

    public LambdaMatcher(Predicate<T> matcher)
    {
        this(matcher, null);
    }

    public LambdaMatcher(Predicate<T> matcher, String 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);
    }
}

Приклад виклику

@Test
public void canFindEmployee()
{
    Employee employee = new Employee("John");
    company.addEmployee(employee);

    verify(mockedDal).registerEmployee(argThat(new LambdaMatcher<>(e -> e.getName()
                                                                         .equals(employee.getName()))));
}

Більше інформації: http://source.coveo.com/2014/10/01/java8-mockito/

Вищезгадані рішення насправді не працювали в моєму випадку. Я не міг використовувати ArgumentCaptor, оскільки метод був викликаний кілька разів, і мені потрібно було перевірити кожен. Простий Матч з "argThat" зробив трюк легко.

Спеціальний відповідник

// custom matcher
private class PolygonMatcher extends ArgumentMatcher<PolygonOptions> {
    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);
    }
}

Тест-бігун

// 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)));

І дуже приємний і чистий розчин у кольтині від com.nhaarman.mockito_kotlin

verify(mock).execute(argThat {
    this.param = expected
})

Ви можете посилатися на таке:

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

Це дозволить перевірити, чи називається метод mockedObject з параметром desireObject як параметром.

Ще один простий спосіб зробити це:

import org.mockito.BDDMockito;    
import static org.mockito.Matchers.argThat;
import org.mockito.ArgumentMatcher;

BDDMockito.verify(mockedObject)
        .someMethodOnMockedObject(argThat(new ArgumentMatcher<TypeOfMethodArg>() {

            @Override
            public boolean matches(Object argument) {
                final TypeOfMethodArg castedArg = (TypeOfMethodArg) argument;

                // Make your verifications and return a boolean to say if it matches or not
                boolean isArgMarching = true;

                return isArgMarching;
            }
        }));

Явадок для refEq згадав, що перевірка рівності є дрібною! Детальнішу інформацію можна знайти за посиланням нижче:

[ https://static.javadoc.io/org.mockito/mockito-core/2.2.29/org/mockito/ArgumentMatchers.html#refEq T,%20java.lang.String...) обвинений1]

Проблему "малої рівності" неможливо контролювати, коли ви використовуєте інші класи, які не реалізують метод .equals (), клас "DefaultMongoTypeMapper" є прикладом, коли метод .equals () не реалізований.

org.springframework.beans.factory.support пропонує метод, який може генерувати визначення bean замість створення примірника об'єкта, і його можна використовувати для позбавлення від провалу порівняння.

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

** "Визначення bean - це лише опис bean, а не саме bean. Описи bean належним чином реалізують рівняння () та hashCode (), тому замість створення нового DefaultMongoTypeMapper () ми надаємо визначення, яке весною розповідає, як це має створити "

У вашому прикладі ви можете зробити щось подібне

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

Спрощене рішення, не створюючи новий клас реалізації Matcher та використовуючи лямбда-вираз:

        verify(mockObject).someMockMethod(argThat((SomeArgument arg) -> arg.fieldToMatch.equals(expectedFieldValue));