In RSpec, what is the difference between a message expectation (receive) and a test spy (have_received)?

Question

In RSpec (specifically rspec-mocks), what is the difference between Message Expectations and Test Spies? They seem similar, and appear right next to each other as seperate sections in the readme.

i.e. what is the difference between:

expect(validator).to receive(:validate) # message expectation

and

expect(validator).to have_received(:validate) # test spy

Answer 1

Message expectations can be set on any object and represent a declaration that something is going to happen (or not happen) to that object in the future. If the expectation is violated during subsequent test execution, the test will fail at the time the violation occurs. If the expectation has not been met by the end of the test, the test will fail as well.

The have_received family of methods only works on test doubles and examines what has happened to the double in the past, from the time of the double's creation up through the current method call. It succeeds or fails at that point in time. The term "test spy" is a little misleading, because the support for this backward-looking mechanism is a standard part of rspec-mocks at this point. You don't do anything "special" to create a "test spy".

Answer 2

You can't always use spies when you test, basically for expectations on classes.

Example:

expect(User).to receive(:new)

there is no way to do this with a spy (unless you do dependency injection).

Now, you could do the following:

user = double('user', save: true)
expect(User).to receive(:new).and_return user

User.new.save

expect(user).to have_received(:save)

You see clearly that:

• you have to set expectations on real object before you run the real code (it kind of looks weird to set expectations before triggering the code)

• you can set expectation on spies after the real code, which is more natural