shoryuken 6.2.1 → 7.0.2

data/spec/lib/active_job/extensions_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'active_job'
+
+# Skip this spec if ActiveSupport is not available, as the extensions require it
+if defined?(ActiveSupport)
+  require 'active_job/extensions'
+
+  RSpec.describe Shoryuken::ActiveJob do
+    describe Shoryuken::ActiveJob::SQSSendMessageParametersAccessor do
+      let(:job_class) do
+        Class.new do
+          include Shoryuken::ActiveJob::SQSSendMessageParametersAccessor
+        end
+      end
+
+      let(:job_instance) { job_class.new }
+
+      describe 'included behavior' do
+        it 'adds sqs_send_message_parameters accessor' do
+          expect(job_instance).to respond_to(:sqs_send_message_parameters)
+          expect(job_instance).to respond_to(:sqs_send_message_parameters=)
+        end
+
+        it 'allows setting and getting sqs_send_message_parameters' do
+          params = { message_group_id: 'group1', message_deduplication_id: 'dedup1' }
+          job_instance.sqs_send_message_parameters = params
+          expect(job_instance.sqs_send_message_parameters).to eq(params)
+        end
+      end
+    end
+
+    describe Shoryuken::ActiveJob::SQSSendMessageParametersSupport do
+      let(:base_class) do
+        Class.new do
+          attr_accessor :sqs_send_message_parameters
+
+          def initialize(*arguments)
+            # Mock ActiveJob::Base initialization
+          end
+
+          def enqueue(options = {})
+            # Mock ActiveJob::Base enqueue method that returns remaining options
+            options
+          end
+        end
+      end
+
+      let(:job_class) do
+        Class.new(base_class) do
+          prepend Shoryuken::ActiveJob::SQSSendMessageParametersSupport
+        end
+      end
+
+      describe '#initialize' do
+        it 'initializes sqs_send_message_parameters to empty hash' do
+          job = job_class.new('arg1', 'arg2')
+          expect(job.sqs_send_message_parameters).to eq({})
+        end
+
+        it 'calls super with the provided arguments' do
+          expect_any_instance_of(base_class).to receive(:initialize).with('arg1', 'arg2')
+          job_class.new('arg1', 'arg2')
+        end
+
+        it 'handles ruby2_keywords compatibility' do
+          # Test that ruby2_keywords is called if available
+          if respond_to?(:ruby2_keywords, true)
+            expect(job_class.method(:new)).to respond_to(:ruby2_keywords) if RUBY_VERSION >= '2.7'
+          end
+        end
+
+        # Regression test for https://github.com/ruby-shoryuken/shoryuken/issues/961
+        # ActiveJob with keyword arguments was broken in Shoryuken 7.0 because
+        # the SQSSendMessageParametersSupport module's initialize method did not
+        # properly forward keyword arguments using ruby2_keywords.
+        context 'with keyword arguments' do
+          let(:base_class_with_kwargs) do
+            Class.new do
+              attr_accessor :sqs_send_message_parameters
+              attr_reader :received_name, :received_count, :received_enabled
+
+              def initialize(name:, count:, enabled: false)
+                @received_name = name
+                @received_count = count
+                @received_enabled = enabled
+              end
+            end
+          end
+
+          let(:job_class_with_kwargs) do
+            Class.new(base_class_with_kwargs) do
+              prepend Shoryuken::ActiveJob::SQSSendMessageParametersSupport
+            end
+          end
+
+          it 'properly forwards keyword arguments to the base class' do
+            job = job_class_with_kwargs.new(name: 'test_name', count: 42, enabled: true)
+
+            expect(job.received_name).to eq('test_name')
+            expect(job.received_count).to eq(42)
+            expect(job.received_enabled).to eq(true)
+            expect(job.sqs_send_message_parameters).to eq({})
+          end
+
+          it 'properly forwards keyword arguments with default values' do
+            job = job_class_with_kwargs.new(name: 'another_test', count: 10)
+
+            expect(job.received_name).to eq('another_test')
+            expect(job.received_count).to eq(10)
+            expect(job.received_enabled).to eq(false)
+            expect(job.sqs_send_message_parameters).to eq({})
+          end
+        end
+
+        # Regression test for https://github.com/ruby-shoryuken/shoryuken/issues/961
+        # Test with a mix of positional and keyword arguments
+        context 'with mixed positional and keyword arguments' do
+          let(:base_class_mixed) do
+            Class.new do
+              attr_accessor :sqs_send_message_parameters
+              attr_reader :received_id, :received_data, :received_options
+
+              def initialize(id, data, options: {})
+                @received_id = id
+                @received_data = data
+                @received_options = options
+              end
+            end
+          end
+
+          let(:job_class_mixed) do
+            Class.new(base_class_mixed) do
+              prepend Shoryuken::ActiveJob::SQSSendMessageParametersSupport
+            end
+          end
+
+          it 'properly forwards mixed arguments to the base class' do
+            job = job_class_mixed.new('job_id', { key: 'value' }, options: { retry: true })
+
+            expect(job.received_id).to eq('job_id')
+            expect(job.received_data).to eq({ key: 'value' })
+            expect(job.received_options).to eq({ retry: true })
+            expect(job.sqs_send_message_parameters).to eq({})
+          end
+        end
+      end
+
+      describe '#enqueue' do
+        let(:job_instance) { job_class.new }
+
+        it 'extracts SQS-specific options and merges them into sqs_send_message_parameters' do
+          options = {
+            wait: 5 * 60, # 5 minutes in seconds
+            message_attributes: { 'type' => 'important' },
+            message_system_attributes: { 'source' => 'api' },
+            message_deduplication_id: 'dedup123',
+            message_group_id: 'group456',
+            other_option: 'value'
+          }
+
+          remaining_options = job_instance.enqueue(options)
+
+          expect(job_instance.sqs_send_message_parameters).to eq({
+            message_attributes: { 'type' => 'important' },
+            message_system_attributes: { 'source' => 'api' },
+            message_deduplication_id: 'dedup123',
+            message_group_id: 'group456'
+          })
+
+          expect(remaining_options).to eq({
+            wait: 300,
+            other_option: 'value'
+          })
+        end
+
+        it 'handles empty options gracefully' do
+          remaining_options = job_instance.enqueue({})
+          expect(job_instance.sqs_send_message_parameters).to eq({})
+          expect(remaining_options).to eq({})
+        end
+
+        it 'merges new SQS options with existing ones' do
+          job_instance.sqs_send_message_parameters = { message_group_id: 'existing_group' }
+
+          options = { message_deduplication_id: 'new_dedup' }
+          job_instance.enqueue(options)
+
+          expect(job_instance.sqs_send_message_parameters).to eq({
+            message_group_id: 'existing_group',
+            message_deduplication_id: 'new_dedup'
+          })
+        end
+
+        it 'overwrites existing SQS options when the same key is provided' do
+          job_instance.sqs_send_message_parameters = { message_group_id: 'old_group' }
+
+          options = { message_group_id: 'new_group' }
+          job_instance.enqueue(options)
+
+          expect(job_instance.sqs_send_message_parameters).to eq({
+            message_group_id: 'new_group'
+          })
+        end
+      end
+    end
+
+    describe 'module constants' do
+      it 'defines SQSSendMessageParametersAccessor' do
+        expect(Shoryuken::ActiveJob::SQSSendMessageParametersAccessor).to be_a(Module)
+      end
+
+      it 'defines SQSSendMessageParametersSupport' do
+        expect(Shoryuken::ActiveJob::SQSSendMessageParametersSupport).to be_a(Module)
+      end
+    end
+  end
+else
+  RSpec.describe 'Shoryuken::ActiveJob (skipped - ActiveSupport not available)' do
+    it 'skips tests when ActiveSupport is not available' do
+      skip('ActiveSupport not available in test environment')
+    end
+  end
+end

