shoryuken 7.0.2 → 7.0.4

data/lib/shoryuken/queue.rb

@@ -52,11 +52,18 @@ module Shoryuken
       failed_messages = client.delete_message_batch(
         options.merge(queue_url: url)
       ).failed || []
-      failed_messages.any? do |failure|
+
+      # Log every failure (not just the first) and return a plain boolean.
+      # The previous `any? { logger.error ... }` short-circuited after the first
+      # failure - so the rest went unlogged - and only returned truthy because
+      # Logger#error happens to return true.
+      failed_messages.each do |failure|
         logger.error do
           "Could not delete #{failure.id}, code: '#{failure.code}', message: '#{failure.message}', sender_fault: #{failure.sender_fault}"
         end
       end
+
+      failed_messages.any?
     end
 
     # Sends a single message to the queue
@@ -82,7 +89,11 @@ module Shoryuken
     # @option options [Array<Hash>] :entries message entries to send
     # @return [Aws::SQS::Types::SendMessageBatchResult] the batch send result
     def send_messages(options)
-      client.send_message_batch(sanitize_messages!(options).merge(queue_url: url))
+      response = client.send_message_batch(sanitize_messages!(options).merge(queue_url: url))
+
+      log_failed_sends(response)
+
+      response
     end
 
     # Receives messages from the queue
@@ -113,6 +124,24 @@ module Shoryuken
 
     private
 
+    # Logs any per-entry failures from a batch send. SQS reports these in
+    # response.failed (throttling, oversize/malformed entries, or a same-batch
+    # duplicate message_deduplication_id) rather than raising, so without this
+    # they are silently swallowed - notably by ShoryukenAdapter#enqueue_all,
+    # which reads only response.successful. Mirrors delete_messages.
+    #
+    # @param response [Aws::SQS::Types::SendMessageBatchResult] the batch result
+    # @return [void]
+    def log_failed_sends(response)
+      return unless response.respond_to?(:failed)
+
+      Array(response.failed).each do |failure|
+        logger.error do
+          "Could not send #{failure.id}, code: '#{failure.code}', message: '#{failure.message}', sender_fault: #{failure.sender_fault}"
+        end
+      end
+    end
+
     # Initializes the FIFO attribute by calling fifo?
     #
     # @return [Boolean] whether the queue is FIFO
@@ -217,8 +246,16 @@ module Shoryuken
     def add_fifo_attributes!(options)
       return unless fifo?
 
-      options[:message_group_id]         ||= MESSAGE_GROUP_ID
-      options[:message_deduplication_id] ||= Digest::SHA256.hexdigest(options[:message_body].to_s)
+      options[:message_group_id] ||= MESSAGE_GROUP_ID
+
+      # Auto-generate a content-based dedup id unless disabled. With it on, two
+      # sends of an identical body within SQS's 5-minute window are deduplicated
+      # (the second is silently dropped); disable it to send such messages
+      # distinctly (requires an explicit message_deduplication_id or the queue's
+      # ContentBasedDeduplication attribute).
+      if Shoryuken.fifo_message_deduplication?
+        options[:message_deduplication_id] ||= Digest::SHA256.hexdigest(options[:message_body].to_s)
+      end
 
       options
     end

data/lib/shoryuken/util.rb

@@ -20,7 +20,10 @@ module Shoryuken
     def fire_event(event, reverse = false, event_options = {})
       logger.debug { "Firing '#{event}' lifecycle event" }
       arr = Shoryuken.options[:lifecycle_events][event]
-      arr.reverse! if reverse
+      # reverse (not reverse!) so the stored handler array keeps its original
+      # order: events fired more than once with reverse: true (e.g. :shutdown
+      # via stop then stop!) must not alternate their handler order.
+      arr = arr.reverse if reverse
       arr.each do |block|
         block.call(event_options)
       rescue => e

data/lib/shoryuken/version.rb

@@ -2,5 +2,5 @@
 
 module Shoryuken
   # Current version of the Shoryuken gem
-  VERSION = '7.0.2'
+  VERSION = '7.0.4'
 end

data/lib/shoryuken/worker/default_executor.rb

