Question

I’m writing program arguments parser, just to get better in TDD, and I stuck with the following problem. Say I have my parser defined as follows:

class ArgumentsParser {
    public ArgumentsParser(ArgumentsConfiguration configuration) {
        this.configuration = configuration;
    }

    public void parse(String[] programArguments) {
        // all the stuff for parsing
    }
}

and I imagine to have ArgumentsConfiguration implementation like:

class ArgumentsConfiguration {
    private Map<String, Class> map = new HashMap<String, Class>();

    public void addArgument(String argName, Class valueClass) {
        map.add(argName, valueClass);
    }

    // get configured arguments methods etc.
}

This is my current stage. For now in test I use:

@Test
public void shouldResultWithOneAvailableArgument() {
    ArgumentsConfiguration config = prepareSampleConfiguration(); 
    config.addArgument("mode", Integer.class);
    ArgumentsParser parser = new ArgumentsParser(configuration);
    parser.parse();
    // ....
}

My question is if such way is correct? I mean, is it ok to use real ArgumentsConfiguration in tests? Or should I mock it out? Default (current) implementation is quite simple (just wrapped Map), but I imagine it can be more complicated like fetching configuration from kind of datasource. Then it’d be natural to mock such “expensive” behaviour. But what is preferred way here?

EDIT:
Maybe more clearly: should I mock ArgumentsConfiguration even without writing any implementation (just define its public methods), use mock for testing and deal with real implementation(s) later, or should I use the simplest one in tests, and let them cover this implementation indirectly. But if so, what about testing another Configuration implementation provided later?

Answer 1

Then it’d be natural to mock such “expensive” behaviour.

That’s not the point. You’re not mocking complex classes.

You’re mocking to isolate classes completely.

Complete isolation assures that the tests demonstrate that classes follow their interface and don’t have hidden implementation quirks.

Also, complete isolation makes debugging a failed test much, much easier. It’s either the test, the class under test or the mocked objects. Ideally, the test and mocks are so simple they don’t need any debugging, leaving just the class under test.