data/spec/lib/active_job/queue_adapters/shoryuken_adapter_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'shared_examples_for_active_job'
+require 'active_job/queue_adapters/shoryuken_adapter'
+require 'active_support/core_ext/numeric/time'
+
+RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter do
+  include_examples 'active_job_adapters'
+
+  describe '#enqueue_after_transaction_commit?' do
+    it 'returns true to support Rails 7.2+ transaction commit behavior' do
+      adapter = described_class.new
+      expect(adapter.enqueue_after_transaction_commit?).to eq(true)
+    end
+  end
+
+  describe '.instance' do
+    it 'returns the same instance (singleton pattern)' do
+      instance1 = described_class.instance
+      instance2 = described_class.instance
+      expect(instance1).to be(instance2)
+    end
+
+    it 'returns a ShoryukenAdapter instance' do
+      expect(described_class.instance).to be_a(described_class)
+    end
+  end
+
+end

data/spec/{shoryuken/extensions/active_job_concurrent_send_adapter_spec.rb → lib/active_job/queue_adapters/shoryuken_concurrent_send_adapter_spec.rb}

@@ -1,7 +1,8 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'shared_examples_for_active_job'
-require 'shoryuken/extensions/active_job_adapter'
-require 'shoryuken/extensions/active_job_concurrent_send_adapter'
+require 'active_job/queue_adapters/shoryuken_adapter'
+require 'active_job/queue_adapters/shoryuken_concurrent_send_adapter'
 
 RSpec.describe ActiveJob::QueueAdapters::ShoryukenConcurrentSendAdapter do
   include_examples 'active_job_adapters'