@@ -15,11 +15,17 @@ module Shoryuken
         # @option options [String] :queue override the default queue
         # @return [Aws::SQS::Types::SendMessageResult] the send result
         def perform_async(worker_class, body, options = {})
-          options[:message_attributes] ||= {}
-          options[:message_attributes]['shoryuken_class'] = {
-            string_value: worker_class.to_s,
-            data_type: 'String'
-          }
+          # Work on a copy: callers may reuse the same options hash across
+          # enqueues, and mutating it (deleting :queue, adding :message_body)
+          # would silently reroute or corrupt later jobs. Merge - rather than
+          # mutate - the nested :message_attributes hash for the same reason.
+          options = options.dup
+          options[:message_attributes] = (options[:message_attributes] || {}).merge(
+            'shoryuken_class' => {
+              string_value: worker_class.to_s,
+              data_type: 'String'
+            }
+          )
 
           options[:message_body] = body
 

data/lib/shoryuken/worker/inline_executor.rb

@@ -15,13 +15,18 @@ module Shoryuken
         # @option options [Hash] :message_attributes custom message attributes
         # @return [Object] the result of the worker's perform method
         def perform_async(worker_class, body, options = {})
+          # Work on a copy so reused/shared options hashes aren't mutated across
+          # calls (deleting :queue would reroute later jobs to the default
+          # queue). Merge - rather than mutate - the nested message_attributes.
+          options = options.dup
           body = JSON.dump(body) if body.is_a?(Hash)
           queue_name = options.delete(:queue) || worker_class.get_shoryuken_options['queue']
-          message_attributes = options.delete(:message_attributes) || {}
-          message_attributes['shoryuken_class'] = {
-            string_value: worker_class.to_s,
-            data_type: 'String'
-          }
+          message_attributes = (options.delete(:message_attributes) || {}).merge(
+            'shoryuken_class' => {
+              string_value: worker_class.to_s,
+              data_type: 'String'
+            }
+          )
 
           sqs_msg = InlineMessage.new(
             body: body,

data/lib/shoryuken/worker.rb

@@ -4,10 +4,9 @@ module Shoryuken
   # Worker module provides the core functionality for creating Shoryuken workers
   # that process messages from Amazon SQS queues.
   #
-  # Including this module in a class provides methods for configuring queue processing,
-  # enqueueing jobs, and setting up middleware. Workers can be configured for different
-  # processing patterns including single message processing, batch processing, and
-  # various retry and visibility timeout strategies.
+  # Including this module in a class provides methods for configuring queue processing, enqueueing jobs, and setting up
+  # middleware. Workers can be configured for different processing patterns including single message processing, batch
+  # processing, and various retry and visibility timeout strategies.
   #
   # @example Basic worker implementation
   #   class EmailWorker
@@ -123,7 +122,8 @@ module Shoryuken
       # @option opts [Boolean] :auto_delete (false) Automatically delete messages after processing
       # @option opts [Boolean] :auto_visibility_timeout (false) Automatically extend message visibility
       # @option opts [Array<Integer>] :retry_intervals Exponential backoff retry intervals in seconds
-      # @option opts [Array<Class>, Proc] :non_retryable_exceptions Exception classes or lambda that should skip retries and delete message immediately
+      # @option opts [Array<Class>, Proc] :non_retryable_exceptions Exception classes or lambda that should
+      #   skip retries and delete message immediately
       # @option opts [Hash] :sqs Additional SQS client options
       #
       # @example Basic worker configuration
@@ -216,25 +216,27 @@ module Shoryuken
         !!get_shoryuken_options['auto_visibility_timeout']
       end
 
-      # Checks if exponential backoff retry is configured for this worker.
-      # When retry intervals are specified, failed jobs will be retried with
-      # increasing delays between attempts.
+      # Checks if exponential backoff retry is configured for this worker. When retry intervals are specified, failed jobs
+      # will be retried with increasing delays between attempts.
       #
       # @return [Boolean] true if retry intervals are configured
       #
       # @example Configuring exponential backoff
       #   shoryuken_options retry_intervals: [1, 5, 25, 125, 625]
-      #   # Will retry after 1s, 5s, 25s, 125s, then 625s before giving up
+      #   # Retries after 1s, 5s, 25s, 125s, then 625s for every later attempt.
+      #   # Shoryuken does not stop retrying on its own once the intervals are
+      #   # exhausted - it keeps reusing the last interval. Configure an SQS
+      #   # redrive policy (maxReceiveCount) to send exhausted messages to a
+      #   # dead-letter queue.
       #
       # @see #shoryuken_options Documentation for configuring retry_intervals
       def exponential_backoff?
         !!get_shoryuken_options['retry_intervals']
       end
 
-      # Checks if automatic message deletion is enabled for this worker.
-      # When enabled, successfully processed messages are automatically deleted
-      # from the SQS queue. When disabled, you must manually delete messages
-      # or they will become visible again after the visibility timeout.
+      # Checks if automatic message deletion is enabled for this worker. When enabled, successfully processed messages are
+      # automatically deleted from the SQS queue. When disabled, you must manually delete messages or they will become
+      # visible again after the visibility timeout.
       #
       # @return [Boolean] true if auto delete is enabled
       #

data/lib/shoryuken.rb

@@ -27,9 +27,8 @@ module Shoryuken
     @_shoryuken_options ||= Shoryuken::Options.new
   end
 
-  # Checks if the Shoryuken server is running and healthy.
-  # A server is considered healthy when all configured processing groups
-  # are running and able to process messages.
+  # Checks if the Shoryuken server is running and healthy. A server is considered healthy when all configured processing
+  # groups are running and able to process messages.
   #
   # @return [Boolean] true if the server is healthy
   def self.healthy?
@@ -58,6 +57,10 @@ module Shoryuken
     :stop_callback=,
     :active_job_queue_name_prefixing?,
     :active_job_queue_name_prefixing=,
+    :active_job_fifo_message_deduplication?,
+    :active_job_fifo_message_deduplication=,
+    :fifo_message_deduplication?,
+    :fifo_message_deduplication=,
     :sqs_client,
     :sqs_client=,
     :sqs_client_receive_message_opts,

data/renovate.json

@@ -56,7 +56,21 @@
         "ruby/setup-ruby",
         "ruby"
       ],
