Testing a Function using Mock - junit

Question

I want to test a function which has a call to another function inside it(which accepts two parameters)
I want to mock that inside function.But I am having difficulty in what to pass as a parameter
void func(classA a,classB b)
{
List<ClassC> list= Objd.func2(a.getSome(),b)
///some other things
}
now I want to mock this func2 , I already have an interface for class of obj C.
I tried using
InterfaceClassD objD=Mockito.mock(InterfaceClassD.class)
Mockito.when(obj.func2(a.getsome(),b)).thenreturn(null);
but it doesn't work,the func2 executes
I even tried
InterfaceClassD objD=Mockito.mock(InterfaceClassD.class)
Mockito.when(obj.func2(anyList(),any(classB.class)).thenreturn(null);
NOTE - a.getSome() returns list
but it too doesn't work,the func2 executes

Answer 1

It's hard to answer this question without more context.
In the function "func", where does the reference to "Objd" come from? Where is it declared?
There are two steps in creating and using mocks in a test:
creating the mock
injecting the mock
"Injecting the mock" refers to (somehow) replacing the reference to the real object that the function will use with the mock version you've created with Mockito.
Example:
// Class under test
public class Foo {
// this is the object we need to mock
private InterfaceClassD objD;
void func(classA a,classB b) {
// here is where we use "objD"
List<ClassC> list= objD.func2(a.getSome(),b)
///some other things
}
}
In order to write a test with a mock objD you have to replace the "real" objD with the mock just before you invoke the method (function) being tested.
Typically it is done with either constructor injection, setter injection, or Mockito annotations.
Example with constructor injection:
// Class under test
public class Foo {
// this is the object we need to mock
private InterfaceClassD objD;
// constructor injection
public Foo(InterfaceClassD objD) {
this.objD = objD;
}
void func(classA a,classB b) {
// here is where we use "objD"
List<ClassC> list= objD.func2(a.getSome(),b);
///some other things
}
}
// Unit test
public class FooTest {
#Test
public void someTest() {
// create the mock:
InterfaceClassD mock = Mockito.mock(InterfaceClassD.class);
// inject the mock:
Foo foo = new Foo(objD);
// test: this should call method func but use the mock
foo.func(dummyA, dummyB);
// verify/assert something...
}
}
Example using setter injection:
// Class under test
public class Foo {
// this is the object we need to mock
private InterfaceClassD objD;
// setter injection
public void setInterfaceClassD(InterfaceClassD objD) {
this.objD = objD;
}
void func(classA a,classB b) {
// here is where we use "objD"
List<ClassC> list= objD.func2(a.getSome(),b);
///some other things
}
}
// Unit test
public class FooTest {
#Test
public void someTest() {
// create the mock:
InterfaceClassD mock = Mockito.mock(InterfaceClassD.class);
Foo foo = new Foo();
// inject the mock:
foo.setInterfaceClassD(mock);
// test: this should call method func but use the mock
foo.func(dummyA, dummyB);
// verify/assert something...
}
}
Example using Mockito annotations and JUnit 5:
// Class under test
public class Foo {
// this is the object we need to mock
private InterfaceClassD objD;
void func(classA a,classB b) {
// here is where we use "objD"
List<ClassC> list= objD.func2(a.getSome(),b);
///some other things
}
}
// Unit test
// Note the Mockito extension annotation.
#ExtendWith(MockitoExtension.class)
public class FooTest {
// the Mockito JUnit extension will instantiate this automagically.
// The name of the mock must exactly match the name of the field in
// containing class.
private #Mock InterfaceClassD objD;
// Mockito annotation processing will create an instance of Foo, and
// replace any of its fields with any mocks that have the same name
// and type. In this case, objD.
private #InjectMocks Foo foo;
#Test
public void someTest() {
// Just use it.
// test: this should call method func but use the mock
foo.func(dummyA, dummyB);
// verify/assert something...
}
}