RSpec: stubbing Kernel::sleep?

Question

Is there a way to stub Kernel.sleep in an rspec scenario?

Answer 1

Since Kernel is an ancestor of all Objects, one should be able to mock the inherited sleep method on the class under test.

MyClass.ancestors --> [MyClass, Object, PP::ObjectMixin, Kernel, BasicObject]

The mock can be accomplished with code similar to this.

before do
  allow(described_class).to receive(:sleep).and_return('')
end

The following more detailed example shows mocking sleep for when it is called within class and instance methods. Would enjoy hearing comments from more experienced Ruby developers.

Class:

class MyClass
  class << self
    def klass_action(sleep_seconds)
      sleep(sleep_seconds)
    end
  end

  def self.class_action(sleep_seconds)
    sleep(sleep_seconds)
  end

  def do_some_action(sleep_seconds)
    sleep(sleep_seconds)
  end
end

Tests:

describe MyClass, focus: true do
  subject { MyClass.new }

  let(:sleep_seconds) { 12 }

  context 'sleep called from an instance' do
    before do
      allow(subject).to receive(:sleep).and_return('')
    end

    it 'sleeps for the requested number of seconds' do
      subject.do_some_action(sleep_seconds)

      expect(subject).to have_received(:sleep).with(sleep_seconds)
    end
  end

  context 'sleep called from a class' do
    before do
      allow(described_class).to receive(:sleep).and_return('')
    end

    it 'class method sleeps for the requested number of seconds' do
      described_class.class_action(sleep_seconds)

      expect(described_class).to have_received(:sleep).with(sleep_seconds)
    end

    it 'klass method sleeps for the requested number of seconds' do
      described_class.klass_action(sleep_seconds)

      expect(described_class).to have_received(:sleep).with(sleep_seconds)
    end
  end
end

Answer 2

For rspec version 1, the stubbing syntax has changed. This works:

allow_any_instance_of(Kernel).to receive(:sleep).and_return("")

When I use it.

Answer 3

Here's the newer way of stubbing Rspec with Kernal::Sleep.

This is basically an update to the following answer: Tony Pitluga's answer to the same question

class Foo
  def self.some_method
    sleep 5
  end
end

it "should call sleep" do
  allow_any_instance_of(Foo).to receive(:sleep)
  expect(Foo).to receive(:sleep).with(5)
  Foo.some_method
end

Answer 4

When the call to sleep is not within an object (while testing a rake task for example), you can add the following in a before block (rspec 3 syntax)

allow_any_instance_of(Object).to receive(:sleep)

Answer 5

I was not able to get the other solutions here to work. Maybe something have changed in the way sleep is handled in newer versions of Ruby, or something else.

What I ended up doing was to monkey-patch the Object class as it appears that this is what receives the sleep calls. So I simply added this:

class Object
    def sleep(*args)
    end
end

So the sleep method now does nothing in stead of something. There might be some way of mocking this better, but I was not able to find a good solution without mocking the sleep metohd of every single object that potentially used it.

Answer 6

If you are calling sleep within the context of an object, you should stub it on the object, like so:

class Foo
  def self.some_method
    sleep 5
  end
end

it "should call sleep" do
  Foo.stub!(:sleep)
  Foo.should_receive(:sleep).with(5)
  Foo.some_method
end

The key is, to stub sleep on whatever "self" is in the context where sleep is called.

Answer 7

I needed to stub require and after long searching I found that the only way that worked for me is this

def method_using_sleep
  sleep
  sleep 0.01
end

it "should use sleep" do
  @expectations = mock('expectations')
  @expectations.should_receive(:sleep).ordered.with()
  @expectations.should_receive(:sleep).ordered.with(0.01)

  def sleep(*args)
    @expectations.sleep(*args)
  end

  method_using_sleep
end

Answer 8

In pure rspec:

before do
  Kernel.stub!(:sleep)
end

it "should sleep" do
  Kernel.should_receive(:sleep).with(100)
  Object.method_to_test #We need to call our method to see that it is called
end

Answer 9

If you're using Mocha, then something like this will work:

def setup
  Kernel.stubs(:sleep)
end

def test_my_sleepy_method
  my_object.take_cat_nap!
  Kernel.assert_received(:sleep).with(1800) #should take a half-hour paower-nap
end

Or if you're using rr:

def setup
  stub(Kernel).sleep
end

def test_my_sleepy_method
  my_object.take_cat_nap!
  assert_received(Kernel) { |k| k.sleep(1800) }
end

You probably shouldn't be testing more complex threading issues with unit tests. On integration tests, however, use the real Kernel.sleep, which will help you ferret out complex threading issues.