I've been working with some folks recently doing some testing and baby-step TDD stuff and we've been using Rhino.Mocks extensively.

Rhino Mocks' API can be overwhelming at first, especially to someone not familiar with Mocking and especially not familiar with Fluent interfaces.

I'm posting this in the hopes that someone starting from scratch and doing some Googling on mocking will save some time.

I'm also assuming that you understand why you'd want to mock in the first place and you've designed with Dependency Injection/Inversion of Control already in mind so I'm not going to go into that in this post.

There are three main types of mocks are likely to use:

  1. 'Strict' Mocks: These are created via the CreateMock<T> method on the MockRepository instance. 
  2. 'Dynamic' Mocks: These are created via the DynamicMock<T> method on the MockRepository
  3. 'Stub' Mocks: These are Dynamic Mocks with the added feature of having all their properties default to using PropertyBehavior. They are created using the Stub<T> method on the MockRepository.

Strict Mocks

As their name implies, these mocks exhibit strict behavior according to the expectations defined for them. If you don't explicitly tell it to expect a particular call and it gets called, the test will fail. Depending on how you go about your testing, these may or may not ever be used, or used only in special circumstances (such as you want to enforce that NOTHING gets called on a particular mocked interface).

Dynamic Mocks

Dynamic mocks will attempt to make appropriate default responses to calls so as to make the tester have to define less 'noise' in order to make their test work.  These are the most common mocks (or should be, IMO) as you can get on with testing what you specifically want to test in a particular test case without having to spend many lines satisfying various dependencies and inner details of your method-under-test. 

Using dynamic mocks helps prevent the test from being a Doppelganger of the original method and, therefore, extremely brittle.

Stub Mocks

Same as dynamic mocks, except you don't have the extra noise of having to set up individual properties with the PropertyBehavior expectation.  This functionality may or may not be desired in certain cases which is why DynamicMock<T> still exists.