如何在 Rspec 3.5 的模块中测试内核睡眠方法？

Question

我在模块的私有部分有以下方法...

  def add_api_delay
    sleep(retry_delay * (retry_multiplier_adjustment - retries)) if retries.positive?
  end

到目前为止，我正在使用的规范看起来像这样......

  let!(:klass) do
    Class.new do
      include AmazonMws::Shared::Utilities
      attr_accessor :retries, :retry_multiplier_adjustment, :retry_delay
      def initialize
        @retries = 1
        @retry_delay = 1
        @retry_multiplier_adjustment = 2
      end

      def test_add_api_delay
        add_api_delay
      end
    end
  end

  describe '.add_api_delay', focus: true do
    # let(:kernel_spy) { class_spy(Kernel, sleep: true) }

    before do

    end

    it 'sleeps retry api calls' do
      # allow(klass).to receive(:sleep).with(1).and_return(kernel_spy)
      # expect(kernel_spy).to have_received(:sleep)
      # expect(Kernel).to receive(:sleep).with(1)
      expect(Kernel).to receive(:sleep).and_return(true)
      klass.new.test_add_api_delay
    end
  end

我有几个目标和原因想测试这个私有方法，但是如何验证 sleep 是否被调用。我不想减慢套件的速度，因此理想情况下我正在尝试对内核使用类间谍。我正在测试的任何东西似乎都不起作用。

更新

  describe '.add_api_delay' do
    before do
      allow_any_instance_of(klass).to receive(:sleep).and_return(1)
    end

    it 'sleeps retry api calls' do
      expect(klass.new.test_add_api_delay).to eq(1)
    end
  end

这可行，但是它并不理想，因为它会标记以下警察......

C: RSpec/AnyInstance: Avoid stubbing using allow_any_instance_of
      allow_any_instance_of(klass).to receive(:sleep).and_return(1)

你有什么想法？

Answer 1

我认为它不起作用，因为你没有把期望放在正确的事情上。看起来您已尝试将其放在 Kernel 和被测类上，但您需要将其放在实例上：

it 'sleeps retry api calls' do
  thing = klass.new
  allow(thing).to receive(:sleep)

  thing.test_add_api_delay

  expect(thing).to have_received(:sleep).with(1)
end

上面有一种测试气味，因为它正在对被测类进行存根。但我认为这可能比在这里强制执行一些设计约束并在调用sleep 时失去一些 Ruby 的优雅要好。

Answer 2

你应该使用allow_any_instace_of

RSpec.describe "allow_any_instance_of" do
  it "returns the specified value on any instance of the class" do
    allow_any_instance_of(Object).to receive(:foo).and_return(:return_value)

    o = Object.new
    expect(o.foo).to eq(:return_value)
  end
end

Answer 3

这是调用睡眠的私有方法的 RSpec 测试的最小示例。

class Sleeper
  def initialize(delay:)
    @delay = delay
  end
  attr_reader :delay

  private

  def rest
    sleep delay
  end
end

require 'rspec'

RSpec.describe Sleeper do
  let(:sleeper) { Sleeper.new(delay: delay) }
  let(:delay) { 10 }

  # Comment here explaining why this test is necessary
  describe '.send :rest' do
    before { allow_any_instance_of(Sleeper).to receive(:sleep) }

     it 'sleeps' do
       expect(sleeper).to receive(:sleep)
       sleeper.send :rest
     end
  end
end

更新：

你必须在这里做出决定。

Rubocop 关于“避免存根”的建议是个好建议，但您说您有理由测试私有方法是否使用内核方法，而存根是最好的方法。如果这些测试原因比 Rubocop 纯度更重要，您应该忽略 Rubocop 警告。

如果 Rubocop 的建议更重要，那么我建议编写一个计算延迟的公共方法，并为此编写测试。可能是这样的：

def retry_delay_duration
  return 0 if retries < 1
  retry_delay * (retry_multiplier_adjustment - retries)
end

private

def add_api_delay
  sleep retry_delay_duration
end

在第二种情况下，您应该删除add_api_delay 的测试，只测试公共方法retry_delay_duration（或任何您称之为的）返回正确的延迟。