RSpec Mocks

rspec-mocks is a test-double framework for rspec with support for method stubs, fakes, and message expectations on generated test-doubles and real objects alike.

Install

gem install rspec       # for rspec-core, rspec-expectations, rspec-mocks
gem install rspec-mocks # for rspec-mocks only

Test Doubles

A Test Double is an object that stands in for a real object in a test. RSpec creates test doubles that support method stubs and message expectations.

book = double("book")

Method Stubs

A method stub is an implementation that returns a pre-determined value. Method stubs can be declared on test doubles or real objects using the same syntax. rspec-mocks supports 3 forms for declaring method stubs:

allow(book).to receive(:title) { "The RSpec Book" }
allow(book).to receive(:title).and_return("The RSpec Book")

You can also use this shortcut, which creates a test double and declares a method stub in one statement:

book = double("book", :title => "The RSpec Book")

The first argument is a name, which is used for documentation and appears in failure messages. If you don't care about the name, you can leave it out, making the combined instantiation/stub declaration very terse:

double(:foo => 'bar')

This is particularly nice when providing a list of test doubles to a method that iterates through them:

order.calculate_total_price(double(:price => 1.99),double(:price => 2.99))

Consecutive return values

When a stub might be invoked more than once, you can provide additional arguments to and_return. The invocations cycle through the list. The last value is returned for any subsequent invocations:

allow(die).to receive(:roll).and_return(1,2,3)
die.roll # => 1
die.roll # => 2
die.roll # => 3
die.roll # => 3
die.roll # => 3

To return an array in a single invocation, declare an array:

allow(team).to receive(:players).and_return([double(:name => "David")])

Message Expectations

A message expectation is an expectation that the test double will receive a message some time before the example ends. If the message is received, the expectation is satisfied. If not, the example fails.

validator = double("validator")
expect(validator).to receive(:validate) { "02134" }
zipcode = Zipcode.new("02134", validator)
zipcode.valid?

Test Spies

Verifies the given object received the expected message during the course of the test. The method must have previously been stubbed in order for messages to be verified.

Stubbing and verifying messages received in this way implements the Test Spy pattern.

  invitation = double('invitation', :accept => true)

  user.accept_invitation(invitation)

  expect(invitation).to have_received(:accept)

  # You can also use other common message expectations. For example:
  expect(invitation).to have_received(:accept).with(mailer)
  expect(invitation).to have_received(:accept).twice
  expect(invitation).to_not have_received(:accept).with(mailer)

Nomenclature

Mock Objects and Test Stubs

The names Mock Object and Test Stub suggest specialized Test Doubles. i.e. a Test Stub is a Test Double that only supports method stubs, and a Mock Object is a Test Double that supports message expectations and method stubs.

There is a lot of overlapping nomenclature here, and there are many variations of these patterns (fakes, spies, etc). Keep in mind that most of the time we're talking about method-level concepts that are variations of method stubs and message expectations, and we're applying to them to one generic kind of object: a Test Double.

Test-Specific Extension

a.k.a. Partial Stub/Mock, a Test-Specific Extension is an extension of a real object in a system that is instrumented with test-double like behaviour in the context of a test. This technique is very common in Ruby because we often see class objects acting as global namespaces for methods. For example, in Rails:

person = double("person")
allow(Person).to receive(:find) { person }

In this case we're instrumenting Person to return the person object we've defined whenever it receives the find message. We can also set a message expectation so that the example fails if find is not called:

person = double("person")
expect(Person).to receive(:find) { person }

RSpec replaces the method we're stubbing or mocking with its own test-double-like method. At the end of the example, RSpec verifies any message expectations, and then restores the original methods.

Expecting Arguments

expect(double).to receive(:msg).with(*args)
expect(double).to_not receive(:msg).with(*args)

You can set multiple expectations for the same message if you need to:

expect(double).to receive(:msg).with("A", 1, 3)
expect(double).to receive(:msg).with("B", 2, 4)

Argument Matchers

Arguments that are passed to with are compared with actual arguments received using ==. In cases in which you want to specify things about the arguments rather than the arguments themselves, you can use any of the matchers that ship with rspec-expectations. They don't all make syntactic sense (they were primarily designed for use with RSpec::Expectations), but you are free to create your own custom RSpec::Matchers.

rspec-mocks also adds some keyword Symbols that you can use to specify certain kinds of arguments:

expect(double).to receive(:msg).with(no_args())
expect(double).to receive(:msg).with(any_args())
expect(double).to receive(:msg).with(1, kind_of(Numeric), "b") #2nd argument can be any kind of Numeric
expect(double).to receive(:msg).with(1, boolean(), "b") #2nd argument can be true or false
expect(double).to receive(:msg).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
expect(double).to receive(:msg).with(1, anything(), "b") #2nd argument can be anything at all
expect(double).to receive(:msg).with(1, duck_type(:abs, :div), "b")
                    #2nd argument can be object that responds to #abs and #div

Receive Counts

