shoryuken 7.0.0.alpha2 → 7.0.0

data/spec/integration/message_attributes/message_attributes_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# This spec tests SQS message attributes including String, Number, and Binary
+# attribute types, system attributes (ApproximateReceiveCount, SentTimestamp),
+# and custom type suffixes.
+
+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
+
+  shoryuken_options auto_delete: true, batch: false
+
+  def perform(sqs_msg, body)
+    DT[:attributes] << sqs_msg.message_attributes
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, worker_class)
+
+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: 'mixed-attr-test',
+  message_attributes: {
+    'StringAttr' => {
+      string_value: 'hello-world',
+      data_type: 'String'
+    },
+    'NumberAttr' => {
+      string_value: '42',
+      data_type: 'Number'
+    },
+    'BinaryAttr' => {
+      binary_value: 'binary-data'.b,
+      data_type: 'Binary'
+    }
+  }
+)
+
+poll_queues_until { DT[:attributes].size >= 1 }
+
+attrs = DT[:attributes].first
+assert_equal(3, attrs.keys.size)
+assert_equal('hello-world', attrs['StringAttr']&.string_value)
+assert_equal('42', attrs['NumberAttr']&.string_value)
+assert_equal('binary-data'.b, attrs['BinaryAttr']&.binary_value)

data/spec/integration/message_operations/message_operations_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# This spec tests message operations from within a worker:
+# - sqs_msg.delete - manually delete a message
+# - sqs_msg.change_visibility - change visibility with options
+
+setup_localstack
+
+queue_name = DT.queue
+create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '5' })
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+# Worker that tests message operations
+message_ops_worker = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: false
+
+  def perform(sqs_msg, body)
+    DT[:processed] << { message_id: sqs_msg.message_id, body: body }
+
+    # Test sqs_msg.change_visibility method
+    sqs_msg.change_visibility(visibility_timeout: 60)
+    DT[:extended] << sqs_msg.message_id
+
+    # Manually delete the message
+    sqs_msg.delete
+    DT[:deleted] << sqs_msg.message_id
+  end
+end
+
+message_ops_worker.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, message_ops_worker)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+# Test: Message operations - change_visibility and delete
+Shoryuken::Client.sqs.send_message(
+  queue_url: queue_url,
+  message_body: 'message ops test'
+)
+
+sleep 1
+poll_queues_until { DT[:deleted].size >= 1 }
+
+# Verify message was processed
+assert_equal(1, DT[:processed].size)
+assert_equal('message ops test', DT[:processed].first[:body])
+
+# Verify visibility was extended
+assert_equal(1, DT[:extended].size, "Visibility should have been extended")
+
+# Verify message was deleted
+assert_equal(1, DT[:deleted].size, "Message should have been deleted")
+
+# Verify message was deleted - should not be reprocessed
+sleep 2
+assert_equal(1, DT[:processed].size, "Deleted message should only be processed once")

data/spec/integration/middleware_chain/empty_chain_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Empty middleware chain executes worker block directly
+
+chain = Shoryuken::Middleware::Chain.new
+
+chain.invoke(nil, 'test', nil, nil) do
+  DT[:calls] << :worker
+end
+
+assert_equal([:worker], DT[:calls])

data/spec/integration/middleware_chain/execution_order_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Middleware executes in onion model order (first-in wraps outermost)
+
+def create_middleware(name)
+  Class.new do
+    define_method(:call) do |worker, queue, sqs_msg, body, &block|
+      DT[:order] << :"#{name}_before"
+      block.call
+      DT[:order] << :"#{name}_after"
+    end
+  end
+end
+
+first = create_middleware(:first)
+second = create_middleware(:second)
+third = create_middleware(:third)
+
+chain = Shoryuken::Middleware::Chain.new
+chain.add first
+chain.add second
+chain.add third
+
+chain.invoke(nil, 'test-queue', nil, nil) do
+  DT[:order] << :worker_perform
+end
+
+expected_order = [
+  :first_before, :second_before, :third_before,
+  :worker_perform,
+  :third_after, :second_after, :first_after
+]
+assert_equal(expected_order, DT[:order])

