JUnit使用Mocked类进行测试

Question

I need solution to write Junit test case for following method. all the classes are in different files and i want to write test case for method2 of class A .

How to use @mock in this case?

class A {
  static String method1(string a)
  {
    B b=new B;
    //some changes applied on a
    return b.method3(a);
  }

  String method2(String a)
  { 
    return A.method1(a);
  }
}

class B {
  String method3(String a)
  {
    C c=new C();
    //some changes applied on a
    return c.method4(a);
  }
}

class C {
  String method4(String a)
  {
    // some changes applied on a
    return a;
  }
}

Answer 1

Ideally, you should only test the layer you are concerned with but if you want to call class A , B and C method in single test case below is the solution. This solution si smore like integration test case.

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Spy;
import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class TestA {

    @Spy
    @InjectMocks
    private B b = new B();
    @Spy
    private C c = new C();  
    @InjectMocks
    private A a = new A();

    @Test
    public void testMethod1() {
        String val = a.method1("test");
        System.out.println(val);
    }   
}

class A {
    public B b;
    public String method2(String a){
        System.out.println("Inside method A.method2");
        return b.method3(a);
    }
    public String method1(String a){ 
        System.out.println("Inside method A.method1");
        return method2(a);
    }
}

class B {
    public C c;
    public String method3(String a){
        System.out.println("Inside method B.method3");
        return c.method4(a);
    }
}

class C {
    public String method4(String a){
        System.out.println("Inside method C.method4");
        return a;
    }
}

output will be as below

Inside method A.method1
Inside method A.method2
Inside method B.method3
Inside method C.method4
test

PS you can use @Mock instead of spy then remove the new operator of that field and Mock the behaviour of that class method.

Answer 2

There is some work to be done. First, dependent class must be injected using some IoC system, like using @Autowired or @Inject :

class A{

    @Autowired
    private B b;

    String method1(string a) {
       //some changes applied on a
       return b.method3(a);
    }

    String method2(String a){ 
       return method1(a);
    }
}

Then, you have to mock in a test like the following:

@RunWith(MockitoJUnitRunner.class)
public class TestA {

@Mock
private B b;

@InjectMocks
private A a;

public void testMethod1() {

    /* test code here */

    }

}

Also consider that B should be an interface, not a concrete class.