chore-core 3.2.3 → 4.0.0

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

@@ -1,74 +1,63 @@
 require 'spec_helper'
 
-module Chore
-  describe Queues::SQS::Publisher do
-    let(:job) { {'class' => 'TestJob', 'args'=>[1,2,'3']}}
-    let(:queue_name) { 'test_queue' }
-    let(:queue_url) {"http://www.queue_url.com/test_queue"}
-    let(:queue) { double('queue', :send_message => nil) }
-    let(:sqs) do
-      double('sqs', :queues => double('queues', :named => queue, :url_for => queue_url, :[] => queue))
-    end
-    let(:publisher) { Queues::SQS::Publisher.new }
-    let(:pool) { double("pool") }
+describe Chore::Queues::SQS::Publisher do
+  include_context 'fake objects'
 
-    before(:each) do
-      AWS::SQS.stub(:new).and_return(sqs)
-    end
+  let(:publisher) { Chore::Queues::SQS::Publisher.new }
+  let(:job) { {'class' => 'TestJob', 'args'=>[1,2,'3']}}
+  let(:send_message_result) { double(Aws::SQS::Types::SendMessageResult, :data => job) }
 
-    it 'should configure sqs' do
-      Chore.config.stub(:aws_access_key).and_return('key')
-      Chore.config.stub(:aws_secret_key).and_return('secret')
+  before(:each) do
+    allow(Aws::SQS::Client).to receive(:new).and_return(sqs)
+    allow(sqs).to receive(:send_message).and_return(send_message_result)
+  end
 
-      AWS::SQS.should_receive(:new).with(
-        :access_key_id => 'key',
-        :secret_access_key => 'secret',
-        :logger => Chore.logger,
-        :log_level => :debug
-      )
-      publisher.publish(queue_name,job)
-    end
+  it 'should configure sqs' do
+    expect(Aws::SQS::Client).to receive(:new)
+    publisher.publish(queue_name,job)
+  end
 
-    it 'should create send an encoded message to the specified queue' do
-      queue.should_receive(:send_message).with(job.to_json)
-      publisher.publish(queue_name,job)
-    end
+  it 'should not create a new SQS client before every publish' do
+    expect(Aws::SQS::Client).to receive(:new).once
+    2.times { publisher.send(:queue, queue_name) }
+  end
 
-    it 'should lookup the queue when publishing' do
-      sqs.queues.should_receive(:url_for).with('test_queue')
-      publisher.publish('test_queue', job)
-    end
+  it 'should lookup the queue when publishing' do
+    expect(sqs).to receive(:get_queue_url).with(queue_name: queue_name)
+    publisher.publish(queue_name, job)
+  end
 
-    it 'should lookup multiple queues if specified' do
-      sqs.queues.should_receive(:url_for).with('test_queue')
-      sqs.queues.should_receive(:url_for).with('test_queue2')
-      publisher.publish('test_queue', job)
-      publisher.publish('test_queue2', job)
-    end
+  it 'should create send an encoded message to the specified queue' do
+    expect(sqs).to receive(:send_message).with(queue_url: queue_url, message_body: job.to_json)
+    publisher.publish(queue_name,job)
+  end
+
+  it 'should lookup multiple queues if specified' do
+    second_queue_name = queue_name + '2'
+    expect(sqs).to receive(:get_queue_url).with(queue_name: queue_name)
+    expect(sqs).to receive(:get_queue_url).with(queue_name: second_queue_name)
+
+    publisher.publish(queue_name, job)
+    publisher.publish(second_queue_name, job)
+  end
+
+  it 'should only lookup a named queue once' do
+    expect(sqs).to receive(:get_queue_url).with(queue_name: queue_name).once
+    4.times { publisher.publish(queue_name, job) }
+  end
 
-    it 'should only lookup a named queue once' do
-      sqs.queues.should_receive(:url_for).with('test_queue').once
-      2.times { publisher.publish('test_queue', job) }
+  describe '#reset_connection!' do
+    it 'should empty API client connection pool after a call to reset_connection!' do
+      expect(Aws).to receive(:empty_connection_pools!)
+      Chore::Queues::SQS::Publisher.reset_connection!
+      publisher.send(:queue, queue_name)
     end
 
