shoryuken 3.0.6 → 4.0.0

data/spec/shoryuken/queue_spec.rb

@@ -1,22 +1,73 @@
 require 'spec_helper'
 
-describe Shoryuken::Queue do
+# rubocop:disable Metrics/BlockLength
+RSpec.describe Shoryuken::Queue do
   let(:credentials) { Aws::Credentials.new('access_key_id', 'secret_access_key') }
   let(:sqs) { Aws::SQS::Client.new(stub_responses: true, credentials: credentials) }
   let(:queue_name) { 'shoryuken' }
-  let(:queue_url) { 'https://eu-west-1.amazonaws.com:6059/123456789012/shoryuken' }
+  let(:queue_url) { "https://sqs.eu-west-1.amazonaws.com:6059/0123456789/#{queue_name}" }
 
   subject { described_class.new(sqs, queue_name) }
-  before {
+
+  before do
     # Required as Aws::SQS::Client.get_queue_url returns 'String' when responses are stubbed,
     # which is not accepted by Aws::SQS::Client.get_queue_attributes for :queue_name parameter.
     allow(subject).to receive(:url).and_return(queue_url)
-  }
+  end
+
+  describe '#new' do
+    context 'when queue URL supplied' do
+      it 'instantiates by URL and validate the URL' do
+        expect_any_instance_of(described_class).to receive(:fifo?).and_return(false)
+
+        subject = described_class.new(sqs, queue_url)
+
+        expect(subject.name).to eq(queue_name)
+      end
+    end
+
+    context 'when queue name supplied' do
+      subject { described_class.new(sqs, queue_name) }
+
+      specify do
+        expect(subject.name).to eq(queue_name)
+      end
+    end
+  end
+
+  describe '#delete_messages' do
+    let(:entries) do
+      [
+        { id: '1', receipt_handle:  '1' },
+        { id: '2', receipt_handle:  '2' }
+      ]
+    end
+
+    it 'deletes' do
+      expect(sqs).to receive(:delete_message_batch).with(entries: entries, queue_url: queue_url).and_return(double(failed: []))
+
+      subject.delete_messages(entries: entries)
+    end
+
+    context 'when it fails' do
+      it 'logs the reason' do
+        failure = double(id: 'id', code: 'code', message: '...', sender_fault: false)
+        logger = double 'Logger'
+
+        expect(sqs).to(
+          receive(:delete_message_batch).with(entries: entries, queue_url: queue_url).and_return(double(failed: [failure]))
+        )
+        expect(subject).to receive(:logger).and_return(logger)
+        expect(logger).to receive(:error)
+
+        subject.delete_messages(entries: entries)
+      end
+    end
+  end
 
   describe '#send_message' do
-    before {
-      allow(subject).to receive(:fifo?).and_return(false)
-    }
+    before { allow(subject).to receive(:fifo?).and_return(false) }
+
     it 'accepts SQS request parameters' do
       # https://docs.aws.amazon.com/sdkforruby/api/Aws/SQS/Client.html#send_message-instance_method
       expect(sqs).to receive(:send_message).with(hash_including(message_body: 'msg1'))
@@ -65,36 +116,30 @@ describe Shoryuken::Queue do
   end
 
   describe '#send_messages' do
-    before {
-      allow(subject).to receive(:fifo?).and_return(false)
-    }
+    before { allow(subject).to receive(:fifo?).and_return(false) }
+
     it 'accepts SQS request parameters' do
       # https://docs.aws.amazon.com/sdkforruby/api/Aws/SQS/Client.html#send_message_batch-instance_method
-      expect(sqs).to receive(:send_message_batch).with(hash_including(entries: [{id: '0', message_body: 'msg1'}, {id: '1', message_body: 'msg2'}]))
+      expect(sqs).to(
+        receive(:send_message_batch).with(hash_including(entries: [{ id: '0', message_body: 'msg1' }, { id: '1', message_body: 'msg2' }]))
+      )
 
-      subject.send_messages(entries: [{id: '0', message_body: 'msg1'}, {id: '1', message_body: 'msg2'}])
+      subject.send_messages(entries: [{ id: '0', message_body: 'msg1' }, { id: '1', message_body: 'msg2' }])
     end
 
     it 'accepts an array of messages' do
