chore-core 3.2.3 → 4.0.0

data/lib/chore/queues/sqs/publisher.rb

@@ -3,21 +3,26 @@ require 'chore/publisher'
 module Chore
   module Queues
     module SQS
-      
       # SQS Publisher, for writing messages to SQS from Chore
       class Publisher < Chore::Publisher
         @@reset_next = true
 
+        # @param [Hash] opts Publisher options
         def initialize(opts={})
           super
           @sqs_queues = {}
           @sqs_queue_urls = {}
         end
 
-        # Takes a given Chore::Job instance +job+, and publishes it by looking up the +queue_name+.
+        # Publishes a message to an SQS queue
+        #
+        # @param [String] queue_name Name of the SQS queue
+        # @param [Hash] job Job instance definition, will be encoded to JSON
+        #
+        # @return [struct Aws::SQS::Types::SendMessageResult]
         def publish(queue_name,job)
-          queue = self.queue(queue_name)
-          queue.send_message(encode_job(job))
+          queue = queue(queue_name)
+          queue.send_message(message_body: encode_job(job))
         end
 
         # Sets a flag that instructs the publisher to reset the connection the next time it's used
@@ -25,29 +30,33 @@ module Chore
           @@reset_next = true
         end
 
-        # Access to the configured SQS connection object
+        private
+
+        # SQS API client object
+        #
+        # @return [Aws::SQS::Client]
         def sqs
-          @sqs ||= AWS::SQS.new(
-            :access_key_id => Chore.config.aws_access_key,
-            :secret_access_key => Chore.config.aws_secret_key,
-            :logger => Chore.logger,
-            :log_level => :debug)
+          @sqs ||= Chore::Queues::SQS.sqs_client
         end
 
-        # Retrieves the SQS queue with the given +name+. The method will cache the results to prevent round trips on subsequent calls
+        # Retrieves the SQS queue object. The method will cache the results to prevent round trips on subsequent calls
+        #
         # If <tt>reset_connection!</tt> has been called, this will result in the connection being re-initialized,
         # as well as clear any cached results from prior calls
+        #
+        # @param [String] name Name of SQS queue
+        #
+        # @return [Aws::SQS::Queue]
         def queue(name)
-         if @@reset_next
-            AWS::Core::Http::ConnectionPool.pools.each do |p|
-              p.empty!
-            end
+          if @@reset_next
+            Aws.empty_connection_pools!
             @sqs = nil
             @@reset_next = false
             @sqs_queues = {}
           end
-          @sqs_queue_urls[name] ||= self.sqs.queues.url_for(name)
-          @sqs_queues[name] ||= self.sqs.queues[@sqs_queue_urls[name]]
+
+          @sqs_queue_urls[name] ||= sqs.get_queue_url(queue_name: name).queue_url
+          @sqs_queues[name] ||= Aws::SQS::Queue.new(url: @sqs_queue_urls[name], client: sqs)
         end
       end
     end

data/lib/chore/strategies/consumer/batcher.rb

@@ -15,17 +15,17 @@ module Chore
         @running = true
       end
 
-      # The main entry point of the Batcher, <tt>schedule</tt> begins a thread with the provided +batch_timeout+ 
-      # as the only argument. While the Batcher is running, it will attempt to check if either the batch is full, 
+      # The main entry point of the Batcher, <tt>schedule</tt> begins a thread with the provided +batch_timeout+
+      # as the only argument. While the Batcher is running, it will attempt to check if either the batch is full,
       # or if the +batch_timeout+ has elapsed since the oldest message was added. If either case is true, the
       # items in the batch will be executed.
-      # 
+      #
       # Calling <tt>stop</tt> will cause the thread to finish it's current check, and exit
       def schedule(batch_timeout)
         @thread = Thread.new(batch_timeout) do |timeout|
-          Chore.logger.info "Batching timeout thread starting"
+          Chore.logger.info "Batching thread starting with #{batch_timeout} second timeout"
           while @running do
-            begin 
+            begin
               oldest_item = @batch.first
               timestamp = oldest_item && oldest_item.created_at
               Chore.logger.debug "Oldest message in batch: #{timestamp}, size: #{@batch.size}"
@@ -33,7 +33,7 @@ module Chore
                 Chore.logger.debug "Batching timeout reached (#{timestamp + timeout}), current size: #{@batch.size}"
                 self.execute(true)
               end
-              sleep(1) 
+              sleep(1)
             rescue => e
               Chore.logger.error "Batcher#schedule raised an exception: #{e.inspect}"
             end