-    describe '#reset_connection!' do
-      it 'should reset the connection after a call to reset_connection!' do
-        AWS::Core::Http::ConnectionPool.stub(:pools).and_return([pool])
-        pool.should_receive(:empty!)
-        Chore::Queues::SQS::Publisher.reset_connection!
-        publisher.queue(queue_name)
-      end
-  
-      it 'should not reset the connection between calls' do
-        sqs = publisher.queue(queue_name)
-        sqs.should be publisher.queue(queue_name)
-      end
-  
-      it 'should reconfigure sqs' do
-        Chore::Queues::SQS::Publisher.reset_connection!
-        AWS::SQS.should_receive(:new)
-        publisher.queue(queue_name)
-      end
+    # TODO: this test seems like basic identity (i.e. not even a real test)
+    it 'should not reset the connection between calls' do
+      expect(Aws).to receive(:empty_connection_pools!).once
+      Chore::Queues::SQS::Publisher.reset_connection!
+      4.times { publisher.send(:queue, queue_name ) }
     end
   end
 end

data/spec/chore/queues/sqs_spec.rb

@@ -1,53 +1,44 @@
 require 'spec_helper'
 
-module Chore
-  describe Queues::SQS do
-    context "when managing queues" do
-      let(:fake_sqs) {double(Object)}
-      let(:fake_queue_collection) {double(Object)}
-      let(:queue_name) {"test"}
-      let(:queue_url) {"http://amazon.sqs.url/queues/#{queue_name}"}
-      let(:fake_queue) {double(Object)}
-
-      before(:each) do
-        allow(AWS::SQS).to receive(:new).and_return(fake_sqs)
-        allow(Chore).to receive(:prefixed_queue_names).and_return([queue_name])
-        allow(fake_queue).to receive(:delete)
+describe Chore::Queues::SQS do
+  include_context 'fake objects'
+
+  context "when managing queues" do
+    before(:each) do
+      allow(Aws::SQS::Client).to receive(:new).and_return(sqs)
+      allow(sqs).to receive(:create_queue).and_return(queue)
+      allow(sqs).to receive(:delete_queue).and_return(Struct.new(nil))
+      allow(queue).to receive(:delete).and_return(sqs.delete_queue(queue))
+      allow(Chore).to receive(:prefixed_queue_names).and_return([queue_name])
+      allow(queue).to receive(:delete)
+    end
 
-        allow(fake_queue_collection).to receive(:[]).and_return(fake_queue)
-        allow(fake_queue_collection).to receive(:create)
-        allow(fake_queue_collection).to receive(:url_for).with(queue_name).and_return(queue_url)
+    it 'should create queues that are defined in its internal job name list' do
+      #Only one job defined in the spec suite
+      expect(sqs).to receive(:create_queue).with(queue_name: queue_name)
+      Chore::Queues::SQS.create_queues!
+    end
 
-        allow(fake_sqs).to receive(:queues).and_return(fake_queue_collection)
-      end
+    it 'should delete queues that are defined in its internal job name list' do
+      #Only one job defined in the spec suite
+      expect(sqs).to receive(:delete_queue).with(queue_url: sqs.get_queue_url.queue_url)
+      Chore::Queues::SQS.delete_queues!
+    end
 
-      it 'should create queues that are defined in its internal job name list' do
-        #Only one job defined in the spec suite
-        expect(fake_queue_collection).to receive(:create)
-        Chore::Queues::SQS.create_queues!
+    context 'and checking for existing queues' do
+      it 'checks for existing queues' do
+        expect(described_class).to receive(:existing_queues).and_return([])
+        Chore::Queues::SQS.create_queues!(true)
       end
 
-      it 'should delete queues that are defined in its internal job name list' do
-        #Only one job defined in the spec suite
-        expect(fake_queue).to receive(:delete)
-        Chore::Queues::SQS.delete_queues!
+      it 'raises an error if a queue does exist' do
+        allow(described_class).to receive(:existing_queues).and_return([queue_name])
+        expect{Chore::Queues::SQS.create_queues!(true)}.to raise_error(RuntimeError)
       end
 
-      context 'and checking for existing queues' do
-        it 'checks for existing queues' do
-          expect(described_class).to receive(:existing_queues).and_return([])
-          Chore::Queues::SQS.create_queues!(true)
-        end
-
-        it 'raises an error if a queue does exist' do
-          allow(described_class).to receive(:existing_queues).and_return([queue_name])
-          expect{Chore::Queues::SQS.create_queues!(true)}.to raise_error(RuntimeError)
-        end
-
-        it 'does not raise an error if a queue does not exist' do
-          allow(described_class).to receive(:existing_queues).and_return([])
-          expect{Chore::Queues::SQS.create_queues!(true)}.not_to raise_error
-        end
+      it 'does not raise an error if a queue does not exist' do
+        allow(described_class).to receive(:existing_queues).and_return([])
+        expect{Chore::Queues::SQS.create_queues!(true)}.not_to raise_error
       end
     end
   end

data/spec/chore/strategies/consumer/single_consumer_strategy_spec.rb