@@ -36,4 +37,4 @@ RSpec.describe ActiveJob::QueueAdapters::ShoryukenConcurrentSendAdapter do
       subject.enqueue(job, options)
     end
   end
-end
+end

data/spec/{shoryuken/extensions/active_job_wrapper_spec.rb → lib/shoryuken/active_job/job_wrapper_spec.rb}

@@ -1,9 +1,10 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'active_job'
-require 'shoryuken/extensions/active_job_extensions'
-require 'shoryuken/extensions/active_job_adapter'
+require 'active_job/extensions'
+require 'active_job/queue_adapters/shoryuken_adapter'
 
-RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper do
+RSpec.describe Shoryuken::ActiveJob::JobWrapper do
   subject { described_class.new }
 
   describe '#perform' do
@@ -17,4 +18,4 @@ RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper do
       subject.perform sqs_msg, job_hash
     end
   end
-end
+end

data/spec/{shoryuken → lib/shoryuken}/body_parser_spec.rb

@@ -1,5 +1,4 @@
-require 'spec_helper'
-require 'shoryuken/body_parser'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::BodyParser do
   let(:sqs_msg) { double }
@@ -69,8 +68,7 @@ RSpec.describe Shoryuken::BodyParser do
       end
 
       specify do
-        expect { described_class.parse(TestWorker, sqs_msg) }
-          .to raise_error(JSON::ParserError, /unexpected token at 'invalid JSON'/)
+        expect { described_class.parse(TestWorker, sqs_msg) }.to raise_error(JSON::ParserError)
       end
     end
 

data/spec/{shoryuken → lib/shoryuken}/client_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Client do
   let(:credentials) { Aws::Credentials.new('access_key_id', 'secret_access_key') }

data/spec/{shoryuken → lib/shoryuken}/default_exception_handler_spec.rb

@@ -1,12 +1,11 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::DefaultExceptionHandler do
   class CustomErrorHandler
     extend Shoryuken::Util
 
     def self.call(_ex, queue, _msg)
-      logger.error("#{queue.to_s} failed to process the message")
+      logger.error("#{queue} failed to process the message")
     end
   end
 
@@ -38,31 +37,31 @@ RSpec.describe Shoryuken::DefaultExceptionHandler do
 
   subject { Shoryuken::Processor.new(queue, sqs_msg) }
 
-  context "with default handler" do
+  context 'with default handler' do
     before do
       Shoryuken.exception_handlers = described_class
     end
 
-    it "logs an error message" do
+    it 'logs an error message' do
       expect(Shoryuken::Logging.logger).to receive(:error).twice
 
