shoryuken 7.0.0.alpha2 → 7.0.0

data/spec/integration/auto_extend_visibility/auto_extend_visibility_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# This spec tests the auto_visibility_timeout middleware functionality.
+# When auto_visibility_timeout: true, the message visibility timeout should be
+# automatically extended during long-running job processing to prevent re-delivery.
+
+setup_localstack
+
+queue_name = DT.uuid
+
+# Create queue with short visibility timeout (10 seconds)
+create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '10' })
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+# Worker with auto_visibility_timeout enabled that takes longer than visibility timeout
+auto_visibility_worker = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_visibility_timeout: true, auto_delete: true
+
+  def perform(sqs_msg, body)
+    DT[:processing_started] << Time.now
+    # Sleep longer than the queue's visibility timeout (10s)
+    # The middleware should extend visibility before it expires
+    sleep 12
+    DT[:processing_completed] << Time.now
+    DT[:processed_messages] << { message_id: sqs_msg.message_id, body: body }
+  end
+end
+
+auto_visibility_worker.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, auto_visibility_worker)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+# Send a message
+Shoryuken::Client.sqs.send_message(
+  queue_url: queue_url,
+  message_body: 'long running job'
+)
+
+sleep 1
+
+# Process the message - this should take ~12 seconds but not fail
+poll_queues_until(timeout: 30) { DT[:processed_messages].size >= 1 }
+
+# Verify message was processed exactly once (visibility was extended, not re-delivered)
+assert_equal(1, DT[:processed_messages].size, "Message should be processed exactly once")
+assert_equal('long running job', DT[:processed_messages].first[:body])
+
+# Verify processing took longer than the visibility timeout
+processing_time = DT[:processing_completed].first - DT[:processing_started].first
+assert(processing_time >= 12, "Processing should have taken at least 12 seconds")
+
+# Cleanup
+delete_test_queue(queue_name)

data/spec/integration/aws_config/aws_config_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# This spec tests that AWS configuration from Shoryuken.options[:aws]
+# is properly passed to the SQS client initialization.
+# This verifies the fix for issue #815: PORO setup does not load AWS config
+
+# Reset any cached SQS client to ensure fresh initialization
+Shoryuken.sqs_client = nil
+
+# Configure AWS options programmatically (simulating PORO setup with config file)
+Shoryuken.options[:aws] = {
+  region: 'us-east-1',
+  endpoint: 'http://localhost:4566',
+  access_key_id: 'test-key-from-config',
+  secret_access_key: 'test-secret-from-config'
+}
+
+# Get the SQS client - this should use the AWS config from options
+client = Shoryuken.sqs_client
+
+# Verify the client was configured with our options
+config = client.config
+
+assert_equal('us-east-1', config.region, "Region should be set from options[:aws]")
+assert_equal('http://localhost:4566', config.endpoint.to_s, "Endpoint should be set from options[:aws]")
+
+# Verify the client actually works by creating a queue
+queue_name = "aws-config-test-#{SecureRandom.hex(6)}"
+
+begin
+  result = client.create_queue(queue_name: queue_name)
+  assert(result.queue_url.include?(queue_name), "Should be able to create queue with configured client")
+
+  # Clean up
+  client.delete_queue(queue_url: result.queue_url)
+rescue Aws::SQS::Errors::ServiceError => e
+  raise "SQS client should work with configured AWS options: #{e.message}"
+end
+
+# Test 2: Verify that reconfiguring options and resetting client works
+Shoryuken.sqs_client = nil
+Shoryuken.options[:aws][:region] = 'us-west-2'
+
+client2 = Shoryuken.sqs_client
+assert_equal('us-west-2', client2.config.region, "New client should use updated region")
+
+# Test 3: Verify that credentials from options are used
+# Reset and reconfigure with explicit credentials
+Shoryuken.sqs_client = nil
+Shoryuken.options[:aws] = {
+  region: 'us-east-1',
+  endpoint: 'http://localhost:4566',
+  access_key_id: 'another-key',
+  secret_access_key: 'another-secret'
+}
+
+client3 = Shoryuken.sqs_client
+assert(client3.is_a?(Aws::SQS::Client), "Client should be created with new credentials")
+assert_equal('us-east-1', client3.config.region, "Region should match configured value")

