shoryuken 6.2.1 → 7.0.2

data/spec/lib/shoryuken/middleware/server/active_record_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Middleware::Server::ActiveRecord do
+  subject { described_class.new }
+
+  # Mock ActiveRecord to avoid requiring the actual gem in tests
+  before do
+    # Create mock ActiveRecord module
+    active_record_module = Module.new
+
+    # Create mock Base class with simplified methods
+    active_record_base = Class.new do
+      @connection_handler = nil
+
+      def self.clear_active_connections!
+        # Mock implementation for Rails < 7.1
+      end
+
+      def self.connection_handler
+        @connection_handler ||= Object.new.tap do |handler|
+          def handler.clear_active_connections!(_pool_key)
+            # Mock implementation for Rails 7.1+
+          end
+        end
+      end
+    end
+
+    active_record_module.const_set('Base', active_record_base)
+    stub_const('ActiveRecord', active_record_module)
+
+    # Mock version checking - start with a simple approach
+    def active_record_module.version
+      @version ||= Object.new.tap do |v|
+        def v.>=(other)
+          # For our tests, we'll control this with instance variables
+          @is_rails_71_or_higher ||= false
+        end
+
+        def v.rails_71_or_higher!
+          @is_rails_71_or_higher = true
+        end
+
+        def v.rails_70!
+          @is_rails_71_or_higher = false
+        end
+      end
+    end
+
+    # Mock Gem::Version
+    unless defined?(Gem::Version)
+      gem_module = Module.new
+      gem_version_class = Class.new do
+        def initialize(_version)
+          # Simple mock
+        end
+      end
+      gem_module.const_set('Version', gem_version_class)
+      stub_const('Gem', gem_module)
+    end
+  end
+
+  describe '#call' do
+    it 'yields to the block' do
+      block_called = false
+      subject.call do
+        block_called = true
+      end
+      expect(block_called).to be true
+    end
+
+    it 'returns the value from the block' do
+      result = subject.call { 'block_result' }
+      expect(result).to eq('block_result')
+    end
+
+    context 'when ActiveRecord version is 7.1 or higher' do
+      before do
+        # Mock Rails 7.1+ behavior
+        allow(ActiveRecord).to receive(:version).and_return(double('>=' => true))
+      end
+
+      it 'calls clear_active_connections! on connection_handler with :all parameter' do
+        connection_handler = ActiveRecord::Base.connection_handler
+        expect(connection_handler).to receive(:clear_active_connections!).with(:all)
+
+        subject.call { 'test' }
+      end
+
+      it 'clears connections even when an exception is raised' do
+        connection_handler = ActiveRecord::Base.connection_handler
+        expect(connection_handler).to receive(:clear_active_connections!).with(:all)
+
+        expect do
+          subject.call { raise StandardError, 'test error' }
+        end.to raise_error(StandardError, 'test error')
+      end
+    end
+
+    context 'when ActiveRecord version is lower than 7.1' do
+      before do
+        # Mock Rails < 7.1 behavior
+        allow(ActiveRecord).to receive(:version).and_return(double('>=' => false))
+      end
+
+      it 'calls clear_active_connections! directly on ActiveRecord::Base' do
+        expect(ActiveRecord::Base).to receive(:clear_active_connections!)
+
+        subject.call { 'test' }
+      end
+
+      it 'clears connections even when an exception is raised' do
+        expect(ActiveRecord::Base).to receive(:clear_active_connections!)
+
+        expect do
+          subject.call { raise StandardError, 'test error' }
+        end.to raise_error(StandardError, 'test error')
+      end
+    end
+
+    it 'works with middleware arguments (ignores them)' do
+      allow(ActiveRecord).to receive(:version).and_return(double('>=' => false))
+      expect(ActiveRecord::Base).to receive(:clear_active_connections!)
+
+      worker = double('worker')
+      message = double('message')
+
+      result = subject.call(worker, message) { 'middleware_result' }
+      expect(result).to eq('middleware_result')
+    end
+  end
+end

data/spec/{shoryuken → lib/shoryuken}/middleware/server/auto_delete_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Shoryuken::Middleware::Server::AutoDelete do
   let(:queue)     { 'default' }