-      "groupName": "ruby setup"
+      "groupName": "ruby setup",
+      "internalChecksFilter": "strict"
+    },
+    {
+      "description": "Let setup-ruby pass age gate before ruby so it is ready when the group PR is created",
+      "matchPackageNames": [
+        "ruby/setup-ruby"
+      ],
+      "minimumReleaseAge": "5 days"
     }
-  ]
+  ],
+  "lockFileMaintenance": {
+    "enabled": true,
+    "schedule": [
+      "before 4am on the first day of the month"
+    ]
+  }
 }

data/shoryuken.gemspec

@@ -11,6 +11,15 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/ruby-shoryuken/shoryuken'
   spec.license       = 'LGPL-3.0'
 
+  spec.metadata = {
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => spec.homepage,
+    'changelog_uri' => "#{spec.homepage}/blob/main/CHANGELOG.md",
+    'bug_tracker_uri' => "#{spec.homepage}/issues",
+    'documentation_uri' => spec.homepage,
+    'rubygems_mfa_required' => 'true'
+  }
+
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = %w[shoryuken]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})

data/spec/integration/active_job/current_attributes/cross_job_reset_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# A message without a CurrentAttributes key must not inherit a previous job's
+# context. Every registered class is reset after each job - even keyless ones -
+# so values set during one job don't leak into the next on a reused worker
+# thread.
+
+setup_sqs
+setup_active_job
+
+require 'active_support/current_attributes'
+require 'shoryuken/active_job/current_attributes'
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+
+class LeakCurrent < ActiveSupport::CurrentAttributes
+  attribute :user_id
+end
+
+Shoryuken::ActiveJob::CurrentAttributes.persist(LeakCurrent)
+
+class CrossJobResetTestJob < ActiveJob::Base
+  def perform
+    # Record what the worker thread sees at the start of the job, then dirty
+    # Current. Without a reset after a keyless job, the second execution on the
+    # same thread would observe 'leaked' instead of nil.
+    DT[:observed] << LeakCurrent.user_id
+    LeakCurrent.user_id = 'leaked'
+  end
+end
+
+CrossJobResetTestJob.queue_as(queue_name)
+
+# Concurrency 1 so the two jobs run sequentially on the same worker thread.
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+# Enqueued with an empty context, so both messages carry no cattr key.
+CrossJobResetTestJob.perform_later
+CrossJobResetTestJob.perform_later
+
+poll_queues_until(timeout: 30) { DT[:observed].size >= 2 }
+
+assert_equal([nil, nil], DT[:observed].first(2),
+             "CurrentAttributes leaked across jobs: #{DT[:observed].inspect}")