-      options = { entries: [{ id: '0',
-                              message_body: 'msg1',
-                              delay_seconds: 1,
-                              message_attributes: { attr: 'attr1' } },
-                            { id: '1',
-                              message_body: 'msg2',
-                              delay_seconds: 1,
-                              message_attributes: { attr: 'attr2' } }] }
-
+      options = { entries: [
+        { id: '0', message_body: 'msg1', delay_seconds: 1, message_attributes: { attr: 'attr1' } },
+        { id: '1', message_body: 'msg2', delay_seconds: 1, message_attributes: { attr: 'attr2' } }
+      ] }
       expect(sqs).to receive(:send_message_batch).with(hash_including(options))
 
-      subject.send_messages([{ message_body:       'msg1',
-                               delay_seconds:      1,
-                               message_attributes: { attr: 'attr1' }
-                             }, {
-                               message_body:       'msg2',
-                               delay_seconds:      1,
-                               message_attributes: { attr: 'attr2' }
-                             }])
+      subject.send_messages(
+        [
+          { message_body: 'msg1', delay_seconds: 1, message_attributes: { attr: 'attr1' } },
+          { message_body: 'msg2', delay_seconds: 1, message_attributes: { attr: 'attr2' } }
+        ]
+      )
     end
 
     context 'when FIFO' do
@@ -124,40 +169,69 @@ describe Shoryuken::Queue do
             expect(first_entry[:message_deduplication_id]).to eq 'my id'
           end
 
-          subject.send_messages([{ message_body: 'msg1',
-                                   message_attributes: { attr: 'attr1' },
-                                   message_group_id: 'my group',
-                                   message_deduplication_id: 'my id' }])
+          subject.send_messages(
+            [
+              { message_body: 'msg1',
+                message_attributes: { attr: 'attr1' },
+                message_group_id: 'my group',
+                message_deduplication_id: 'my id' }
+            ]
+          )
         end
       end
     end
 
     it 'accepts an array of string' do
-      expect(sqs).to receive(:send_message_batch).with(hash_including(entries: [{ id: '0', message_body: 'msg1' }, { id: '1', message_body: 'msg2' }]))
+      expect(sqs).to(
+        receive(:send_message_batch).with(
+          hash_including(entries: [{ id: '0', message_body: 'msg1' }, { id: '1', message_body: 'msg2' }])
+        )
+      )
 
-      subject.send_messages(%w(msg1 msg2))
+      subject.send_messages(%w[msg1 msg2])
     end
   end
 
   describe '#fifo?' do
+    let(:attribute_response) { double 'Aws::SQS::Types::GetQueueAttributesResponse' }
     before do
-      attribute_response = double 'Aws::SQS::Types::GetQueueAttributesResponse'
-
-      allow(attribute_response).to receive(:attributes).and_return('FifoQueue' => fifo.to_s, 'ContentBasedDeduplication' => 'true')
+      allow(attribute_response).to(
+        receive(:attributes).and_return('FifoQueue' => fifo.to_s, 'ContentBasedDeduplication' => 'true')
+      )
       allow(subject).to receive(:url).and_return(queue_url)
-      allow(sqs).to receive(:get_queue_attributes).with(queue_url: queue_url, attribute_names: ['All']).and_return(attribute_response)
+      allow(sqs).to(
+        receive(:get_queue_attributes).with(queue_url: queue_url, attribute_names: ['All']).and_return(attribute_response)
+      )
     end
 
     context 'when queue is FIFO' do
       let(:fifo) { true }
 
-      it { expect(subject.fifo?).to be }
+      specify { expect(subject.fifo?).to be }
+
+      it 'memoizes response' do
+        expect(sqs).to(
+          receive(:get_queue_attributes).with(queue_url: queue_url, attribute_names: ['All']).and_return(attribute_response)
+        ).exactly(1).times
+
+        subject.fifo?
+        subject.fifo?
+      end
     end
 
     context 'when queue is not FIFO' do
       let(:fifo) { false }
 
-      it { expect(subject.fifo?).to_not be }
+      specify { expect(subject.fifo?).to_not be }
+
+      it 'memoizes response' do
+        expect(sqs).to(
+          receive(:get_queue_attributes).with(queue_url: queue_url, attribute_names: ['All']).and_return(attribute_response)
+        ).exactly(1).times
+
+        subject.fifo?
+        subject.fifo?
+      end
     end
   end
 end

