How to avoid mock object's method calls in strings used for logging?

Question

I have written a test method in which there is a mocked object(say mockA). I am able to expect mockA's method calls for the actual program logic. But, part of my program also has logging which require objects' information in the form of string. While creating the string message, there are some unnecessary methods being called on the objects. So, while running the test, these method calls are causing the test to fail. Here's an example.

public class Example {
    public int method(Foo foo) {
       int a = foo.doSomething(); //required for program.
       String logMessage = "foo did something." + foo.getA() + foo.getB().getC();
       logger.log(logFile, logMessage);
       return a;
    }
}

Here's the example test method.

@Test
public void testMethod() {
   int something = 0;
   Foo mockFoo = EasyMock.createMock(Foo.class);
   expect(mockFoo.doSomething()).andReturn(something);
   EasyMock.replay(mockFoo);
   assertEquals(new Example().method(mockFoo), something);
   EasyMock.verify(mockFoo);
}

This is giving unexpected method calls for foo.getA(). If I create a nice mock instead for Foo.class, it gives me null pointer exception for foo.getB().getC() since B is an object inside foo. It's not possible for me to create nice mocks of all objects inside foo.

Is there anyway to prevent such string operations which are used for logging? Or alternatively, what could be done?

Thanks

Answer 1

There are two approaches. First, you mock everything that's needed for proper interaction with Foo (as mentioned in other answer) or second, you extract whatever the complexity is to separate dependency.

In your example, the complexity is message creation. You could either have:

class FooLogMessageFactory {
    public string createLogSomethingMessage(Foo foo) {
        return "foo did something." + foo.getA() + foo.getB().getC();
    }
}

Or entire logging part in separate class:

class FooDedicatedLogger {
    public void logOnSomething(Foo foo) {
        String message = "foo did something." + foo.getA() + foo.getB().getC();
        logger.log(logFile, message);
    }
}

This is of course injected to your Example class as constructor dependency. Then in test you can mock it easily and forget about log message creation entirely (as it should be, given it's irrelevant to what actual tested method does).

Now, whichever approach to choose largely depends on the complexity of objects involved (i.e. How difficult is it to actually build log message? More difficult than setting up few extra mock calls?).