Comments on: TDD: Hungarian notation for mocks/stubs

By: Andy Palmer

Andy Palmer — Fri, 08 Jan 2010 00:55:39 +0000

@MM I have used a number of different test double type names (including fake) when that is how I am using it… I think this might be introducing more noise than I need.
On the other hand, I use dummySomething to specifically indicate that this is not being used in this test… if a test fails because a mock didn’t respond correctly and it’s called dummySomething, that gives me a clue that something new is happening in the real code

By: Brent Snook

Brent Snook — Wed, 06 Jan 2010 14:56:18 +0000

I like to name the variable for the role the object is acting in too, I agree that “mock” or “stub” is unecessary noise.

I’m only interested in the role something is playing and the interactions it has; I don’t care what it is. What the thing is actually is (mock, stub, spy) is something I find only changes as the code changes so I want that detail to leak into the test as little as possible.

By: MM

MM — Wed, 06 Jan 2010 14:36:26 +0000

I also favor not specifying whether the dependency is a mock or stub. However, if I feel the need to make it clear that it is not “real” code being used, I like to just use the word fake. So I would use “someFakeDependency”. I guess this is similar to Andy’s idea of using “dummy” but to me “fake” is more a part of the testing lexicon.

By: Colin Jack

Colin Jack — Wed, 06 Jan 2010 14:34:47 +0000

When looking at a test I personally want to know where an object is a test double. However I’m not bothered whether its specifically a stub or mock (far better seeing that from its usage), I’d be happy with one or other term used consistently or just use of nameTestDouble.

By: Aaron Jensen

Aaron Jensen — Wed, 06 Jan 2010 08:26:24 +0000

Mark,

My personal preference is to just never use CreateMock. In my mind, instances are not mocks or stubs–you either stub or mock methods. It’s entirely possible to stub MethodA on IFoo and mock MethodB.

Rhino makes this easy–just use CreateStub (always) and use .Stub or .AssertWasCalled. CreateMock causes more coupling than I think is healthy in a test. If you want to assert that something was not called, use AssertWasNotCalled. It’s very rare that I actually want to spec out that *nothing* was called on a dependency other than one thing. That’s just the kind of coupling that leads to brittle unit tests.

Oh and back to the point of your post, I don’t like the suffix either. It is what it is, the fact that parts of it are mocked or stubbed is evident by the .Stub or .AssertWasCalled calls.

By: Mark Needham

Mark Needham — Wed, 06 Jan 2010 07:42:26 +0000

@Perryn ah that’s interesting I hadn’t thought of it from that perspective. That makes sense.

@Andy hmmm that’s a cool idea, don’t think I’ve seen that so explicitly done before. Might give that one a try!

@Mark I think I might have seen that but I’d need to re-read it. Do you have a link to it?

By: Andy Palmer

Andy Palmer — Wed, 06 Jan 2010 01:24:21 +0000

I tend to use mockSomething or stubSomething, but I think I might drop that. One thing I do with Mockito is create "mocks" of dependencies I don't care about for this test and call them dummySomething. I do this rather than pass in null (don't get me started on null =))

By: Perryn Fowler

Perryn Fowler — Wed, 06 Jan 2010 00:55:21 +0000

Hi Mark,

I tent to agree with you, however I sometimes use the ‘hungarian notation’ approach when coaching people who are new to mocking and stubbing and who can often have trouble distinguishing between what is a mock and what is a real object in even quite simple tests.

I find it helps avoid a surprisingly common problem with beginners where they set an expectation, and then fulfill that expectation in the test rather than in the implementation.

Also, then if I come across a test with a stub mislabeled as a mock then that gives me a clue that the person that wrote it is having trouble understanding the difference.

By: Mark Nijhof

Mark Nijhof — Wed, 06 Jan 2010 00:48:09 +0000

Interesting, I like adding Mock to the end of the mocked dependency exactly because then I don’t have to go where it was assigned but can just read the test. Also for small tests. Have you seen my Specifications post? There I auto mocks and use a different way to acces the mocks using a small DSL. What are your thoughts on that?