data/spec/shoryuken/runner_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'shoryuken/runner'
-require 'shoryuken/launcher'
 
 # rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::Runner do
@@ -17,10 +16,10 @@ RSpec.describe Shoryuken::Runner do
   describe '#run' do
     let(:launcher) { instance_double('Shoryuken::Launcher') }
 
-    before(:each) do
+    before do
       allow(Shoryuken::Launcher).to receive(:new).and_return(launcher)
-      allow(launcher).to receive(:run).and_raise(Interrupt)
-      allow(launcher).to receive(:stop)
+      allow(launcher).to receive(:start).and_raise(Interrupt)
+      allow(launcher).to receive(:stop!)
     end
 
     it 'does not raise' do

data/spec/shoryuken/util_spec.rb

@@ -26,4 +26,28 @@ describe 'Shoryuken::Util' do
 
     it 'returns ActiveJob worker name'
   end
+
+  describe '#fire_event' do
+    let(:value_holder) { Object.new }
+    let(:callback_without_options) { proc { value_holder.value = :without_options } }
+    let(:callback_with_options) { proc { |options| value_holder.value = [:with_options, options] } }
+
+    after :all do
+      Shoryuken.options[:lifecycle_events].delete(:some_event)
+    end
+
+    it 'triggers callbacks that do not accept arguments' do
+      Shoryuken.options[:lifecycle_events][:some_event] = [callback_without_options]
+
+      expect(value_holder).to receive(:value=).with(:without_options)
+      subject.fire_event(:some_event)
+    end
+
+    it 'triggers callbacks that accept an argument' do
+      Shoryuken.options[:lifecycle_events][:some_event] = [callback_with_options]
+
+      expect(value_holder).to receive(:value=).with([:with_options, { my_option: :some_option }])
+      subject.fire_event(:some_event, false, my_option: :some_option)
+    end
+  end
 end

data/spec/shoryuken/worker/default_executor_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Worker::DefaultExecutor do
+  let(:sqs_queue) { double 'SQS Queue' }
+  let(:queue)     { 'default' }
+
+  before do
+    allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+  end
+
+  describe '.perform_in' do
+    it 'delays a message' do
+      expect(sqs_queue).to receive(:send_message).with(
+        message_attributes: {
+          'shoryuken_class' => {
+            string_value: TestWorker.to_s,
+            data_type: 'String'
+          }
+        },
+        message_body: 'message',
+        delay_seconds: 60
+      )
+
+      TestWorker.perform_in(60, 'message')
+    end
+
+    it 'raises an exception' do
+      expect {
+        TestWorker.perform_in(901, 'message')
+      }.to raise_error 'The maximum allowed delay is 15 minutes'
+    end
+  end
+
+  describe '.perform_at' do
+    it 'delays a message' do
+      expect(sqs_queue).to receive(:send_message).with(
+        message_attributes: {
+          'shoryuken_class' => {
+            string_value: TestWorker.to_s,
+            data_type: 'String'
+          }
+        },
+        message_body: 'message',
+        delay_seconds: 60
+      )
+
+      TestWorker.perform_in(Time.now + 60, 'message')
+    end
+
+    it 'raises an exception' do
+      expect {
+        TestWorker.perform_in(Time.now + 901, 'message')
+      }.to raise_error 'The maximum allowed delay is 15 minutes'
+    end
+  end
+
+  describe '.perform_async' do
+    it 'enqueues a message' do
+      expect(sqs_queue).to receive(:send_message).with(
+        message_attributes: {
+          'shoryuken_class' => {
+            string_value: TestWorker.to_s,
+            data_type: 'String'
+          }
+        },
+        message_body: 'message'
+      )
+
+      TestWorker.perform_async('message')
+    end
+
+    it 'enqueues a message with options' do
+      expect(sqs_queue).to receive(:send_message).with(
+        delay_seconds: 60,
+        message_attributes: {
+          'shoryuken_class' => {
+            string_value: TestWorker.to_s,
+            data_type: 'String'
+          }
+        },
+        message_body: 'delayed message'
+      )
+
+      TestWorker.perform_async('delayed message', delay_seconds: 60)
+    end
+
+    it 'accepts an `queue` option' do
+      new_queue = 'some_different_queue'
+
+      expect(Shoryuken::Client).to receive(:queues).with(new_queue).and_return(sqs_queue)
+
+      expect(sqs_queue).to receive(:send_message).with(
+        message_attributes: {
+          'shoryuken_class' => {
+            string_value: TestWorker.to_s,
+            data_type: 'String'
+          }
+        },
+        message_body: 'delayed message'
+      )
+
+      TestWorker.perform_async('delayed message', queue: new_queue)
+    end
+  end
+end

