shoryuken 7.0.1 → 7.0.3

data/spec/integration/strict_priority_polling/strict_priority_polling_spec.rb

@@ -3,7 +3,7 @@
 # This spec tests the StrictPriority polling strategy.
 # Higher priority queues are always processed before lower priority queues.
 
-setup_localstack
+setup_sqs
 
 queue_high = DT.queues[0]
 queue_low = DT.queues[1]

data/spec/integration/visibility_timeout/visibility_timeout_spec.rb

@@ -3,7 +3,7 @@
 # This spec tests visibility timeout management including manual visibility
 # extension during long processing.
 
-setup_localstack
+setup_sqs
 
 queue_name = DT.queue
 create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '5' })

data/spec/integration/worker_enqueueing/worker_enqueueing_spec.rb

@@ -4,7 +4,7 @@
 # - perform_async - enqueue a job for immediate processing
 # - perform_in - enqueue a job with a delay
 
-setup_localstack
+setup_sqs
 
 queue_name = DT.queue
 create_test_queue(queue_name)

data/spec/integration/worker_groups/worker_groups_spec.rb

@@ -5,7 +5,7 @@
 
 require 'concurrent'
 
-setup_localstack
+setup_sqs
 
 queue_group1 = DT.queues[0]
 queue_group2 = DT.queues[1]

data/spec/integration/worker_lifecycle/worker_lifecycle_spec.rb

@@ -2,7 +2,7 @@
 
 # This spec tests worker lifecycle including worker registration and discovery.
 
-setup_localstack
+setup_sqs
 
 queue_name = DT.queue
 create_test_queue(queue_name)

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/')
 
@@ -145,13 +144,13 @@ module IntegrationsHelper
     ActiveJob::Base.queue_adapter = :shoryuken
   end
 
-  # Configure Shoryuken to use LocalStack for real SQS integration tests
-  def setup_localstack
+  # Configure Shoryuken to use ElasticMQ for real SQS integration tests
+  def setup_sqs
     Aws.config[:stub_responses] = false
 
     sqs_client = Aws::SQS::Client.new(
       region: 'us-east-1',
-      endpoint: 'http://localhost:4566',
+      endpoint: 'http://localhost:9324',
       access_key_id: 'fake',
       secret_access_key: 'fake'
     )
@@ -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/options_spec.rb

@@ -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)
@@ -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

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