data/lib/chore/strategies/consumer/single_consumer_strategy.rb

@@ -10,16 +10,16 @@ module Chore
       end
 
       # Begins fetching from the configured queue by way of the configured Consumer. This can only be used if you have a
-      # single queue which can be kept up with at a relatively low volume. If you have more than a single queue configured,
-      # it will raise an exception.
+      # single queue which can be kept up with at a relatively low volume. If you have more than a single queue
+      # configured, it will raise an exception.
       def fetch
         Chore.logger.debug "Starting up consumer strategy: #{self.class.name}"
         queues = Chore.config.queues
         raise "When using SingleConsumerStrategy only one queue can be defined. Queues: #{queues}" unless queues.size == 1
-        
+
         @consumer = Chore.config.consumer.new(queues.first)
-        @consumer.consume do |id,queue_name,queue_timeout,body,previous_attempts|
-          work = UnitOfWork.new(id, queue_name, queue_timeout, body, previous_attempts, @consumer)
+        @consumer.consume do |message_id, message_receipt_handle, queue_name, queue_timeout, body, previous_attempts|
+          work = UnitOfWork.new(message_id, message_receipt_handle, queue_name, queue_timeout, body, previous_attempts, @consumer)
           @fetcher.manager.assign(work)
         end
       end

data/lib/chore/strategies/consumer/threaded_consumer_strategy.rb

@@ -23,7 +23,7 @@ module Chore
         Chore.logger.debug "Starting up consumer strategy: #{self.class.name}"
         threads = []
         Chore.config.queues.each do |queue|
-          Chore.config.threads_per_queue.times do 
+          Chore.config.threads_per_queue.times do
             if running?
               threads << start_consumer_thread(queue)
             end
@@ -32,7 +32,7 @@ module Chore
 
         threads.each(&:join)
       end
-      
+
       # If the ThreadedConsumerStrategy is currently running <tt>stop!</tt> will begin signalling it to stop
       # It will stop the batcher from forking more work, as well as set a flag which will disable it's own consuming
       # threads once they finish with their current work.
@@ -49,21 +49,21 @@ module Chore
         @running
       end
 
-      private 
+      private
       # Starts a consumer thread for polling the given +queue+.
       # If <tt>stop!<tt> is called, the threads will shut themsevles down.
       def start_consumer_thread(queue)
         t = Thread.new(queue) do |tQueue|
           begin
             consumer = Chore.config.consumer.new(tQueue)
-            consumer.consume do |id, queue_name, queue_timeout, body, previous_attempts|
+            consumer.consume do |message_id, message_receipt_handle, queue_name, queue_timeout, body, previous_attempts|
               # Quick hack to force this thread to end it's work
               # if we're shutting down. Could be delayed due to the
               # weird sometimes-blocking nature of SQS.
               consumer.stop if !running?
-              Chore.logger.debug { "Got message: #{id}"}
+              Chore.logger.debug { "Got message: #{message_id}"}
 
-              work = UnitOfWork.new(id, queue_name, queue_timeout, body, previous_attempts, consumer)
+              work = UnitOfWork.new(message_id, message_receipt_handle, queue_name, queue_timeout, body, previous_attempts, consumer)
               Chore.run_hooks_for(:consumed_from_source, work)
               @batcher.add(work)
             end

data/lib/chore/strategies/consumer/throttled_consumer_strategy.rb

@@ -65,7 +65,7 @@ module Chore
       end
 
       # Gives work back to the queue in case it couldn't be assigned
-      # 
+      #
       # This will go into a separate queue so that it will be prioritized
       # over other work that hasn't been attempted yet.  It also avoids
       # a deadlock where @queue is full and the master is waiting to return
@@ -100,22 +100,21 @@ module Chore
       end
 
       def create_work_units(consumer)
-        consumer.consume do |id, queue, timeout, body, previous_attempts|
-          # Note: The unit of work object contains a consumer object that when 
-          # used to consume from SQS, would have a mutex (that comes as a part 
-          # of the AWS sdk); When sending these objects across from one process 
-          # to another, we cannot send this across (becasue of the mutex). To 
+        consumer.consume do |message_id, message_receipt_handle, queue, timeout, body, previous_attempts|
+          # Note: The unit of work object contains a consumer object that when
+          # used to consume from SQS, would have a mutex (that comes as a part
+          # of the AWS sdk); When sending these objects across from one process
+          # to another, we cannot send this across (becasue of the mutex). To
           # work around this, we simply ignore the consumer object when creating
