shoryuken 7.0.2 → 7.0.3

data/spec/integration/non_retryable_exception/with_retry_intervals_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# This spec tests the interplay between non_retryable_exceptions and
+# retry_intervals (exponential backoff) when both are configured on the
+# same worker.
+#
+# Expected behavior: non_retryable_exceptions takes precedence - a message
+# raising a non-retryable exception must be deleted immediately and never
+# retried, while other exceptions still go through the backoff schedule.
+#
+# Regression: ExponentialBackoffRetry sits inside NonRetryableException in
+# the default middleware chain and used to swallow every exception after
+# scheduling a retry, so NonRetryableException never saw non-retryable
+# errors and the message was retried (with the last interval repeated)
+# instead of being deleted.
+
+require 'timeout'
+
+setup_sqs
+
+DT.clear
+
+queue_name = DT.queue
+create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '2' })
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+# Exception classes for testing
+PermanentValidationError = Class.new(StandardError)
+TransientNetworkError = Class.new(StandardError)
+
+# Worker with BOTH retry_intervals and non_retryable_exceptions configured
+combined_worker = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: true,
+                    batch: false,
+                    retry_intervals: [1, 1],
+                    non_retryable_exceptions: [PermanentValidationError]
+
+  def perform(sqs_msg, body)
+    receive_count = sqs_msg.attributes['ApproximateReceiveCount'].to_i
+    DT[:attempts] << { receive_count: receive_count, body: body, time: Time.now }
+
+    case body
+    when 'non_retryable'
+      raise PermanentValidationError, 'Permanently invalid input'
+    when 'retryable'
+      # Fail on first 2 attempts (covered by retry_intervals), succeed on 3rd
+      raise TransientNetworkError, "Temporary failure on attempt #{receive_count}" if receive_count < 3
+
+      DT[:successful_processing] << { body: body, final_receive_count: receive_count }
+    end
+  end
+end
+
+combined_worker.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, combined_worker)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+launcher = Shoryuken::Launcher.new
+launcher.start
+
+begin
+  # Test 1: a non-retryable exception must win over the backoff schedule -
+  # the message is attempted exactly once and deleted, never retried.
+  Shoryuken::Client.sqs.send_message(
+    queue_url: queue_url,
+    message_body: 'non_retryable'
+  )
+
+  Timeout.timeout(10) { sleep 0.5 until DT[:attempts].size >= 1 }
+
+  # Give a buggy retry every chance to happen: with retry_intervals [1, 1]
+  # a swallowed exception would bring the message back after ~1s.
+  sleep 5
+
+  non_retryable_attempts = DT[:attempts].select { |a| a[:body] == 'non_retryable' }
+  assert_equal(
+    1,
+    non_retryable_attempts.size,
+    'Non-retryable exception must not be retried even when retry_intervals is configured ' \
+    "(got #{non_retryable_attempts.size} attempts)"
+  )
+
+  attributes = Shoryuken::Client.sqs.get_queue_attributes(
+    queue_url: queue_url,
+    attribute_names: %w[ApproximateNumberOfMessages ApproximateNumberOfMessagesNotVisible]
+  ).attributes
+
+  total_messages = attributes['ApproximateNumberOfMessages'].to_i +
+                   attributes['ApproximateNumberOfMessagesNotVisible'].to_i
+  assert_equal(
+    0,
+    total_messages,
+    'Message with non-retryable exception must be deleted immediately, not scheduled for retry'
+  )
+
+  # Test 2: exceptions NOT in the non-retryable list still follow the
+  # backoff schedule and eventually succeed.
+  Shoryuken::Client.sqs.send_message(
+    queue_url: queue_url,
+    message_body: 'retryable'
+  )
+
+  Timeout.timeout(20) { sleep 0.5 until DT[:successful_processing].size >= 1 }
+
+  retryable_attempts = DT[:attempts].select { |a| a[:body] == 'retryable' }
+  assert(retryable_attempts.size >= 3, 'Retryable exception should still go through the backoff schedule')
+  assert_equal('retryable', DT[:successful_processing].first[:body])
+  assert_equal(3, DT[:successful_processing].first[:final_receive_count])
+ensure
+  Timeout.timeout(30) { launcher.stop }
+end