-      allow_any_instance_of(TestWorker).to receive(:perform).and_raise(StandardError, "error")
+      allow_any_instance_of(TestWorker).to receive(:perform).and_raise(StandardError, 'error')
       allow(sqs_msg).to receive(:body)
 
       expect { subject.process }.to raise_error(StandardError)
     end
   end
 
-  context "with custom handler" do
+  context 'with custom handler' do
     before do
       Shoryuken.exception_handlers = [described_class, CustomErrorHandler]
     end
 
-    it "logs default and custom error messages" do
+    it 'logs default and custom error messages' do
       expect(Shoryuken::Logging.logger).to receive(:error).twice
-      expect(Shoryuken::Logging.logger).to receive(:error).with("default failed to process the message").once
+      expect(Shoryuken::Logging.logger).to receive(:error).with('default failed to process the message').once
 
-      allow_any_instance_of(TestWorker).to receive(:perform).and_raise(StandardError, "error")
+      allow_any_instance_of(TestWorker).to receive(:perform).and_raise(StandardError, 'error')
       allow(sqs_msg).to receive(:body)
 
       expect { subject.process }.to raise_error(StandardError)

data/spec/{shoryuken → lib/shoryuken}/default_worker_registry_spec.rb

@@ -1,6 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::DefaultWorkerRegistry do
   class RegistryTestWorker
     include Shoryuken::Worker

data/spec/{shoryuken → lib/shoryuken}/environment_loader_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'active_job'
 
 RSpec.describe Shoryuken::EnvironmentLoader do
@@ -23,7 +24,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
     context "when given queues don't exist" do
       specify do
         expect { subject.load }.to raise_error(
-          ArgumentError,
+          Shoryuken::Errors::QueueNotFoundError,
           <<-MSG.gsub(/^\s+/, '')
             The specified queue(s) stubbed_queue do not exist.
             Try 'shoryuken sqs create QUEUE-NAME' for creating a queue with default settings.
@@ -63,7 +64,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
     end
 
     specify do
-      Shoryuken.options[:queues] = ['queue1', 'queue2'] # default queues
+      Shoryuken.options[:queues] = %w[queue1 queue2] # default queues
       Shoryuken.options[:groups] = [['custom', { queues: ['queue3'], delay: 25 }]]
       subject.load
 
@@ -124,11 +125,11 @@ RSpec.describe Shoryuken::EnvironmentLoader do
     end
   end
 
-  describe "#setup_options" do
-    let(:cli_queues) { { "queue1" => 10, "queue2" => 20 } }
-    let(:config_queues) { [["queue1", 8], ["queue2", 4]] }
+  describe '#setup_options' do
+    let(:cli_queues) { { 'queue1' => 10, 'queue2' => 20 } }
+    let(:config_queues) { [['queue1', 8], ['queue2', 4]] }
 
-    context "when given queues through config and CLI" do
+    context 'when given queues through config and CLI' do
       specify do
         allow_any_instance_of(Shoryuken::EnvironmentLoader).to receive(:config_file_options).and_return({ queues: config_queues })
         Shoryuken::EnvironmentLoader.setup_options(queues: cli_queues)
@@ -136,7 +137,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
       end
     end
 
-    context "when given queues through config only" do
+    context 'when given queues through config only' do
       specify do
         allow_any_instance_of(Shoryuken::EnvironmentLoader).to receive(:config_file_options).and_return({ queues: config_queues })
         Shoryuken::EnvironmentLoader.setup_options({})
@@ -144,7 +145,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
       end
     end
 
-    context "when given queues through CLI only" do
+    context 'when given queues through CLI only' do
       specify do
         Shoryuken::EnvironmentLoader.setup_options(queues: cli_queues)
         expect(Shoryuken.options[:queues]).to eq(cli_queues)

data/spec/{shoryuken → lib/shoryuken}/fetcher_spec.rb

@@ -1,8 +1,5 @@
-require 'spec_helper'
-require 'shoryuken/manager'
-require 'shoryuken/fetcher'
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::Fetcher do
   let(:queue)        { instance_double('Shoryuken::Queue', fifo?: false) }
   let(:queue_name)   { 'default' }
@@ -29,17 +26,17 @@ RSpec.describe Shoryuken::Fetcher do
       Shoryuken.sqs_client_receive_message_opts[group] = { wait_time_seconds: 10 }
 
       expect(queue).to receive(:receive_messages).with({
-        wait_time_seconds: 10,
-        max_number_of_messages: limit,
-        message_attribute_names: ['All'],
-        attribute_names: ['All']
-      }).and_return([])
+                                                         wait_time_seconds: 10,
+                                                         max_number_of_messages: limit,
+                                                         message_attribute_names: ['All'],
+                                                         attribute_names: ['All']
+                                                       }).and_return([])
 
       subject.fetch(queue_config, limit)
     end
 
     it 'logs debug only' do