data/spec/{shoryuken → lib/shoryuken}/middleware/server/auto_extend_visibility_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
   let(:queue) { 'default' }
@@ -64,4 +64,54 @@ RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
 
     Runner.new.run_and_sleep(TestWorker.new, queue, sqs_msg, visibility_timeout)
   end
+
+  context 'when batch worker with auto_visibility_timeout' do
+    it 'warns and does not extend visibility for batch workers' do
+      TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
+
+      expect(Shoryuken.logger).to receive(:warn) do |&block|
+        expect(block.call).to include("Auto extend visibility isn't supported for batch workers")
+      end
+
+      expect { |b| subject.call(TestWorker.new, queue, [sqs_msg], nil, &b) }.to yield_control
+    end
+  end
+
+  context 'when visibility extension fails' do
+    it 'logs error when change_visibility raises an exception' do
+      TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
+
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
+      allow(sqs_msg).to receive(:message_id).and_return('test-message-id')
+      allow(sqs_msg).to receive(:change_visibility).and_raise(StandardError, 'AWS error')
+
+      expect(Shoryuken.logger).to receive(:error) do |&block|
+        msg = block.call
+        expect(msg).to include('Could not auto extend the message')
+        expect(msg).to include('test-message-id')
+        expect(msg).to include('AWS error')
+      end
+
+      Runner.new.run_and_sleep(TestWorker.new, queue, sqs_msg, visibility_timeout)
+    end
+  end
+
+  context 'debug logging' do
+    it 'logs debug message when extending visibility' do
+      TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
+
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
+      allow(sqs_msg).to receive(:message_id).and_return('test-message-id')
+      allow(sqs_msg).to receive(:change_visibility)
+
+      expect(Shoryuken.logger).to receive(:debug) do |&block|
+        msg = block.call
+        expect(msg).to include('Extending message')
+        expect(msg).to include('test-message-id')
+        expect(msg).to include("by #{visibility_timeout}s")
+      end
+
+      Runner.new.run_and_sleep(TestWorker.new, queue, sqs_msg, visibility_timeout)
+    end
+  end
 end

data/spec/{shoryuken → lib/shoryuken}/middleware/server/exponential_backoff_retry_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 # rubocop:disable /BlockLength, Metrics/
 RSpec.describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do