data/spec/integrations_helper.rb

@@ -2,12 +2,15 @@
 
 # Integration test helper for process-isolated testing
 
-# Enable Ruby warnings to catch deprecations and potential issues
-Warning[:performance] = true if RUBY_VERSION >= '3.3'
-Warning[:deprecated] = true
+require 'warning'
+
 $VERBOSE = true
 
-require 'warning'
+if Warning.respond_to?(:categories)
+  (Warning.categories - %i[experimental]).each do |cat|
+    Warning[cat] = true
+  end
+end
 
 # Process warnings and raise on unexpected ones from our code
 Warning.process do |warning|
@@ -17,10 +20,6 @@ Warning.process do |warning|
   # Filter out warnings we don't care about in specs
   next if warning.include?('_spec')
 
-  # We redefine methods to simulate various scenarios in tests
-  next if warning.include?('previous definition of')
-  next if warning.include?('method redefined')
-
   # Ignore vendor directory
   next if warning.include?('vendor/')
 
@@ -191,7 +190,9 @@ module IntegrationsHelper
     launcher.start
     Timeout.timeout(timeout) { sleep 0.5 until yield }
   ensure
-    launcher.stop
+    # Guard stop with a hard deadline so a stuck dispatch thread (e.g. an SQS
+    # HTTP call that never returns) can't block the spec process forever.
+    Timeout.timeout(30) { launcher.stop }
   end
 
   # Simple mock object

data/spec/lib/shoryuken/fetcher_spec.rb

@@ -113,6 +113,19 @@ RSpec.describe Shoryuken::Fetcher do
         subject.fetch(queue_config, limit)
       end
 
+      it 'caps at one message even when the queue config requests more' do
+        # A custom polling strategy can put max_number_of_messages in the
+        # QueueConfiguration options; the FIFO one-at-a-time guard must still win
+        # so SQS can't return several messages from the same group.
+        config = Shoryuken::Polling::QueueConfiguration.new(queue_name, max_number_of_messages: 10)
+
+        allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
+        expect(queue).to receive(:receive_messages)
+          .with(hash_including(max_number_of_messages: 1)).and_return([])
+
+        subject.fetch(config, limit)
+      end
+
       context 'with batch=true' do
         it 'polls the provided limit' do
           # see https://github.com/ruby-shoryuken/shoryuken/pull/530

data/spec/lib/shoryuken/helpers/timer_task_spec.rb

@@ -295,4 +295,28 @@ RSpec.describe Shoryuken::Helpers::TimerTask do
       expect(false_count).to eq(4)
     end
   end
+
+  describe 'thread priority' do
+    it 'does not inherit a lowered priority from the creating thread' do
+      observed = ::Queue.new
+
+      # Shoryuken starts the visibility-extension timer from a worker thread
+      # whose priority is lowered to Shoryuken.thread_priority (default -1).
+      # The timer thread must not inherit that lowered priority, otherwise a
+      # delayed extension under load can miss the visibility timeout and let the
+      # message be redelivered (double processed).
+      creator = Thread.new do
+        Thread.current.priority = -1
+        timer = described_class.new(execution_interval: 0.05) do
+          observed << Thread.current.priority
+        end
+        timer.execute
+        sleep(0.15)
+        timer.kill
+      end
+      creator.join
+
+      expect(observed.pop).to eq(0)
+    end
+  end
 end

data/spec/lib/shoryuken/launcher_spec.rb

@@ -78,6 +78,22 @@ RSpec.describe Shoryuken::Launcher do
       expect(first_group_manager).to have_received(:stop_new_dispatching)
       expect(second_group_manager).to have_received(:stop_new_dispatching)
     end
