sneakers_custom_bunny 1.0.4

data/spec/sneakers/worker_handlers_spec.rb

@@ -0,0 +1,390 @@
+require 'spec_helper'
+require 'sneakers'
+require 'timeout'
+require 'sneakers/handlers/oneshot'
+require 'sneakers/handlers/maxretry'
+require 'json'
+
+
+# Specific tests of the Handler implementations you can use to deal with job
+# results. These tests only make sense with a worker that requires acking.
+
+class HandlerTestWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+             :ack => true
+
+  def work(msg)
+    if msg.is_a?(StandardError)
+      raise msg
+    elsif msg.is_a?(String)
+      hash = maybe_json(msg)
+      if hash.is_a?(Hash)
+        hash['response'].to_sym
+      else
+        hash
+      end
+    else
+      msg
+    end
+  end
+
+  def maybe_json(string)
+    JSON.parse(string)
+  rescue
+    string
+  end
+end
+
+class TestPool
+  def process(*args,&block)
+    block.call
+  end
+end
+
+
+describe 'Handlers' do
+  let(:channel) { Object.new }
+  let(:queue) { Object.new }
+  let(:worker) { HandlerTestWorker.new(@queue, TestPool.new) }
+
+  before(:each) do
+    Sneakers.configure(:daemonize => true, :log => 'sneakers.log')
+    Sneakers::Worker.configure_logger(Logger.new('/dev/null'))
+    Sneakers::Worker.configure_metrics
+  end
+
+  describe 'Oneshot' do
+    before(:each) do
+      @opts = Object.new
+      @handler = Sneakers::Handlers::Oneshot.new(channel, queue, @opts)
+
+      @header = Object.new
+      stub(@header).delivery_tag { 37 }
+    end
+
+    describe '#do_work' do
+      it 'should work and handle acks' do
+        mock(channel).acknowledge(37, false)
+
+        worker.do_work(@header, nil, :ack, @handler)
+      end
+
+      it 'should work and handle rejects' do
+        mock(channel).reject(37, false)
+
+        worker.do_work(@header, nil, :reject, @handler)
+      end
+
+      it 'should work and handle requeues' do
+        mock(channel).reject(37, true)
+
+        worker.do_work(@header, nil, :requeue, @handler)
+      end
+
+      it 'should work and handle user-land timeouts' do
+        mock(channel).reject(37, false)
+
+        worker.do_work(@header, nil, :timeout, @handler)
+      end
+
+      it 'should work and handle user-land error' do
+        mock(channel).reject(37, false)
+
+        worker.do_work(@header, nil, StandardError.new('boom!'), @handler)
+      end
+
+      it 'should work and handle noops' do
+        worker.do_work(@header, nil, :wait, @handler)
+      end
+    end
+
+  end
+
+  describe 'Maxretry' do
+    let(:max_retries) { nil }
+    let(:props_with_x_death_count) {
+      {
+        :headers => {
+          "x-death" => [
+                        {
+                          "count" => 3,
+                          "reason" => "expired",
+                          "queue" => "downloads-retry",
+                          "time" => Time.now,
+                          "exchange" => "RawMail-retry",
+                          "routing-keys" => ["RawMail"]
+                        },
+                        {
+                          "count" => 3,
+                          "reason" => "rejected",
+                          "queue" => "downloads",
+                          "time" => Time.now,
+                          "exchange" => "",
+                          "routing-keys" => ["RawMail"]
+                        }
+                       ]
+        },
+        :delivery_mode => 1
+      }
+    }
+
+    before(:each) do
+      @opts = {
+        :exchange => 'sneakers',
+        :durable => 'true',
+      }.tap do |opts|
+        opts[:retry_max_times] = max_retries unless max_retries.nil?
+      end
+
+      mock(queue).name { 'downloads' }
+
+      @retry_exchange = Object.new
+      @error_exchange = Object.new
+      @requeue_exchange = Object.new
+
+      @retry_queue = Object.new
+      @error_queue = Object.new
+
+      mock(channel).exchange('downloads-retry',
+                             :type => 'topic',
+                             :durable => 'true').once { @retry_exchange }
+      mock(channel).exchange('downloads-error',
+                             :type => 'topic',
+                             :durable => 'true').once { @error_exchange }
+      mock(channel).exchange('downloads-retry-requeue',
+                             :type => 'topic',
+                             :durable => 'true').once { @requeue_exchange }
+
+      mock(channel).queue('downloads-retry',
+                          :durable => 'true',
+                          :arguments => {
+                            :'x-dead-letter-exchange' => 'downloads-retry-requeue',
+                            :'x-message-ttl' => 60000
+                          }
+                          ).once { @retry_queue }
+      mock(@retry_queue).bind(@retry_exchange, :routing_key => '#')
+
+      mock(channel).queue('downloads-error',
+                          :durable => 'true').once { @error_queue }
+      mock(@error_queue).bind(@error_exchange, :routing_key => '#')
+
+      mock(queue).bind(@requeue_exchange, :routing_key => '#')
+
+      @handler = Sneakers::Handlers::Maxretry.new(channel, queue, @opts)
+
+      @header = Object.new
+      stub(@header).delivery_tag { 37 }
+
+      @props = {}
+      @props_with_x_death = {
+        :headers => {
+          "x-death" => [
+                        {
+                          "reason" => "expired",
+                          "queue" => "downloads-retry",
+                          "time" => Time.now,
+                          "exchange" => "RawMail-retry",
+                          "routing-keys" => ["RawMail"]
+                        },
+                        {
+                          "reason" => "rejected",
+                          "queue" => "downloads",
+                          "time" => Time.now,
+                          "exchange" => "",
+                          "routing-keys" => ["RawMail"]
+                        }
+                       ]
+        },
+        :delivery_mode => 1}
+    end
+
+    # it 'allows overriding the retry exchange name'
+    # it 'allows overriding the error exchange name'
+    # it 'allows overriding the retry timeout'
+
+    describe '#do_work' do
+      before do
+        @now = Time.now
+      end
+
+      # Used to stub out the publish method args. Sadly RR doesn't support
+      # this, only proxying existing methods.
+      module MockPublish
+        attr_reader :data, :opts, :called
+
+        def publish(data, opts)
+          @data = data
+          @opts = opts
+          @called = true
+        end
+      end
+
+      it 'should work and handle acks' do
+        mock(channel).acknowledge(37, false)
+
+        worker.do_work(@header, @props, :ack, @handler)
+      end
+
+      describe 'rejects' do
+        describe 'more retries ahead' do
+          it 'should work and handle rejects' do
+            mock(channel).reject(37, false)
+
+            worker.do_work(@header, @props_with_x_death, :reject, @handler)
+          end
+        end
+
+        describe 'no more retries' do
+          let(:max_retries) { 1 }
+
+          it 'sends the rejection to the error queue' do
+            mock(@header).routing_key { '#' }
+            mock(channel).acknowledge(37, false)
+
+            @error_exchange.extend MockPublish
+            worker.do_work(@header, @props_with_x_death, :reject, @handler)
+            @error_exchange.called.must_equal(true)
+            @error_exchange.opts.must_equal({ :routing_key => '#' })
+            data = JSON.parse(@error_exchange.data)
+            data['error'].must_equal('reject')
+            data['num_attempts'].must_equal(2)
+            data['payload'].must_equal(Base64.encode64(:reject.to_s))
+            Time.parse(data['failed_at']).wont_be_nil
+          end
+
+          it 'counts the number of attempts using the count key' do
+            mock(@header).routing_key { '#' }
+            mock(channel).acknowledge(37, false)
+
+            @error_exchange.extend MockPublish
+            worker.do_work(@header, props_with_x_death_count, :reject, @handler)
+            @error_exchange.called.must_equal(true)
+            @error_exchange.opts.must_equal({ :routing_key => '#' })
+            data = JSON.parse(@error_exchange.data)
+            data['error'].must_equal('reject')
+            data['num_attempts'].must_equal(4)
+            data['payload'].must_equal(Base64.encode64(:reject.to_s))
+            Time.parse(data['failed_at']).wont_be_nil
+          end
+
+        end
+      end
+
+      describe 'requeues' do
+        it 'should work and handle requeues' do
+          mock(channel).reject(37, true)
+
+          worker.do_work(@header, @props_with_x_death, :requeue, @handler)
+        end
+
+        describe 'no more retries left' do
+          let(:max_retries) { 1 }
+
+          it 'continues to reject with requeue' do
+            mock(channel).reject(37, true)
+
+            worker.do_work(@header, @props_with_x_death, :requeue, @handler)
+          end
+        end
+
+      end
+
+      describe 'timeouts' do
+        describe 'more retries ahead' do
+          it 'should reject the message' do
+            mock(channel).reject(37, false)
+
+            worker.do_work(@header, @props_with_x_death, :timeout, @handler)
+          end
+        end
+
+        describe 'no more retries left' do
+          let(:max_retries) { 1 }
+
+          it 'sends the rejection to the error queue' do
+            mock(@header).routing_key { '#' }
+            mock(channel).acknowledge(37, false)
+            @error_exchange.extend MockPublish
+
+            worker.do_work(@header, @props_with_x_death, :timeout, @handler)
+            @error_exchange.called.must_equal(true)
+            @error_exchange.opts.must_equal({ :routing_key => '#' })
+            data = JSON.parse(@error_exchange.data)
+            data['error'].must_equal('timeout')
+            data['num_attempts'].must_equal(2)
+            data['payload'].must_equal(Base64.encode64(:timeout.to_s))
+            Time.parse(data['failed_at']).wont_be_nil
+          end
+        end
+      end
+
+      describe 'exceptions' do
+        describe 'more retries ahead' do
+          it 'should reject the message' do
+            mock(channel).reject(37, false)
+
+            worker.do_work(@header, @props_with_x_death, StandardError.new('boom!'), @handler)
+          end
+        end
+
+        describe 'no more retries left' do
+          let(:max_retries) { 1 }
+
+          it 'sends the rejection to the error queue' do
+            mock(@header).routing_key { '#' }
+            mock(channel).acknowledge(37, false)
+            @error_exchange.extend MockPublish
+
+            worker.do_work(@header, @props_with_x_death, StandardError.new('boom!'), @handler)
+            @error_exchange.called.must_equal(true)
+            @error_exchange.opts.must_equal({ :routing_key => '#' })
+            data = JSON.parse(@error_exchange.data)
+            data['error'].must_equal('boom!')
+            data['error_class'].must_equal(StandardError.to_s)
+            data['backtrace'].wont_be_nil
+            data['num_attempts'].must_equal(2)
+            data['payload'].must_equal(Base64.encode64('boom!'))
+            Time.parse(data['failed_at']).wont_be_nil
+          end
+        end
+      end
+
+      it 'should work and handle user-land error' do
+        mock(channel).reject(37, false)
+
+        worker.do_work(@header, @props, StandardError.new('boom!'), @handler)
+      end
+
+      it 'should work and handle noops' do
+        worker.do_work(@header, @props, :wait, @handler)
+      end
+
+      # Since we encode in json, we want to make sure if the actual payload is
+      # json, then it's something you can get back out.
+      describe 'JSON payloads' do
+        let(:max_retries) { 1 }
+
+        it 'properly encodes the json payload' do
+          mock(@header).routing_key { '#' }
+          mock(channel).acknowledge(37, false)
+          @error_exchange.extend MockPublish
+
+          payload = {
+            data: 'hello',
+            response: :timeout
+          }
+          worker.do_work(@header, @props_with_x_death, payload.to_json, @handler)
+          @error_exchange.called.must_equal(true)
+          @error_exchange.opts.must_equal({ :routing_key => '#' })
+          data = JSON.parse(@error_exchange.data)
+          data['error'].must_equal('timeout')
+          data['num_attempts'].must_equal(2)
+          data['payload'].must_equal(Base64.encode64(payload.to_json))
+        end
+
+      end
+
+    end
+  end
+end

