Sử dụng Mockito để mô phỏng các lớp với các tham số chung

Có một phương pháp sạch để chế nhạo một lớp với các tham số chung không? Nói rằng tôi phải chế nhạo một lớp Foo<T>mà tôi cần truyền vào một phương thức mong đợi mộtFoo<Bar> . Tôi có thể làm như sau đủ dễ dàng:

Foo mockFoo = mock(Foo.class);
when(mockFoo.getValue).thenReturn(new Bar());

Giả sử getValue()trả về loại chung T. Nhưng điều đó sẽ có mèo con khi sau này tôi chuyển nó thành một phương pháp mong đợi Foo<Bar>. Là đúc phương tiện duy nhất để làm điều này?

Tôi nghĩ rằng bạn cần phải bỏ nó, nhưng nó không quá tệ:

Foo<Bar> mockFoo = (Foo<Bar>) mock(Foo.class);
when(mockFoo.getValue()).thenReturn(new Bar());

Một cách khác để sử dụng là sử dụng @Mock chú thích thay thế. Không hoạt động trong mọi trường hợp, nhưng trông quyến rũ hơn nhiều :)

Đây là một ví dụ:

@RunWith(MockitoJUnitRunner.class)
public class FooTests {

    @Mock
    public Foo<Bar> fooMock;

    @Test
    public void testFoo() {
        when(fooMock.getValue()).thenReturn(new Bar());
    }
}

Việc MockitoJUnitRunnerkhởi tạo các trường được chú thích bằng @Mock.

Bạn luôn có thể tạo một lớp / giao diện trung gian thỏa mãn loại chung mà bạn muốn chỉ định. Ví dụ: nếu Foo là một giao diện, bạn có thể tạo giao diện sau trong lớp thử nghiệm của mình.

private interface FooBar extends Foo<Bar>
{
}

Trong trường hợp Foo là một lớp không phải là cuối cùng , bạn có thể mở rộng lớp với mã sau đây và làm điều tương tự:

public class FooBar extends Foo<Bar>
{
}

Sau đó, bạn có thể sử dụng một trong các ví dụ trên với mã sau:

Foo<Bar> mockFoo = mock(FooBar.class);
when(mockFoo.getValue()).thenReturn(new Bar());

Tạo một phương thức thử nghiệm tiện ích . Đặc biệt hữu ích nếu bạn cần nó nhiều lần.

@Test
public void testMyTest() {
    // ...
    Foo<Bar> mockFooBar = mockFoo();
    when(mockFooBar.getValue).thenReturn(new Bar());

    Foo<Baz> mockFooBaz = mockFoo();
    when(mockFooBaz.getValue).thenReturn(new Baz());

    Foo<Qux> mockFooQux = mockFoo();
    when(mockFooQux.getValue).thenReturn(new Qux());
    // ...
}

@SuppressWarnings("unchecked") // still needed :( but just once :)
private <T> Foo<T> mockFoo() {
    return mock(Foo.class);
}

Tôi đồng ý rằng người ta không nên ngăn chặn các cảnh báo trong các lớp hoặc phương thức vì người ta có thể bỏ qua các cảnh báo khác, vô tình bị triệt tiêu. Nhưng IMHO hoàn toàn hợp lý để ngăn chặn một cảnh báo chỉ ảnh hưởng đến một dòng mã.

@SuppressWarnings("unchecked")
Foo<Bar> mockFoo = mock(Foo.class);

Đây là một trường hợp thú vị: phương thức nhận bộ sưu tập chung và trả về bộ sưu tập chung có cùng loại cơ sở. Ví dụ:

Collection<? extends Assertion> map(Collection<? extends Assertion> assertions);

Phương pháp này có thể được mô phỏng bằng sự kết hợp của trình so khớp Mockito anyCollectionOf và Câu trả lời.

when(mockedObject.map(anyCollectionOf(Assertion.class))).thenAnswer(
     new Answer<Collection<Assertion>>() {
         @Override
         public Collection<Assertion> answer(InvocationOnMock invocation) throws Throwable {
             return new ArrayList<Assertion>();
         }
     });