+
+    it 'bounds the wait for termination by the configured timeout' do
+      allow(executor).to receive(:shutdown)
+      expect(executor).to receive(:wait_for_termination).with(Shoryuken.options[:timeout]).and_return(true)
+      expect(executor).not_to receive(:kill)
+
+      subject.stop
+    end
+
+    it 'kills the executor when workers do not finish within the timeout' do
+      allow(executor).to receive(:shutdown)
+      allow(executor).to receive(:wait_for_termination).and_return(false)
+      expect(executor).to receive(:kill)
+
+      subject.stop
+    end
   end
 
   describe '#stop!' do
@@ -102,6 +118,28 @@ RSpec.describe Shoryuken::Launcher do
     end
   end
 
+  describe 'executor ownership' do
+    context 'when no launcher_executor is configured' do
+      before { allow(Shoryuken).to receive(:launcher_executor).and_return(nil) }
+
+      it 'uses a dedicated executor rather than the process-global IO executor' do
+        expect(subject.send(:executor)).not_to be(Concurrent.global_io_executor)
+      end
+
+      it 'does not shut down or kill the global IO executor on stop!' do
+        allow(first_group_manager).to receive(:stop_new_dispatching)
+        allow(second_group_manager).to receive(:stop_new_dispatching)
+
+        subject.stop!
+
+        # Verify by inspecting state after the call rather than mocking methods
+        # on the process-global singleton: RSpec proxies on a singleton used by
+        # background concurrent-ruby threads can deadlock on Ruby 3.2.
+        expect(Concurrent.global_io_executor).to be_running
+      end
+    end
+  end
+
   describe '#stopping?' do
     it 'returns false by default' do
       expect(subject.stopping?).to be false

data/spec/lib/shoryuken/manager_spec.rb

@@ -34,6 +34,39 @@ RSpec.describe Shoryuken::Manager do
     end
   end
 
+  describe '#await_dispatching_in_progress' do
+    it 'returns for repeated graceful stops (e.g. TSTP followed by USR1)' do
+      subject.stop_new_dispatching
+      # The dispatch loop observes the stop flag and releases all waiters
+      subject.start
+
+      waiter = Thread.new do
+        subject.await_dispatching_in_progress
+        subject.await_dispatching_in_progress
+      end
+
+      expect(waiter.join(5)).to eq(waiter), 'await_dispatching_in_progress deadlocked on a repeated stop'
+    end
+
+    context 'when the executor rejects the dispatch post' do
+      let(:executor) do
+        double('executor', running?: true).tap do |rejecting_executor|
+          allow(rejecting_executor).to receive(:post).and_raise(Concurrent::RejectedExecutionError)
+        end
+      end
+
+      it 'releases waiters instead of leaving the signal queue unsignaled' do
+        # A hard stop can shut the executor down between the running? check and
+        # the post; the dispatch chain must still release stop waiters
+        subject.start
+
+        waiter = Thread.new { subject.await_dispatching_in_progress }
+
+        expect(waiter.join(5)).to eq(waiter), 'await_dispatching_in_progress deadlocked after a rejected post'
+      end
+    end
+  end
+
   describe '#start' do
     before do
       # prevent dispatch loop
@@ -153,6 +186,44 @@ RSpec.describe Shoryuken::Manager do
     end
   end
 