data/spec/integration/middleware_chain/removal_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Middleware can be removed from the chain
+
+def create_middleware(name)
+  Class.new do
+    define_method(:call) do |worker, queue, sqs_msg, body, &block|
+      DT[:calls] << :"#{name}_before"
+      block.call
+      DT[:calls] << :"#{name}_after"
+    end
+  end
+end
+
+first = create_middleware(:first)
+second = create_middleware(:second)
+third = create_middleware(:third)
+
+chain = Shoryuken::Middleware::Chain.new
+chain.add first
+chain.add second
+chain.add third
+chain.remove second
+
+chain.invoke(nil, 'test', nil, nil) do
+  DT[:calls] << :worker
+end
+
+assert_includes(DT[:calls], :first_before)
+refute(DT[:calls].include?(:second_before), "Second should be removed")
+assert_includes(DT[:calls], :third_before)

data/spec/integration/middleware_chain/short_circuit_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Middleware can short-circuit the chain by not calling the block
+
+def create_middleware(name)
+  Class.new do
+    define_method(:call) do |worker, queue, sqs_msg, body, &block|
+      DT[:calls] << :"#{name}_before"
+      block.call
+      DT[:calls] << :"#{name}_after"
+    end
+  end
+end
+
+def create_short_circuit_middleware
+  Class.new do
+    define_method(:call) do |worker, queue, sqs_msg, body, &block|
+      DT[:calls] << :short_circuit
+    end
+  end
+end
+
+first = create_middleware(:first)
+short_circuit = create_short_circuit_middleware
+third = create_middleware(:third)
+
+chain = Shoryuken::Middleware::Chain.new
+chain.add first
+chain.add short_circuit
+chain.add third
+
+chain.invoke(nil, 'test', nil, nil) do
+  DT[:calls] << :worker
+end
+
+assert_includes(DT[:calls], :first_before)
+assert_includes(DT[:calls], :short_circuit)
+refute(DT[:calls].include?(:third_before), "Third should not execute")
+refute(DT[:calls].include?(:worker), "Worker should not execute")
+assert_includes(DT[:calls], :first_after)

data/spec/integration/polling_strategies/polling_strategies_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# This spec tests polling strategies including WeightedRoundRobin (default)
+# with multi-queue worker message distribution.
+
+setup_localstack
+
+queue_high = DT.queues[0]
+queue_medium = DT.queues[1]
+queue_low = DT.queues[2]
+
+[queue_high, queue_medium, queue_low].each { |q| create_test_queue(q) }
+
+Shoryuken.add_group('default', 1)
+# Higher weight = higher priority
+Shoryuken.add_queue(queue_high, 3, 'default')
+Shoryuken.add_queue(queue_medium, 2, 'default')
+Shoryuken.add_queue(queue_low, 1, 'default')
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: true, batch: false
+
+  def perform(sqs_msg, body)
+    queue = sqs_msg.queue_url.split('/').last
+    DT[:by_queue] << { queue: queue, body: body }
+  end
+end
+
+[queue_high, queue_medium, queue_low].each do |queue|
+  worker_class.get_shoryuken_options['queue'] = queue
+  Shoryuken.register_worker(queue, worker_class)
+end
+
+Shoryuken::Client.queues(queue_high).send_message(message_body: 'high-msg')
+Shoryuken::Client.queues(queue_medium).send_message(message_body: 'medium-msg')
+Shoryuken::Client.queues(queue_low).send_message(message_body: 'low-msg')
+
+sleep 1
+
+poll_queues_until { DT[:by_queue].size >= 3 }
+
+queues_with_messages = DT[:by_queue].map { |m| m[:queue] }.uniq
+assert_equal(3, queues_with_messages.size)
+assert_equal(3, DT[:by_queue].size)