-          # the unit of work object, and when the worker recieves the work 
-          # object, it assigns it a consumer object. 
+          # the unit of work object, and when the worker recieves the work
+          # object, it assigns it a consumer object.
           # (to allow for communication back to the queue it was consumed from)
-          work = UnitOfWork.new(id, queue, timeout, body,
-                                previous_attempts)
+          work = UnitOfWork.new(message_id, message_receipt_handle, queue, timeout, body, previous_attempts)
           Chore.run_hooks_for(:consumed_from_source, work)
           @queue.push(work) if running?
           Chore.run_hooks_for(:added_to_queue, work)
         end
       end
-    end # ThrottledConsumerStrategyyeah 
+    end # ThrottledConsumerStrategy
   end
 end # Chore

data/lib/chore/strategies/worker/helpers/ipc.rb

@@ -75,7 +75,6 @@ module Chore
 
       private
 
-      # TODO: do we need this as a optional param
       def socket_file
         "./prefork_worker_sock-#{Process.pid}"
       end

data/lib/chore/unit_of_work.rb

@@ -2,13 +2,14 @@ module Chore
   # Simple class to hold job processing information.
   # Has six attributes:
   # * +:id+ The queue implementation specific identifier for this message.
+  # * +:receipt_handle+ The queue implementation specific identifier for the receipt of this message.
   # * +:queue_name+ The name of the queue the job came from
   # * +:queue_timeout+ The time (in seconds) before the job will get re-enqueued if not processed
   # * +:message+ The actual data of the message.
   # * +:previous_attempts+ The number of times the work has been attempted previously.
   # * +:consumer+ The consumer instance used to fetch this message. Most queue implementations won't need access to this, but some (RabbitMQ) will. So we
   # make sure to pass it along with each message. This instance will be used by the Worker for things like <tt>complete</tt> and </tt>reject</tt>.
-  class UnitOfWork < Struct.new(:id,:queue_name,:queue_timeout,:message,:previous_attempts,:consumer,:decoded_message, :klass)
+  class UnitOfWork < Struct.new(:id, :receipt_handle, :queue_name, :queue_timeout, :message, :previous_attempts, :consumer, :decoded_message, :klass)
     # The time at which this unit of work was created
     attr_accessor :created_at
 

data/lib/chore/version.rb

@@ -1,8 +1,8 @@
 module Chore
   module Version #:nodoc:
-    MAJOR = 3
-    MINOR = 2
-    PATCH = 3
+    MAJOR = 4
+    MINOR = 0
+    PATCH = 0
 
     STRING = [ MAJOR, MINOR, PATCH ].join('.')
   end

data/lib/chore/worker.rb

@@ -56,7 +56,7 @@ module Chore
 
         if item.consumer.duplicate_message?(dedupe_key, item.klass, item.queue_timeout)
           Chore.logger.info { "Found and deleted duplicate job #{item.klass}"}
-          item.consumer.complete(item.id)
+          item.consumer.complete(item.id, item.receipt_handle)
           return true
         end
       end
@@ -89,7 +89,7 @@ module Chore
           Chore.logger.error { "Failed to run job for #{item.message} with error: #{e.message} #{e.backtrace * "\n"}" }
           if item.current_attempt >= Chore.config.max_attempts
             Chore.run_hooks_for(:on_permanent_failure,item.queue_name,item.message,e)
-            item.consumer.complete(item.id)
+            item.consumer.complete(item.id, item.receipt_handle)
           else
             Chore.run_hooks_for(:on_failure,item.message,e)
             item.consumer.reject(item.id)
@@ -112,7 +112,7 @@ module Chore
       begin
         Chore.logger.info { "Running job #{klass} with params #{message}"}
         perform_job(klass,message)
-        item.consumer.complete(item.id)
+        item.consumer.complete(item.id, item.receipt_handle)
         Chore.logger.info { "Finished job #{klass} with params #{message}"}
         klass.run_hooks_for(:after_perform, message)
         Chore.run_hooks_for(:worker_ended, item)
@@ -141,7 +141,7 @@ module Chore
       Chore.logger.error { "Failed to run job #{item.message} with error: #{e.message} at #{e.backtrace * "\n"}" }
       if item.current_attempt >= klass.options[:max_attempts]
         klass.run_hooks_for(:on_permanent_failure,item.queue_name,message,e)
