为什么我们不能使用Mockito为参数化构造函数创建间谍

问题描述

我的代码中只有参数化的构造函数，我需要通过它进行注入.

I have only parameterized constructor in my code and i need to inject through it.

我想监视参数化的构造函数，以将模拟对象作为对我的junit的依赖项注入.

I want to spy parameterized constructor to inject mock object as dependency for my junit.

public RegDao(){
 //original object instantiation here
Notification ....
EntryService .....
}

public RegDao(Notification notification , EntryService entry) {
 // initialize here
}

we have something like below :
RegDao dao = Mockito.spy(RegDao.class);

但是我们有什么东西可以将模拟对象注入到构造函数中并对其进行监视吗?.

But do we have something that i can inject mocked object in the Constructor and spy it?.

推荐答案

您可以通过在junit中使用参数化的构造函数实例化您的主类，然后从中创建一个间谍来做到这一点.

You can do that by instantiating your main class with parametrized constructor in your junit and then creating a spy from it.

让我们假设您的主要课程是A.其中B和C是其依赖项

Let's suppose your main class is A. Where B and C are its dependencies

public class A {

    private B b;

    private C c;

    public A(B b,C c)
    {
        this.b=b;
        this.c=c;
    }

    void method() {
        System.out.println("A's method called");
        b.method();
        c.method();
        System.out.println(method2());

    }

    protected int method2() {
        return 10;
    }
}

然后您可以使用如下所示的参数化类为此编写junit

Then you can write junit for this using your parametrized class as below

@RunWith(MockitoJUnitRunner.class)
public class ATest {

    A a;

    @Mock
    B b;

    @Mock
    C c;

    @Test
    public void test() {
        a=new A(b, c);
        A spyA=Mockito.spy(a);

        doReturn(20).when(spyA).method2();

        spyA.method();
    }
}

测试类的输出

A's method called
20

1. 此处B和C是使用参数化构造函数注入类A中的模拟对象.
2. 然后我们创建了A的spy，称为spyA.
3. 我们通过修改类A中受保护方法method2的返回值来检查spy是否确实有效，如果spyA不是A的实际spy，则不可能实现

1. Here B and C are mocked object that you injected in your class A using parametrized constructor.
2. Then we created a spy of A called spyA.
3. We checked if spy is really working by modifying the return value of a protected method method2 in class A which could not have been possible if spyA was not an actual spy of A.

这篇关于为什么我们不能使用Mockito为参数化构造函数创建间谍的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！