data/spec/integration/active_job/current_attributes/incremental_persist_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# CurrentAttributes registered one class per persist call are all preserved.
+#
+# persist derived each storage key from the per-call index, so calling it once
+# per class (as an app might across several initializers) made the third call
+# reuse "cattr_0" and silently overwrite the second class - its attributes were
+# then never serialized or restored.
+
+setup_sqs
+setup_active_job
+
+require 'active_support/current_attributes'
+require 'shoryuken/active_job/current_attributes'
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+
+class CurrentA < ActiveSupport::CurrentAttributes
+  attribute :a_val
+end
+
+class CurrentB < ActiveSupport::CurrentAttributes
+  attribute :b_val
+end
+
+class CurrentC < ActiveSupport::CurrentAttributes
+  attribute :c_val
+end
+
+# Registered incrementally, one class per call.
+Shoryuken::ActiveJob::CurrentAttributes.persist(CurrentA)
+Shoryuken::ActiveJob::CurrentAttributes.persist(CurrentB)
+Shoryuken::ActiveJob::CurrentAttributes.persist(CurrentC)
+
+# Every class must be registered, each under a distinct storage key.
+registered = Shoryuken::ActiveJob::CurrentAttributes.cattrs
+assert_equal(
+  %w[CurrentA CurrentB CurrentC],
+  registered.values.sort,
+  'every persisted CurrentAttributes class must be registered (none silently dropped)'
+)
+assert_equal(3, registered.keys.uniq.size, 'each class must use a distinct storage key')
+
+class IncrementalCurrentJob < ActiveJob::Base
+  def perform
+    DT[:executions] << {
+      a_val: CurrentA.a_val,
+      b_val: CurrentB.b_val,
+      c_val: CurrentC.c_val
+    }
+  end
+end
+
+IncrementalCurrentJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+CurrentA.a_val = 'a-value'
+CurrentB.b_val = 'b-value'
+CurrentC.c_val = 'c-value'
+
+IncrementalCurrentJob.perform_later
+
+CurrentA.reset
+CurrentB.reset
+CurrentC.reset
+
+poll_queues_until(timeout: 30) { DT[:executions].size >= 1 }
+
+result = DT[:executions].first
+assert_equal('a-value', result[:a_val])
+assert_equal('b-value', result[:b_val], 'the second incrementally-persisted class must not be dropped')
+assert_equal('c-value', result[:c_val])