@@ -11,13 +11,13 @@ describe Chore::Strategy::SingleConsumerStrategy do
     fetcher.stub(:manager) { manager }
     Chore.config.stub(:queues).and_return(test_queues)
     Chore.config.stub(:consumer).and_return(consumer)
-    
+
   end
 
   it "should consume and then assign a message" do
     consumer.should_receive(:new).with(test_queues.first).and_return(consumer)
-    consumer.should_receive(:consume).and_yield(1, 'test-queue', 60, "test", 0)
-    manager.should_receive(:assign).with(Chore::UnitOfWork.new(1, 'test-queue', 60, "test", 0, consumer))
+    consumer.should_receive(:consume).and_yield(1, nil, 'test-queue', 60, "test", 0)
+    manager.should_receive(:assign).with(Chore::UnitOfWork.new(1, nil, 'test-queue', 60, "test", 0, consumer))
     strategy.fetch
   end
 end

data/spec/chore/strategies/consumer/threaded_consumer_strategy_spec.rb

@@ -29,8 +29,8 @@ describe Chore::Strategy::ThreadedConsumerStrategy do
   before(:each) do
     fetcher.stub(:consumers) { [consumer] }
     fetcher.stub(:manager) { manager }
-    Chore.configure do |c| 
-      c.queues = ['test'] 
+    Chore.configure do |c|
+      c.queues = ['test']
       c.consumer = consumer
       c.batch_size = batch_size
     end
@@ -40,7 +40,7 @@ describe Chore::Strategy::ThreadedConsumerStrategy do
     let(:batch_size) { 2 }
 
     it "should queue but not assign the message" do
-      consumer.any_instance.should_receive(:consume).and_yield(1, 'test-queue', 60, "test", 0)
+      consumer.any_instance.should_receive(:consume).and_yield(1, nil, 'test-queue', 60, "test", 0)
       strategy.fetch
       strategy.batcher.batch.size.should == 1
 
@@ -60,7 +60,7 @@ describe Chore::Strategy::ThreadedConsumerStrategy do
 
     it "should assign the batch" do
       manager.should_receive(:assign)
-      consumer.any_instance.should_receive(:consume).and_yield(1, 'test-queue', 60, "test", 0)
+      consumer.any_instance.should_receive(:consume).and_yield(1, nil, 'test-queue', 60, "test", 0)
       strategy.fetch
       strategy.batcher.batch.size.should == 0
     end
@@ -90,8 +90,8 @@ describe Chore::Strategy::ThreadedConsumerStrategy do
 
     before do
       fetcher.stub(:consumers) { [bad_consumer] }
-      Chore.configure do |c| 
-        c.queues = ['test'] 
+      Chore.configure do |c|
+        c.queues = ['test']
         c.consumer = bad_consumer
         c.batch_size = batch_size
         c.threads_per_queue = 1

data/spec/chore/strategies/worker/forked_worker_strategy_spec.rb

