Method not mocked at partial mock

[jOlliv]

In the following example code one test fails because the real method is called, although the class that declares the method is mocked. It occurs if the tested class instance is partially mocked and a sub class of the mocked class.

public abstract class AbstractClass {
    protected boolean isRendered() {
        System.out.println("### real isRendered() is called");
        return false;
    }
}

public class ImplementationClass extends AbstractClass {}

public class ImplementationClassTest {
    @Tested private ImplementationClass implementationClass;
    @Mocked private AbstractClass mockAbstractClass;

    @Test public void testWillSucceedBecauseIsRenderedIsMockedWithExpectedResultAtAbstractClass() throws Exception {
        new NonStrictExpectations() {{ mockAbstractClass.isRendered(); result = true; }};
        assertThat( implementationClass.isRendered(), is( true ));
    }

    @Test public void testWillSucceedBecauseIsRenderedIsMockedWithExpectedResultAtImplementationClass() throws Exception {
        new NonStrictExpectations( implementationClass ) {{ implementationClass.isRendered(); result = true; }};
        assertThat( implementationClass.isRendered(), is( true ));
    }

    @Test public void testWillUnexpectedlyFailBecauseTheRealIsRenderedIsCalled() throws Exception {
        // just the declaration for the partial mock let the test fail,
        // it is not necessary to record any method calls for the partial mock
        new NonStrictExpectations( implementationClass ) {{ mockAbstractClass.isRendered(); result = true; }};
        assertThat( implementationClass.isRendered(), is( true ));
    }
}

[rliesenfeld]

Thanks. The third test should fail with a proper validation failure; I will fix this.

[jOlliv]

I don't understand why the test should fail.
After reading the jmockit tutorial I would expect that all methods of AbstractClass are mocked, because the type AbstractClass is mocked. When I have a sub class of AbstractClass then all methods declared explicitly in the sub class are not mocked but the methods inherited from AbstractClass are mocked. Now when I partial mock the sub class I would expect that additional to the mocked methods of AbstractClass I can mock some methods explicitly declared in the sub class. And consistent to that assumptions in a case where the sub class overrides a method of AbstractClass I would expect that only the method implementation of the AbstractClass is mocked until I mock the sub class as type or partial (for the method).

From the following test code I supposed that it is legal code for a jmockit test.

Please can you explain, what is wrong with my above assumptions and why the test should fail with a validation failure as you mentioned in your comment!

public class BaseClass {
    protected boolean isRendered() {
        System.out.println("real isRendered() of BaseClass called");
        return false;
    }
}

public class ImplClass extends BaseClass {
    @Override protected boolean isRendered() {
        final boolean rendered = super.isRendered();
        if (! rendered) { generateHiddenFlag(); }
        return rendered;
    }

    protected void generateHiddenFlag() {
        System.out.println("real generateHiddenFlag() called");
    }
}

public class ImplClassTest {
    @Tested private ImplClass implClass;
    @Mocked private BaseClass mockBaseClass;

    @Test public void testGeneratingNoHiddenFlagWhenRendered() throws Exception {
        new NonStrictExpectations(implClass) {{
            mockBaseClass.isRendered(); result = true;
            implClass.generateHiddenFlag(); times = 0;
        }};
        assertThat( implClass.isRendered(), is( true ));
    }

    @Test public void testGeneratingHiddenFlagWhenNotRendered() throws Exception {
        new NonStrictExpectations(implClass) {{
            mockBaseClass.isRendered(); result = false;
            implClass.generateHiddenFlag(); times = 1;
        }};
        assertThat( implClass.isRendered(), is( false ));
    }

    // some further tests that verify the behaviour of method generateHiddenFlag
}

[rliesenfeld]

Yes, but all methods from AbstractClass do get mocked. The only problem was that in the third test, the "new NonStrictExpectations( implementationClass )" call caused JMockit to get into an inconsistent state regarding the mocking of the base class. But the real problem here is not that, but the fact that this partial mocking call shouldn't have been accepted in the first place; it should instead have triggered an "InvalidArgumentException: class AbstractClass is already mocked". This is the fix I am applying, to tighten up the validation against duplicate mockings which already is in place, so that it also checks the super-classes.

You probably want to write "@tested @mocked ImplementationClass implementationClass". This should provide all that's needed for the tests.

[jOlliv]

Thank you for the explanation! With the @tested annotation it works for me as expected.