用参数模拟构造函数

89

我的课如下：

public class A {
    public A(String test) {
        bla bla bla
    }

    public String check() {
        bla bla bla
    }
}

在构造函数中的逻辑A(String test)和check()是我试图嘲弄的事情。我想要任何调用，例如：new A($$$any string$$$).check()返回一个虚拟字符串"test"。

我试过了：

 A a = mock(A.class); 
 when(a.check()).thenReturn("test");

 String test = a.check(); // to this point, everything works. test shows as "tests"

 whenNew(A.class).withArguments(Matchers.anyString()).thenReturn(rk);
 // also tried:
 //whenNew(A.class).withParameterTypes(String.class).withArguments(Matchers.anyString()).thenReturn(rk);

 new A("random string").check();  // this doesn't work

但这似乎不起作用。new A($$$any string$$$).check()仍在执行构造函数逻辑，而不是获取的模拟对象A。

java  junit  mocking  mockito  powermock 
— 圣杰
source
您嘲笑的check（）方法工作正常吗？
— 本格拉斯
@BenGlasser check（）正常。只是whenNew似乎根本不起作用。我也更新了说明。
— 圣杰

Answers:

93

您发布的代码适用于我的最新版本的Mockito和Powermockito。也许您还没有准备A？试试这个：

A.java

public class A {
     private final String test;

    public A(String test) {
        this.test = test;
    }

    public String check() {
        return "checked " + this.test;
    }
}

MockA.java

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

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

@RunWith(PowerMockRunner.class)
@PrepareForTest(A.class)
public class MockA {
    @Test
    public void test_not_mocked() throws Throwable {
        assertThat(new A("random string").check(), equalTo("checked random string"));
    }
    @Test
    public void test_mocked() throws Throwable {
         A a = mock(A.class); 
         when(a.check()).thenReturn("test");
         PowerMockito.whenNew(A.class).withArguments(Mockito.anyString()).thenReturn(a);
         assertThat(new A("random string").check(), equalTo("test"));
    }
}

两项测试均应通过嘲笑1.9.0，powermockito 1.4.12和junit 4.8.2通过

— 奥尔本
source
24
还要注意，如果构造函数是从另一个类调用的，则将其包括在PrepareForTest
— Jeff E
有人知道为什么在调用“ PowerMockito.whenNew”时我们应该准备自我吗？
— udayanga '18 -4-5
50

据我所知，您不能仅使用模拟方法来模拟构造方法。但是根据Mockito谷歌代码页上的Wiki，有一种方法可以通过在类中创建一个方法来模拟构造函数的行为，该方法返回该类的新实例。那么您可以模拟该方法。以下是直接摘自Mockito Wiki的摘录：

模式1-使用单行方法创建对象

要使用模式1（测试名为MyClass的类），您可以替换如下调用

   Foo foo = new Foo( a, b, c );

与

   Foo foo = makeFoo( a, b, c );

并编写单行方法

   Foo makeFoo( A a, B b, C c ) { 
        return new Foo( a, b, c );
   }

重要的是，在此方法中不要包含任何逻辑。仅创建对象的一行。原因是该方法本身永远不会进行单元测试。

当您测试类时，您测试的对象实际上将是Mockito间谍，并重写此方法以返回模拟。因此，您要测试的不是类本身，而是其稍作修改的版本。

您的测试课程可能包含以下成员

  @Mock private Foo mockFoo;
  private MyClass toTest = spy(new MyClass());

最后，在您的测试方法中，用类似下面的行模拟对makeFoo的调用

  doReturn( mockFoo )
      .when( toTest )
      .makeFoo( any( A.class ), any( B.class ), any( C.class ));

如果要检查传递给构造函数的参数，可以使用比any（）更特定的匹配器。

如果您只是想返回类的模拟对象，我认为这应该对您有用。无论如何，您可以在此处阅读有关模拟对象创建的更多信息：

http://code.google.com/p/mockito/wiki/MockingObjectCreation

— 本·格拉瑟
source
21
+1，我不喜欢需要调整源代码以使其更易于模仿的事实。多谢分享。
— 圣杰
22
拥有可测试性更高的源代码，或者在编写代码时避免可测试性反模式，从不坏。如果您编写的源代码更具可测试性，那么它会自动更易于维护。在自己的方法中隔离构造函数调用只是实现此目的的一种方法。
— 达伍德·伊本·卡里姆
1
编写可测试的代码是好的。由于A对C具有硬编码的依赖关系，被迫重新设计A类，以便我可以为依赖于A的B类编写测试，这感觉……不好。是的，最终代码会更好，但是最终我将重新设计几个类，以便完成一个测试的编写？
— 马克伍德
在我的经验中，@ MarkWood笨拙的测试经验通常表示某些设计缺陷。如果您正在测试构造函数，则需要IRL，您的代码可能会因工厂或某种依赖注入而大喊大叫。如果您针对这两种情况遵循典型的设计模式，则代码将变得更容易测试和使用。如果由于其中有大量逻辑而正在测试构造函数，则可能需要多态性层，或者可以将该逻辑移至初始化方法。
— Ben Glasser
12

不使用Powermock ....请参阅下面基于Ben Glasser答案的示例，因为我花了一些时间才弄清楚..希望可以节省一些时间...

原始班级：

public class AClazz {

    public void updateObject(CClazz cClazzObj) {
        log.debug("Bundler set.");
        cClazzObj.setBundler(new BClazz(cClazzObj, 10));
    } 
}

修改后的类别：

@Slf4j
public class AClazz {

    public void updateObject(CClazz cClazzObj) {
        log.debug("Bundler set.");
        cClazzObj.setBundler(getBObject(cClazzObj, 10));
    }

    protected BClazz getBObject(CClazz cClazzObj, int i) {
        return new BClazz(cClazzObj, 10);
    }
 }

测试班 

public class AClazzTest {

    @InjectMocks
    @Spy
    private AClazz aClazzObj;

    @Mock
    private CClazz cClazzObj;

    @Mock
    private BClazz bClassObj;

    @Before
    public void setUp() throws Exception {
        Mockito.doReturn(bClassObj)
               .when(aClazzObj)
               .getBObject(Mockito.eq(cClazzObj), Mockito.anyInt());
    }

    @Test
    public void testConfigStrategy() {
        aClazzObj.updateObject(cClazzObj);

        Mockito.verify(cClazzObj, Mockito.times(1)).setBundler(bClassObj);
    }
}
— 用户666
source
6

使用嘲笑，您可以使用withSettings（），例如，如果CounterService需要2个依赖关系，则可以将它们作为模仿传递：

UserService userService = Mockito.mock(UserService.class); SearchService searchService = Mockito.mock(SearchService.class); CounterService counterService = Mockito.mock(CounterService.class, withSettings().useConstructor(userService, searchService));

— 梅夫吕特兹迈德
source
我认为，这是最简单，最好的答案。谢谢。
— Eldon
4

Mockito在测试最终，静态和私有方法方面有局限性。

使用jMockit测试库，您可以非常简单明了地完成以下工作：

java.io.File类的模拟构造函数：

new MockUp<File>(){
    @Mock
    public void $init(String pathname){
        System.out.println(pathname);
        // or do whatever you want
    }
};
  • 公共构造函数名称应替换为$ init
  • 引发的参数和异常保持不变
  • 返回类型应定义为void

模拟一个静态方法：

  • 从方法模拟签名中删除静态
  • 方法签名保持不变，否则
— 阿米特·坎尼里亚（Amit Kaneria）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.