data/spec/integration/queue_operations/queue_operations_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# This spec tests Shoryuken::Queue operations including:
+# - Queue initialization (by name, URL, and ARN)
+# - Visibility timeout retrieval
+# - FIFO queue detection
+# - Batch message sending
+# - Batch message deletion
+
+setup_localstack
+
+# Test 1: Queue initialization by name
+queue_name = DT.uuid
+create_test_queue(queue_name)
+
+queue = Shoryuken::Queue.new(Shoryuken::Client.sqs, queue_name)
+assert_equal(queue_name, queue.name)
+assert(queue.url.include?(queue_name), "URL should contain queue name")
+refute(queue.fifo?, "Standard queue should not be FIFO")
+
+# Test 2: Queue initialization by URL
+queue_url = queue.url
+queue_by_url = Shoryuken::Queue.new(Shoryuken::Client.sqs, queue_url)
+assert_equal(queue_name, queue_by_url.name)
+assert_equal(queue_url, queue_by_url.url)
+
+# Test 3: Visibility timeout retrieval
+visibility_timeout = queue.visibility_timeout
+assert(visibility_timeout.is_a?(Integer), "Visibility timeout should be an integer")
+assert(visibility_timeout >= 0, "Visibility timeout should be non-negative")
+
+# Test 4: FIFO queue detection
+fifo_queue_name = "#{DT.uuid}.fifo"
+create_fifo_queue(fifo_queue_name)
+
+fifo_queue = Shoryuken::Queue.new(Shoryuken::Client.sqs, fifo_queue_name)
+assert_equal(fifo_queue_name, fifo_queue.name)
+assert(fifo_queue.fifo?, "FIFO queue should be detected as FIFO")
+
+# Test 5: Send single message
+send_result = queue.send_message(message_body: 'test message 1')
+assert(send_result.message_id, "Send result should have message_id")
+
+# Test 6: Send message with hash body (auto JSON serialization)
+hash_body = { key: 'value', number: 42 }
+send_result2 = queue.send_message(message_body: hash_body)
+assert(send_result2.message_id, "Send result should have message_id for hash body")
+
+# Test 7: Batch message sending
+batch_result = queue.send_messages([
+  { message_body: 'batch msg 1' },
+  { message_body: 'batch msg 2' },
+  { message_body: 'batch msg 3' }
+])
+assert_equal(3, batch_result.successful.size, "All 3 batch messages should succeed")
+
+# Test 8: Receive messages
+sleep 1 # Allow messages to become visible
+received = queue.receive_messages(max_number_of_messages: 10)
+assert(received.size > 0, "Should receive at least one message")
+assert(received.first.is_a?(Shoryuken::Message), "Received items should be Message objects")
+
+# Test 9: Batch message deletion
+entries = received.map.with_index do |msg, idx|
+  { id: idx.to_s, receipt_handle: msg.receipt_handle }
+end
+delete_result = queue.delete_messages(entries: entries)
+refute(delete_result, "Delete should succeed without failures")
+
+# Test 10: FIFO queue message sending with auto-generated attributes
+fifo_send_result = fifo_queue.send_message(message_body: 'fifo test message')
+assert(fifo_send_result.message_id, "FIFO send should have message_id")
+assert(fifo_send_result.sequence_number, "FIFO send should have sequence_number")
+
+# Test 11: Send message with delay
+delayed_result = queue.send_message(
+  message_body: 'delayed message',
+  delay_seconds: 5
+)
+assert(delayed_result.message_id, "Delayed message should have message_id")
+
+# Cleanup
+delete_test_queue(queue_name)
+delete_test_queue(fifo_queue_name)

data/spec/integration/rails/rails_72/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec path: '../../../../'
+
+gem 'activejob', '~> 8.0'
+gem 'rails', '~> 8.0'

