使用 Mockito 模拟局部范围对象的方法

Question

我需要一些帮助：

示例：

void method1{
    MyObject obj1=new MyObject();
    obj1.method1();
}

我想在测试中模拟 obj1.method1() ，但要透明，所以我不想制作和更改代码。 Mockito 有什么办法可以做到这一点吗？

Answer 1

@edutesoy 的答案指向 PowerMockito 的文档，并提到构造函数模拟作为提示，但没有提及如何将其应用于问题中的当前问题。

这是一个基于此的解决方案。从问题中获取代码：

public class MyClass {
    void method1 {
        MyObject obj1 = new MyObject();
        obj1.method1();
    }
}

以下测试将通过准备实例化它的类来创建 MyObject 实例类的模拟（在本例中我将其称为 MyClass）使用 PowerMock 并让 PowerMockito 存根 MyObject 类的构造函数，然后让您存根 MyObject 实例 方法1()调用：

@RunWith(PowerMockRunner.class)
@PrepareForTest(MyClass.class)
public class MyClassTest {
    @Test
    public void testMethod1() {      
        MyObject myObjectMock = mock(MyObject.class);
        when(myObjectMock.method1()).thenReturn(<whatever you want to return>);   
        PowerMockito.whenNew(MyObject.class).withNoArguments().thenReturn(myObjectMock);
        
        MyClass objectTested = new MyClass();
        objectTested.method1();
        
        ... // your assertions or verification here 
    }
}

这样您的内部 method1() 调用将返回您想要的内容。

如果您喜欢单行代码，您可以通过创建模拟和内联存根来缩短代码：

MyObject myObjectMock = when(mock(MyObject.class).method1()).thenReturn(<whatever you want>).getMock();   

Answer 2

如果您确实想避免接触此代码，可以使用 Powermockito （PowerMock for Mockito）。

有了这个，除其他外，您可以模拟新对象的构造简单的方法。

Answer 3

决不。您将需要一些依赖项注入，即不应实例化 obj1，而是应由某个工厂提供它。

MyObjectFactory factory;

public void setMyObjectFactory(MyObjectFactory factory)
{
  this.factory = factory;
}

void method1()
{
  MyObject obj1 = factory.get();
  obj1.method();
}

那么你的测试将如下所示：

@Test
public void testMethod1() throws Exception
{
  MyObjectFactory factory = Mockito.mock(MyObjectFactory.class);
  MyObject obj1 = Mockito.mock(MyObject.class);
  Mockito.when(factory.get()).thenReturn(obj1);
  
  // mock the method()
  Mockito.when(obj1.method()).thenReturn(Boolean.FALSE);

  SomeObject someObject = new SomeObject();
  someObject.setMyObjectFactory(factory);
  someObject.method1();

  // do some assertions
}

Answer 4

在最新的mockito版本和junit5中，无需PowerMock就可以模拟新实例的创建和静态方法。

查看 Mockito.mockConstruction() 和 Mockito.mockStatic() 方法。

在你的情况下：

try (MockedConstruction<MyObject> myobjectMockedConstruction = Mockito.mockConstruction(MyObject.class,
        (mock, context) -> {
            given(mock.method1()).willReturn("some result"); //any additional mocking
        })) {
    underTest.method1();
    assertThat(myobjectMockedConstruction.constructed()).hasSize(1);
    MyObject mock = myobjectMockedConstruction.constructed().get(0);
    verify(mock).method1();
}

Answer 5

您可以避免更改代码（尽管我推荐鲍里斯的答案）并模拟构造函数，就像在本示例中模拟方法内创建 File 对象一样。 不要忘记将创建文件的类放入@PrepareForTest中。

package hello.easymock.constructor;

import java.io.File;

import org.easymock.EasyMock;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.easymock.PowerMock;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
    
@RunWith(PowerMockRunner.class)
@PrepareForTest({File.class})
public class ConstructorExampleTest {
        
    @Test
    public void testMockFile() throws Exception {

        // first, create a mock for File
        final File fileMock = EasyMock.createMock(File.class);
        EasyMock.expect(fileMock.getAbsolutePath()).andReturn("/my/fake/file/path");
        EasyMock.replay(fileMock);

        // then return the mocked object if the constructor is invoked
        Class<?>[] parameterTypes = new Class[] { String.class };
        PowerMock.expectNew(File.class, parameterTypes , EasyMock.isA(String.class)).andReturn(fileMock);
        PowerMock.replay(File.class); 
    
        // try constructing a real File and check if the mock kicked in
        final String mockedFilePath = new File("/real/path/for/file").getAbsolutePath();
        Assert.assertEquals("/my/fake/file/path", mockedFilePath);
    }
}

Answer 6

如果您不喜欢使用 PowerMock，您可以尝试以下方式：

public class Example{
...
void method1(){
    MyObject obj1 = getMyObject();
    obj1.doSomething();
}

protected MyObject getMyObject(){
    return new MyObject();
}
...
}

像这样编写测试：

@Mock
MyObject mockMyObject;

@Test
void testMethod1(){
    Example spyExample = spy(new Example());
    when(spyExample.getMyObject()).thenReturn(mockMyObject);
    //stub if required
    doNothing().when(mockMyObject.doSomething());
    verify(mockMyObject).doSomething();
}

Answer 7

您可以通过在 MyObject 中创建工厂方法来实现此目的：

class MyObject {
    public static MyObject create() {
      return new MyObject();
    }
}

然后使用 PowerMock 模拟该方法。

但是，通过模拟本地范围对象的方法，您依赖于该方法的实现部分保持不变。因此，您将失去在不破坏测试的情况下重构该方法部分的能力。此外，如果您在模拟中存根返回值，那么您的单元测试可能会通过，但在使用真实对象时该方法可能会出现意外行为。

总之，您可能不应该尝试这样做。相反，让测试驱动您的代码（又名 TDD），您将得到一个解决方案，例如：

void method1(MyObject obj1) {
   obj1.method1();
}

传递依赖项，您可以轻松地模拟单元测试。