data/spec/integration/batch_processing/batch_processing_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# This spec tests batch processing including batch message reception (up to 10
+# messages), batch vs single worker behavior differences, JSON body parsing in
+# batch mode, and maximum batch size handling.
+
+setup_localstack
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  def perform(sqs_msgs, bodies)
+    msgs = Array(sqs_msgs)
+    DT[:batch_sizes] << msgs.size
+    DT[:messages].concat(Array(bodies))
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+worker_class.get_shoryuken_options['auto_delete'] = true
+worker_class.get_shoryuken_options['batch'] = true
+Shoryuken.register_worker(queue_name, worker_class)
+
+entries = 5.times.map { |i| { id: SecureRandom.uuid, message_body: "message-#{i}" } }
+Shoryuken::Client.queues(queue_name).send_messages(entries: entries)
+
+sleep 1
+
+poll_queues_until { DT[:messages].size >= 5 }
+
+assert_equal(5, DT[:messages].size)
+assert(DT[:batch_sizes].any? { |size| size > 1 }, "Expected at least one batch with size > 1")

data/spec/integration/body_parser/json_parser_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# This spec tests the body_parser option with :json setting
+# Verifies that JSON messages are automatically parsed into Ruby hashes
+
+setup_localstack
+
+queue_name = DT.uuid
+create_test_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options body_parser: :json
+
+  def perform(sqs_msg, body)
+    DT[:parsed_bodies] << body
+    DT[:body_classes] << body.class.name
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+worker_class.get_shoryuken_options['auto_delete'] = true
+Shoryuken.register_worker(queue_name, worker_class)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+# Send a JSON message
+json_body = { 'name' => 'test', 'value' => 42, 'nested' => { 'key' => 'val' } }
+Shoryuken::Client.sqs.send_message(
+  queue_url: queue_url,
+  message_body: JSON.dump(json_body)
+)
+
+sleep 1
+
+poll_queues_until { DT[:parsed_bodies].size >= 1 }
+
+assert_equal(1, DT[:parsed_bodies].size)
+assert_equal('Hash', DT[:body_classes].first)
+assert_equal('test', DT[:parsed_bodies].first['name'])
+assert_equal(42, DT[:parsed_bodies].first['value'])
+assert_equal('val', DT[:parsed_bodies].first['nested']['key'])

data/spec/integration/body_parser/proc_parser_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# This spec tests the body_parser option with a custom Proc
+# Verifies that custom parsing logic can be applied to messages
+
+setup_localstack
+
+queue_name = DT.uuid
+create_test_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+# Custom parser that uppercases the body and adds metadata
+custom_parser = proc do |sqs_msg|
+  {
+    original: sqs_msg.body,
+    transformed: sqs_msg.body.upcase,
+    message_id: sqs_msg.message_id
+  }
+end
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  def perform(sqs_msg, body)
+    DT[:parsed_bodies] << body
+    DT[:body_classes] << body.class.name
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+worker_class.get_shoryuken_options['auto_delete'] = true
+worker_class.get_shoryuken_options['body_parser'] = custom_parser
+Shoryuken.register_worker(queue_name, worker_class)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+# Send a message to be processed by custom parser
+Shoryuken::Client.sqs.send_message(
+  queue_url: queue_url,
+  message_body: 'hello world'
+)
+
+sleep 1
+
+poll_queues_until { DT[:parsed_bodies].size >= 1 }
+
+assert_equal(1, DT[:parsed_bodies].size)
+assert_equal('Hash', DT[:body_classes].first)
+
+parsed = DT[:parsed_bodies].first
+assert_equal('hello world', parsed[:original])
+assert_equal('HELLO WORLD', parsed[:transformed])
+assert(parsed[:message_id], "Should include message_id from sqs_msg")

