Xác minh giá trị thuộc tính đối tượng với mockito

Tôi có một cuộc gọi phương thức mà tôi muốn chế giễu với mockito. Để bắt đầu, tôi đã tạo và chèn một thể hiện của một đối tượng mà phương thức sẽ được gọi. Mục đích của tôi là xác minh một trong các đối tượng trong cuộc gọi phương thức.

Có cách nào mockito cho phép bạn xác nhận hoặc xác minh đối tượng và thuộc tính của nó khi phương thức giả được gọi không?

thí dụ

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

Thay vì làm, anyObject()tôi muốn kiểm tra đối tượng đối số có chứa một số trường cụ thể

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

Tính năng mới được thêm vào Mockito giúp việc này trở nên dễ dàng hơn,

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

Hãy xem tài liệu của Mockito

Trong trường hợp khi có nhiều hơn một tham số và chỉ cần chụp một tham số duy nhất, hãy sử dụng các đối số ArgumentMatchers khác để bọc phần còn lại của các đối số:

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

Tôi nghĩ cách dễ nhất để xác minh một đối tượng đối số là sử dụng refEqphương thức:

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

Nó có thể được sử dụng ngay cả khi đối tượng không thực hiện equals(), vì phản xạ được sử dụng. Nếu bạn không muốn so sánh một số trường, chỉ cần thêm tên của chúng làm đối số cho refEq.

Một khả năng nữa, nếu bạn không muốn sử dụng ArgumentCaptor(ví dụ, vì bạn cũng đang sử dụng tính năng khai thác), là sử dụng Bộ so khớp Hamcrest kết hợp với Mockito.

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

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

Đây là câu trả lời dựa trên câu trả lời từ iraSenthil nhưng có chú thích ( Captor ). Theo tôi nó có một số lợi thế:

• nó ngắn hơn
• nó dễ đọc hơn
• nó có thể xử lý thuốc generic mà không cần cảnh báo

Thí dụ:

@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"));
    }
}

Nếu bạn đang sử dụng Java 8, bạn có thể sử dụng các biểu thức Lambda để khớp.

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

Cuộc gọi ví dụ

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

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

Thông tin thêm: http://source.coveo.com/2014/10/01/java8-mockito/

Các giải pháp trên không thực sự hiệu quả trong trường hợp của tôi. Tôi không thể sử dụng ArgumentCaptor vì phương thức được gọi nhiều lần và tôi cần xác thực từng cái. Một Matcher đơn giản với "argThat" đã thực hiện thủ thuật một cách dễ dàng.

Trình so khớp tùy chỉnh

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

Người chạy thử

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

Và giải pháp rất hay và sạch trong koltin từ com.nhaarman.mockito_kotlin

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

Bạn có thể tham khảo như sau:

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

Điều này sẽ xác minh xem phương thức của mockedObject có được gọi với tham số mong muốn không.

Một cách dễ dàng khác để làm như vậy:

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

Các javadoc cho refEq đã đề cập rằng kiểm tra bình đẳng là nông cạn! Bạn có thể tìm thêm chi tiết tại liên kết dưới đây:

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

Vấn đề "bình đẳng nông" không thể được kiểm soát khi bạn sử dụng các lớp khác không triển khai phương thức .equals (), lớp "DefaultMongoTypeMapper" là một ví dụ trong đó phương thức .equals () không được triển khai.

org.springframework.beans.factory.support cung cấp một phương thức có thể tạo ra một định nghĩa bean thay vì tạo một thể hiện của đối tượng và nó có thể được sử dụng để loại bỏ Lỗi so sánh.

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

** "Định nghĩa bean chỉ là một mô tả về bean chứ không phải là bean. Các mô tả bean thực hiện đúng bằng () và hashCode (), vì vậy thay vì tạo một DefaultMongoTypeMapper () mới, chúng tôi cung cấp một định nghĩa cho mùa xuân biết nó như thế nào nên tạo một "

Trong ví dụ của bạn, bạn có thể làm điều gì đó như thế này

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

Một giải pháp đơn giản hóa mà không cần tạo lớp triển khai Matcher mới và sử dụng biểu thức lambda:

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