Mocking a Browser for RSpec, Without Test Doubles Leaking

Question

I find mocking things with RSpec to be entirely problematic and I often don't know how much code to include, in terms of it being diagnostic. So I'll start with the situation I have and the code that I've isolated as causing the problem.

I have tests where I need to mock a browser. I have a mock driver I set up like this:

require "watir"

def mock_driver
  browser = double("watir")
  allow(browser).to receive(:is_a?).with(Watir::Browser).and_return(true)
  allow(browser).to receive(:driver).and_return(true)
  browser
end

The only problems I have in my test suite are these two tests:

  context "an empiric driver is requested" do
    it "a watir browser is provided" do
      allow(Watir::Browser).to receive(:new).and_return(Empiric.browser)
      Empiric.set_browser mock_driver
    end

    it "the requested watir browser can be shut down" do
      #allow(Empiric.browser).to receive(:quit)
      Empiric.quit_browser
      #allow(mock_browser).to receive(:new).and_return(Empiric.browser)
      #Empiric.set_browser mock_driver
    end
  end

(The commented out bits in the second test are on purpose to illustrate what's going on.)

With that one line in place in the second test, I get the following error on that test:

<Double "watir"> was originally created in one example but has leaked into another
example and can no longer be used. rspec-mocks' doubles are designed to only last for
one example, and you need to create a new one in each example you wish to use it for.

If I entirely comment out the first test above, that error doesn't happen so I know I've isolated the two tests that are interacting with each other.

Okay, now notice the final line of my second test that is commented out. That seems to be what the error is indicating to me. It's saying I need to create a new double in the other. Okay, so I'll change my last test:

    it "the requested watir browser can be shut down" do
      #allow(Empiric.browser).to receive(:quit)
      Empiric.quit_browser
      #allow(mock_browser).to receive(:new).and_return(Empiric.browser)
      Empiric.set_browser mock_driver
    end

So here I've uncommented the last line so I'm establishing the mock_driver in that test and not allowing the code to leak.

That, however, returns exactly the same error on exactly the same test.

I'm not sure if it would help to see the methods that are being called in that test, but here they are. First is set_browser:

def set_browser(app = :chrome, *args)
  @browser = Watir::Browser.new(app, *args)
  Empiric.browser = @browser
end

And here is quit_browser:

def quit_browser
  @browser.quit
end

The fact that RSpec thought one test was "leaking" into the other made me think that perhaps my @browser instance was the problem, essentially being what's persisting between the two tests. But I don't see how to get around that. I thought that maybe if I quit the browser in the first test, that would help. So I changed the first test to this:

it "a watir browser is provided" do
  Empiric.quit_browser
  allow(Watir::Browser).to receive(:new).and_return(Empiric.browser)
  Empiric.start_browser mock_driver
end

That, however, led to the above error being shown on both tests now.

My more likely accurate guess is that I simply don't know how to provide a mock in this context.

Answer 1

Given some advice from Micah, I wanted to provide an answer with a solution. I ended up doing this:

  context "an empiric driver is requested" do
    it "a watir browser is provided" do
      allow(Watir::Browser).to receive(:new).and_return(Empiric.browser)
      allow(Empiric.browser).to receive(:driver).and_return(true)
      expect { Empiric.start_browser :some_browser }.not_to raise_error
    end

    it "the requested watir browser can be shut down" do
      allow(Empiric.browser).to receive(:quit)
      allow(Watir::Browser).to receive(:new).and_return(Empiric.browser)
      allow(Empiric.browser).to receive(:driver).and_return(true)
      expect { Empiric.quit_browser }.not_to raise_error
    end
  end

All of that was needed as it is or I would get some error or other. I removed my mock driver and, per Micah's suggestion, simply tried to incorporate what seemed to work. The above "contraption" is what I ended up with as the sweet spot.

This works in the sense of giving coverage of the methods in question. What was interesting was that I had to add this to my RSpec configuration:

RSpec.configure do |config|
  config.mock_with :rspec do |mocks|
    mocks.allow_message_expectations_on_nil = true
  end
end

I needed to do this because RSpec was reporting that I was calling allowing something that was nil to receive a value.

This brought up some interesting things, if you think about it. I have a test that is clearly passing. And it adds to my code coverage. But is it actually testing the quit action on a browser? Well, not really since it was testing a quit action on something that it thought was nil.

But -- it does work. And it must be calling the lines of code in question because the code coverage, as reported my SimpleCov, indicates that the statements in question have been checked.

Answer 2

I think you have to use allow with the mock and not Watir::Browser.

For example, what happens if you allow the mock browser to receive whatever calls the browser would and have the it return the mock browser?

Right now you're allowing the "Watir::Browser" to receive those messages and that's returning an "Empiric.browser". Looking at your code, I understand why you put that in there but I think that might be what's screwing you up here.

Mocks in RSpec are horrible things that rarely if ever work correctly in situations like this. I would entirely recommend not using the mock_driver that you have set up. Rather, for each of your tests just do something similar to what you are doing in the mock_driver. My guess is you're including the mock driver as part of a shared context and that, too, is another thing that is very fragile in RSpec. Not recommended.

Instead you might want to use contexts to break up your tests. Then for each context block have a before block. I'm not sure if you should use before:all or before:each given that you're simulating a browser. But that way you can set up the browser in the before and tear it down in an after.

But I would recommend getting it working in each test individually first. Even if it's a lot of code duplication. Then once all tests are passing, refactor to put the browser stuff in those before/after blocks.

But, again, don't use mocks. Don't use shared contexts. It never ends well and honestly it makes your tests harder to reason about.