Forbid mocking methods that are undefined on original object - ruby-on-rails-3

Question

I want to ensure that my EventNotifier object catches and logs an exception to the Rails logger, so I writed the following rspec test using rspec-mocks:
describe EventNotifier do
before(:all) do
RSpec::Mocks::setup(self)
end
it 'logs exception on error' do
error = RuntimeError.new('simulated for tests')
EventDispatcher.should_receive(:dispatch).with('a message').and_raise(error)
Rails.logger.should_receive(:warning).with(error)
subject.notify('a message')
end
end
class EventDispatcher
def dispatch(message)
# stuff
end
end
class EventNotifier
def notify(message)
EventDispatcher.dispatch(message)
rescue RuntimeError => e
Rails.logger.warning(e)
end
end
The test passes with bells and whistles, but I did a big mistake. Can you spot it? Indeed, the Rails method to log a warning is warn, not warning. So this code will fail when used for real.
Is there a way to make rspec-mock forbid mocking methods that do not exist on the original object?
Another example where it can be useful: if I decide to rename EventDispatcher#dispatch as EventDispatcher#route, then the test still passes. If it was java, it would have failed at compilation because the interface has changed. With rspec-mock, I do not know how to make it fail automatically.

Answer 1

It will be possible with rspec-mocks 3.0 which introduces verifying doubles:
Verifying doubles are a stricter alternative to normal doubles that provide
guarantees about what is being verified. When using verifying doubles, RSpec
will check that the methods being stubbed are actually present on the
underlying object if it is available. Prefer using verifying doubles over
normal doubles.
So given these classes (examples taken from the spec):
class ConsoleNotifier
def notify(msg)
puts message
end
end
class User < Struct.new(:notifier)
def suspend!
notifier.notify("suspended as")
end
end
This example would pass because the method notify exists for a real ConsoleNotifier instance:
describe User, '#suspend!' do
it 'notifies the console' do
notifier = instance_double("ConsoleNotifier")
expect(notifier).to receive(:notify).with("suspended as")
user = User.new(notifier)
user.suspend!
end
end
If the notify method is renamed as publish, the example would fail because expectations are on the method notify and that method does not exist on target object.
# would make example fail
class ConsoleNotifier
def publish(msg)
puts message
end
end
If we add a color argument to the notify method, it will fail too because the method arity is incorrect in the expectation (wrong number of arguments).
class ConsoleNotifier
def notify(msg, color)
puts color + message
end
end
When putting expectations on class, like EventDispatcher.should_receive(:dispatch) or expect(EventDispatcher).to receive(:dispatch), the created double is named a partial double in rspec-mocks vocabulary.
To make partial doubles act like verifying doubles, the verify_partial_doubles configuration option must be set:
RSpec.configure do |config|
config.mock_with :rspec do |mocks|
mocks.verify_partial_doubles = true
end
end
And it will automagically ensure that the EventDispatcher class has a dispatch method. So if this method is renamed, the test will fail, as expected!