-      # See https://github.com/phstc/shoryuken/issues/435
+      # See https://github.com/ruby-shoryuken/shoryuken/issues/435
       logger = double 'logger'
 
       allow(subject).to receive(:logger).and_return(logger)
@@ -63,10 +60,10 @@ RSpec.describe Shoryuken::Fetcher do
         Shoryuken.sqs_client_receive_message_opts[queue_name] = { max_number_of_messages: 1 }
 
         expect(queue).to receive(:receive_messages).with({
-          max_number_of_messages: 1,
-          message_attribute_names: ['All'],
-          attribute_names: ['All']
-        }).and_return([])
+                                                           max_number_of_messages: 1,
+                                                           message_attribute_names: ['All'],
+                                                           attribute_names: ['All']
+                                                         }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -79,10 +76,10 @@ RSpec.describe Shoryuken::Fetcher do
         Shoryuken.sqs_client_receive_message_opts[queue_name] = { max_number_of_messages: 20 }
 
         expect(queue).to receive(:receive_messages).with({
-          max_number_of_messages: limit,
-          message_attribute_names: ['All'],
-          attribute_names: ['All']
-        }).and_return([])
+                                                           max_number_of_messages: limit,
+                                                           message_attribute_names: ['All'],
+                                                           attribute_names: ['All']
+                                                         }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -94,8 +91,8 @@ RSpec.describe Shoryuken::Fetcher do
       specify do
         allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
         expect(queue).to receive(:receive_messages).with({
-          max_number_of_messages: described_class::FETCH_LIMIT, attribute_names: ['All'], message_attribute_names: ['All']
-        }).and_return([])
+                                                           max_number_of_messages: described_class::FETCH_LIMIT, attribute_names: ['All'], message_attribute_names: ['All']
+                                                         }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -106,26 +103,26 @@ RSpec.describe Shoryuken::Fetcher do
       let(:queue) { instance_double('Shoryuken::Queue', fifo?: true, name: queue_name) }
 
       it 'polls one message at a time' do
-        # see https://github.com/phstc/shoryuken/pull/530
+        # see https://github.com/ruby-shoryuken/shoryuken/pull/530
 
         allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
         expect(queue).to receive(:receive_messages).with({
-          max_number_of_messages: 1, attribute_names: ['All'], message_attribute_names: ['All']
-        }).and_return([])
+                                                           max_number_of_messages: 1, attribute_names: ['All'], message_attribute_names: ['All']
+                                                         }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
 
       context 'with batch=true' do
         it 'polls the provided limit' do
-          # see https://github.com/phstc/shoryuken/pull/530
+          # see https://github.com/ruby-shoryuken/shoryuken/pull/530
 
           allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
           allow(Shoryuken.worker_registry).to receive(:batch_receive_messages?).with(queue.name).and_return(true)
 
           expect(queue).to receive(:receive_messages).with({
-            max_number_of_messages: limit, attribute_names: ['All'], message_attribute_names: ['All']
-          }).and_return([])
+                                                             max_number_of_messages: limit, attribute_names: ['All'], message_attribute_names: ['All']
+                                                           }).and_return([])
 
           subject.fetch(queue_config, limit)
         end