shoryuken 3.1.4 → 3.2.0

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

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

data/spec/spec_helper.rb

@@ -59,6 +59,8 @@ RSpec.configure do |config|
 
     Aws.config[:stub_responses] = true
 
+    Shoryuken.sqs_client_receive_message_opts.clear
+
     allow(Concurrent).to receive(:global_io_executor).and_return(Concurrent::ImmediateExecutor.new)
     allow(Shoryuken).to receive(:active_job?).and_return(false)
   end