Mockito:如何在方法中创建的对象上调用方法？

Question

我是Mockito的新手.

鉴于下面的类,我如何使用Mockito来验证someMethod在调用之后是否被调用了一次foo？

public class Foo
{
    public void foo(){
        Bar bar = new Bar();
        bar.someMethod();
    }
}

我想进行以下验证通话,

verify(bar, times(1)).someMethod();

在哪里bar是一个模拟的实例Bar.

Answer 1

依赖注入

如果您注入Bar实例或用于创建Bar实例的工厂(或其他483种方法之一),您将拥有执行测试所需的访问权限.

工厂示例:

给定一个这样编写的Foo类:

public class Foo {
  private BarFactory barFactory;

  public Foo(BarFactory factory) {
    this.barFactory = factory;
  }

  public void foo() {
    Bar bar = this.barFactory.createBar();
    bar.someMethod();
  }
}

在你的测试方法中,你可以像这样注入一个BarFactory:

@Test
public void testDoFoo() {
  Bar bar = mock(Bar.class);
  BarFactory myFactory = new BarFactory() {
    public Bar createBar() { return bar;}
  };

  Foo foo = new Foo(myFactory);
  foo.foo();

  verify(bar, times(1)).someMethod();
}

额外奖励:这是TDD如何推动代码设计的一个例子.

Answer 2

经典的回答是,"你没有." 您测试公共API Foo,而不是其内部.

是否存在受到影响的Foo对象(或不太好,环境中的其他对象)的任何行为foo()？如果是这样,请测试一下.如果没有,该方法有何作用？

Answer 3

如果您不想使用DI或工厂.您可以通过一些棘手的方式重构您的课程:

public class Foo {
    private Bar bar;

    public void foo(Bar bar){
        this.bar = (bar != null) ? bar : new Bar();
        bar.someMethod();
        this.bar = null;  // for simulating local scope
    }
}

而你的测试班:

@RunWith(MockitoJUnitRunner.class)
public class FooTest {
    @Mock Bar barMock;
    Foo foo;

    @Test
    public void testFoo() {
       foo = new Foo();
       foo.foo(barMock);
       verify(barMock, times(1)).someMethod();
    }
}

那么调用你的foo方法的类就会这样做:

public class thirdClass {

   public void someOtherMethod() {
      Foo myFoo = new Foo();
      myFoo.foo(null);
   }
}

正如您在以这种方式调用方法时所看到的那样,您不需要在调用您的foo方法的任何其他类中导入Bar类,这可能是您想要的.

当然缺点是你允许调用者设置Bar Object.

希望能帮助到你.

Answer 4

使用的示例代码解决方案 PowerMockito.whenNew

• mockito-all 1.10.8
• powermock-core 1.6.1
• powermock-module-junit4 1.6.1
• powermock-api-mockito 1.6.1
• junit 4.12

FooTest.java

package foo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

//Both @PrepareForTest and @RunWith are needed for `whenNew` to work 
@RunWith(PowerMockRunner.class)
@PrepareForTest({ Foo.class })
public class FooTest {

    // Class Under Test
    Foo cut;

    @Mock
    Bar barMock;

    @Before
    public void setUp() throws Exception {
        cut = new Foo();

    }

    @After
    public void tearDown() {
        cut = null;

    }

    @Test
    public void testFoo() throws Exception {

        // Setup
        PowerMockito.whenNew(Bar.class).withNoArguments()
                .thenReturn(this.barMock);

        // Test
        cut.foo();

        // Validations
        Mockito.verify(this.barMock, Mockito.times(1)).someMethod();

    }

}

JUnit输出

Answer 5

我认为Mockito @InjectMocks是要走的路.

根据您的意图,您可以使用:

1. 构造函数注入
2. 物业二传手注射
3. 现场注射

更多信息在docs中

以下是现场注入的示例:

类别:

public class Foo
{
    private Bar bar = new Bar();

    public void foo() 
    {
        bar.someMethod();
    }
}

public class Bar
{
    public void someMethod()
    {
         //something
    }
}

测试:

@RunWith(MockitoJUnitRunner.class)
public class FooTest
{
    @Mock
    Bar bar;

    @InjectMocks
    Foo foo;

    @Test
    public void FooTest()
    {
        doNothing().when( bar ).someMethod();
        foo.foo();
        verify(bar, times(1)).someMethod();
    }
}

Answer 6

是的，如果您确实想要/需要这样做，您可以使用 PowerMock。这应该被视为最后的手段。使用 PowerMock，您可以使其从对构造函数的调用中返回模拟。然后在模拟上进行验证。也就是说，csturtz 的答案是“正确”的。

这是新对象的模拟构造的链接