+  describe '#assign' do
+    let(:sqs_msg) { double(Shoryuken::Message, message_id: SecureRandom.uuid) }
+    let(:sqs_queue) { double(Shoryuken::Queue, fifo?: false) }
+
+    before do
+      allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+      allow(Shoryuken::Processor).to receive(:process)
+    end
+
+    it 'runs completion exactly once on success' do
+      expect(subject).to receive(:processor_done).with(queue).once.and_call_original
+
+      subject.send(:assign, queue, sqs_msg)
+
+      expect(subject.send(:busy)).to eq(0)
+    end
+
+    it 'runs completion exactly once when processing raises' do
+      allow(Shoryuken::Processor).to receive(:process).and_raise('processing failed')
+
+      expect(subject).to receive(:processor_done).with(queue).once.and_call_original
+
+      subject.send(:assign, queue, sqs_msg)
+
+      expect(subject.send(:busy)).to eq(0)
+    end
+
+    it 'does not double decrement the busy counter when completion raises' do
+      allow(sqs_queue).to receive(:fifo?).and_return(true)
+      allow(polling_strategy).to receive(:message_processed).and_raise('callback failed')
+
+      subject.send(:assign, queue, sqs_msg)
+
+      expect(polling_strategy).to have_received(:message_processed).once
+      expect(subject.send(:busy)).to eq(0)
+    end
+  end
+
   describe '#processor_done' do
     let(:sqs_queue)         { double Shoryuken::Queue }
 
@@ -177,6 +248,34 @@ RSpec.describe Shoryuken::Manager do
     end
   end
 
+  describe '#handle_dispatch_error' do
+    let(:error) { StandardError.new('boom') }
+
+    context 'when running under the CLI (server mode)' do
+      before { allow(Shoryuken).to receive(:server?).and_return(true) }
+
+      it 'stops the manager and signals the process to shut down' do
+        expect(Process).to receive(:kill).with('USR1', Process.pid)
+
+        subject.send(:handle_dispatch_error, error)
+
+        expect(subject.running?).to be false
+      end
+    end
+
+    context 'when embedded (no Runner)' do
+      before { allow(Shoryuken).to receive(:server?).and_return(false) }
+
+      it 'stops the manager without signalling the process' do
+        expect(Process).not_to receive(:kill)
+
+        subject.send(:handle_dispatch_error, error)
+
+        expect(subject.running?).to be false
+      end
+    end
+  end
+
   describe '#running?' do
     context 'when the executor is running' do
       before do

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

@@ -114,4 +114,39 @@ RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
       Runner.new.run_and_sleep(TestWorker.new, queue, sqs_msg, visibility_timeout)
     end
   end
+
+  context 'when the visibility timeout is too short for the upfront margin' do
+    # interval would be visibility_timeout - extend_upfront == 0, which used to
+    # make TimerTask raise before the worker ran.
+    let(:visibility_timeout) { extend_upfront }
+
+    it 'runs the worker instead of raising' 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)
+
+      ran = false
+      subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { ran = true }
+
+      expect(ran).to be true
+    end
+  end
+
+  context 'when the visibility timeout is zero' do
+    let(:visibility_timeout) { 0 }
+
+    it 'warns and runs the worker without scheduling an extension' 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')
+      expect(sqs_msg).not_to receive(:change_visibility)
+      expect(Shoryuken.logger).to receive(:warn)
+
+      ran = false
+      subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { ran = true }
+
+      expect(ran).to be true
+    end
+  end
 end

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

@@ -92,6 +92,62 @@ RSpec.describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
 
         expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
       end