data/spec/lib/shoryuken/middleware/server/non_retryable_exception_spec.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+RSpec.describe Shoryuken::Middleware::Server::NonRetryableException do
+  let(:queue)     { 'default' }
+  let(:sqs_queue) { double Shoryuken::Queue }
+
+  def build_message
+    double Shoryuken::Message,
+           queue_url: queue,
+           body: 'test',
+           message_id: SecureRandom.uuid,
+           receipt_handle: SecureRandom.uuid
+  end
+
+  let(:sqs_msg) { build_message }
+
+  before do
+    allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+  end
+
+  context 'when non_retryable_exceptions is not configured' do
+    it 're-raises the exception' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = nil
+
+      expect(sqs_queue).not_to receive(:delete_messages)
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise StandardError, 'test error' }
+      }.to raise_error(StandardError, 'test error')
+    end
+  end
+
+  context 'when exception is not in non_retryable_exceptions list' do
+    it 're-raises the exception' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [ArgumentError]
+
+      expect(sqs_queue).not_to receive(:delete_messages)
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise StandardError, 'test error' }
+      }.to raise_error(StandardError, 'test error')
+    end
+  end
+
+  context 'when exception is in non_retryable_exceptions list' do
+    it 'deletes the message and does not re-raise' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [StandardError]
+
+      expect(sqs_queue).to receive(:delete_messages).with(entries: [
+        { id: '0', receipt_handle: sqs_msg.receipt_handle }
+      ])
+
+      expect(Shoryuken.logger).to receive(:warn) do |&block|
+        expect(block.call).to match(/Non-retryable exception StandardError/)
+      end
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise StandardError, 'test error' }
+      }.not_to raise_error
+    end
+
+    it 'logs the exception backtrace in debug mode' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [StandardError]
+
+      error = StandardError.new('test error')
+      error.set_backtrace(['backtrace line 1', 'backtrace line 2'])
+
+      allow(sqs_queue).to receive(:delete_messages)
+
+      expect(Shoryuken.logger).to receive(:warn)
+      expect(Shoryuken.logger).to receive(:debug) do |&block|
+        expect(block.call).to eq("backtrace line 1\nbacktrace line 2")
+      end
+
+      subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise error }
+    end
+
+    it 'handles multiple exception classes' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [ArgumentError, StandardError]
+
+      expect(sqs_queue).to receive(:delete_messages).with(entries: [
+        { id: '0', receipt_handle: sqs_msg.receipt_handle }
+      ])
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise ArgumentError, 'test error' }
+      }.not_to raise_error
+    end
+
+    it 'handles custom exception classes' do
+      custom_error = Class.new(StandardError)
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [custom_error]
+
+      expect(sqs_queue).to receive(:delete_messages).with(entries: [
+        { id: '0', receipt_handle: sqs_msg.receipt_handle }
+      ])
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise custom_error, 'test error' }
+      }.not_to raise_error
+    end
+  end
+
+  context 'with batch messages' do
+    it 'deletes all messages in the batch' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [StandardError]
+
+      sqs_msg2 = build_message
+      sqs_msg3 = build_message
+      sqs_msgs = [sqs_msg, sqs_msg2, sqs_msg3]
+
+      expect(sqs_queue).to receive(:delete_messages).with(entries: [
+        { id: '0', receipt_handle: sqs_msg.receipt_handle },
+        { id: '1', receipt_handle: sqs_msg2.receipt_handle },
+        { id: '2', receipt_handle: sqs_msg3.receipt_handle }
+      ])
+
+      expect(Shoryuken.logger).to receive(:warn) do |&block|
+        expect(block.call).to match(/Non-retryable exception StandardError/)
+        expect(block.call).to match(/#{sqs_msg.message_id}/)
+        expect(block.call).to match(/#{sqs_msg2.message_id}/)
+        expect(block.call).to match(/#{sqs_msg3.message_id}/)
+      end
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msgs, [sqs_msg.body, sqs_msg2.body, sqs_msg3.body]) do
+          raise StandardError, 'test error'
+        end
+      }.not_to raise_error
+    end
+  end
+
+  context 'when no exception occurs' do
+    it 'does not delete the message' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [StandardError]
+
+      expect(sqs_queue).not_to receive(:delete_messages)
+
+      subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) {}
+    end
+  end
+
+  context 'when using lambda for dynamic classification' do
+    it 'calls the lambda with the exception and deletes if lambda returns true' do
+      lambda_called = false
+      lambda_result = true
+
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = lambda do |error|
+        lambda_called = true
+        expect(error).to be_a(StandardError)
+        expect(error.message).to eq('test error')
+        lambda_result
+      end
+
+      expect(sqs_queue).to receive(:delete_messages).with(entries: [
+        { id: '0', receipt_handle: sqs_msg.receipt_handle }
+      ])
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise StandardError, 'test error' }
+      }.not_to raise_error
+
+      expect(lambda_called).to be true
+    end
+
+    it 're-raises if lambda returns false' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = ->(_error) { false }
+
+      expect(sqs_queue).not_to receive(:delete_messages)
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise StandardError, 'test error' }
+      }.to raise_error(StandardError, 'test error')
+    end
+
+    it 'supports complex lambda logic based on exception properties' do
+      TestWorker.get_shoryuken_options['non_retryable_exceptions'] = lambda do |error|
+        error.is_a?(ArgumentError) || (error.is_a?(StandardError) && error.message.include?('permanent'))
+      end
+
+      # ArgumentError should be deleted
+      expect(sqs_queue).to receive(:delete_messages).with(entries: [
+        { id: '0', receipt_handle: sqs_msg.receipt_handle }
+      ])
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise ArgumentError, 'invalid argument' }
+      }.not_to raise_error
+
+      # StandardError with 'permanent' should be deleted
+      sqs_msg2 = build_message
+      allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+
+      expect(sqs_queue).to receive(:delete_messages).with(entries: [
+                                                           { id: '0', receipt_handle: sqs_msg2.receipt_handle }
+                                                         ])
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg2, sqs_msg2.body) { raise StandardError, 'permanent failure' }
+      }.not_to raise_error
+
+      # StandardError without 'permanent' should be retried
+      sqs_msg3 = build_message
+      allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+
+      expect(sqs_queue).not_to receive(:delete_messages)
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg3, sqs_msg3.body) { raise StandardError, 'temporary failure' }
+      }.to raise_error(StandardError, 'temporary failure')
+    end
+  end
+end
+