data/spec/integration/body_parser/text_parser_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# This spec tests the body_parser option with :text setting (default)
+# Verifies that messages are returned as plain strings
+
+setup_localstack
+
+queue_name = DT.uuid
+create_test_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options body_parser: :text
+
+  def perform(sqs_msg, body)
+    DT[:parsed_bodies] << body
+    DT[:body_classes] << body.class.name
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+worker_class.get_shoryuken_options['auto_delete'] = true
+Shoryuken.register_worker(queue_name, worker_class)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+# Send a plain text message
+text_body = 'Hello, this is a plain text message!'
+Shoryuken::Client.sqs.send_message(
+  queue_url: queue_url,
+  message_body: text_body
+)
+
+sleep 1
+
+poll_queues_until { DT[:parsed_bodies].size >= 1 }
+
+assert_equal(1, DT[:parsed_bodies].size)
+assert_equal('String', DT[:body_classes].first)
+assert_equal(text_body, DT[:parsed_bodies].first)

data/spec/integration/concurrent_processing/concurrent_processing_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# This spec tests concurrent message processing with multiple processors.
+
+require 'concurrent'
+
+setup_localstack
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+Shoryuken.add_group('concurrent', 5) # 5 concurrent processors
+Shoryuken.add_queue(queue_name, 1, 'concurrent')
+
+# Atomic counters for tracking concurrency
+concurrent_count = Concurrent::AtomicFixnum.new(0)
+max_concurrent = Concurrent::AtomicFixnum.new(0)
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: true, batch: false
+
+  define_method(:perform) do |sqs_msg, body|
+    concurrent_count.increment
+    current = concurrent_count.value
+    max_concurrent.update { |max| [max, current].max }
+
+    sleep 0.5 # Simulate work
+
+    DT[:processing_times] << Time.now
+
+    concurrent_count.decrement
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, worker_class)
+
+10.times { |i| Shoryuken::Client.queues(queue_name).send_message(message_body: "msg-#{i}") }
+
+poll_queues_until(timeout: 20) { DT[:processing_times].size >= 10 }
+
+assert_equal(10, DT[:processing_times].size)
+# With multiple processors, we should see concurrency > 1
+assert(max_concurrent.value > 1, "Expected concurrency > 1, got #{max_concurrent.value}")

data/spec/integration/dead_letter_queue/dead_letter_queue_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# This spec tests dead letter queue (DLQ) functionality.
+# When a message exceeds maxReceiveCount, it should be moved to the DLQ.
+# Note: This test doesn't use poll_queues_until because messages should fail
+# and be moved to DLQ rather than being successfully processed.
+
+setup_localstack
+
+main_queue_name = DT.queues[0]
+dlq_name = DT.queues[1]
+
+# Create the dead letter queue first
+create_test_queue(dlq_name)
+
+dlq_url = Shoryuken::Client.sqs.get_queue_url(queue_name: dlq_name).queue_url
+dlq_arn = Shoryuken::Client.sqs.get_queue_attributes(
+  queue_url: dlq_url,
+  attribute_names: ['QueueArn']
+).attributes['QueueArn']
+
+# Create main queue with redrive policy - move to DLQ after 2 receives
+redrive_policy = { maxReceiveCount: 2, deadLetterTargetArn: dlq_arn }.to_json
+create_test_queue(main_queue_name, attributes: {
+  'VisibilityTimeout' => '1',
+  'RedrivePolicy' => redrive_policy
+})
+
+main_queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: main_queue_name).queue_url
+
+# Send a message
+Shoryuken::Client.sqs.send_message(
+  queue_url: main_queue_url,
+  message_body: 'dlq test message'
+)
+
+# Manually receive the message multiple times to trigger DLQ
+# maxReceiveCount = 2, so after 2 receives without deletion, it goes to DLQ
+3.times do |i|
+  msgs = Shoryuken::Client.sqs.receive_message(
+    queue_url: main_queue_url,
+    max_number_of_messages: 1,
+    wait_time_seconds: 3,
+    attribute_names: ['ApproximateReceiveCount']
+  ).messages
+
+  if msgs.any?
+    receive_count = msgs.first.attributes['ApproximateReceiveCount'].to_i
+    DT[:receives] << { attempt: i + 1, receive_count: receive_count }
+    # Don't delete - let visibility timeout expire
+    sleep 2
+  else
+    DT[:receives] << { attempt: i + 1, no_message: true }
+    break
+  end
+end
+
+# Verify message was received at least twice
+actual_receives = DT[:receives].reject { |r| r[:no_message] }
+assert(actual_receives.size >= 2, "Message should have been received at least twice (was #{actual_receives.size})")
+
+# Wait for message to be moved to DLQ
+sleep 3
+
+# Check that message is now in the DLQ
+dlq_messages = Shoryuken::Client.sqs.receive_message(
+  queue_url: dlq_url,
+  max_number_of_messages: 10,
+  wait_time_seconds: 5,
+  attribute_names: ['All']
+).messages
+
+assert(dlq_messages.size >= 1, 'Message should have been moved to DLQ')
+assert_equal('dlq test message', dlq_messages.first.body)
+
+# Verify message is no longer in main queue
+main_attrs = Shoryuken::Client.sqs.get_queue_attributes(
+  queue_url: main_queue_url,
+  attribute_names: %w[ApproximateNumberOfMessages ApproximateNumberOfMessagesNotVisible]
+).attributes
+main_count = main_attrs['ApproximateNumberOfMessages'].to_i +
+             main_attrs['ApproximateNumberOfMessagesNotVisible'].to_i
+assert_equal(0, main_count, 'Main queue should be empty after DLQ move')
+
+# Clean up DLQ message
+dlq_messages.each do |msg|
+  Shoryuken::Client.sqs.delete_message(
+    queue_url: dlq_url,
+    receipt_handle: msg.receipt_handle
+  )
+end

