shoryuken 3.1.1 → 3.2.0

data/spec/shoryuken/manager_spec.rb

@@ -13,8 +13,9 @@ RSpec.describe Shoryuken::Manager do
   let(:polling_strategy) { Shoryuken::Polling::WeightedRoundRobin.new(queues) }
   let(:fetcher) { double Shoryuken::Fetcher }
   let(:concurrency) { 1 }
+  let(:executor) { Concurrent::ImmediateExecutor.new }
 
-  subject { Shoryuken::Manager.new(fetcher, polling_strategy, concurrency) }
+  subject { Shoryuken::Manager.new(fetcher, polling_strategy, concurrency, executor) }
 
   before do
     allow(fetcher).to receive(:fetch).and_return([])
@@ -27,9 +28,9 @@ RSpec.describe Shoryuken::Manager do
 
   describe '#stop' do
     specify do
-      allow(subject).to receive(:stopped?).and_return(false, false, true)
-      expect(subject).to receive(:dispatch).thrice.and_call_original
-      expect(subject).to receive(:dispatch_later).once.and_call_original
+      allow(subject).to receive(:running?).and_return(true, true, false)
+      expect(subject).to receive(:dispatch).once.and_call_original
+      expect(subject).to receive(:dispatch_loop).twice.and_call_original
       subject.start
     end
   end
@@ -37,12 +38,12 @@ RSpec.describe Shoryuken::Manager do
   describe '#start' do
     before do
       # prevent dispatch loop
-      allow(subject).to receive(:stopped?).and_return(false, true)
+      allow(subject).to receive(:running?).and_return(true, true, false)
     end
 
     it 'pauses when there are no active queues' do
       expect(polling_strategy).to receive(:next_queue).and_return(nil)
-      expect(subject).to receive(:dispatch_later)
+      expect(subject).to receive(:dispatch).and_call_original
       subject.start
     end
 
@@ -59,24 +60,36 @@ RSpec.describe Shoryuken::Manager do
   end
 
   describe '#dispatch' do
-    it 'fires a dispatch event' do
-      # prevent dispatch loop
-      allow(subject).to receive(:stopped?).and_return(false, true)
+    before do
+      allow(subject).to receive(:running?).and_return(true, true, false)
+    end
 
-      expect(subject).to receive(:fire_event).with(:dispatch)
+    specify do
+      message  = ['test1']
+      messages = [message]
+      q = Shoryuken::Polling::QueueConfiguration.new(queue, {})
+
+      expect(fetcher).to receive(:fetch).with(q, concurrency).and_return(messages)
+      expect(subject).to receive(:fire_event).with(:dispatch, false, queue_name: q.name)
+      expect(Shoryuken::Processor).to receive(:process).with(q, message)
       expect(Shoryuken.logger).to_not receive(:info)
 
       subject.send(:dispatch)
     end
-  end
 
-  describe '#dispatch_batch' do
-    it 'assings batch as a single message' do
-      q = polling_strategy.next_queue
-      messages = [1, 2, 3]
-      expect(fetcher).to receive(:fetch).with(q, described_class::BATCH_LIMIT).and_return(messages)
-      expect_any_instance_of(described_class).to receive(:assign).with(q.name, messages)
-      subject.send(:dispatch_batch, q)
+    context 'when batch' do
+      specify do
+        messages = %w(test1 test2 test3)
+        q = Shoryuken::Polling::QueueConfiguration.new(queue, {})
+
+        expect(fetcher).to receive(:fetch).with(q, described_class::BATCH_LIMIT).and_return(messages)
+        expect(subject).to receive(:fire_event).with(:dispatch, false, queue_name: q.name)
+        allow(subject).to receive(:batched_queue?).with(q).and_return(true)
+        expect(Shoryuken::Processor).to receive(:process).with(q, messages)
+        expect(Shoryuken.logger).to_not receive(:info)
+
+        subject.send(:dispatch)
+      end
     end
   end
 

data/spec/shoryuken/middleware/chain_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Shoryuken::Middleware::Chain do
+RSpec.describe Shoryuken::Middleware::Chain do
   class CustomMiddleware
     def initialize(name, recorder)
       @name     = name
@@ -14,20 +14,32 @@ describe Shoryuken::Middleware::Chain do
     end
   end
 
+  class CustomMiddlewareB < CustomMiddleware; end
+
   it 'supports custom middleware' do
     subject.add CustomMiddleware, 1, []
 
     expect(CustomMiddleware).to eq subject.entries.last.klass
   end
 
+  it 'can add middleware to the front of chain' do
+    subject.prepend CustomMiddleware, 1, []
+
+    expect([CustomMiddleware]).to eq subject.entries.map(&:klass)
+
+    subject.prepend CustomMiddlewareB, 1, []
+
+    expect([CustomMiddlewareB, CustomMiddleware]).to eq subject.entries.map(&:klass)
+  end
+
   it 'invokes a middleware' do
     recorder = []
-    subject.add CustomMiddleware, 'Pablo', recorder
+    subject.add CustomMiddleware, 'custom', recorder
 
     final_action = nil
     subject.invoke { final_action = true }
     expect(final_action).to eq true
