[ruby-talk:20701] ANN: Ruby/Mock 1.0

I mentioned this in another thread, but thought I would announce it properly
in case anyone missed it.

Ruby/Mock is a package that makes it easy to implement mock objects in
RubyUnit test cases. It provides a generic Mock class that can be used to
create mock objects for any interface.  A test uses closures to define the
expectations of a mock object.  Tests can also encapsulate protocols into
reusable mock-object classes.

Ruby/Mock is available from http://www.b13media.com/dev/ruby/mock.html.

What is a Mock Object?

A mock object is an implementation of the interface of an object that is
used by the class being tested.  E.g. if a class being tested uses a
database connection, you would mock up the database connection in order to
test the class rather than connect to a real database.

A mock object is related to using stubbed behaviour but extends stubs by
executing tests in the mock object itself. The inventors of the mock object
technique call this "endotesting" because you are insert tests into the
implementation of a class in a controlled manner, rather than testing only
by probing it from the outside.

Using mock objects provides several advantages.

1) It's more convenient than setting up a "real" test environment; e.g. a
database host and server, networking, etc.
2) You can guarantee predetermined responses from the mock object, and so
test the behaviour of your class without worrying about unexpected errors.
E.g. someone might unplug the database server in your test environment which
would cause unexpected test failures unrelated to the features being tested.
3) You can make the mock object throw exceptions, to test how the client
class acts in the face of errors. You would be amazed how much code is only
tested through the success control paths.
4) For each test, you can verity that the class makes the expected sequence
of method calls, and passes in the expected parameters. These are termed
"expectations".
5) You can test that the class meets the preconditions of the objects it
uses by asserting those preconditions in the mock object.  Normally unit
tests only check the postconditions and invariants of the class under test,
not that it meets preconditions required of it by other parts of the system.
6) You can encapsulate a mocked protocol -- e.g. preconditions and valid
sequences of method calls -- as a reusable class that can be parameterised
by expectations.

More info about mock objects can be found at http://www.mockobjects.com/.