data/spec/integration/exception_handlers/exception_handlers_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# This spec tests custom exception handlers.
+# Exception handlers are called when a worker raises an error.
+
+setup_localstack
+
+queue_name = DT.queue
+create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '2' })
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+# Save original handlers to restore later
+original_handlers = Shoryuken.exception_handlers.dup
+
+# Custom exception handler that records exceptions
+custom_handler = Object.new
+custom_handler.define_singleton_method(:call) do |exception, queue, sqs_msg|
+  DT[:exceptions] << {
+    message: exception.message,
+    queue: queue,
+    message_id: sqs_msg.message_id
+  }
+end
+
+# Add custom handler alongside default
+Shoryuken.exception_handlers << custom_handler
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: false, batch: false
+
+  def perform(sqs_msg, body)
+    receive_count = sqs_msg.attributes['ApproximateReceiveCount'].to_i
+    DT[:attempts] << receive_count
+
+    if receive_count < 2
+      raise 'Intentional failure for testing'
+    end
+
+    # Succeed on second attempt and delete
+    DT[:success] << body
+    sqs_msg.delete
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, worker_class)
+
+Shoryuken::Client.queues(queue_name).send_message(message_body: 'exception test')
+
+sleep 1
+
+begin
+  poll_queues_until(timeout: 15) { DT[:success].size >= 1 }
+
+  # Verify exception handler was called on first attempt
+  assert(DT[:exceptions].size >= 1, 'Exception handler should have been called')
+  assert_equal('Intentional failure for testing', DT[:exceptions].first[:message])
+  assert_equal(queue_name, DT[:exceptions].first[:queue])
+
+  # Verify message was eventually processed successfully
+  assert_equal(1, DT[:success].size)
+  assert_equal('exception test', DT[:success].first)
+ensure
+  # Restore original handlers to prevent cross-test interference
+  Shoryuken.exception_handlers.replace(original_handlers)
+end