data/spec/sneakers/worker_spec.rb

@@ -0,0 +1,463 @@
+require 'spec_helper'
+require 'sneakers'
+require 'timeout'
+
+
+class DummyWorker
+  include Sneakers::Worker
+  from_queue 'downloads',
+             :durable => false,
+             :ack => false,
+             :threads => 50,
+             :prefetch => 40,
+             :timeout_job_after => 1,
+             :exchange => 'dummy',
+             :heartbeat => 5
+
+  def work(msg)
+  end
+end
+
+class DefaultsWorker
+  include Sneakers::Worker
+  from_queue 'defaults'
+
+  def work(msg)
+  end
+end
+
+class TimeoutWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+    :timeout_job_after => 0.5,
+    :ack => true
+
+  def work(msg)
+  end
+end
+
+class AcksWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+             :ack => true
+
+  def work(msg)
+    if msg == :ack
+      ack!
+    elsif msg == :nack
+      nack!
+    elsif msg == :reject
+      reject!
+    else
+      msg
+    end
+  end
+end
+
+class PublishingWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+             :ack => false,
+             :exchange => 'foochange'
+
+  def work(msg)
+    publish msg, :to_queue => 'target'
+  end
+end
+
+
+
+class LoggingWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+             :ack => false
+
+  def work(msg)
+    logger.info "hello"
+  end
+end
+
+
+class MetricsWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+             :ack => true,
+             :timeout_job_after => 0.5
+
+  def work(msg)
+    metrics.increment "foobar"
+    msg
+  end
+end
+
+class WithParamsWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+             :ack => true,
+             :timeout_job_after => 0.5
+
+  def work_with_params(msg, delivery_info, metadata)
+    msg
+  end
+end
+
+
+class TestPool
+  def process(*args,&block)
+    block.call
+  end
+end
+
+def with_test_queuefactory(ctx, ack=true, msg=nil, nowork=false)
+  qf = Object.new
+  q = Object.new
+  s = Object.new
+  hdr = Object.new
+  mock(qf).build_queue(anything, anything, anything) { q }
+  mock(q).subscribe(anything){ s }
+
+  mock(s).each(anything) { |h,b| b.call(hdr, msg) unless nowork }
+  mock(hdr).ack{true} if !nowork && ack
+  mock(hdr).reject{true} if !nowork && !ack
+
+  mock(ctx).queue_factory { qf } # should return our own
+end
+
+describe Sneakers::Worker do
+  before do
+    @queue = Object.new
+    @exchange = Object.new
+    stub(@queue).name { 'test-queue' }
+    stub(@queue).opts { {} }
+    stub(@queue).exchange { @exchange }
+
+    Sneakers.clear!
+    Sneakers.configure(:daemonize => true, :log => 'sneakers.log')
+    Sneakers::Worker.configure_metrics
+  end
+
+  describe ".enqueue" do
+    it "publishes a message to the class queue" do
+      message = "my message"
+      mock = MiniTest::Mock.new
+
+      mock.expect(:publish, true) do |msg, opts|
+        msg.must_equal(message)
+        opts.must_equal(:to_queue => "defaults")
+      end
+
+      stub(Sneakers::Publisher).new { mock }
+      DefaultsWorker.enqueue(message)
+    end
+  end
+
+  describe "#initialize" do
+    describe "builds an internal queue" do
+      before do
+        @dummy_q = DummyWorker.new.queue
+        @defaults_q = DefaultsWorker.new.queue
+      end
+
+      it "should build a queue with correct configuration given defaults" do
+        @defaults_q.name.must_equal('defaults')
+        @defaults_q.opts.to_hash.must_equal(
+          :runner_config_file => nil,
+          :metrics => nil,
+          :daemonize => true,
+          :start_worker_delay => 0.2,
+          :workers => 4,
+          :log => "sneakers.log",
+          :pid_path => "sneakers.pid",
+          :timeout_job_after => 5,
+          :prefetch => 10,
+          :threads => 10,
+          :durable => true,
+          :ack => true,
+          :amqp => "amqp://guest:guest@localhost:5672",
+          :vhost => "/",
+          :exchange => "sneakers",
+          :exchange_type => :direct,
+          :hooks => {},
+          :handler => Sneakers::Handlers::Oneshot,
+          :heartbeat  =>  2
+        )
+      end
+
+      it "should build a queue with given configuration" do
+        @dummy_q.name.must_equal('downloads')
+        @dummy_q.opts.to_hash.must_equal(
+          :runner_config_file => nil,
+          :metrics => nil,
+          :daemonize => true,
+          :start_worker_delay => 0.2,
+          :workers => 4,
+          :log => "sneakers.log",
+          :pid_path => "sneakers.pid",
+          :timeout_job_after => 1,
+          :prefetch => 40,
+          :threads => 50,
+          :durable => false,
+          :ack => false,
+          :amqp => "amqp://guest:guest@localhost:5672",
+          :vhost => "/",
+          :exchange => "dummy",
+          :exchange_type => :direct,
+          :hooks => {},
+          :handler => Sneakers::Handlers::Oneshot,
+          :heartbeat => 5
+        )
+      end
+    end
+
+    describe "initializes worker" do
+      it "should generate a worker id" do
+        DummyWorker.new.id.must_match(/^worker-/)
+      end
+    end
+  end
+
+
+  describe "#run" do
+    it "should subscribe on internal queue" do
+      q = Object.new
+      w = DummyWorker.new(q)
+      mock(q).subscribe(w).once #XXX once?
+      stub(q).name{ "test" }
+      stub(q).opts { nil }
+      w.run
+    end
+  end
+
+  describe "#stop" do
+    it "should unsubscribe from internal queue" do
+      q = Object.new
+      mock(q).unsubscribe.once #XXX once?
+      stub(q).name { 'test-queue' }
+      stub(q).opts {nil}
+      w = DummyWorker.new(q)
+      w.stop
+    end
+  end
+
+
+  describe "#do_work" do
+    it "should perform worker's work" do
+      w = DummyWorker.new(@queue, TestPool.new)
+      mock(w).work("msg").once
+      w.do_work(nil, nil, "msg", nil)
+    end
+
+    it "should catch runtime exceptions from a bad work" do
+      w = AcksWorker.new(@queue, TestPool.new)
+      mock(w).work("msg").once{ raise "foo" }
+      handler = Object.new
+      header = Object.new
+      mock(handler).error(header, nil, "msg", anything)
+      mock(w.logger).error(/unexpected error \[Exception error="foo" error_class=RuntimeError backtrace=.*/)
+      w.do_work(header, nil, "msg", handler)
+    end
+
+    it "should log exceptions from workers" do
+      handler = Object.new
+      header = Object.new
+      w = AcksWorker.new(@queue, TestPool.new)
+      mock(w).work("msg").once{ raise "foo" }
+      mock(w.logger).error(/error="foo" error_class=RuntimeError backtrace=/)
+      mock(handler).error(header, nil, "msg", anything)
+      w.do_work(header, nil, "msg", handler)
+    end
+
+    it "should timeout if a work takes too long" do
+      w = TimeoutWorker.new(@queue, TestPool.new)
+      stub(w).work("msg"){ sleep 10 }
+
+      handler = Object.new
+      header = Object.new
+
+      mock(handler).timeout(header, nil, "msg")
+      mock(w.logger).error(/timeout/)
+
+      w.do_work(header, nil, "msg", handler)
+    end
+
+    describe "with ack" do
+      before do
+        @delivery_info = Object.new
+        stub(@delivery_info).delivery_tag{ "tag" }
+
+        @worker = AcksWorker.new(@queue, TestPool.new)
+      end
+
+      it "should work and handle acks" do
+        handler = Object.new
+        mock(handler).acknowledge(@delivery_info, nil, :ack)
+
+        @worker.do_work(@delivery_info, nil, :ack, handler)
+      end
+
+      it "should work and handle rejects" do
+        handler = Object.new
+        mock(handler).reject(@delivery_info, nil, :reject)
+
+        @worker.do_work(@delivery_info, nil, :reject, handler)
+      end
+
+      it "should work and handle requeues" do
+        handler = Object.new
+        mock(handler).reject(@delivery_info, nil, :requeue, true)
+
+        @worker.do_work(@delivery_info, nil, :requeue, handler)
+      end
+
+      it "should work and handle user-land timeouts" do
+        handler = Object.new
+        mock(handler).timeout(@delivery_info, nil, :timeout)
+
+        @worker.do_work(@delivery_info, nil, :timeout, handler)
+      end
+
+      it "should work and handle user-land error" do
+        handler = Object.new
+        mock(handler).error(@delivery_info, nil, :error, anything)
+
+        @worker.do_work(@delivery_info, nil, :error, handler)
+      end
+    end
+
+    describe "without ack" do
+      it "should work and not care about acking if not ack" do
+        handler = Object.new
+        mock(handler).reject(anything).never
+        mock(handler).acknowledge(anything).never
+
+        w = DummyWorker.new(@queue, TestPool.new)
+        w.do_work(nil, nil, 'msg', handler)
+      end
+    end
+  end
+
+
+  describe 'publish' do
+    it 'should be able to publish a message from working context' do
+      w = PublishingWorker.new(@queue, TestPool.new)
+      mock(@exchange).publish('msg', :routing_key => 'target').once
+      w.do_work(nil, nil, 'msg', nil)
+    end
+
+    it 'should be able to publish arbitrary metadata' do
+      w = PublishingWorker.new(@queue, TestPool.new)
+      mock(@exchange).publish('msg', :routing_key => 'target', :expiration => 1).once
+      w.publish 'msg', :to_queue => 'target', :expiration => 1
+    end
+  end
+
+
+  describe 'Logging' do
+    it 'should be able to use the logging facilities' do
+      log = Logger.new('/dev/null')
+      mock(log).debug(anything).once
+      mock(log).info("hello").once
+      Sneakers::Worker.configure_logger(log)
+
+      w = LoggingWorker.new(@queue, TestPool.new)
+      w.do_work(nil,nil,'msg',nil)
+    end
+
+    it 'has a helper to constuct log prefix values' do
+      w = DummyWorker.new(@queue, TestPool.new)
+      w.instance_variable_set(:@id, 'worker-id')
+      m = w.log_msg('foo')
+      w.log_msg('foo').must_match(/\[worker-id\]\[#<Thread:.*>\]\[test-queue\]\[\{\}\] foo/)
+    end
+
+    describe '#worker_error' do
+      it 'only logs backtraces if present' do
+        w = DummyWorker.new(@queue, TestPool.new)
+        mock(w.logger).error(/cuz \[Exception error="boom!" error_class=RuntimeError\]/)
+        w.worker_error('cuz', RuntimeError.new('boom!'))
+      end
+    end
+
+  end
+
+
+  describe 'Metrics' do
+    before do
+      @handler = Object.new
+      @header = Object.new
+
+      # We don't care how these are called, we're focusing on metrics here.
+      stub(@handler).acknowledge
+      stub(@handler).reject
+      stub(@handler).timeout
+      stub(@handler).error
+      stub(@handler).noop
+
+      @delivery_info = Object.new
+      stub(@delivery_info).delivery_tag { "tag" }
+
+      @w = MetricsWorker.new(@queue, TestPool.new)
+      mock(@w.metrics).increment("work.MetricsWorker.started").once
+      mock(@w.metrics).increment("work.MetricsWorker.ended").once
+      mock(@w.metrics).timing("work.MetricsWorker.time").yields.once
+    end
+
+    it 'should be able to meter acks' do
+      mock(@w.metrics).increment("foobar").once
+      mock(@w.metrics).increment("work.MetricsWorker.handled.ack").once
+      @w.do_work(@delivery_info, nil, :ack, @handler)
+    end
+
+    it 'should be able to meter rejects' do
+      mock(@w.metrics).increment("foobar").once
+      mock(@w.metrics).increment("work.MetricsWorker.handled.reject").once
+      @w.do_work(@header, nil, :reject, @handler)
+    end
+
+    it 'should be able to meter requeue' do
+      mock(@w.metrics).increment("foobar").once
+      mock(@w.metrics).increment("work.MetricsWorker.handled.requeue").once
+      @w.do_work(@header, nil, :requeue, @handler)
+    end
+
+    it 'should be able to meter errors' do
+      mock(@w.metrics).increment("work.MetricsWorker.handled.error").once
+      mock(@w).work('msg'){ raise :error }
+      @w.do_work(@delivery_info, nil, 'msg', @handler)
+    end
+
+    it 'should be able to meter timeouts' do
+      mock(@w.metrics).increment("work.MetricsWorker.handled.timeout").once
+      mock(@w).work('msg'){ sleep 10 }
+      @w.do_work(@delivery_info, nil, 'msg', @handler)
+    end
+
+    it 'defaults to noop when no response is specified' do
+      mock(@w.metrics).increment("foobar").once
+      mock(@w.metrics).increment("work.MetricsWorker.handled.noop").once
+      @w.do_work(@header, nil, nil, @handler)
+    end
+  end
+
+
+
+  describe 'With Params' do
+    before do
+      @props = { :foo => 1 }
+      @handler = Object.new
+      @header = Object.new
+
+      @delivery_info = Object.new
+
+      stub(@handler).noop(@delivery_info, {:foo => 1}, :ack)
+
+      @w = WithParamsWorker.new(@queue, TestPool.new)
+      mock(@w.metrics).timing("work.WithParamsWorker.time").yields.once
+    end
+
+    it 'should call work_with_params and not work' do
+      mock(@w).work_with_params(:ack, @delivery_info, {:foo => 1}).once
+      @w.do_work(@delivery_info, {:foo => 1 }, :ack, @handler)
+    end
+  end
+end