模拟私有方法并创建新对象

Question

I've written a class which reads the entire file and returns the content.

class ClassToTest {
    public methodToTest(String input) {
       return privateMethod(input);
    }

    private privateMethod(input) {
        ClassPathResource classPathResource = new ClassPathResource(input);
        IOUtils.toString(classPathResource.getFile());
    }
}

Now, inside my test class, I don't want my test to actually read the file from so I'm trying to mock the method classPathResource.getFile() but somehow I'm not able to do so without writing PrepareForTests() and if I do that those test are not counted in JaCoCo.

I've written test case as

@Test
public void test_methodToTest() {
     mockStatic(IOUtils.class);
     when(IOUtils.toString(any()).thenReturn("DUMMY_STRING");
     methodToTesT("file1.txt");
     ...
}

The problem is IOUtils.toString gets mocked properly but the call classPathResource.getFile() tries to access the file on the disk. For this, I can do this

PowerMockito.whenNew(ClassPathResource.class)
            .withAnyArguments().thenReturn(mockedClassPath);

And add annotation to my test class as

@PrepareForTest(ClassToTest.class)
class MyTestClass {
... 
}

But now the problem is this test class is skipped from the JACOCO test coverage . How can I write tests for this class?

Answer 1

You can pass a mocked reference into the constructor doing this:

class ClassToTest {
    private ClassPathResource classPathResource;

    public ClassToTest(ClassPathResource classPathResource) {
        this.classPathResource = classPathResource;
    }

    public methodToTest(String input) {
        IOUtils.toString(classPathResource.getFile(input));
    }
}

Or you can pass the mocked reference into the method doing this:

class ClassToTest {
    public methodToTest(ClassPathResource classPathResource) {
        IOUtils.toString(classPathResource.getFile());
    }
}

Answer 2

Having to mock a private member should be seen as a code smell and an indication that something is wrong with the current design. Because ClassPathResource is being initialized internal to the subject class it is now tightly coupled to that class. While not entirely impossible to mock it does make testing the class cleanly more difficult. Consider inverting the creation of the class to a delegate as a dependency.

public interface PathResource {
    String getFile(String input);
}

This will allow the injection of the dependency

class ClassToTest {
    private classPathResource;

    public ClassToTest (PathResource resource) {
        this.classPathResource = resource;
    }

    public String methodToTest(String input) {
        return privateMethod(input);
    }

    private String privateMethod(String input) {
        return IOUtils.toString(classPathResource.getFile(input));
    }
}

and the dependency can be mocked/faked/stubbed when testing.

public void Test() {
    //Arrange
    //mock creation     
    PathResource resource = mock(PathResource.class); 
    String input = "path";
    String expected = "expected_output";
    //stubbing
    when(resource.getFile(input)).thenReturn(expected);

    ClassToTest subject = new ClassToTest(resource);

    //Act
    String actual = subject.methodToTest(input);

    //Assert
    verify(resource).getFile(input);
    assertEquals(expected, actual);
}

in production code the ClassPathResource would be derived from the abstraction

public class ClassPathResource implements PathResource {
    //...code removed for brevity
}

and it would be associated with the abstraction at the composition root.

Following the above suggestions would now allow ClassToTest to be tested in isolation without any knock on effects of implementation concerns.