Should I practice "mockist" or "classical" TDD?
I've read (and re-read) Martin Fowler's Mocks Aren't Stubs. In it, he defines two different approaches to TDD: "Classical" and "Mockist". He attempts to answer the question "So should I be a classicist or a mockist?", but he admits that he has never tried mockist TDD on "anything more than toys." So I thought I'd ask the question here. Good answers may repeat Fowler's arguments (but hopefully more clearly) or add arguments that he didn't think of or that others have come up with since Fowler last updated the essay back in January 2007.
Solution 1:
I don't think you need to choose one over the other. Both have their advantages and disadvantages and both are tools for your toolbox. "Mockist" tdd makes you a bit more flexible in what you can test while classical TDD makes your tests a bit less brittle because they tend to look more at the input/vs output instead of looking at the actual implementation. When doing mockist unit testing I seem to have more tests break when changing the implementation.
I try to use classical tdd whenever possible (although i often use a mocking framework to set up the stubs quickly). Sometimes I notice I start testing too much at one time or i need too many objects to set up a test. That's when mockist testing can often help you set up smaller tests.
This is all quite abstract so I hope i make sense
Solution 2:
The question about mockist or classic tdd is very much about what part of your application you're testing. If you have a "standard" layered architecture (like DDD for example) the domain layer is usually suited for classic tdd where you unit test by setting up the object under test, call a few methods and check the result and/or the state.
On the otherhand when you're testing application services, controllers or presentation logic which all do more coordinating work, mocking or stubbing is often needed to get good tests. My experience is also that these classes tend to call other layers (webservice, datalayer,...) which you really want to mock or stub. These unit tests also need more setup code so you should only mock when you have to.
My advice is to go classic whenever you can and mock when you must.
Solution 3:
You might consider looking at our book, at http://www.growing-object-oriented-software.com/. It includes an extended worked example. As we wrote it we discovered that the state vs. interaction distinction is largely misleading and it's more about one's approach to OO design.
Solution 4:
A very pragmatic approach was exposed by Sandi Metz:
An object can communicate to other object through outgoing or incoming messages. The messages can be queries (returns something) or commands (executes something).
There are four combinations. The outgoing query messages not should be tested (already tested as incoming query of external class) You could to use the mockist test method on outgoing command messages and classical test to the rest.
Check the links
http://jnoconor.github.io/blog/2013/10/07/the-magic-tricks-of-testing-by-sandi-metz/
https://speakerdeck.com/skmetz/magic-tricks-of-testing-ancientcityruby
Youtube
Solution 5:
I am still relatively new at TDD - but the way I was taught/introduced to the differences was to think of it in terms of testing the integration between classes and so that you are not dependent on live data. For instance if I have a class that is pretty much stand-alone - not dependent on other classes I have built for a project and it doesn't go out to a live data/dev environment for input (like a DB or an API to a system) then I would only use classical unit tests in something like NUnit or JUnit - but when I start to test interaction between built classes - that's when it can get real handy to mock other custom classes and/or outside interaction - so that you can single out and test your current classes' code without trying to chase down a a potential bug in other classes you are calling.