-    expect(recorder).to eq [%w[Pablo before], %w[Pablo after]]
+    expect(recorder).to eq [%w(custom before), %w(custom after)]
   end
 
   class NonYieldingMiddleware
@@ -37,7 +49,7 @@ describe Shoryuken::Middleware::Chain do
   it 'allows middleware to abruptly stop processing rest of chain' do
     recorder = []
     subject.add NonYieldingMiddleware
-    subject.add CustomMiddleware, 'Pablo', recorder
+    subject.add CustomMiddleware, 'custom', recorder
 
     final_action = nil
     subject.invoke { final_action = true }

data/spec/shoryuken/middleware/server/timing_spec.rb

@@ -1,14 +1,16 @@
 require 'spec_helper'
 
-describe Shoryuken::Middleware::Server::Timing do
+RSpec.describe Shoryuken::Middleware::Server::Timing do
   let(:queue) { 'default' }
   let(:sqs_queue) { double Shoryuken::Queue, visibility_timeout: 60 }
 
   let(:sqs_msg) do
-    double Shoryuken::Message,
+    double(
+      Shoryuken::Message,
       queue_url: queue,
       body: 'test',
       message_id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e'
+    )
   end
 
   before do
@@ -28,7 +30,7 @@ describe Shoryuken::Middleware::Server::Timing do
 
   context 'when exceeded the `visibility_timeout`' do
     it 'logs exceeded' do
-      allow(subject).to receive(:elapsed).and_return(120000)
+      allow(subject).to receive(:elapsed).and_return(120_000)
 
       expect(Shoryuken.logger).to receive(:info) do |&block|
         expect(block.call).to match(/started at/)

data/spec/shoryuken/options_spec.rb

@@ -97,4 +97,84 @@ RSpec.describe Shoryuken::Options do
         "and Shoryuken doesn't support a batchable worker for a queue with multiple workers")
     end
   end
+
+  describe '.polling_strategy' do
+    context 'when not set' do
+      specify do
+        expect(Shoryuken.polling_strategy('default')).to eq Shoryuken::Polling::WeightedRoundRobin
+        expect(Shoryuken.polling_strategy('group1')).to eq Shoryuken::Polling::WeightedRoundRobin
+      end
+    end
+
+    context 'when set to StrictPriority string' do
+      before do
+        Shoryuken.options[:polling_strategy] = 'StrictPriority'
+
+        Shoryuken.options[:groups] = {
+          'group1' => {
+            polling_strategy: 'StrictPriority'
+          }
+        }
+      end
+
+      specify do
+        expect(Shoryuken.polling_strategy('default')).to eq Shoryuken::Polling::StrictPriority
+        expect(Shoryuken.polling_strategy('group1')).to eq Shoryuken::Polling::StrictPriority
+      end
+    end
+
+    context 'when set to WeightedRoundRobin string' do
+      before do
+        Shoryuken.options[:polling_strategy] = 'WeightedRoundRobin'
+
+        Shoryuken.options[:groups] = {
+          'group1' => {
+            polling_strategy: 'WeightedRoundRobin'
+          }
+        }
+      end
+
+      specify do
+        expect(Shoryuken.polling_strategy('default')).to eq Shoryuken::Polling::WeightedRoundRobin
+        expect(Shoryuken.polling_strategy('group1')).to eq Shoryuken::Polling::WeightedRoundRobin
+      end
+    end
+
+    context 'when set to non-existent string' do
+      before do
+        Shoryuken.options[:polling_strategy] = 'NonExistent1'
+
+        Shoryuken.options[:groups] = {
+          'group1' => {
+            polling_strategy: 'NonExistent2'
+          }
+        }
+      end
+
+      specify do
+        expect { Shoryuken.polling_strategy('default') }.to raise_error(ArgumentError)
+        expect { Shoryuken.polling_strategy('group1') }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when set to a class' do
+      before do
+        class Foo < Shoryuken::Polling::BaseStrategy; end
+        class Bar < Shoryuken::Polling::BaseStrategy; end
+
+        Shoryuken.options[:polling_strategy] = Foo
+
+        Shoryuken.options[:groups] = {
+          'group1' => {
+            polling_strategy: Bar
+          }
+        }
+      end
+
+      specify do
+        expect(Shoryuken.polling_strategy('default')).to eq Foo
+        expect(Shoryuken.polling_strategy('group1')).to eq Bar
+      end
+    end
+  end
 end

data/spec/shoryuken/processor_spec.rb

@@ -1,6 +1,4 @@
 require 'spec_helper'
-require 'shoryuken/processor'
-require 'shoryuken/manager'
 
 RSpec.describe Shoryuken::Processor do
   let(:manager)   { double Shoryuken::Manager }
@@ -8,12 +6,14 @@ RSpec.describe Shoryuken::Processor do
   let(:queue)     { 'default' }
 
   let(:sqs_msg) do
