How do I mock objects that I can't instantiate in my tests?

Question

I'm using EasyMock to mock objects in my tests. But how do I mock objects that are created somewhere else in my code? Look at the following psudo code. I want to mock WebService#getPersonById, how do I do that?

public class Person {
  public Person find(int id) {
    WebService ws = new WebService();
    return ws.getPersonById(id);
  }
}

public class PersonTest {
  testFind() {
    // How do I mock WebService#getPersonById here?
  }
}

Answer 1

Mocking typically works well if you use inversion of control and dependency injection to wire up your services. So your person should look like

public class Person() {
  WebService ws = null;

  // or use setters instead of constructor injection
  Persion(WebService ws) {
     this.ws = ws;
  }
  public Person find(int id) {
    return ws.getPersonById(id);
  }
}

hopefully it is clear that with this change, you can now create a mock and mock control for WebService and just plug it in in your test, because when you create the Person to test, you can pass in the mock to the constructor (or setter if you go that route).

In your real environment, the IoC container will inject the real web service in.

Now, if you don't want to deal with all this IoC stuff, what you need to do is decouple your webservice from your Person (which should be call PersonService or something, not just Person, which denotes entity). In other words, the way the code is written you can only use one type of WebService. You need to make it so the Person just needs some type of WebService, not the specific one you have hard-coded in.

Finally, in the code as written, WebService is a class, not an interface. The WebService should be an interface, and you should put in some sort of implementation. EasyMock works well with interfaces; it might be able to mock concrete classes (been a while since I actually used it), but as a design principle you should specify the required interface, not the concrete class.

Answer 2

There is no way to do it with EasyMock (or most other mocking APIs). With JMockit, on the other hand, such a test would be very simple and elegant:

public class PersonTest
{
    @Test
    public testFind(@Mocked final WebService ws) {
        final int id = 123;

        new NonStrictExpectations() {{
            ws.getPersonById(id); result = new Person(id);
        }};

        Person personFound = new Person().find(id);

        assertEquals(id, personFound.getId());
    }
}

So, whenever we run into a situation where a unit test cannot be written at first, we can't automatically conclude that the code under test is untestable and needs to be refactored. Sometimes it will be the case, but certainly not always. Maybe the problem is not in the code under test, but in the limitations of a particular mocking tool that is being used.

Answer 3

I think you're missing a much bigger problem. The difficulty in testing is trying to tell you something, that having a Person object (part of the domain) that also uses a remote service to find further instances of itself (part of the system) is mixing up concerns. Separate the getting of Persons out of the Person object and you'll end up with cleaner, more portable code.

Don't confuse immediate convenience (I have a Person object in my hand, so I'll use that for getting more) with maintainability.

Answer 4

You can try using PowerMock whenNew method

https://github.com/jayway/powermock/wiki/MockitoUsage#how-to-mock-construction-of-new-objects

More examples here - http://www.programcreek.com/java-api-examples/index.php?api=org.powermock.api.mockito.PowerMockito

your code might look like -

whenNew(WebService.class).withAnyArguments().thenReturn(yourMockInstanceToWebServiceClass);

Answer 5

First of you need to make ws a mock, usually by injecting it.

public abstract class Person() {
  public Person find(int id) {
    WebService ws = createWebService();
    return ws.getPersonById(id);
  }
  protected abstract WebService createWebService();
}

Then you can slip it in and use EasyMock.expect to setup the return

public class PersonTest() {
  testFind() {
    WebService mock = EasyMock.createMock(WebService.class);
    Person p = new Persion() {
      protected WebService createWebService() {
        return mock;
      }
    }
    EasyMock.expect(mock.getPersonById()).andReturn(dummyValue);
    //Test code
  }
}

You'll also need a PersonImpl to have the real create method.