data/spec/integration/exponential_backoff/exponential_backoff_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# This spec tests the exponential_backoff_retry middleware functionality.
+# When retry_intervals is configured, failed jobs should have their visibility
+# timeout adjusted based on the retry attempt number.
+
+setup_localstack
+
+queue_name = DT.queue
+
+# Create queue with short visibility timeout
+create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '2' })
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+# Worker that fails on first attempts, succeeds after retry_intervals exhausted
+backoff_worker = Class.new do
+  include Shoryuken::Worker
+
+  # Retry after 1 second, then 2 seconds
+  shoryuken_options retry_intervals: [1, 2], auto_delete: true
+
+  def perform(sqs_msg, body)
+    receive_count = sqs_msg.attributes['ApproximateReceiveCount'].to_i
+    DT[:attempts] << { receive_count: receive_count, time: Time.now }
+
+    # Fail on first 2 attempts, succeed on 3rd
+    if receive_count < 3
+      raise "Simulated failure on attempt #{receive_count}"
+    end
+
+    DT[:successful_processing] << { body: body, final_receive_count: receive_count }
+  end
+end
+
+backoff_worker.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, backoff_worker)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+# Send a message
+Shoryuken::Client.sqs.send_message(
+  queue_url: queue_url,
+  message_body: 'backoff test'
+)
+
+sleep 1
+
+# Process - should fail twice then succeed on 3rd attempt
+# Total time: ~1s (first retry) + ~2s (second retry) = ~3s minimum
+poll_queues_until(timeout: 20) { DT[:successful_processing].size >= 1 }
+
+# Verify the message was eventually processed successfully
+assert_equal(1, DT[:successful_processing].size)
+assert_equal('backoff test', DT[:successful_processing].first[:body])
+assert_equal(3, DT[:successful_processing].first[:final_receive_count])
+
+# Verify we had 3 attempts total
+assert_equal(3, DT[:attempts].size, 'Should have 3 attempts total')
+
+# Verify backoff timing - second attempt should be ~1s after first
+first_to_second = DT[:attempts][1][:time] - DT[:attempts][0][:time]
+assert(first_to_second >= 0.5, "Second attempt should be at least 0.5s after first (was #{first_to_second}s)")
+
+# Verify backoff timing - third attempt should be ~2s after second
+second_to_third = DT[:attempts][2][:time] - DT[:attempts][1][:time]
+assert(second_to_third >= 1.0, "Third attempt should be at least 1s after second (was #{second_to_third}s)")

data/spec/integration/fifo_ordering/fifo_ordering_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# This spec tests FIFO queue ordering guarantees including message ordering
+# within the same message group.
+
+setup_localstack
+
+queue_name = "#{DT.uuid}.fifo"
+create_fifo_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  def perform(sqs_msg, body)
+    DT[:messages] << body
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+worker_class.get_shoryuken_options['auto_delete'] = true
+worker_class.get_shoryuken_options['batch'] = false
+Shoryuken.register_worker(queue_name, worker_class)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+5.times do |i|
+  Shoryuken::Client.sqs.send_message(
+    queue_url: queue_url,
+    message_body: "msg-#{i}",
+    message_group_id: 'group-a',
+    message_deduplication_id: SecureRandom.uuid
+  )
+end
+
+sleep 1
+
+poll_queues_until { DT[:messages].size >= 5 }
+
+assert_equal(5, DT[:messages].size)
+
+expected = (0..4).map { |i| "msg-#{i}" }
+assert_equal(expected, DT[:messages])

data/spec/integration/large_payloads/large_payloads_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# This spec tests large payload handling including payloads near the 256KB SQS limit.
+
+setup_localstack
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  def perform(sqs_msg, body)
+    DT[:bodies] << body
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+worker_class.get_shoryuken_options['auto_delete'] = true
+worker_class.get_shoryuken_options['batch'] = false
+Shoryuken.register_worker(queue_name, worker_class)
+
+payload = 'x' * (250 * 1024)
+Shoryuken::Client.queues(queue_name).send_message(message_body: payload)
+
+poll_queues_until { DT[:bodies].size >= 1 }
+
+assert_equal(250 * 1024, DT[:bodies].first.size)

data/spec/integration/launcher/launcher_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# This spec tests the Launcher's ability to consume messages from SQS queues,
+# including single message consumption, batch consumption, and command workers.
+
+require 'concurrent'
+
+setup_localstack
+
+# Use atomic counter for thread-safe message counting
+message_counter = Concurrent::AtomicFixnum.new(0)
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: true
+
+  define_method(:perform) do |sqs_msg, _body|
+    message_counter.increment(Array(sqs_msg).size)
+  end
+end
+
+queue_name = DT.queue
+
+create_test_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+worker_class.get_shoryuken_options['queue'] = queue_name
+worker_class.get_shoryuken_options['batch'] = true
+Shoryuken.register_worker(queue_name, worker_class)
+
+entries = 10.times.map { |i| { id: SecureRandom.uuid, message_body: i.to_s } }
+Shoryuken::Client.queues(queue_name).send_messages(entries: entries)
+
+# Give the messages a chance to hit the queue
+sleep 2
+
+poll_queues_until { message_counter.value > 0 }
+
+assert(message_counter.value > 1, "Expected more than 1 message in batch, got #{message_counter.value}")