data/spec/integration/active_job/fifo_dedup_opt_out/fifo_dedup_opt_out_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+# This spec tests opting out of the automatic FIFO message_deduplication_id that
+# the ActiveJob adapter generates.
+#
+# For FIFO queues the adapter derives a content-based message_deduplication_id
+# from the serialized job minus job_id/enqueued_at (see issues #457 / #750). That
+# means two *distinct* enqueues of the same job class + args within SQS's 5-minute
+# window collapse into one - the second is silently dropped. That is intentional,
+# but it is a "skipped message" trap for users who legitimately enqueue the same
+# work twice.
+#
+# Expected behavior: setting Shoryuken.active_job_fifo_message_deduplication = false
+# stops the adapter from generating the id, so those enqueues are no longer
+# silently deduplicated. The default (true) preserves the existing behavior.
+#
+# Regression: there was no way to disable the auto-generated deduplication id.
+
+setup_active_job
+
+class FifoOptOutJob < ActiveJob::Base
+  queue_as :fifo_opt_out
+
+  def perform(_arg); end
+end
+
+fifo_queue_mock = Object.new
+fifo_queue_mock.define_singleton_method(:fifo?) { true }
+fifo_queue_mock.define_singleton_method(:name) { 'fifo_opt_out.fifo' }
+
+captured = nil
+fifo_queue_mock.define_singleton_method(:send_message) { |params| captured = params }
+
+Shoryuken::Client.define_singleton_method(:queues) { |_queue_name = nil| fifo_queue_mock }
+Shoryuken.define_singleton_method(:register_worker) { |*| nil }
+
+# Default behavior: the adapter sets a content-based dedup id (excluding the
+# per-enqueue job_id/enqueued_at), so two identical jobs would collapse to one.
+FifoOptOutJob.perform_later('same-args')
+
+assert(
+  captured.key?(:message_deduplication_id),
+  'by default a FIFO ActiveJob send gets an auto-generated message_deduplication_id'
+)
+
+body = captured[:message_body]
+expected = Digest::SHA256.hexdigest(JSON.dump(body.except('job_id', 'enqueued_at')))
+assert_equal(expected, captured[:message_deduplication_id])
+
+# Opt-out: with deduplication disabled the adapter no longer sets a dedup id, so
+# distinct enqueues of identical jobs are not silently dropped.
+Shoryuken.active_job_fifo_message_deduplication = false
+captured = nil
+FifoOptOutJob.perform_later('same-args')
+
+refute(
+  captured.key?(:message_deduplication_id),
+  'with deduplication disabled the adapter must not set message_deduplication_id'
+)
+
+# An explicit deduplication id must still be honored even when auto-generation is off.
+captured = nil
+FifoOptOutJob.set(message_deduplication_id: 'explicit-id').perform_later('same-args')
+
+assert_equal('explicit-id', captured[:message_deduplication_id])

data/spec/integration/auto_extend_visibility/short_visibility_timeout_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# This spec tests that auto_visibility_timeout still processes messages when the
+# queue's visibility timeout is short (<= EXTEND_UPFRONT_SECONDS).
+#
+# AutoExtendVisibility schedules a TimerTask at execution_interval =
+# visibility_timeout - EXTEND_UPFRONT_SECONDS (5s). When the queue's visibility
+# timeout is <= 5s that interval is <= 0, and TimerTask#initialize raises
+# ArgumentError *before* the worker runs - so every receive fails and the
+# message is reprocessed (and re-fails) until it hits a DLQ.
+#
+# Expected behavior: a short visibility timeout no longer breaks processing; the
+# extension interval is clamped to a positive value and the worker runs normally.
+#
+# Regression: auto_visibility_timeout + a <= 5s queue visibility timeout broke
+# processing entirely.
+
+require 'timeout'
+
+setup_sqs
+
+DT.clear
+
+queue_name = DT.queue
+# 5s visibility timeout -> interval would be 5 - 5 = 0 -> TimerTask raised pre-fix.
+create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '5' })
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+short_vt_worker = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: true, auto_visibility_timeout: true
+
+  def perform(_sqs_msg, body)
+    DT[:processed] << body
+  end
+end
+
+short_vt_worker.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, short_vt_worker)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+Shoryuken::Client.sqs.send_message(queue_url: queue_url, message_body: 'hello')
+
+poll_queues_until(timeout: 20) { DT[:processed].size >= 1 }
+
+assert_equal(
+  ['hello'],
+  DT[:processed].to_a,
+  'auto_visibility_timeout must not break processing on a queue with a short visibility timeout'
+)

