示例代码

以下是代码的简化示例。生产版本要复杂得多。

public class Example {
    public static enum EntryType {
        TYPE_1,
        TYPE_2
    }

    public static class Thing {
        List<String> data = new ArrayList<String>();
        EnumSet<EntryType> failedConversions = EnumSet.noneOf(EntryType.class);
    }

    public static class MyHelper {
        public String unmarshal(String input) throws UnmarshalException {
            // pretend this does more complicated stuff
            return input + " foo "; 
        }
    }

    public static class MyService {

        MyHelper adapter = new MyHelper();

        public Thing process() {
            Thing processed = new Thing();

            try {
                adapter.unmarshal("Type 1");
            } catch (UnmarshalException e) {
                processed.failedConversions.add(EntryType.TYPE_1);
            }

            // do some stuff

            try {
                adapter.unmarshal("Type 2");
            } catch (UnmarshalException e) {
                processed.failedConversions.add(EntryType.TYPE_2);
            }

            return processed;
        }
    }
}

我尝试过的事情

这是我尝试过的一系列事情。为简洁起见，我没有填写所有平凡的细节。

间谍

以下方法不执行任何操作，并且不抛出异常。我不确定为什么。

@Test
public void shouldFlagFailedConversionUsingSpy()
        throws Exception {
    MyHelper spied = spy(fixture.adapter);
    doThrow(new UnmarshalException("foo")).when(spied).unmarshal(
            Mockito.eq("Type 1"));

    Thing actual = fixture.process();
    assertEquals(1, actual.failedConversions.size());
    assertThat(actual.failedConversions.contains(EntryType.TYPE_1), is(true));
}

嘲讽

以下操作不起作用，因为部分模拟似乎不能很好地抛出异常的方法。

@Test
public void shouldFlagFailedConversionUsingMocks()
        throws Exception {
    MyHelper mockAdapter = mock(MyHelper.class);
    when(mockAdapter.unmarshal(Mockito.anyString())).thenCallRealMethod();
    when(mockAdapter.unmarshal(Mockito.eq("Type 2"))).thenThrow(
            new UnmarshalException("foo"));

    Thing actual = fixture.process();
    assertEquals(1, actual.failedConversions.size());
    assertThat(actual.failedConversions.contains(EntryType.TYPE_2), is(true));
}

ThenAnswer

这有效，但我不确定这是否是正确的方法：

@Test
public void shouldFlagFailedConversionUsingThenAnswer() throws Exception {
    final MyHelper realAdapter = new MyHelper();
    MyHelper mockAdapter = mock(MyHelper.class);
    fixture.adapter = mockAdapter;

    when(mockAdapter.unmarshal(Mockito.anyString())).then(
            new Answer<String>() {

                @Override
                public String answer(InvocationOnMock invocation)
                        throws Throwable {
                    Object[] args = invocation.getArguments();
                    String input = (String) args[0];
                    if (input.equals("Type 1")) {
                        throw new UnmarshalException("foo");
                    }
                    return realAdapter.unmarshal(input);
                }

            });

    Thing actual = fixture.process();
    assertEquals(1, actual.failedConversions.size());
    assertThat(actual.failedConversions.contains(EntryType.TYPE_1), is(true));
}

问题

尽管thenAnswer方法有效，但它似乎不是正确的解决方案。在这种情况下执行局部模拟的正确方法是什么？

Answer 1

我不是非常确定你在嘲笑和间谍活动中得到了什么，但你真的需要在这里嘲笑。

首先，无论出于何种原因，我在尝试嘲笑时遇到了一些障碍。我认为这与以某种方式搞砸的spy电话有关。我最终克服了这些，但我希望能够通过一些简单的方法。

接下来，我确实注意到你的间谍方式（我的方法的基础）：

MyHelper spied = spy(fixture.adapter);

这意味着你想要一个MyHelper实例被嘲笑，不是间谍。最糟糕的是，即使这个物体是完全水合的，它也不会被正确注入，因为你还没有将它重新分配给测试对象（我认为是fixture）。

我的偏好是使用MockitoJUnitRunner来帮助注入模拟实例，并从那里建立了我实际需要模拟的基础。

只有一个模拟实例，然后是测试对象，这个声明将确保它们实例化并注入：

@RunWith(MockitoJUnitRunner.class)
public class ExampleTest {

    @Mock
    private MyHelper adapter;

    @InjectMocks
    private MyService fixture;
}

您的想法是将模拟注入灯具中。你不必使用它 - 你可以在@Before声明中使用标准的setter，但我更喜欢这个，因为它大大减少了你必须编写的样板代码才能让模拟工作。

现在只进行一项更改：删除间谍实例并将其先前的用法替换为实际的模拟。

doThrow(new UnmarshalException("foo")).when(adapter).unmarshal(eq("Type 1"));

随着所有代码的提升，这传递了：

@RunWith(MockitoJUnitRunner.class)
public class ExampleTest {
    @Mock
    private MyHelper adapter;

    @InjectMocks
    private MyService fixture;

    @Test
    public void shouldFlagFailedConversionUsingSpy()
            throws Exception {

        doThrow(new UnmarshalException("foo")).when(adapter).unmarshal(eq("Type 1"));

        Thing actual = fixture.process();
        assertEquals(1, actual.failedConversions.size());
        assertThat(actual.failedConversions.contains(Example.EntryType.TYPE_1), is(true));
    }
}

不想让问题/用例不完整，我绕着圈子替换了内部类的测试，它也可以正常工作：

@RunWith(MockitoJUnitRunner.class)
public class ExampleTest {
    @Mock
    private Example.MyHelper adapter;

    @InjectMocks
    private Example.MyService fixture;

    @Test
    public void shouldFlagFailedConversionUsingSpy()
            throws Exception {

        doThrow(new UnmarshalException("foo")).when(adapter).unmarshal(eq("Type 1"));

        Example.Thing actual = fixture.process();
        assertEquals(1, actual.failedConversions.size());
        assertThat(actual.failedConversions.contains(Example.EntryType.TYPE_1), is(true));
    }
}

如何使用Mockito部分模拟抛出异常的方法？

示例代码

我尝试过的事情

间谍

嘲讽

ThenAnswer

问题

1 个答案: