问题描述

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

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. 然后我们创建了一个名为 spyA 的 A 的 spy.
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 为参数化构造函数创建间谍的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持跟版网！