expect(double).to receive(:msg).once
expect(double).to receive(:msg).twice
expect(double).to receive(:msg).exactly(n).times
expect(double).to receive(:msg).at_least(:once)
expect(double).to receive(:msg).at_least(:twice)
expect(double).to receive(:msg).at_least(n).times
expect(double).to receive(:msg).at_most(:once)
expect(double).to receive(:msg).at_most(:twice)
expect(double).to receive(:msg).at_most(n).times
expect(double).to receive(:msg).any_number_of_times

Ordering

expect(double).to receive(:msg).ordered
expect(double).to receive(:other_msg).ordered
  #This will fail if the messages are received out of order

This can include the same message with different arguments:

expect(double).to receive(:msg).with("A", 1, 3).ordered
expect(double).to receive(:msg).with("B", 2, 4).ordered

Setting Responses

Whether you are setting a message expectation or a method stub, you can tell the object precisely how to respond. The most generic way is to pass a block to receive:

expect(double).to receive(:msg) { value }

When the double receives the msg message, it evaluates the block and returns the result.

expect(double).to receive(:msg).and_return(value)
expect(double).to receive(:msg).exactly(3).times.and_return(value1, value2, value3)
  # returns value1 the first time, value2 the second, etc
expect(double).to receive(:msg).and_raise(error)
  #error can be an instantiated object or a class
  #if it is a class, it must be instantiable with no args
expect(double).to receive(:msg).and_throw(:msg)
expect(double).to receive(:msg).and_yield(values,to,yield)
expect(double).to receive(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
  # for methods that yield to a block multiple times

Any of these responses can be applied to a stub as well

allow(double).to receive(:msg).and_return(value)
allow(double).to receive(:msg).and_return(value1, value2, value3)
allow(double).to receive(:msg).and_raise(error)
allow(double).to receive(:msg).and_throw(:msg)
allow(double).to receive(:msg).and_yield(values,to,yield)
allow(double).to receive(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)

Arbitrary Handling

Once in a while you'll find that the available expectations don't solve the particular problem you are trying to solve. Imagine that you expect the message to come with an Array argument that has a specific length, but you don't care what is in it. You could do this:

expect(double).to receive(:msg) do |arg|
  expect(arg.size).to eq 7
end

If the method being stubbed itself takes a block, and you need to yield to it in some special way, you can use this:

expect(double).to receive(:msg) do |&arg|
  begin
    arg.call
  ensure
    # cleanup
  end
end

Delegating to the Original Implementation

When working with a partial mock object, you may occasionally want to set a message expecation without interfering with how the object responds to the message. You can use and_call_original to achieve this:

expect(Person).to receive(:find).and_call_original
Person.find # => executes the original find method and returns the result

Combining Expectation Details

Combining the message name with specific arguments, receive counts and responses you can get quite a bit of detail in your expectations:

expect(double).to receive(:<<).with("illegal value").once.and_raise(ArgumentError)

While this is a good thing when you really need it, you probably don't really need it! Take care to specify only the things that matter to the behavior of your code.

Stubbing and Hiding Constants

See the mutating constants README for info on this feature.

Use `before(:each)`, not `before(:all)`

Stubs in before(:all) are not supported. The reason is that all stubs and mocks get cleared out after each example, so any stub that is set in before(:all) would work in the first example that happens to run in that group, but not for any others.

Instead of before(:all), use before(:each).

Name		Name	Last commit message	Last commit date
Latest commit History 1,036 Commits
benchmarks		benchmarks
features		features
lib		lib
script		script
spec		spec
.autotest		.autotest
.document		.document
.gitignore		.gitignore
.rspec		.rspec
.travis.yml		.travis.yml
.yardopts		.yardopts
Changelog.md		Changelog.md
DEV-README.md		DEV-README.md
Gemfile		Gemfile
Gemfile-custom.sample		Gemfile-custom.sample
Guardfile		Guardfile
License.txt		License.txt
README.md		README.md
Rakefile		Rakefile
cucumber.yml		cucumber.yml
rspec-mocks.gemspec		rspec-mocks.gemspec
specs.watchr		specs.watchr

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

RSpec Mocks

Install

Test Doubles

Method Stubs

Consecutive return values

Message Expectations

Test Spies

Nomenclature

Mock Objects and Test Stubs

Test-Specific Extension

Expecting Arguments

Argument Matchers

Receive Counts

Ordering

Setting Responses

Arbitrary Handling

Delegating to the Original Implementation

Combining Expectation Details

Stubbing and Hiding Constants

Use `before(:each)`, not `before(:all)`

Further Reading

Also see

About

Releases

Packages

License

ransingh/rspec-mocks

Folders and files

Latest commit

History

Repository files navigation

RSpec Mocks

Install

Test Doubles

Method Stubs

Consecutive return values

Message Expectations

Test Spies

Nomenclature

Mock Objects and Test Stubs

Test-Specific Extension

Expecting Arguments

Argument Matchers

Receive Counts

Ordering

Setting Responses

Arbitrary Handling

Delegating to the Original Implementation

Combining Expectation Details

Stubbing and Hiding Constants

Use before(:each), not before(:all)

Further Reading

Also see

About

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Use `before(:each)`, not `before(:all)`

Packages