如何使用 JUnit 和 JMock 测试抽象类的受保护方法

Question

I have such situation - I have interface (say MyInterface ) and simple partial implementation ( AbstractMyInterface ). The latter adds a few protected methods which I would like to test.

Currently I simply write by hand a mock object which extends AbstractMyInterface and export protected methods as public. Is there a simpler way of doing this - for example using JMock+scripting?

Answer 1

I cannot see any problem with testing protected methods with JUnit. As long as package structure for tests mirrors source tree structure, methods other than private are visible for tests.

Of course if implementation to test is abstract, you have to create normal subclass of class under test by yourself (or do it via some mocking library if fits better for your purposes). Also in such a case, no need to create layer of public methods for just for calling protected visibility methods. Only for private methods this strategy does not work. But often need to test private methods is sign of design problem anyway.

For example: Class to test located to src/mypackage/AbstractClass.java package mypackage;

/** This could as well implement some interface, 
    but that does not change a thing */
public abstract class AbstractClass {
    protected int returnsOne() {
        return 1;
    }
}

And test which is located to tests/mypackage/AbstractClassTest.java

package mypackage;

import org.junit.Test;

import static junit.framework.Assert.assertEquals;

public class AbstractClassTest {
    @Test
    public void returnsOneReturnsOne() {
        AbstractClass instanceToTest = new AbstractClassTestable();
        assertEquals(1, instanceToTest.returnsOne());
    }
}

/** This is needed, because we cannot construct abstract class directly */
class AbstractClassTestable extends AbstractClass {
}

Answer 2

Just a suggestion,

What if we don't test the protected methods, can we use the public methods to cover those protected methods?

If not, is it because of the protected methods too complicated, refactor to extract the complicated things to a new object, which provides public interfaces, leaving the old object just one private object in some public methods.

The test will later be on the new object.

This blog post might be helpful.

Answer 3

you can make an abstract test case for the interface (or abstract class). then make a concrete test case that extends your abstract test case for each concrete implementation of your interface (or abstract class).