JUnit / Spring / Mockito-无法模拟从另一个实现ApplicationContextAware的类返回的类

Question

I am new to Spring and JUnit. I need to mock a class which is derived from ApplicationContextAware class which is inside my toBeTested(getList) method. In the following short code snippet, I need to test the getList method in abc class.

I am able to mock ModulesConfigRegistry because there is a setter for it. But I am not able to mock ModuleConfig and ListProvider. Both ModulesConfigRegistry and ModuleConfig have implemented ApplicationContextAware so it returns classes from bean. ListProvider.getList(lst.getList in code) is the method which makes further calls up to database and is required to be mocked. Appreciate your help in advance. Code sample will be helpful as I am new to Spring and JUnit.

class abc { 

    private ModulesConfigRegistry modulesConfigRegistry; 

    public void setModulesConfigRegistry(ModulesConfigRegistry modulesConfigRegistry) { 
        this.modulesConfigRegistry = modulesConfigRegistry; 
    } 

    public List getList(String name, String moduleName) 
    { 
        ModuleConfig moduleConfig = modulesConfigRegistry.getModuleConfig(moduleName); 
        Object mlist = moduleConfig.getListProvider(name); 
        if(mlist instanceof ListProvider) 
        { 
            ListProvider lst = (ListProvider)mList; 
        } 
        return lst.getList("abc"); 
    } 
}

Answer 1

Maybe there is another more simple way to achieve this (not mandatory the best). In my experience I've used Reflection in Java when it's up to Unit-testing. After all, to me the main purpose of the unit tests is to simply exercise smallest testable part and nothing more. That's why I simply use my dummy-test-object and get/set fields/properties I need.

But one thing that must be considered here is that reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects. So if you know what your doing it's a good alternative.

Since you already using

JUnit

One very common use case in Java is the usage with annotations. JUnit 4, for example, will use reflection to look through your classes for methods tagged with the @Test annotation, and will then call them when running the unit test.

If you want to consider it and use it - here you can find some good examples .

Cheers.

Answer 2

One approach here is create mock objects for each object that you need to interact with ModuleConfig and ListProvider

@RunWith(MockitoJUnitRunner.class)
public class abcTest{

    @InjectMocks
    private abc abcInstance;

    @Mock
    private ModulesConfigRegistry modulesConfigRegistry ;

    @Test
    private voidTestGetList(){
    //Create the mock and interactions
    ModuleConfig moduleConfigMock = Mockito.mock(ModuleConfig.class);
    ListProvider listProviderMock =  Mockito.mock(ListProvider.class);
    ArrayList listToReturn = new ArrayList();
    Mockito.when(modulesConfigRegistry.getModuleConfig(Mockito.anyString())).thenReturn(moduleConfigMock);
    Mockito.when(moduleConfigMock.getListProvider(Mockito.anyString())).thenReturn(listProviderMock);
    Mockito.when(listProviderMock.getList(Mockito.anyString())).thenReturn(listProviderMock);
    //Call real method
    List resultList = abcInstance.getList("stringInput1", "stringInput2");
    //Make assertions
    } 
}

Basically you need to create mock objects for any of the instances that you get from a mock object and use mockito to define the result of its method.

Other options is create a new class that implements or is a subclass of the returned object type and override the methods.