-        item.consumer.complete(item.id)
+        item.consumer.complete(item.id, item.receipt_handle)
       else
         klass.run_hooks_for(:on_failure, message, e)
         item.consumer.reject(item.id)

data/spec/chore/consumer_spec.rb

@@ -31,6 +31,6 @@ describe Chore::Consumer do
   end
 
   it 'should not have an implemented complete method' do
-    expect { consumer.complete(message) }.to raise_error(NotImplementedError)
+    expect { consumer.complete(message, nil) }.to raise_error(NotImplementedError)
   end
 end

data/spec/chore/queues/filesystem/filesystem_consumer_spec.rb

@@ -121,7 +121,7 @@ describe Chore::Queues::Filesystem::Consumer do
       end
 
       it "should consume a published job and yield the job to the handler block" do
-        expect { |b| consumer.consume(&b) }.to yield_with_args(anything, 'test-queue', 60, test_job_hash.to_json, 0)
+        expect { |b| consumer.consume(&b) }.to yield_with_args(anything, anything, 'test-queue', 60, test_job_hash.to_json, 0)
       end
 
       context "rejecting a job" do
@@ -136,7 +136,7 @@ describe Chore::Queues::Filesystem::Consumer do
           expect(rejected).to be true
 
           Timecop.freeze(Time.now + 61) do
-            expect { |b| consumer.consume(&b) }.to yield_with_args(anything, 'test-queue', 60, test_job_hash.to_json, 1)
+            expect { |b| consumer.consume(&b) }.to yield_with_args(anything, anything, 'test-queue', 60, test_job_hash.to_json, 1)
           end
         end
       end
@@ -145,12 +145,11 @@ describe Chore::Queues::Filesystem::Consumer do
         let!(:consumer_run_for_two_messages) { allow(consumer).to receive(:running?).and_return(true, false,true,false) }
 
         it "should remove job on completion" do
-          completed = false
+
           consumer.consume do |job_id, queue_name, job_hash|
+            expect(File).to receive(:delete).with(kind_of(String))
             consumer.complete(job_id)
-            completed = true
           end
-          expect(completed).to be true
 
           expect { |b| consumer.consume(&b) }.to_not yield_control
         end
@@ -160,7 +159,7 @@ describe Chore::Queues::Filesystem::Consumer do
         let(:timeout) { 30 }
 
         it "should consume a published job and yield the job to the handler block" do
-          expect { |b| consumer.consume(&b) }.to yield_with_args(anything, 'test-queue', 30, test_job_hash.to_json, 0)
+          expect { |b| consumer.consume(&b) }.to yield_with_args(anything, anything, 'test-queue', 30, test_job_hash.to_json, 0)
         end
       end
     end
@@ -172,4 +171,3 @@ describe Chore::Queues::Filesystem::Consumer do
     end
   end
 end
-

data/spec/chore/queues/sqs/consumer_spec.rb

@@ -1,131 +1,170 @@
 require 'spec_helper'
 
 describe Chore::Queues::SQS::Consumer do
-  let(:queue_name) { "test" }
-  let(:queue_url) { "test_url" }
-  let(:queues) { double("queues") }
-  let(:queue) { double("test_queue", :visibility_timeout=>10, :url=>"test_queue", :name=>"test_queue") }
+  include_context 'fake objects'
+
   let(:options) { {} }
   let(:consumer) { Chore::Queues::SQS::Consumer.new(queue_name) }
-  let(:message) { TestMessage.new("handle",queue, "message body", 1) }
-  let(:message_data) {{:id=>message.id, :queue=>message.queue.url, :visibility_timeout=>message.queue.visibility_timeout}}
-  let(:pool) { double("pool") }
-  let(:sqs) { double('AWS::SQS') }
-  let(:backoff_func) { nil }
+  let(:job) { {'class' => 'TestJob', 'args'=>[1,2,'3']} }
+  let(:backoff_func) { Proc.new { 2 + 2 } }
+
+  let(:receive_message_result) { Aws::SQS::Message::Collection.new([message], size: 1) }
+
+  let(:message) do
+      Aws::SQS::Message.new(
+      message_id: 'message id',
+      receipt_handle: "receipt_handle",
+      body: job.to_json,
+      data: job,
+      queue: queue,
+      queue_url: queue_url,
+    )
+  end
 
-  before do
-    allow(AWS::SQS).to receive(:new).and_return(sqs)
-    allow(sqs).to receive(:queues) { queues }
+  # Since a message handler is required (but not validated), this convenience method lets us
+  # effectively stub the block.
+  def consume(&block)
+    block = Proc.new{} unless block_given?
+    consumer.consume(&block)
+  end
 
