Posted on by

Testing that a block is called

CapnKernul asks:

Hey Avdi. How would you test that a method’s provided block is called in RSpec? Would you stub #to_proc (for &block) and mock ?

Typically the way I test that a block is called goes something like this:

describe ZeroWing do
  let(:probe) { lambda{} }

  context "given a signal handler" do
    subject.on_we_get_signal(&probe)

    it "triggers the handler when signaled" do
      probe.should_receive(:call)
      subject.we_get_signal!
    end
  end
end

That’s for the simple case of just checking if the block is called. When I want to make assertions about the block arguments, I often switch to a style which records the yielded arguments and then makes assertions on them after the fact.

describe Array do
  subject { [1,2,3] }

  describe "#reverse_each" do
    it "yields the elements in backwards order" do
      yielded = []
      subject.reverse_each do |e| yielded << e end
      yielded.should eq([3,2,1])
    end
  end
end

I don’t know if this is the best way, but it’s the way I usually do it.

Want farm-to-table coding tips?

The DevSeeds newsletter brings you developer tips from me (Avdi Grimm) and my Graceful.Dev garden of developer training straight to your inbox. Subscribe for free articles, discounts, and news!

9 comments

  1. I think  subject.on_we_get_signal(&amp;probe) needs to be in a before(:each) block–you can’t call it like that ddirectly in the “class body” of the example group.

    The mocking approach you’ve described here is interesting, I always use something closer to your second approach even for the simple case of just asserting the block was called:

    it ‘calls the given block’ do
    block_called = false
    subject.method_that_calls_block { block_called = true }
    block_called.should be_true
    end

    The mocking doesn’t gain anything over this approach IMHO, and it’s more fragile. If the method-under-test calls the block using #call, it’ll work fine, but what if it just uses a plain old yield?

  2. What about something like MockBlock here: https://gist.github.com/1428875

    That doesn’t care whether the implementation actually uses #call or yield, and shows a readable technique for testing the order of the calls.  I find that a lot nicer to read than the old block_called.should be_true or yielded.should == style.

  3. Given the following code block:

    barcode = Barby::Code128B.new(data)
    File.open(“test.png”, ‘w’) do |f|
    f.write barcode.to_png(height: 100, margin: 5)
    end

    How would I test that code within the block was executed? Specifically the calls to f.write or barcode.to_png?

      1. Couldn’t you stub File.open to yield a mock file, then assert that the mock receives the write call?

  4. The first example is just great! I really don’t like creating superfluous instance variables to validate things. By adding on a .with(foo) I can keep my tests completely out of the caller/consumer space. Thanks!

Comments are closed.