data/spec/integration/rails/rails_72/activejob_adapter_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# ActiveJob adapter integration tests for Rails 7.2
+
+setup_active_job
+
+class EmailJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(user_id, message)
+    { user_id: user_id, message: message, sent_at: Time.current }
+  end
+end
+
+class DataProcessingJob < ActiveJob::Base
+  queue_as :high_priority
+
+  def perform(data_file)
+    "Processed: #{data_file}"
+  end
+end
+
+class SerializationJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(complex_data)
+    complex_data.transform_values(&:upcase)
+  end
+end
+
+# Test adapter setup
+adapter = ActiveJob::Base.queue_adapter
+assert_equal("ActiveJob::QueueAdapters::ShoryukenAdapter", adapter.class.name)
+
+# Test singleton pattern
+instance1 = ActiveJob::QueueAdapters::ShoryukenAdapter.instance
+instance2 = ActiveJob::QueueAdapters::ShoryukenAdapter.instance
+assert_equal(instance1.object_id, instance2.object_id)
+
+# Test transaction commit hook (Rails 7.2+)
+adapter_instance = ActiveJob::QueueAdapters::ShoryukenAdapter.new
+assert(adapter_instance.respond_to?(:enqueue_after_transaction_commit?))
+assert_equal(true, adapter_instance.enqueue_after_transaction_commit?)
+
+# Test simple job enqueue
+job_capture = JobCapture.new
+job_capture.start_capturing
+
+EmailJob.perform_later(1, 'Hello World')
+
+assert_equal(1, job_capture.job_count)
+job = job_capture.last_job
+message_body = job[:message_body]
+assert_equal('EmailJob', message_body['job_class'])
+assert_equal([1, 'Hello World'], message_body['arguments'])
+assert_equal('default', message_body['queue_name'])
+
+# Test different queue
+job_capture2 = JobCapture.new
+job_capture2.start_capturing
+
+DataProcessingJob.perform_later('large_dataset.csv')
+
+job2 = job_capture2.last_job
+message_body2 = job2[:message_body]
+assert_equal('DataProcessingJob', message_body2['job_class'])
+assert_equal('high_priority', message_body2['queue_name'])
+
+# Test complex data serialization
+complex_data = {
+  'user' => { 'name' => 'John', 'age' => 30 },
+  'preferences' => ['email', 'sms']
+}
+
+job_capture3 = JobCapture.new
+job_capture3.start_capturing
+
+SerializationJob.perform_later(complex_data)
+
+job3 = job_capture3.last_job
+message_body3 = job3[:message_body]
+args_data = message_body3['arguments'].first
+assert_equal('John', args_data['user']['name'])
+assert_equal(30, args_data['user']['age'])
+
+# Test shoryuken_class message attribute
+job_capture4 = JobCapture.new
+job_capture4.start_capturing
+
+EmailJob.perform_later(1, 'Attributes test')
+
+job4 = job_capture4.last_job
+attributes = job4[:message_attributes]
+expected_shoryuken_class = {
+  string_value: "Shoryuken::ActiveJob::JobWrapper",
+  data_type: 'String'
+}
+assert_equal(expected_shoryuken_class, attributes['shoryuken_class'])

data/spec/integration/rails/rails_80/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec path: '../../../../'
+
+gem 'activejob', '~> 8.0'
+gem 'rails', '~> 8.0'

data/spec/integration/rails/rails_80/activejob_adapter_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# ActiveJob adapter integration tests for Rails 8.0
+
+setup_active_job
+
+class EmailJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(user_id, message)
+    { user_id: user_id, message: message, sent_at: Time.current }
+  end
+end
+
+class DataProcessingJob < ActiveJob::Base
+  queue_as :high_priority
+
+  def perform(data_file)
+    "Processed: #{data_file}"
+  end
+end
+
+class SerializationJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(complex_data)
+    complex_data.transform_values(&:upcase)
+  end
+end
+
+# Test adapter setup
+adapter = ActiveJob::Base.queue_adapter
+assert_equal("ActiveJob::QueueAdapters::ShoryukenAdapter", adapter.class.name)
+
+# Test singleton pattern
+instance1 = ActiveJob::QueueAdapters::ShoryukenAdapter.instance
+instance2 = ActiveJob::QueueAdapters::ShoryukenAdapter.instance
+assert_equal(instance1.object_id, instance2.object_id)
+
+# Test transaction commit hook
+adapter_instance = ActiveJob::QueueAdapters::ShoryukenAdapter.new
+assert(adapter_instance.respond_to?(:enqueue_after_transaction_commit?))
+assert_equal(true, adapter_instance.enqueue_after_transaction_commit?)
+
+# Test simple job enqueue
+job_capture = JobCapture.new
+job_capture.start_capturing
+
+EmailJob.perform_later(1, 'Hello World')
+
+assert_equal(1, job_capture.job_count)
+job = job_capture.last_job
+message_body = job[:message_body]
+assert_equal('EmailJob', message_body['job_class'])
+assert_equal([1, 'Hello World'], message_body['arguments'])
+assert_equal('default', message_body['queue_name'])
+
+# Test different queue
+job_capture2 = JobCapture.new
+job_capture2.start_capturing
+
+DataProcessingJob.perform_later('large_dataset.csv')
+
+job2 = job_capture2.last_job
+message_body2 = job2[:message_body]
+assert_equal('DataProcessingJob', message_body2['job_class'])
+assert_equal('high_priority', message_body2['queue_name'])
+
+# Test complex data serialization
+complex_data = {
+  'user' => { 'name' => 'John', 'age' => 30 },
+  'preferences' => ['email', 'sms']
+}
+
+job_capture3 = JobCapture.new
+job_capture3.start_capturing
+
+SerializationJob.perform_later(complex_data)
+
+job3 = job_capture3.last_job
+message_body3 = job3[:message_body]
+args_data = message_body3['arguments'].first
+assert_equal('John', args_data['user']['name'])
+assert_equal(30, args_data['user']['age'])
+
+# Test shoryuken_class message attribute
+job_capture4 = JobCapture.new
+job_capture4.start_capturing
+
+EmailJob.perform_later(1, 'Attributes test')
+
+job4 = job_capture4.last_job
+attributes = job4[:message_attributes]
+expected_shoryuken_class = {
+  string_value: "Shoryuken::ActiveJob::JobWrapper",
+  data_type: 'String'
+}
+assert_equal(expected_shoryuken_class, attributes['shoryuken_class'])