-    double Shoryuken::Message,
+    double(
+      Shoryuken::Message,
       queue_url: queue,
       body: 'test',
       message_attributes: {},
       message_id: SecureRandom.uuid,
       receipt_handle: SecureRandom.uuid
+    )
   end
 
   before do
@@ -25,101 +25,15 @@ RSpec.describe Shoryuken::Processor do
   subject { described_class.new(queue, sqs_msg) }
 
   describe '#process' do
-    it 'parses the body into JSON' do
-      TestWorker.get_shoryuken_options['body_parser'] = :json
+    it 'sets log context' do
+      expect(Shoryuken::Logging).to receive(:with_context).with("TestWorker/#{queue}/#{sqs_msg.message_id}")
 
-      body = { 'test' => 'hi' }
-
-      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
-
-      allow(sqs_msg).to receive(:body).and_return(JSON.dump(body))
+      allow_any_instance_of(TestWorker).to receive(:perform)
+      allow(sqs_msg).to receive(:body)
 
       subject.process
     end
 
-    it 'parses the body calling the proc' do
-      TestWorker.get_shoryuken_options['body_parser'] = proc { |sqs_msg| "*#{sqs_msg.body}*" }
-
-      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, '*test*')
-
-      allow(sqs_msg).to receive(:body).and_return('test')
-
-      subject.process
-    end
-
-    it 'parses the body as text' do
-      TestWorker.get_shoryuken_options['body_parser'] = :text
-
-      body = 'test'
-
-      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
-
-      allow(sqs_msg).to receive(:body).and_return(body)
-
-      subject.process
-    end
-
-    it 'parses calling `.load`' do
-      TestWorker.get_shoryuken_options['body_parser'] = Class.new do
-        def self.load(*args)
-          JSON.load(*args)
-        end
-      end
-
-      body = { 'test' => 'hi' }
-
-      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
-
-      allow(sqs_msg).to receive(:body).and_return(JSON.dump(body))
-
-      subject.process
-    end
-
-    it 'parses calling `.parse`' do
-      TestWorker.get_shoryuken_options['body_parser'] = Class.new do
-        def self.parse(*args)
-          JSON.parse(*args)
-        end
-      end
-
-      body = { 'test' => 'hi' }
-
-      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
-
-      allow(sqs_msg).to receive(:body).and_return(JSON.dump(body))
-
-      subject.process
-    end
-
-    context 'when parse errors' do
-      before do
-        TestWorker.get_shoryuken_options['body_parser'] = :json
-
-        allow(sqs_msg).to receive(:body).and_return('invalid JSON')
-      end
-
-      specify do
-        expect(subject.logger).to receive(:error).twice
-
-        expect { subject.process }.
-          to raise_error(JSON::ParserError, /unexpected token at 'invalid JSON'/)
-      end
-    end
-
-    context 'when `object_type: nil`' do
-      it 'parses the body as text' do
-        TestWorker.get_shoryuken_options['body_parser'] = nil
-
-        body = 'test'
-
-        expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
-
-        allow(sqs_msg).to receive(:body).and_return(body)
-
-        subject.process
-      end
-    end
-
     context 'when custom middleware' do
       let(:queue) { 'worker_called_middleware' }
 
@@ -220,15 +134,19 @@ RSpec.describe Shoryuken::Processor do
 
     context 'when shoryuken_class header' do
       let(:sqs_msg) do
-        double Shoryuken::Message,
+        double(
+          Shoryuken::Message,
           queue_url: queue,
           body: 'test',
           message_attributes: {
             'shoryuken_class' => {
               string_value: TestWorker.to_s,
-              data_type: 'String' }},
-              message_id: SecureRandom.uuid,
-              receipt_handle: SecureRandom.uuid
+              data_type: 'String'
+            }
+          },
+          message_id: SecureRandom.uuid,
+          receipt_handle: SecureRandom.uuid
+        )
       end
 
       it 'performs without delete' do

data/spec/shoryuken/queue_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 
+# 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) }
@@ -15,10 +16,12 @@ RSpec.describe Shoryuken::Queue do
   end
 
   describe '#new' do
-    context 'when queue url supplied' do
-      subject { described_class.new(sqs, queue_url) }
+    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)
 
-      specify do
         expect(subject.name).to eq(queue_name)
       end
     end
@@ -51,7 +54,9 @@ RSpec.describe Shoryuken::Queue 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(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)
 
@@ -111,36 +116,30 @@ RSpec.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'}])
     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
@@ -170,16 +169,24 @@ RSpec.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))
     end
@@ -189,9 +196,13 @@ RSpec.describe Shoryuken::Queue do
     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

data/spec/shoryuken/util_spec.rb

@@ -9,7 +9,7 @@ describe 'Shoryuken::Util' do
 
   describe '#unparse_queues' do
     it 'returns queues and weights' do
-      queues = %w[queue1 queue1 queue2 queue3 queue4 queue4 queue4]
+      queues = %w(queue1 queue1 queue2 queue3 queue4 queue4 queue4)
 
       expect(subject.unparse_queues(queues)).to eq([['queue1', 2], ['queue2', 1], ['queue3', 1], ['queue4', 3]])
     end
@@ -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,100 @@
+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