data/spec/shoryuken/worker/inline_executor_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Worker::InlineExecutor do
+  before do
+    Shoryuken.worker_executor = described_class
+  end
+
+  describe '.perform_async' do
+    specify do
+      expect_any_instance_of(TestWorker).to receive(:perform).with(anything, 'test')
+
+      TestWorker.perform_async('test')
+    end
+  end
+
+  describe '.perform_in' do
+    specify do
+      expect_any_instance_of(TestWorker).to receive(:perform).with(anything, 'test')
+
+      TestWorker.perform_in(60, 'test')
+    end
+  end
+
+  context 'batch' do
+    before do
+      TestWorker.get_shoryuken_options['batch'] = true
+    end
+
+    after do
+      TestWorker.get_shoryuken_options['batch'] = false
+    end
+
+    describe '.perform_async' do
+      specify do
+        expect_any_instance_of(TestWorker).to receive(:perform).with(anything, ['test'])
+
+        TestWorker.perform_async('test')
+      end
+    end
+
+    describe '.perform_in' do
+      specify do
+        expect_any_instance_of(TestWorker).to receive(:perform).with(anything, ['test'])
+
+        TestWorker.perform_in(60, 'test')
+      end
+    end
+  end
+end

data/spec/shoryuken/worker_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe 'Shoryuken::Worker' do
+RSpec.describe Shoryuken::Worker do
   let(:sqs_queue) { double 'SQS Queue' }
   let(:queue)     { 'default' }
 
@@ -8,96 +8,6 @@ RSpec.describe 'Shoryuken::Worker' do
     allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
   end
 
-  describe '.perform_in' do
-    it 'delays a message' do
-      expect(sqs_queue).to receive(:send_message).with(
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'message',
-        delay_seconds: 60)
-
-      TestWorker.perform_in(60, 'message')
-    end
-
-    it 'raises an exception' do
-      expect {
-        TestWorker.perform_in(901, 'message')
-      }.to raise_error 'The maximum allowed delay is 15 minutes'
-    end
-  end
-
-  describe '.perform_at' do
-    it 'delays a message' do
-      expect(sqs_queue).to receive(:send_message).with(
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'message',
-        delay_seconds: 60)
-
-      TestWorker.perform_in(Time.now + 60, 'message')
-    end
-
-    it 'raises an exception' do
-      expect {
-        TestWorker.perform_in(Time.now + 901, 'message')
-      }.to raise_error 'The maximum allowed delay is 15 minutes'
-    end
-  end
-
-  describe '.perform_async' do
-    it 'enqueues a message' do
-      expect(sqs_queue).to receive(:send_message).with(
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'message')
-
-      TestWorker.perform_async('message')
-    end
-
-    it 'enqueues a message with options' do
-      expect(sqs_queue).to receive(:send_message).with(
-        delay_seconds: 60,
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'delayed message')
-
-      TestWorker.perform_async('delayed message', delay_seconds: 60)
-    end
-
-    it 'accepts an `queue` option' do
-      new_queue = 'some_different_queue'
-
-      expect(Shoryuken::Client).to receive(:queues).with(new_queue).and_return(sqs_queue)
-
-      expect(sqs_queue).to receive(:send_message).with(
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'delayed message')
-
-      TestWorker.perform_async('delayed message', queue: new_queue)
-    end
-  end
-
   describe '.shoryuken_options' do
     it 'registers a worker' do
       expect(Shoryuken.worker_registry.workers('default')).to eq([TestWorker])
@@ -109,13 +19,27 @@ RSpec.describe 'Shoryuken::Worker' do
       class NewTestWorker
         include Shoryuken::Worker
 
-        shoryuken_options queue: ->{ "#{$queue_prefix}_default" }
+        shoryuken_options queue: -> { "#{$queue_prefix}_default" }
       end
 
       expect(Shoryuken.worker_registry.workers('production_default')).to eq([NewTestWorker])
       expect(NewTestWorker.get_shoryuken_options['queue']).to eq 'production_default'
     end
 
