为什么“不要在诸如`before`之类的钩子中使用`expect`”？

Question

My question is pretty much explained by the title. I was trying to google it but did not find anything satisfying at all. rubocop-rspec does not allow expect inside before , why is that? Is there a good reason to avoid such a usage? Thanks for your explanations in advance!

Answer 1

Four phase test is a testing pattern commonly used for unit tests. It's general form:

test do
  setup
  exercise
  verify
  teardown
end

before is part of the setup phase where the developer creates the scenario and supporting data.

expect is part of the verify phase, which happens inside a it block.

A common pattern is to use allow in before blocks and use expect in it blocks for example.

RSpec.describe User do
  describe '#forgot_password' do
    before { allow(EmailService).to receive(:send) }

    subject { FactoryBot.create(:user).forgot_password }

    it 'sends an email to user to start the password resetting process' do
      subject
      expect(EmailService).to have_received(:send).with(...)
    end
  end
end

before blocks can also be added in other layers of the application ( spec_helper.rb , shared examples) and one does not want to rely on the correct order of before blocks in order for a test to be successful.

Answer 2

Only tests should include expectations (also known as assertions). before blocks are meant to configure the environment in which your tests run. They are not meant to be tests themselves.

Answer 3

I agree with expects in before filters since you are not changing anything in the examples, you are always testing the general setup, but in after filters I do not see a reason to avoid expectations.

When writing tests, context is what matters most, you are testing the same code under different parameters (or contexts), hence, the examples need only to modify the context and the assertion could remain constant.

See this example:

 RSpec.describe Foo do
  subject { create(:foo) }

  describe 'some_method' do
    let(:foo) { create(:foo) }

    after do
      foo.update_rate
      subject.update_rate

      expect(foo.rate).to be > subject.rate
    end

    it 'gives higher rates to foos with more reviews if all are positive' do
      foo.update!(votes_up_count: 10, reviews_count: 10)
      subject.update!(votes_up_count: 1, reviews_count: 1)
    end

    it 'gives higher rates to foos with less positive reviews and no negative reviews' do
      foo.update!(votes_up_count: 4, reviews_count: 4)
      subject.update!(votes_up_count: 5, reviews_count: 6)
    end
  end
end

As opposed to

 RSpec.describe Foo do
  subject { create(:foo) }

  describe 'some_method' do
    let(:foo) { create(:foo) }

    it 'gives higher rates to foos with more reviews if all are positive' do
      foo.update!(votes_up_count: 10, reviews_count: 10)
      subject.update!(votes_up_count: 1, reviews_count: 1)

      foo.update_rate
      subject.update_rate

      expect(foo.rate).to be > subject.rate
    end

    it 'gives higher rates to foos with less positive reviews and no negative reviews' do
      foo.update!(votes_up_count: 4, reviews_count: 4)
      subject.update!(votes_up_count: 5, reviews_count: 6)

      foo.update_rate
      subject.update_rate

      expect(foo.rate).to be > subject.rate
    end
  end
end

So I would not take this cop as gospel to be honest, i think it goes against good testing practices.