FlexMock is a flexible mocking library for use in unit testing and behavior specification in Ruby. Version 0.6.0 introduces a number of API enhancements to make testing with mocks even easier than before.
Integration with RSpec (version 0.9.0 or later of RSpec is required).
flexmock method will now create both regular mocks and
flexmock() # => a full mock flexmock(person) # => a partial mock based on person
flexstub is still included for backwards compatibility).
Quick and simple mocks my now be created using an expectation hash. For example:
flexmock(:foo => 10, :bar => "Hello")
will create a mock with two methods, :foo and :bar,defined. :foo will return 10 when invoked, and :bar will return "Hello".
should_receive method will now allow multiple methods
(with the same constraints) be defined in a single call. For example, the
following declares that both :read and :write need to be called at least
one time each on the mock object.
should_receive now will allow expectation hashes as arguments.
This is similar to the list of methods, but allows each defined method to
have its own return value.
flexmock.should_receive(:name => "John", :age => 32)
In addition to using a block for defining constrains, constraints may now
be applied directly to the return value of
Combined with the expectation hashes supported by
should_receive, simple mocking scenarios have become much more
succinct. For example:
flexmock(Person).new_instances.should_receive(:name => "John", :age => 32)
Improved implementation, allowing for more flexible use and greater consistency between full mock and partial mocks.
Version 0.6.0 also includes a fix for an incompatibility with some older versions of RCov. The FlexMock Rakefile now includes a RCov task (and we have 100% code coverage).
FlexMock is a flexible framework for creating mock object for testing. When running unit tests, it is often desirable to use isolate the objects being tested from the "real world" by having them interact with simplified test objects. Sometimes these test objects simply return values when called, other times they verify that certain methods were called with particular arguments in a particular order.
FlexMock makes creating these test objects easy.
Easy integration with both Test::Unit and RSpec. Mocks created with the flexmock method are automatically verified at the end of the test or example.
A fluent interface that allows mock behavior to be specified very easily.
A "record mode" where an existing implementation can record its interaction with a mock for later validation against a new implementation.
Easy mocking of individual methods in existing, non-mock objects.
The ability to cause classes to instantiate test instances (instead of real instances) for the duration of a test.
Suppose you had a Dog object that wagged a tail when it was happy. Something like this:
class Dog def initialize(a_tail) @tail = a_tail end def happy @tail.wag end end
To test the
Dog class without a real
(perhaps because real
Tail objects activate servos in some
robotic equipment), you can do something like this:
require 'test/unit' require 'flexmock/test_unit'
class TestDog < Test::Unit::TestCase def test_dog_wags_tail_when_happy tail = flexmock("tail") tail.should_receive(:wag).once dog = Dog.new(tail) dog.happy end end
FlexMock will automatically verify that
the mocked tail object received the message
wag exactly one
time. If it doesn't, the test will not pass.
See the FlexMock documentation at flexmock.rubyforge.org for details on specifying arguments and return values on mocked methods, as well as a simple technique for mocking tail objects when the Dog class creates the tail objects directly.
You can make sure you have the latest version with a quick RubyGems command:
gem install flexmock (you may need root/admin privileges)
Otherwise, you can get it from the more traditional places:
You will find documentation at: flexmock.rubyforge.org.
-- Jim Weirich