data/spec/integration/rails/rails_80/continuation_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# ActiveJob Continuations integration tests for Rails 8.0+
+# Tests the stopping? method and continuation timestamp handling
+
+setup_active_job
+
+# Skip if ActiveJob::Continuable is not available (Rails < 8.0)
+unless defined?(ActiveJob::Continuable)
+  puts "Skipping continuation tests - ActiveJob::Continuable not available (requires Rails 8.0+)"
+  exit 0
+end
+
+# Test stopping? returns false when launcher is not initialized
+adapter = ActiveJob::QueueAdapters::ShoryukenAdapter.new
+assert_equal(false, adapter.stopping?)
+
+# Test stopping? returns true when launcher is stopping
+launcher = Shoryuken::Launcher.new
+runner = Shoryuken::Runner.instance
+runner.instance_variable_set(:@launcher, launcher)
+
+adapter2 = ActiveJob::QueueAdapters::ShoryukenAdapter.new
+assert_equal(false, adapter2.stopping?)
+
+launcher.instance_variable_set(:@stopping, true)
+assert_equal(true, adapter2.stopping?)
+
+# Reset launcher state
+launcher.instance_variable_set(:@stopping, false)
+
+# Test past timestamps for continuation retries
+job_capture = JobCapture.new
+job_capture.start_capturing
+
+class ContinuableTestJob < ActiveJob::Base
+  include ActiveJob::Continuable if defined?(ActiveJob::Continuable)
+  queue_as :default
+  def perform; end
+end
+
+adapter3 = ActiveJob::QueueAdapters::ShoryukenAdapter.new
+job = ContinuableTestJob.new
+job.sqs_send_message_parameters = {}
+
+past_timestamp = Time.current.to_f - 60
+adapter3.enqueue_at(job, past_timestamp)
+
+captured_job = job_capture.last_job
+assert(captured_job[:delay_seconds] <= 0, "Past timestamp should result in immediate delivery")
+
+# Test current timestamp
+job_capture2 = JobCapture.new
+job_capture2.start_capturing
+
+job2 = ContinuableTestJob.new
+job2.sqs_send_message_parameters = {}
+
+current_timestamp = Time.current.to_f
+adapter3.enqueue_at(job2, current_timestamp)
+
+captured_job2 = job_capture2.last_job
+delay = captured_job2[:delay_seconds]
+assert(delay >= -1 && delay <= 1, "Current timestamp should have minimal delay")
+
+# Test future timestamp
+job_capture3 = JobCapture.new
+job_capture3.start_capturing
+
+job3 = ContinuableTestJob.new
+job3.sqs_send_message_parameters = {}
+
+future_timestamp = Time.current.to_f + 30
+adapter3.enqueue_at(job3, future_timestamp)
+
+captured_job3 = job_capture3.last_job
+delay3 = captured_job3[:delay_seconds]
+assert(delay3 > 0, "Future timestamp should have positive delay")
+assert(delay3 <= 30, "Delay should not exceed scheduled time")

data/spec/integration/rails/rails_81/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec path: '../../../../'
+
+gem 'activejob', '~> 8.1'
+gem 'rails', '~> 8.1'