-    allow(queues).to receive(:url_for) { queue_url }
-    allow(queues).to receive(:[]) { queue }
-    allow(queue).to receive(:receive_message) { message }
-    allow(pool).to receive(:empty!) { nil }
+  before do
+    allow(Aws::SQS::Client).to receive(:new).and_return(sqs)
+    allow(Aws::SQS::Queue).to receive(:new).and_return(queue)
+    allow(queue).to receive(:receive_messages).and_return(receive_message_result)
+    allow(message).to receive(:attributes).and_return({ 'ApproximateReceiveCount' => rand(10) })
   end
 
   describe "consuming messages" do
-    let!(:consumer_run_for_one_message) { allow(consumer).to receive(:running?).and_return(true, false) }
-    let!(:messages_be_unique) { allow_any_instance_of(Chore::DuplicateDetector).to receive(:found_duplicate?).and_return(false) }
-    let!(:queue_contain_messages) { allow(queue).to receive(:receive_messages).and_return(message) }
-
-    it 'should configure sqs' do
-      allow(Chore.config).to receive(:aws_access_key).and_return('key')
-      allow(Chore.config).to receive(:aws_secret_key).and_return('secret')
-
-      expect(AWS::SQS).to receive(:new).with(
-        :access_key_id => 'key',
-        :secret_access_key => 'secret'
-      ).and_return(sqs)
-      consumer.consume
+    before do
+      allow(consumer).to receive(:running?).and_return(true, false)
     end
 
-    it 'should not configure sqs multiple times' do
-      allow(consumer).to receive(:running?).and_return(true, true, false)
+    context "should create objects for interacting with the SQS API" do
+      it 'should create an sqs client' do
+        expect(queue).to receive(:receive_messages)
+        consume
+      end
 
-      expect(AWS::SQS).to receive(:new).once.and_return(sqs)
-      consumer.consume
-    end
+      it "should only create an sqs client when one doesn't exist" do
+        allow(consumer).to receive(:running?).and_return(true, true, true, true, false, true, true)
+        expect(Aws::SQS::Client).to receive(:new).exactly(:once)
+        consume
+      end
 
-    it 'should look up the queue url based on the queue name' do
-      expect(queues).to receive(:url_for).with('test').and_return(queue_url)
-      consumer.consume
-    end
+      it 'should look up the queue url based on the queue name' do
+        expect(sqs).to receive(:get_queue_url).with(queue_name: queue_name)
+        consume
+      end
 
-    it 'should look up the queue based on the queue url' do
-      expect(queues).to receive(:[]).with(queue_url).and_return(queue)
-      consumer.consume
+      it 'should create a queue object' do
+        expect(consumer.send(:queue)).to_not be_nil
+        consume
+      end
     end
 
     context "should receive a message from the queue" do
-
       it 'should use the default size of 10 when no queue_polling_size is specified' do
-        expect(queue).to receive(:receive_messages).with(:limit => 10, :attributes => [:receive_count])
-        consumer.consume
+        expect(queue).to receive(:receive_messages).with(
+          :max_number_of_messages => 10,
+          :attribute_names => ['ApproximateReceiveCount']
+        ).and_return(message)
+        consume
       end
 
       it 'should respect the queue_polling_size when specified' do
         allow(Chore.config).to receive(:queue_polling_size).and_return(5)
-        expect(queue).to receive(:receive_messages).with(:limit => 5, :attributes => [:receive_count])
-        consumer.consume
+        expect(queue).to receive(:receive_messages).with(
+          :max_number_of_messages => 5,
+          :attribute_names => ['ApproximateReceiveCount']
+        )
+        consume
       end
     end
 
-    it "should check the uniqueness of the message" do
-      allow_any_instance_of(Chore::DuplicateDetector).to receive(:found_duplicate?).with(message_data).and_return(false)
-      consumer.consume
-    end
-
-    it "should yield the message to the handler block" do
-      expect { |b| consumer.consume(&b) }.to yield_with_args('handle', queue_name, 10, 'message body', 0)
-    end
-
-    it 'should not yield for a dupe message' do
-      allow_any_instance_of(Chore::DuplicateDetector).to receive(:found_duplicate?).with(message_data).and_return(true)
-      expect {|b| consumer.consume(&b) }.not_to yield_control
-    end
-
     context 'with no messages' do
