Mocking frameworks are like cologne …
they help make your tests smell better, but they can cover up some really stinky code.
I was working my way through some old bookmarked blog posts when I ran across Decoupling tests with .NET 4 by Mr. Berridge and it reminded of a discussion I had a few weeks back while teaching a refactoring workshop. The discussion centered around the question: When should I use a mocking framework and when should I use real objects or hand-coded stubs?
*** I will leave the questions of the differences between stubs & mocks and the merits of testing in true isolations versus using real objects for another day ***
Mocking frameworks like Mockito or Moq are great tools, but lately I have been finding myself using them less and less. I have found that the more I use mocking frameworks the more easily I break the Single Responsibility Principle. Now, this obviously isn’t the fault of the tool. It is my fault. And my pair’s. The real problem is that we grew accustomed to using the tool and began to lean on it as a crutch. As we added more features our code took on more and more responsibilities; but we didn’t feel the pain directly because Mockito was doing more and more of the heavy lifting.
In Kevin’s post, he specifically talks about TDDing an object with many dependencies and the pain of updating each test as new dependencies were added. Now, I have a ton of respect for Kevin and his code … but I wonder if the another solution to his problem would be to re-examine why the object needed so many dependencies. Is it doing too much? Could these dependencies be re-described and possibly combined into the overall roles they fulfill?
Kevin’s solution was clever and a nice tip to keep in my pocket. The devil is in the details. As I try to “follow the pain” I am trying to write more hand-coded stubs and evaluate any time I find myself relying on side-effects to verify how my code works. Wish me luck.