Java: mock call to external library to test constructor

Question

I'm trying to unit test ClassA(String) constructor of following ClassA class:

import ExternalObject;

class ClassA{

    private ExternalObject externalObject;

    public ClassA() {
        super();
    }

    public ClassA(String string) {
        super();
        this.externalObject = new ExternalObject().parseString(string);
    }
}

I want to mock the new ExternalObject().parseString(string) call and stub it with a sample ExternalObject object.

I've looked into Mockito, but it seems this task isn't possible with Mockito because:

Mockito can only mock methods, not statements inside methods.
Mockito requires object to be created before mocking them. Mockito needs an instance of the class before you can begin mocking. So even if I put new ExternalObject().parseString() call in a separate method in ClassA class, I can't call it without a ClassA instance.

Is it possible to do this in Mockito (or any other mocking library) without rewriting a lot of code? I'm open to small code changes to make it more test-friendly.

do not mock what you do not own. encapsulate that external dependency behind an abstraction you control and inject it into the dependent class — Nkosi, Jan 29 '18 at 07:30

glytching · Accepted Answer · 2018-01-29T09:55:44.173

In order to mock the ExternalObject you have to be able to supply the instance of ExternalObject which is used in your test flow.

That's going to be difficult as long as the ExternalObject is created inside public ClassA(String string).

In order to make your ClassA more testable you'll need to be able to provide an instance of ExternalObject when constructing ClassA.

For example:

class ClassA{

    private ExternalObject externalObject;

    public ClassA() {
        super();
    }

    public ClassA(ExternalObject externalObject, String string) {
        super();
        this.externalObject = externalObject.parseString(string);
    }
}

This can be then tested as follows:

public class ClasssATest {

    @Test
    public void someTest() {
        String input = "a string";
        ExternalObject externalObject = Mockito.mock(ExternalObject.class);
        Mockito.when(externalObject.parseString(eq(input))).thenReturn(externalObject);

        ClassA sut = new ClassA(externalObject, input);
        ...
    }
}

The key point here is: inject the external dependency into your class. Once you make this change, testing becomes much easier and, more generally, this approach makes it easier to change system behaviour by swapping in/out implementations of that external dependency.

Shouldn't `Mockito.when(externalObject.parseString()).thenReturn("some string");` be `Mockito.when(externalObject.parseString("some string")).thenReturn(externalObject);`? — narendra-choudhary, Jan 29 '18 at 09:53
@glytching Why do you use `Mockito.eq()` ? It seems not required here. — davidxxx, Jan 29 '18 at 10:03
Agreed, not required for a `String` argument. Force of habit, I guess. — glytching, Jan 29 '18 at 10:04
@glytching just for the recores: `Mockito.eq()` is not needed because you compare with the same object (one that qualifies to return `true` when its `equals()` method is called). That would also work with a custom object if the *same instance* is passed along by the cut or with a DTO created inside the cut having an `equals()` implementation. — Timothy Truckle, Jan 31 '18 at 08:54

Java: mock call to external library to test constructor

1 Answers1