+
+      it 'keeps reusing the last interval for far-later attempts (does not give up)' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+
+        allow(sqs_msg).to receive(:attributes) { { 'ApproximateReceiveCount' => 10 } }
+        allow(sqs_msg).to receive(:queue) { sqs_queue }
+        expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 1800)
+
+        expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
+      end
+    end
+
+    context 'and the exception is non-retryable' do
+      it 're-raises so NonRetryableException can delete the message' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+        TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [ArgumentError]
+
+        expect(sqs_msg).not_to receive(:change_visibility)
+
+        expect {
+          subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise ArgumentError, 'permanently invalid' }
+        }.to raise_error(ArgumentError, 'permanently invalid')
+      end
+
+      it 're-raises when a non_retryable_exceptions lambda returns true' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+        TestWorker.get_shoryuken_options['non_retryable_exceptions'] = ->(e) { e.message.include?('permanent') }
+
+        expect(sqs_msg).not_to receive(:change_visibility)
+
+        expect {
+          subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'permanent failure' }
+        }.to raise_error(RuntimeError, 'permanent failure')
+      end
+
+      it 'still retries when a non_retryable_exceptions lambda returns false' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+        TestWorker.get_shoryuken_options['non_retryable_exceptions'] = ->(e) { e.message.include?('permanent') }
+
+        allow(sqs_msg).to receive(:queue) { sqs_queue }
+        expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 300)
+
+        expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'transient failure' } }
+          .not_to raise_error
+      end
+
+      it 'still retries exceptions not in the non-retryable list' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+        TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [ArgumentError]
+
+        allow(sqs_msg).to receive(:queue) { sqs_queue }
+        expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 300)
+
+        expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'transient failure' } }
+          .not_to raise_error
+      end
     end
 
     it 'limits the visibility timeout to 12 hours' do

data/spec/lib/shoryuken/polling/strict_priority_spec.rb

@@ -155,4 +155,29 @@ RSpec.describe Shoryuken::Polling::StrictPriority do
       expect(strategy.active_queues).to eq([[queue1, 2], [queue2, 1]])
     end
   end
+
+  describe 'thread safety' do
+    it 'serializes concurrent next_queue, messages_found and message_processed' do
+      strategy = Shoryuken::Polling::StrictPriority.new([queue1, queue2], 10)
+
+      errors = []
+      errors_mutex = Mutex.new
+
+      threads = Array.new(6) do
+        Thread.new do
+          50.times do |i|
+            strategy.next_queue
+            strategy.messages_found(queue1, i.even? ? 0 : 1)
+            strategy.message_processed(queue1)
+            strategy.active_queues
+          end
+        rescue => e
+          errors_mutex.synchronize { errors << e }
+        end
+      end
+      threads.each(&:join)
+
+      expect(errors).to be_empty
+    end
+  end
 end

data/spec/lib/shoryuken/polling/weighted_round_robin_spec.rb

@@ -138,5 +138,55 @@ RSpec.describe Shoryuken::Polling::WeightedRoundRobin do
       expect(subject.next_queue).to eq(queue1) # implicitly unpauses queue2
       expect(subject.active_queues).to eq([[queue1, 2], [queue2, 1]])
     end
+
+    it 'unpauses a processed queue stuck behind an earlier-paused queue' do
+      queues << queue1
+      queues << queue2
+
+      allow(subject).to receive(:delay).and_return(10)
+      now = Time.now
+      allow(Time).to receive(:now).and_return(now)
+
+      subject.messages_found(queue1, 0) # queue1 paused until now + 10
+
+      now += 1
+      allow(Time).to receive(:now).and_return(now)
+      subject.messages_found(queue2, 0) # queue2 paused until now + 10 (after queue1)
+
+      # both queues paused, nothing pollable yet
+      expect(subject.next_queue).to eq(nil)
+
+      # queue2 finishes processing and is marked ready while queue1 is still paused
+      subject.message_processed(queue2)
+
+      # queue2 must be pollable even though the earlier-paused queue1 is still paused
+      expect(subject.next_queue).to eq(queue2)
+    end
+  end
+
+  describe 'thread safety' do
+    it 'serializes concurrent next_queue, messages_found and message_processed' do
+      queues << queue1
+      queues << queue2
+
+      errors = []
+      errors_mutex = Mutex.new
+
+      threads = Array.new(6) do
+        Thread.new do
+          50.times do |i|
+            subject.next_queue
+            subject.messages_found(queue1, i.even? ? 0 : 1)
+            subject.message_processed(queue1)
+            subject.active_queues
+          end
+        rescue => e
+          errors_mutex.synchronize { errors << e }
+        end
+      end
+      threads.each(&:join)
+
+      expect(errors).to be_empty
+    end
   end
 end