@@ -13,6 +13,7 @@ describe Chore::Strategy::ForkedWorkerStrategy do
   let(:job) do
     Chore::UnitOfWork.new(
       SecureRandom.uuid,
+      nil,
       'test',
       job_timeout,
       Chore::Encoder::JsonEncoder.encode(TestJob.job_hash([1,2,"3"])),
@@ -296,4 +297,3 @@ describe Chore::Strategy::ForkedWorkerStrategy do
     end
   end
 end
-

data/spec/chore/strategies/worker/single_worker_strategy_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chore::Strategy::SingleWorkerStrategy do
   let(:manager) { double('Manager') }
   let(:job_timeout) { 60 }
-  let(:job) { Chore::UnitOfWork.new(SecureRandom.uuid, 'test', job_timeout, Chore::Encoder::JsonEncoder.encode(TestJob.job_hash([1,2,"3"])), 0) }
+  let(:job) { Chore::UnitOfWork.new(SecureRandom.uuid, nil, 'test', job_timeout, Chore::Encoder::JsonEncoder.encode(TestJob.job_hash([1,2,"3"])), 0) }
   subject       { described_class.new(manager) }
 
   describe '#stop!' do

data/spec/chore/worker_spec.rb

@@ -23,7 +23,7 @@ describe Chore::Worker do
       :publisher => FakePublisher,
       :max_attempts => 100,
       :dedupe_lambda => lambda { |first, second, third| first }
-    
+
     def perform(first, second, third)
       return second
     end
@@ -35,7 +35,7 @@ describe Chore::Worker do
       :publisher => FakePublisher,
       :max_attempts => 100,
       :dedupe_lambda => lambda { |first, second, third| first }
-    
+
     def perform(first, second)
       return second
     end
@@ -52,9 +52,9 @@ describe Chore::Worker do
 
   shared_examples_for "a worker" do
     it 'processing a single job' do
-      work = Chore::UnitOfWork.new('1', 'test', 60, encoded_job, 0, consumer)
+      work = Chore::UnitOfWork.new('1', nil, 'test', 60, encoded_job, 0, consumer)
       SimpleJob.should_receive(:perform).with(*payload)
-      consumer.should_receive(:complete).with('1')
+      consumer.should_receive(:complete).with('1', nil)
       w = Chore::Worker.new(work, {:payload_handler => payload_handler})
       w.start
     end
@@ -62,7 +62,7 @@ describe Chore::Worker do
     it 'processing multiple jobs' do
       work = []
       10.times do |i|
-        work << Chore::UnitOfWork.new(i, 'test', 60, encoded_job, 0, consumer)
+        work << Chore::UnitOfWork.new(i, nil, 'test', 60, encoded_job, 0, consumer)
       end
       SimpleJob.should_receive(:perform).exactly(10).times
       consumer.should_receive(:complete).exactly(10).times
@@ -77,7 +77,7 @@ describe Chore::Worker do
         it 'should call complete for each unique value' do
           allow(consumer).to receive(:duplicate_message?).and_return(false)
           work = []
-          work << Chore::UnitOfWork.new(1, 'dedupe_test', 60, Chore::Encoder::JsonEncoder.encode(SimpleDedupeJob.job_hash([rand,2,'3'])), 0, consumer)
+          work << Chore::UnitOfWork.new(1, nil, 'dedupe_test', 60, Chore::Encoder::JsonEncoder.encode(SimpleDedupeJob.job_hash([rand,2,'3'])), 0, consumer)
           SimpleDedupeJob.should_receive(:perform).exactly(1).times
           consumer.should_receive(:complete).exactly(1).times
           Chore::Worker.start(work, {:payload_handler => payload_handler})
@@ -87,9 +87,9 @@ describe Chore::Worker do
       context 'when the dedupe lambda does not take the same number of arguments as perform' do
         it 'should raise an error and not complete the job' do
           work = []
-          work << Chore::UnitOfWork.new(1, 'invalid_dedupe_test', 60, Chore::Encoder::JsonEncoder.encode(InvalidDedupeJob.job_hash([rand,2,'3'])), 0, consumer)
-          work << Chore::UnitOfWork.new(2, 'invalid_dedupe_test', 60, Chore::Encoder::JsonEncoder.encode(InvalidDedupeJob.job_hash([rand,2,'3'])), 0, consumer)
-          work << Chore::UnitOfWork.new(1, 'invalid_dedupe_test', 60, Chore::Encoder::JsonEncoder.encode(InvalidDedupeJob.job_hash([rand,2,'3'])), 0, consumer)
+          work << Chore::UnitOfWork.new(1, nil, 'invalid_dedupe_test', 60, Chore::Encoder::JsonEncoder.encode(InvalidDedupeJob.job_hash([rand,2,'3'])), 0, consumer)
+          work << Chore::UnitOfWork.new(2, nil, 'invalid_dedupe_test', 60, Chore::Encoder::JsonEncoder.encode(InvalidDedupeJob.job_hash([rand,2,'3'])), 0, consumer)
+          work << Chore::UnitOfWork.new(1, nil, 'invalid_dedupe_test', 60, Chore::Encoder::JsonEncoder.encode(InvalidDedupeJob.job_hash([rand,2,'3'])), 0, consumer)
           consumer.should_not_receive(:complete)
           Chore::Worker.start(work, {:payload_handler => payload_handler})
         end
@@ -109,7 +109,7 @@ describe Chore::Worker do
     let(:queue_timeouts) { [10, 20, 30] }
     let(:work) do
       queue_timeouts.map do |queue_timeout|
-        Chore::UnitOfWork.new('1', 'test', queue_timeout, Chore::Encoder::JsonEncoder.encode(job), 0, consumer)
+        Chore::UnitOfWork.new('1', nil, 'test', queue_timeout, Chore::Encoder::JsonEncoder.encode(job), 0, consumer)
       end
     end
     let(:worker) do
@@ -140,14 +140,14 @@ describe Chore::Worker do
       let(:job) { "Not-A-Valid-Json-String" }
 
       it 'should fail cleanly' do
-        work = Chore::UnitOfWork.new(2,'test',60,job,0,consumer)
+        work = Chore::UnitOfWork.new(2,nil,'test',60,job,0,consumer)
         consumer.should_not_receive(:complete)
         Chore.should_receive(:run_hooks_for).with(:on_failure, job, anything())
         Chore::Worker.start(work)
       end
 
       it 'should reject job' do
-        work = Chore::UnitOfWork.new(2,'test',60,job,0,consumer)
+        work = Chore::UnitOfWork.new(2,nil,'test',60,job,0,consumer)
         consumer.should_receive(:reject).with(2)
         Chore::Worker.start(work)
       end
@@ -158,14 +158,14 @@ describe Chore::Worker do
         end
 
         it 'should permanently fail' do
-          work = Chore::UnitOfWork.new(2,'test',60,job,9,consumer)
+          work = Chore::UnitOfWork.new(2,nil,'test',60,job,9,consumer)
           Chore.should_receive(:run_hooks_for).with(:on_permanent_failure, 'test', job, anything())
           Chore::Worker.start(work)
         end
 
         it 'should mark the item as completed' do
-          work = Chore::UnitOfWork.new(2,'test',60,job,9,consumer)
-          consumer.should_receive(:complete).with(2)
+          work = Chore::UnitOfWork.new(2,nil,'test',60,job,9,consumer)
+          consumer.should_receive(:complete).with(2, nil)
           Chore::Worker.start(work)
         end
       end
@@ -181,7 +181,7 @@ describe Chore::Worker do
       end
 
       it 'should fail cleanly' do
-        work = Chore::UnitOfWork.new(2,'test',60,encoded_job,0,consumer)
+        work = Chore::UnitOfWork.new(2,nil,'test',60,encoded_job,0,consumer)
         consumer.should_not_receive(:complete)
         SimpleJob.should_receive(:run_hooks_for).with(:on_failure, parsed_job, anything())
 
@@ -189,7 +189,7 @@ describe Chore::Worker do
       end
 
       it 'should reject job' do
-        work = Chore::UnitOfWork.new(2,'test',60,encoded_job,0,consumer)
+        work = Chore::UnitOfWork.new(2,nil,'test',60,encoded_job,0,consumer)
         consumer.should_receive(:reject).with(2)
 
         Chore::Worker.start(work)
@@ -197,14 +197,14 @@ describe Chore::Worker do
 
       context 'more than the maximum allowed times' do
         it 'should permanently fail' do
-          work = Chore::UnitOfWork.new(2,'test',60,encoded_job,999,consumer)
+          work = Chore::UnitOfWork.new(2,nil,'test',60,encoded_job,999,consumer)
           SimpleJob.should_receive(:run_hooks_for).with(:on_permanent_failure, 'test', parsed_job, anything())
           Chore::Worker.start(work)
         end
 
         it 'should mark the item as completed' do
-          work = Chore::UnitOfWork.new(2,'test',60,encoded_job,999,consumer)
-          consumer.should_receive(:complete).with(2)
+          work = Chore::UnitOfWork.new(2,nil,'test',60,encoded_job,999,consumer)
+          consumer.should_receive(:complete).with(2, nil)
           Chore::Worker.start(work)
         end
       end
@@ -214,7 +214,7 @@ describe Chore::Worker do
   describe 'delaying retries' do
     let(:encoded_job) { Chore::Encoder::JsonEncoder.encode(job) }
     let(:parsed_job) { JSON.parse(encoded_job) }
-    let(:work) { Chore::UnitOfWork.new(2, 'test', 60, encoded_job, 0, consumer) }
+    let(:work) { Chore::UnitOfWork.new(2, nil, 'test', 60, encoded_job, 0, consumer) }
 
     before(:each) do
       SimpleJob.options[:backoff] = lambda { |work| work.current_attempt }

data/spec/spec_helper.rb

@@ -26,7 +26,7 @@ class FakePublisher < Chore::Publisher
   end
 end
 
-TestMessage = Struct.new(:handle, :queue, :body, :receive_count) do
+TestMessage = Struct.new(:handle, :receipt_handle, :queue, :body, :receive_count) do
   def empty?
     false
   end

data/spec/support/queues/sqs/fake_objects.rb

@@ -0,0 +1,18 @@
+describe Chore::Queues::SQS do
+  RSpec.shared_context 'fake objects' do
+    let(:queue_name) { 'test_queue' }
+    let(:queue_url) { "http://amazon.sqs.url/queues/#{queue_name}" }
+
+    let(:queue) do
+      double(Aws::SQS::Queue,
+        attributes: {'VisibilityTimeout' => rand(10)}
+      )
+    end
+
+    let(:sqs) do
+      double(Aws::SQS::Client,
+        get_queue_url: double(Aws::SQS::Types::GetQueueUrlResult, :queue_url => queue_url),
+      )
+    end
+  end
+end