data/spec/integration/cli/find_all_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# `shoryuken sqs dump`/`mv` drain a queue via CLI::SQS#find_all. With short
+# polling, real (distributed) SQS routinely returns an empty batch while the
+# queue still has messages, so find_all must use long polling and must not stop
+# on the first empty response - otherwise dump/mv silently process only a
+# fraction of the queue.
+#
+# ElasticMQ never produces those false-empties (nor visibility-timeout re-reads),
+# so this drives find_all with scripted clients to verify the behavior
+# deterministically.
+#
+# Lives under spec/integration (not spec/lib) because requiring bin/cli defines
+# Shoryuken::CLI, and Shoryuken#server? is `defined?(Shoryuken::CLI)` - loading
+# it in the unit suite would flip server? for every other spec. Integration
+# specs each run in their own process, so that's contained here.
+
+require 'thor'
+require_relative '../../../bin/cli/base'
+require_relative '../../../bin/cli/sqs'
+
+Msg = Struct.new(:message_id, :receipt_handle)
+
+# A scripted SQS client: hands out pre-canned batches in order (to simulate
+# false-empties and visibility-timeout re-reads), ignoring max_number_of_messages
+# and recording the wait_time_seconds it was asked for.
+class ScriptedSqsClient
+  attr_reader :wait_times
+
+  def initialize(batches)
+    @batches = batches.dup
+    @wait_times = []
+  end
+
+  def receive_message(params)
+    @wait_times << params[:wait_time_seconds]
+    Struct.new(:messages).new(@batches.shift || [])
+  end
+end
+
+# A more realistic client backed by a flat list that honours
+# max_number_of_messages, so the finite-limit / batch-sizing path can be driven.
+class FlatSqsClient
+  def initialize(messages)
+    @messages = messages.dup
+  end
+
+  def receive_message(params)
+    Struct.new(:messages).new(@messages.shift(params[:max_number_of_messages]))
+  end
+end
+
+def find_all_with(client, limit)
+  cli = Shoryuken::CLI::SQS.allocate
+  cli.instance_variable_set(:@_sqs, client)
+
+  collected = []
+  count = cli.send(:find_all, 'http://example.com/q', limit) { |msg| collected << msg }
+  [collected, count]
+end
+
+# --- Drains past a false-empty batch, using long polling -------------------
+client = ScriptedSqsClient.new(
+  [
+    [Msg.new('a'), Msg.new('b'), Msg.new('c')],
+    [Msg.new('d'), Msg.new('e')],
+    [],                       # false-empty while 'f' is still queued
+    [Msg.new('f')]
+  ]
+)
+collected, = find_all_with(client, Float::INFINITY)
+
+assert_equal(%w[a b c d e f], collected.map(&:message_id), 'find_all should drain past a false-empty batch')
+assert(
+  client.wait_times.any? && client.wait_times.all? { |w| w && w.positive? },
+  "find_all should use long polling, saw wait_time_seconds: #{client.wait_times.uniq.inspect}"
+)
+
+# --- Does not re-yield a message that reappears after its visibility timeout ---
+# 'a' is handed back on a later receive (its visibility timeout lapsed before
+# dump/mv deleted it). find_all must yield and count it only once.
+reappearing = ScriptedSqsClient.new(
+  [
+    [Msg.new('a'), Msg.new('b')],
+    [Msg.new('a')],           # re-read of 'a' while it is still in the queue
+    [Msg.new('c')]
+  ]
+)
+collected, count = find_all_with(reappearing, Float::INFINITY)
+
+assert_equal(%w[a b c], collected.map(&:message_id), 'find_all must not re-yield a re-read message')
+assert_equal(3, count, 'find_all count must not double-count a re-read message')
+
+# --- Retains the newest receipt handle for a re-read message ----------------
+# SQS only honors the most recently received receipt handle for deletion, and
+# dump/mv batch_delete after the drain, so the yielded (and later deleted)
+# message must carry the handle from the latest receive, not the first.
+handles = ScriptedSqsClient.new(
+  [
+    [Msg.new('x', 'rh-x-1'), Msg.new('y', 'rh-y')],
+    [Msg.new('x', 'rh-x-2')], # re-read of 'x' with a fresh handle
+    [Msg.new('z', 'rh-z')]
+  ]
+)
+collected, = find_all_with(handles, Float::INFINITY)
+
+x = collected.find { |msg| msg.message_id == 'x' }
+assert_equal('rh-x-2', x.receipt_handle, 'find_all must retain the newest receipt handle for a re-read message')
+assert_equal(%w[x y z], collected.map(&:message_id), 'a re-read must not be yielded twice')
+
+# --- Stops at a finite limit without over-fetching -------------------------
+flat = FlatSqsClient.new((1..25).map { |i| Msg.new("m#{i}") })
+collected, count = find_all_with(flat, 15)
+
+assert_equal(15, count, 'find_all must stop once the limit is reached')
+assert_equal(
+  (1..15).map { |i| "m#{i}" },
+  collected.map(&:message_id),
+  'find_all must yield exactly the first `limit` messages'
+)