使用RSpec在Rails控制器中存根/模拟方法的最现代方法是什么？

Question

I've been using the technique described in this article for mocking methods in controllers in my request specs. TLDR, the technique uses "allow_any_instance_of" to mock controller methods. I've found some other StackOverflow posts which seem to agree with the article.

However, while reading through the rspec 3.8 documentation , it says the following:

• The rspec-mocks API is designed for individual object instances, but this feature operates on entire classes of objects. As a result there are some semantically confusing edge cases. For example, in expect_any_instance_of(Widget).to receive(:name).twice it isn't clear whether a specific instance is expected to receive name twice, or if two receives total are expected. (It's the former.)
• Using this feature is often a design smell. It may be that your test is trying to do too much or that the object under test is too complex.
• It is the most complicated feature of rspec-mocks, and has historically received the most bug reports. (None of the core team actively use it, which doesn't help.)

What is the correct and "modern" way to mock a method in a request spec?

I don't think the following matters, but just in case:

• Rails 5.2
• Ruby 2.4.1
• RSpec 3.8

Edit: Adding some example code.

module A
  def my_pain
    puts "I don't want to run this during testing"
  end
end

class TestController < ApplicationController
  include A
  def index
    my_pain
  end
end

So what is the modern way to test "#index" while mocking "#my_pain" with RSpec in a controller/request test.

Answer 1

In my opinion, we don't need to test the Controller, just take feature tests. because what end-users are expecting is what will be rendered, not just navigation.

Answer 2

Another approach - try to mock as little as possible.

• Mock nothing until tests become slow or require external resources to configure.
  Then mock only dependencies/classes which are slow or access external resources(webservice, file system etc.)

• Mock nothing until test setup become very complicated.
  Then mock dependencies which contains very complicated logic, to simplify/reduce amount of logical branches to test.

In case you decided to mock some of dependencies:
If instance of dependency provided to the class under the test

class Order
    def initialize(printer)
        @printer = printer
    end

    def print
        @printer.print("my-printer", self)
    end
end

# Test
RSpec.describe "Order.print" do
    it "prints order to my printer" do
        fake_printer = double("Printer", :print => nil)
        order = Order.new(fake_printer)

        expect(fake_printer).to receive(:print).with("my-printer", order)

        order.print
    end
end

If instance of dependency instantiated inside class under the test

class Order
    def initialize
        @printer = Printer.new("my-printer")
    end

    def print
        @printer.print(self)
    end
end

# Test
RSpec.describe "Order.print" do
    it "prints order to my printer" do
        fake_printer = double("Printer", :print => nil)
        allow(Printer).to receive(:new).with("my-printer").and_return(fake_printer)

        order = Order.new

        expect(fake_printer).to receive(:print).with(order)

        order.print
    end
end

Notice that when you are using double("ClassName") you need to configure all methods which will be called during the test, if not - exception will be thrown.

RSpec Test Doubles