Interesting use of setup for constructing tests

setup_test_example_with_opaque_input_params.rb

describe Acme::MessageQueue::SqsMessageQueue do

  def setup(payload, &block)
    config = {
      :access_key => 'first',
      :secret_key => 'second'
    }

    mock_queue  = double(:mock_queue)
    mock_queues = double(:mock_queues)
    mock_sqs    = double(queues: mock_queues)

    aws_configs = {
      :access_key_id     => config.fetch(:access_key),
      :secret_access_key => config.fetch(:secret_key)
    }

    AWS::SQS.should_receive(:new).with(aws_configs).and_return(mock_sqs)
    mock_queues.should_receive(:create).with('wat-bro').and_return(mock_queue)

    block.call(mock_queue, payload, config)
  end

  it 'sends a message to an Amazon SQS queue' do
    setup({'test' => 'ing'}) do |mock_queue, message, config|
      mock_queue.should_receive(:send_message).with(MultiJson.dump(message))
      described_class.new(config, 'wat').send_message('bro', message)
    end
  end

  it 'sends multiple messages to an Amazon SQS queue' do
    setup([{one: :two}, {three: :four}]) do |mock_queue, messages, config|
      payload = messages.map { |message| MultiJson.dump(message) }
      mock_queue.should_receive(:batch_send).with(payload)
      described_class.new(config, 'wat').send_messages('bro', messages)
    end
  end

  it 'sends messages in batches of ten' do
    setup([{one: :message}, {two: :message},   {three: :message}, {four: :message}, {five: :message}, 
           {six: :message}, {seven: :message}, {eight: :message}, {nine: :message}, {ten: :message}, 
           {eleven: :message}, {twelve: :message}]) do |mock_queue, messages, config|
             payloads = messages.map { |message| MultiJson.dump(message) }
             payloads.each_slice(10).each do |payload|
               mock_queue.should_receive(:batch_send).with(payload)
             end
             described_class.new(config, 'wat').send_messages('bro', messages)
           end
  end

  it 'pops a message off the queue' do
    setup({'test' => 'ing'}) do |mock_queue, payload, config|
      mock_message = double(body: MultiJson.dump(payload))
      mock_queue.should_receive(:receive_message) do |&block|
        block.call(mock_message)
      end

      described_class.new(config, 'wat').pop('bro').should == payload
    end
  end
end