data/spec/lib/shoryuken/queue_spec.rb

@@ -99,6 +99,43 @@ RSpec.describe Shoryuken::Queue do
 
         subject.delete_messages(entries: entries)
       end
+
+      it 'returns true' do
+        failure = double(id: 'id', code: 'code', message: '...', sender_fault: false)
+        allow(sqs).to receive(:delete_message_batch).and_return(double(failed: [failure]))
+        allow(subject).to receive(:logger).and_return(double('Logger', error: nil))
+
+        expect(subject.delete_messages(entries: entries)).to be true
+      end
+    end
+
+    context 'when several deletes fail' do
+      let(:failures) do
+        [
+          double(id: '1', code: 'c1', message: 'm1', sender_fault: false),
+          double(id: '2', code: 'c2', message: 'm2', sender_fault: true)
+        ]
+      end
+
+      it 'logs every failure, not just the first' do
+        logger = double('Logger')
+        allow(sqs).to receive(:delete_message_batch).and_return(double(failed: failures))
+        allow(subject).to receive(:logger).and_return(logger)
+
+        # Real Logger#error returns true; that truthy return made the old `any?`
+        # short-circuit after the first failure, so the rest went unlogged.
+        expect(logger).to receive(:error).twice.and_return(true)
+
+        subject.delete_messages(entries: entries)
+      end
+    end
+
+    context 'when all deletes succeed' do
+      it 'returns false' do
+        allow(sqs).to receive(:delete_message_batch).and_return(double(failed: []))
+
+        expect(subject.delete_messages(entries: entries)).to be false
+      end
     end
   end
 

data/spec/lib/shoryuken/util_spec.rb

@@ -69,5 +69,31 @@ describe 'Shoryuken::Util' do
       expect(value_holder).to receive(:value=).with([:with_options, { my_option: :some_option }])
       subject.fire_event(:some_event, false, my_option: :some_option)
     end
+
+    it 'fires handlers in reverse order consistently across repeated reverse firings' do
+      order = []
+      Shoryuken.options[:lifecycle_events][:some_event] = [
+        ->(_) { order << :a },
+        ->(_) { order << :b },
+        ->(_) { order << :c }
+      ]
+
+      # e.g. :shutdown is fired with reverse: true and can fire more than once
+      # (stop then stop!); every firing must use the same reversed order.
+      subject.fire_event(:some_event, true)
+      subject.fire_event(:some_event, true)
+
+      expect(order).to eq(%i[c b a c b a])
+    end
+
+    it 'does not mutate the stored handler array when firing in reverse' do
+      handlers = [->(_) {}, ->(_) {}]
+      original = handlers.dup
+      Shoryuken.options[:lifecycle_events][:some_event] = handlers
+
+      subject.fire_event(:some_event, true)
+
+      expect(Shoryuken.options[:lifecycle_events][:some_event]).to eq(original)
+    end
   end
 end

data/spec/shared_examples_for_active_job.rb

@@ -55,6 +55,24 @@ RSpec.shared_examples 'active_job_adapters' do
         subject.enqueue(job)
       end
 
+      context 'when active_job_fifo_message_deduplication is disabled' do
+        before { Shoryuken.active_job_fifo_message_deduplication = false }
+
+        it 'does not set an auto-generated message_deduplication_id' do
+          expect(queue).to receive(:send_message) do |hash|
+            expect(hash).not_to have_key(:message_deduplication_id)
+          end
+          subject.enqueue(job)
+        end
+
+        it 'still honors an explicit message_deduplication_id' do
+          expect(queue).to receive(:send_message) do |hash|
+            expect(hash[:message_deduplication_id]).to eq('explicit-id')
+          end
+          subject.enqueue(job, message_deduplication_id: 'explicit-id')
+        end
+      end
+
       context 'with message_deduplication_id' do
         context 'when message_deduplication_id is specified in options' do
           it 'should enqueue a message with the deduplication_id specified in options' do