+    it 'does not change the original hash' do
+      class TestWorker
+        include Shoryuken::Worker
+
+        OPT = { queue: :default }.freeze
+
+        shoryuken_options OPT
+      end
+
+      expect(TestWorker::OPT['queue']).to eq(nil)
+      expect(TestWorker.get_shoryuken_options['queue']).to eq('default')
+      expect(TestWorker::OPT[:queue]).to eq(:default)
+    end
+
     it 'accepts an array as a queue' do
       class WorkerMultipleQueues
         include Shoryuken::Worker
@@ -164,12 +88,29 @@ RSpec.describe 'Shoryuken::Worker' do
       expect(Shoryuken.worker_registry.workers('symbol_queue2')).to eq([WorkerMultipleSymbolQueues])
       expect(Shoryuken.worker_registry.workers('symbol_queue3')).to eq([WorkerMultipleSymbolQueues])
     end
+
+    it 'preserves parent class options' do
+      class ParentWorker
+        include Shoryuken::Worker
+
+        shoryuken_options queue: 'myqueue', auto_delete: false
+      end
+
+      class ChildWorker < ParentWorker
+        shoryuken_options auto_delete: true
+      end
+
+      expect(ParentWorker.get_shoryuken_options['queue']).to eq('myqueue')
+      expect(ChildWorker.get_shoryuken_options['queue']).to eq('myqueue')
+      expect(ParentWorker.get_shoryuken_options['auto_delete']).to eq(false)
+      expect(ChildWorker.get_shoryuken_options['auto_delete']).to eq(true)
+    end
   end
 
   describe '.server_middleware' do
     before do
       class FakeMiddleware
-        def call(*args)
+        def call(*_args)
           yield
         end
       end
@@ -192,9 +133,7 @@ RSpec.describe 'Shoryuken::Worker' do
         class NewTestWorker2
           include Shoryuken::Worker
 
-          server_middleware do |chain|
-            chain.clear
-          end
+          server_middleware(&:clear)
         end
       end
 

data/spec/shoryuken_spec.rb

@@ -1,63 +1,4 @@
 require 'spec_helper'
 
 RSpec.describe Shoryuken do
-  describe '.add_queue' do
-    after { Shoryuken.queues.clear }
-
-    it 'adds queues' do
-      described_class.add_queue('default')
-      expect(described_class.queues).to eq(['default'])
-
-      described_class.add_queue('high', 2)
-      expect(described_class.queues).to eq(%w(default high high))
-    end
-  end
-
-  describe '.register_worker' do
-    it 'registers a worker' do
-      described_class.worker_registry.clear
-      described_class.register_worker('default', TestWorker)
-      expect(described_class.worker_registry.workers('default')).to eq([TestWorker])
-    end
-
-    it 'registers a batchable worker' do
-      described_class.worker_registry.clear
-      TestWorker.get_shoryuken_options['batch'] = true
-      described_class.register_worker('default', TestWorker)
-      expect(described_class.worker_registry.workers('default')).to eq([TestWorker])
-    end
-
-    it 'allows multiple workers' do
-      described_class.worker_registry.clear
-      described_class.register_worker('default', TestWorker)
-      expect(described_class.worker_registry.workers('default')).to eq([TestWorker])
-
-      class Test2Worker
-        include Shoryuken::Worker
-
-        shoryuken_options queue: 'default'
-
-        def perform(sqs_msg, body); end
-      end
-
-      expect(described_class.worker_registry.workers('default')).to eq([Test2Worker])
-    end
-
-    it 'raises an exception when mixing batchable with non batchable' do
-      described_class.worker_registry.clear
-      TestWorker.get_shoryuken_options['batch'] = true
-      described_class.register_worker('default', TestWorker)
-
-      expect {
-        class BatchableWorker
-          include Shoryuken::Worker
-
-          shoryuken_options queue: 'default', batch: true
-
-          def perform(sqs_msg, body); end
-        end
-      }.to raise_error("Could not register BatchableWorker for 'default', because TestWorker is already registered for this queue, " \
-                       "and Shoryuken doesn't support a batchable worker for a queue with multiple workers")
-    end
-  end
 end