shoryuken 3.1.8 → 3.2.0

data/spec/shoryuken/body_parser_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'shoryuken/body_parser'
+
+RSpec.describe Shoryuken::BodyParser do
+  let(:sqs_msg) { double }
+
+  describe '#parser' do
+    it 'parses the body into JSON' do
+      TestWorker.get_shoryuken_options['body_parser'] = :json
+
+      body = { 'test' => 'hi' }
+
+      allow(sqs_msg).to receive(:body).and_return(JSON.dump(body))
+
+      expect(described_class.parse(TestWorker, sqs_msg)).to eq(body)
+    end
+
+    it 'parses the body calling the proc' do
+      TestWorker.get_shoryuken_options['body_parser'] = proc { |sqs_msg| "*#{sqs_msg.body}*" }
+
+      allow(sqs_msg).to receive(:body).and_return('test')
+
+      expect(described_class.parse(TestWorker, sqs_msg)).to eq('*test*')
+    end
+
+    it 'parses the body as text' do
+      TestWorker.get_shoryuken_options['body_parser'] = :text
+
+      body = 'test'
+
+      allow(sqs_msg).to receive(:body).and_return(body)
+
+      expect(described_class.parse(TestWorker, sqs_msg)).to eq('test')
+    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' }
+
+      allow(sqs_msg).to receive(:body).and_return(JSON.dump(body))
+
+      expect(described_class.parse(TestWorker, sqs_msg)).to eq(body)
+    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' }
+
+      allow(sqs_msg).to receive(:body).and_return(JSON.dump(body))
+
+      expect(described_class.parse(TestWorker, sqs_msg)).to eq(body)
+    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 { described_class.parse(TestWorker, sqs_msg) }.
+          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'
+
+        allow(sqs_msg).to receive(:body).and_return(body)
+
+        expect(described_class.parse(TestWorker, sqs_msg)).to eq(body)
+      end
+    end
+  end
+end

data/spec/shoryuken/fetcher_spec.rb

@@ -38,6 +38,22 @@ RSpec.describe Shoryuken::Fetcher do
       subject.fetch(queue_config, limit)
     end
 
+    it 'logs debug only' do
+      # See https://github.com/phstc/shoryuken/issues/435
+      logger = double 'logger'
+
+      allow(subject).to receive(:logger).and_return(logger)
+
+      expect(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
+
+      expect(queue).to receive(:receive_messages).and_return([double('SQS Msg')])
+
+      expect(logger).to receive(:debug).exactly(3).times
+      expect(logger).to_not receive(:info)
+
+      subject.fetch(queue_config, limit)
+    end
+
     context 'when receive options per queue' do
       let(:limit) { 5 }
 

data/spec/shoryuken/manager_spec.rb

@@ -70,7 +70,7 @@ RSpec.describe Shoryuken::Manager do
       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)
+      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)
 
@@ -83,7 +83,7 @@ RSpec.describe Shoryuken::Manager do
         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)
+        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)

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/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/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

data/spec/shoryuken/worker/inline_executor_spec.rb

@@ -0,0 +1,23 @@
+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)
+
+      TestWorker.perform_async('test')
+    end
+  end
+
+  describe '.perform_in' do
+    specify do
+      expect_any_instance_of(TestWorker).to receive(:perform)
+
+      TestWorker.perform_in(60, 'test')
+    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])
@@ -116,6 +26,20 @@ RSpec.describe 'Shoryuken::Worker' do
       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 }
+
+        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,6 +88,23 @@ 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