使用Mockito模拟类的成员变量

我是开发的新手，尤其是单元测试的新手。我想我的要求很简单，但是我很想知道其他人对此的想法。

假设我有两个这样的类-

public class First {

    Second second ;

    public First(){
        second = new Second();
    }

    public String doSecond(){
        return second.doSecond();
    }
}

class Second {

    public String doSecond(){
        return "Do Something";
    }
}

假设我正在编写单元测试到测试First.doSecond()方法。但是，假设我想像这样模拟Second.doSecond()课程。我正在使用Mockito执行此操作。

public void testFirst(){
    Second sec = mock(Second.class);
    when(sec.doSecond()).thenReturn("Stubbed Second");

    First first = new First();
    assertEquals("Stubbed Second", first.doSecond());
}

我看到模拟未生效，并且断言失败。没有办法模拟我要测试的类的成员变量。？

您需要提供一种访问成员变量的方式，以便您可以进行模拟传递（最常见的方式是使用参数的setter方法或构造函数）。

如果您的代码没有提供执行此操作的方法，则TDD（测试驱动开发）会将其错误地考虑在内。

如果您无法更改代码，则不可能这样做。但是我喜欢依赖注入，Mockito支持它：

public class First {    
    @Resource
    Second second;

    public First() {
        second = new Second();
    }

    public String doSecond() {
        return second.doSecond();
    }
}

您的测试：

@RunWith(MockitoJUnitRunner.class)
public class YourTest {
   @Mock
   Second second;

   @InjectMocks
   First first = new First();

   public void testFirst(){
      when(second.doSecond()).thenReturn("Stubbed Second");
      assertEquals("Stubbed Second", first.doSecond());
   }
}

这是非常容易的。

如果仔细查看代码，您会发现second测试中的属性仍然是的实例Second，而不是模拟（您不会将模拟传递给first代码中）。

最简单的方法是创建一个二传手second在First类和显式传递的模拟。

像这样：

public class First {

Second second ;

public First(){
    second = new Second();
}

public String doSecond(){
    return second.doSecond();
}

    public void setSecond(Second second) {
    this.second = second;
    }


}

class Second {

public String doSecond(){
    return "Do Something";
}
}

....

public void testFirst(){
Second sec = mock(Second.class);
when(sec.doSecond()).thenReturn("Stubbed Second");


First first = new First();
first.setSecond(sec)
assertEquals("Stubbed Second", first.doSecond());
}

另一个是将Second实例传递为First的构造函数参数。

如果您不能修改代码，我认为唯一的选择就是使用反射：

public void testFirst(){
    Second sec = mock(Second.class);
    when(sec.doSecond()).thenReturn("Stubbed Second");


    First first = new First();
    Field privateField = PrivateObject.class.
        getDeclaredField("second");

    privateField.setAccessible(true);

    privateField.set(first, sec);

    assertEquals("Stubbed Second", first.doSecond());
}

但是您可能可以，因为很少对不受您控制的代码进行测试（尽管可以想象一种情况，您必须测试外部库，因为它的作者没有:)）

如果您不能更改成员变量，那么另一种方法是使用powerMockit并调用

Second second = mock(Second.class)
when(second.doSecond()).thenReturn("Stubbed Second");
whenNew(Second.class).withAnyArguments.thenReturn(second);

现在的问题是，对new Second的任何调用都将返回相同的模拟实例。但是在您的简单情况下，这将起作用。

我有一个相同的问题，即未设置私有值，因为Mockito不会调用超级构造函数。这是我通过反射增强模拟的方式。

首先，我创建了一个TestUtils类，其中包含许多有用的工具，包括这些反射方法。每次都需要实现反射访问。我创建了这些方法来测试由于某种原因而没有模拟包的项目上的代码，并且没有邀请我包括它。

public class TestUtils {
    // get a static class value
    public static Object reflectValue(Class<?> classToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField  = reflectField(classToReflect, fieldNameValueToFetch);
            reflectField.setAccessible(true);
            Object reflectValue = reflectField.get(classToReflect);
            return reflectValue;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch);
        }
        return null;
    }
    // get an instance value
    public static Object reflectValue(Object objToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField  = reflectField(objToReflect.getClass(), fieldNameValueToFetch);
            Object reflectValue = reflectField.get(objToReflect);
            return reflectValue;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch);
        }
        return null;
    }
    // find a field in the class tree
    public static Field reflectField(Class<?> classToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField = null;
            Class<?> classForReflect = classToReflect;
            do {
                try {
                    reflectField = classForReflect.getDeclaredField(fieldNameValueToFetch);
                } catch (NoSuchFieldException e) {
                    classForReflect = classForReflect.getSuperclass();
                }
            } while (reflectField==null || classForReflect==null);
            reflectField.setAccessible(true);
            return reflectField;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch +" from "+ classToReflect);
        }
        return null;
    }
    // set a value with no setter
    public static void refectSetValue(Object objToReflect, String fieldNameToSet, Object valueToSet) {
        try {
            Field reflectField  = reflectField(objToReflect.getClass(), fieldNameToSet);
            reflectField.set(objToReflect, valueToSet);
        } catch (Exception e) {
            fail("Failed to reflectively set "+ fieldNameToSet +"="+ valueToSet);
        }
    }

}

然后，我可以使用这样的私有变量测试类。这对于在您也无法控制的类树中进行深度模拟非常有用。

@Test
public void testWithRectiveMock() throws Exception {
    // mock the base class using Mockito
    ClassToMock mock = Mockito.mock(ClassToMock.class);
    TestUtils.refectSetValue(mock, "privateVariable", "newValue");
    // and this does not prevent normal mocking
    Mockito.when(mock.somthingElse()).thenReturn("anotherThing");
    // ... then do your asserts
}

我在页面的实际项目中修改了代码。可能存在一两个编译问题。我认为您已大致了解。如果发现有用，请随时获取并使用它。

许多其他人已经建议您重新考虑您的代码以使其更具可测试性-好的建议并且通常比我要建议的更简单。

如果您无法更改代码以使其更具可测试性，请访问PowerMock：https：//code.google.com/p/powermock/

PowerMock扩展了Mockito（因此您不必学习新的模拟框架），并提供其他功能。这包括使构造函数返回模拟的能力。功能强大，但有点复杂-因此请谨慎使用。

您使用其他的模拟赛跑者。并且您需要准备要调用构造函数的类。（请注意，这是一个常见的陷阱-准备调用构造函数的类，而不是构造的类）

@RunWith(PowerMockRunner.class)
@PrepareForTest({First.class})

然后在测试设置中，可以使用whenNew方法使构造函数返回一个模拟

whenNew(Second.class).withAnyArguments().thenReturn(mock(Second.class));

是的，可以做到，如以下测试所示（使用我开发的JMockit模拟API编写）：

@Test
public void testFirst(@Mocked final Second sec) {
    new NonStrictExpectations() {{ sec.doSecond(); result = "Stubbed Second"; }};

    First first = new First();
    assertEquals("Stubbed Second", first.doSecond());
}

但是，对于Mockito，无法编写这样的测试。这是由于在Mockito中实现了模拟的方式，其中创建了要模拟的类的子类。仅此“ mock”子类的实例可以具有模拟行为，因此您需要让经过测试的代码使用它们，而不是任何其他实例。

如果您想在Mockito中替代Spring的ReflectionTestUtils，请使用

Whitebox.setInternalState(first, "second", sec);