-      let!(:consumer_run_for_one_message) { allow(consumer).to receive(:running?).and_return(true, true, false) }
-      let!(:queue_contain_messages) { allow(queue).to receive(:receive_messages).and_return(message, nil) }
+      before do
+        allow(consumer).to receive(:handle_messages).and_return([])
+      end
 
       it 'should sleep' do
         expect(consumer).to receive(:sleep).with(1)
-        consumer.consume
+        consume
       end
     end
 
     context 'with messages' do
-      let!(:consumer_run_for_one_message) { allow(consumer).to receive(:running?).and_return(true, true, false) }
-      let!(:queue_contain_messages) { allow(queue).to receive(:receive_messages).and_return(message, message) }
+      before do
+        allow(consumer).to receive(:duplicate_message?).and_return(false)
+        allow(queue).to receive(:receive_messages).and_return(message)
+      end
+
+      it "should check the uniqueness of the message" do
+        expect(consumer).to receive(:duplicate_message?)
+        consume
+      end
+
+      it "should yield the message to the handler block" do
+        expect { |b| consume(&b) }
+          .to yield_with_args(
+                message.message_id,
+                message.receipt_handle,
+                queue_name,
+                queue.attributes['VisibilityTimeout'].to_i,
+                message.body,
+                message.attributes['ApproximateReceiveCount'].to_i - 1
+              )
+      end
 
       it 'should not sleep' do
         expect(consumer).to_not receive(:sleep)
-        consumer.consume
+        consume
       end
+
+      context 'with duplicates' do
+        before do
+          allow(consumer).to receive(:duplicate_message?).and_return(true)
+        end
+
+        it 'should not yield for a dupe message' do
+          expect {|b| consume(&b) }.not_to yield_control
+        end
+      end
+    end
+  end
+
+  describe "completing work" do
+    it 'deletes the message from the queue' do
+      expect(queue).to receive(:delete_messages).with(entries: [{id: message.message_id, receipt_handle: message.receipt_handle}])
+      consumer.complete(message.message_id, message.receipt_handle)
     end
   end
 
   describe '#delay' do
-    let(:item) { Chore::UnitOfWork.new(message.id, message.queue, 60, message.body, 0, consumer) }
-    let(:backoff_func) { lambda { |item| 2 } }
+    let(:item) { Chore::UnitOfWork.new(message.message_id, message.receipt_handle, message.queue, 60, message.body, 0, consumer) }
+    let(:entries) do
+      [
+        { id: item.id, receipt_handle: item.receipt_handle, visibility_timeout: backoff_func.call(item) },
+      ]
+    end
 
     it 'changes the visiblity of the message' do
-      expect(queue).to receive(:batch_change_visibility).with(2, [item.id])
+      expect(queue).to receive(:change_message_visibility_batch).with(entries: entries)
       consumer.delay(item, backoff_func)
     end
   end
 
   describe '#reset_connection!' do
     it 'should reset the connection after a call to reset_connection!' do
-      expect(AWS::Core::Http::ConnectionPool).to receive(:pools).and_return([pool])
-      expect(pool).to receive(:empty!)
+      expect(Aws).to receive(:empty_connection_pools!)
       Chore::Queues::SQS::Consumer.reset_connection!
       consumer.send(:queue)
     end
 
     it 'should not reset the connection between calls' do
-      sqs = consumer.send(:queue)
-      expect(sqs).to be consumer.send(:queue)
+      expect(Aws).to receive(:empty_connection_pools!).once
+      q = consumer.send(:queue)
+      expect(consumer.send(:queue)).to be(q)
     end
 
     it 'should reconfigure sqs' do
@@ -133,13 +172,15 @@ describe Chore::Queues::SQS::Consumer do
       allow_any_instance_of(Chore::DuplicateDetector).to receive(:found_duplicate?).and_return(false)
 
       allow(queue).to receive(:receive_messages).and_return(message)
-      consumer.consume
+      allow(sqs).to receive(:receive_message).with({:attribute_names=>["ApproximateReceiveCount"], :max_number_of_messages=>10, :queue_url=>queue_url})
+
+      consume
 
       Chore::Queues::SQS::Consumer.reset_connection!
-      allow(AWS::SQS).to receive(:new).and_return(sqs)
+      allow(Aws::SQS::Client).to receive(:new).and_return(sqs)
 
       expect(consumer).to receive(:running?).and_return(true, false)
-      consumer.consume
+      consume
     end
   end
 end