使用 Mockito 模拟具有泛型参数的类

Question

是否有一种干净的方法来模拟带有泛型参数的类？假设我必须模拟一个 Foo 类，我需要将其传递到需要 Foo 的方法中。我可以很容易地执行以下操作：

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

假设 getValue() 返回泛型类型 T。但是，当我稍后将其传递到需要 Foo 的方法时，就会有小猫。铸造是做到这一点的唯一方法吗？

Answer 1

我认为你确实需要投射它，但它应该不会太糟糕：

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

Answer 2

另一种解决方法是使用 @Mock 注释。
并非在所有情况下都有效，但看起来更性感:)

这是一个示例：

@RunWith(MockitoJUnitRunner.class)
public class FooTests {

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

MockitoJUnitRunner 初始化用 @Mock。

Answer 3

您始终可以创建一个中间类/接口来满足您想要指定的泛型类型。例如，如果 Foo 是一个接口，您可以在测试类中创建以下接口。

private interface FooBar extends Foo<Bar>
{
}

在 Foo 是非最终类的情况下，您可以使用以下代码扩展该类并执行相同的操作：

public class FooBar extends Foo<Bar>
{
}

然后您可以使用以下代码使用上述示例之一：

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

Answer 4

创建一个测试实用方法。如果您多次需要它，则特别有用。

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

Answer 5

我同意不应抑制类或方法中的警告，因为人们可能会忽略其他意外抑制的警告。但恕我直言，抑制仅影响单行代码的警告是绝对合理的。

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

Answer 6

对于 JUnit5，我认为最好的方法是在方法参数或字段中使用 @ExtendWith(MockitoExtension.class) 和 @Mock。

以下示例通过 Hamcrest 匹配器演示了这一点。

package com.vogella.junit5;                                                                    
                                                                                               
import static org.hamcrest.MatcherAssert.assertThat;                                           
import static org.hamcrest.Matchers.hasItem;                                                   
import static org.mockito.Mockito.verify;                                                      
                                                                                               
import java.util.Arrays;                                                                       
import java.util.List;                                                                         
                                                                                               
import org.junit.jupiter.api.Test;                                                             
import org.junit.jupiter.api.extension.ExtendWith;                                             
import org.mockito.ArgumentCaptor;                                                             
import org.mockito.Captor;                                                                     
import org.mockito.Mock;                                                                       
import org.mockito.junit.jupiter.MockitoExtension;                                             
                                                                                               
@ExtendWith(MockitoExtension.class)                                                            
public class MockitoArgumentCaptureTest {                                                      
                                                                                               
                                                                                               
    @Captor                                                                                    
    private ArgumentCaptor<List<String>> captor;                                               
                                                                                               
    @Test                                                                                      
    public final void shouldContainCertainListItem(@Mock List<String> mockedList) {            
        var asList = Arrays.asList("someElement_test", "someElement");                         
        mockedList.addAll(asList);                                                             
                                                                                               
        verify(mockedList).addAll(captor.capture());                                           
        List<String> capturedArgument = captor.getValue();                                     
        assertThat(capturedArgument, hasItem("someElement"));                                  
    }                                                                                          
}                                                                                              
                                                                                              

请参阅https://www.vogella.com/tutorials/Mockito/article.html 所需的 Maven/Gradle 依赖项。

Answer 7

正如其他答案所提到的，没有一个很好的方法来使用 mock() & 。直接使用 spy() 方法，无需不安全的泛型访问和/或抑制泛型警告。

Mockito 项目中当前存在一个未解决的问题 (#1531)，以添加对使用的支持mock() &没有泛型警告的 spy() 方法。该问题于 2018 年 11 月提出，但没有任何迹象表明它会被优先处理。根据 Mockito 贡献者对此问题的评论之一：

鉴于 .class 不能很好地与泛型配合，我认为我们在 Mockito 中无法提供任何解决方案。您已经可以执行 @Mock （JUnit5 扩展还允许方法参数 @Mock），这应该是一个合适的替代方案。因此，我们可以让这个问题保持开放状态，但考虑到 @Mock 是一个更好的 API，它不太可能得到解决。

Answer 8

JUnit5：在测试类上使用@ExtendWith(MockitoExtension.class)，然后添加此字段：

@Mock
Foo<Bar> barMock;

Answer 9

所以你有这个：

Foo mockFoo = mock(Foo.class);

修复它的方法，从我最不喜欢到最喜欢：

1. 使用 @SuppressWarnings("unchecked") 注释。并不能真正解决问题，但您将不再收到警告。

@SuppressWarnings("unchecked")
Foo mockFoo = mock(Foo.class);
when(mockFoo.getValue).thenReturn(new Bar());

2. 投射它。不幸的是，尽管它仍然发出警告。所以这里也需要使用注解：

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

3. 使用@Mock注解。不会有任何警告。这里，实际测试时可以添加when。

@Mock
public Foo<Bar> fooMock;

4. 使用@MockBean注解。这将直接创建一个模拟 bean。没有警告。

@MockBean
public Foo<Bar> fooMock;

Answer 10

这是一个有趣的案例：方法接收泛型集合并返回相同基类型的泛型集合。例如：

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

可以使用 Mockito anyCollectionOf 匹配器和答案的组合来模拟此方法。

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

Answer 11

（在我看来）最简单、最易读的方法是使用方法级注入。

这将导致测试方法中包含所有测试数据。这将使您的测试类保持干净，因为没有“浮动”模拟。

@ExtendWith(MockitoExtension.class)
public class SomeClassTest {

    @Test
    void someTestMethod(@Mock Foo<Bar> fooMock) {
        // do something with your mock
    }
    
}

Answer 12

为什么不使用间谍

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