data/spec/{shoryuken → lib/shoryuken}/middleware/server/timing_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Middleware::Server::Timing do
   let(:queue) { 'default' }

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

@@ -1,11 +1,11 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Options do
   subject { Shoryuken.shoryuken_options }
 
   describe '.on_stop' do
     specify do
-      on_stop = Proc.new {}
+      on_stop = proc {}
       Shoryuken.on_stop(&on_stop)
 
       expect(Shoryuken.stop_callback).to eq(on_stop)
@@ -14,7 +14,7 @@ RSpec.describe Shoryuken::Options do
 
   describe '.on_start' do
     specify do
-      on_start = Proc.new {}
+      on_start = proc {}
       Shoryuken.on_start(&on_start)
 
       expect(Shoryuken.start_callback).to eq(on_start)
@@ -41,6 +41,36 @@ RSpec.describe Shoryuken::Options do
     end
   end
 
+  describe '.add_group with polling_strategy' do
+    before do
+      Shoryuken.groups.clear
+    end
+
+    it 'stores the polling_strategy in the group configuration' do
+      Shoryuken.add_group('group1', 25, polling_strategy: Shoryuken::Polling::StrictPriority)
+
+      expect(Shoryuken.groups['group1'][:polling_strategy]).to eq(Shoryuken::Polling::StrictPriority)
+    end
+
+    it 'defaults polling_strategy to nil when not provided' do
+      Shoryuken.add_group('group1', 25)
+
+      expect(Shoryuken.groups['group1'][:polling_strategy]).to be_nil
+    end
+
+    it 'accepts a string polling_strategy' do
+      Shoryuken.add_group('group1', 25, polling_strategy: 'StrictPriority')
+
+      expect(Shoryuken.groups['group1'][:polling_strategy]).to eq('StrictPriority')
+    end
+
+    it 'raises InvalidPollingStrategyError for invalid polling_strategy type' do
+      expect {
+        Shoryuken.add_group('group1', 25, polling_strategy: 123)
+      }.to raise_error(Shoryuken::Errors::InvalidPollingStrategyError)
+    end
+  end
+
   describe '.delay works for each group' do
     specify do
       Shoryuken.add_group('group1', 25)
@@ -81,7 +111,7 @@ RSpec.describe Shoryuken::Options do
 
       expect(Shoryuken.sqs_client_receive_message_opts).to eq(
         'default' => { test: 1 },
-        'group1'  => { test: 2 }
+        'group1' => { test: 2 }
       )
     end
   end
@@ -188,8 +218,8 @@ RSpec.describe Shoryuken::Options do
       end
 
       specify do
-        expect { Shoryuken.polling_strategy('default') }.to raise_error(ArgumentError)
-        expect { Shoryuken.polling_strategy('group1') }.to raise_error(ArgumentError)
+        expect { Shoryuken.polling_strategy('default') }.to raise_error(Shoryuken::Errors::InvalidPollingStrategyError)
+        expect { Shoryuken.polling_strategy('group1') }.to raise_error(Shoryuken::Errors::InvalidPollingStrategyError)
       end
     end
 
@@ -212,5 +242,18 @@ RSpec.describe Shoryuken::Options do
         expect(Shoryuken.polling_strategy('group1')).to eq Bar
       end
     end
+
+    context 'when set via add_group' do
+      before do
+        class Baz < Shoryuken::Polling::BaseStrategy; end
+
+        Shoryuken.groups.clear
+        Shoryuken.add_group('custom_group', 25, polling_strategy: Baz)
+      end
+
+      specify do
+        expect(Shoryuken.polling_strategy('custom_group')).to eq Baz
+      end
+    end
   end
 end