Interfaces & TDD

I was having a discussion with a friend and was trying to explain why do you need an interface ( separation ) and how it can help you think in terms of SOLID principle & Test Driven Development philosophy..

From the discussion I realized it is hard to explain things by just talking over it and thought I will write down into a blog post.So here it goes ….

If there is business requirement and the user stakeholder says that “I need a Car which I could drive” we generally think of implementing in code like this :-

But the problem is that if we need to test the drive method or hook it up to UI for mocking, we have to create Real Car object and real implementation of the Drive() method.

For some people it doesn’t sound too bad but just imagine if it was like creating a database connection/connecting to Active directory/calling a webservice etc.
and getting some data would require a lot of pluming/the whole infrastructure to be developed before we could even write a single line of test.

Now in terms of strict TDD you would start with the test code and as a result of the test code you could create the interface. But lets say you are not following a strict TDD principles but thinking of separation and some of the principles of “SOLID” like the “I” Interface segregation and “S”Single responsibility.

We would start with something like this :-

With this interface we are separating the function from the main class so that in future we could plug-in a “Railway train” or something else and still can hook up the Drive() method and we are also applying the “D” and “L” principle of “SOLID”.

So lets re factor the Car class as

Now with the separation of function based on the interface we can create a Fake implementation and not concern at this stage about the actual implementation.

And the fake test would look like :-

And once we are happy with the test result we can implement the real class like this

And it’s integration test(with real object) would be

As you can see the implementation is almost the same as the fake one and you can control how the interface gets the Fake or the Real object.
( I smell some DI and IoC here 😉 )