shoryuken 6.2.1 → 7.0.2

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# CurrentAttributes with complex data types (hashes, arrays, symbols) are serialized and 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 TestCurrent < ActiveSupport::CurrentAttributes
+  attribute :user_id, :tenant_id
+end
+
+Shoryuken::ActiveJob::CurrentAttributes.persist(TestCurrent)
+
+class ComplexTypesTestJob < ActiveJob::Base
+  def perform
+    DT[:executions] << {
+      user_id: TestCurrent.user_id,
+      tenant_id: TestCurrent.tenant_id
+    }
+  end
+end
+
+ComplexTypesTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+TestCurrent.user_id = { role: :admin, permissions: [:read, :write, :delete] }
+TestCurrent.tenant_id = [:tenant_a, :tenant_b]
+
+ComplexTypesTestJob.perform_later
+
+TestCurrent.reset
+
+poll_queues_until(timeout: 30) { DT[:executions].size >= 1 }
+
+result = DT[:executions].first
+
+user_data = result[:user_id]
+assert(user_data.is_a?(Hash))
+role = user_data['role'] || user_data[:role]
+assert_equal('admin', role.to_s)
+permissions = user_data['permissions'] || user_data[:permissions]
+assert_equal(3, permissions.size)
+
+tenant_data = result[:tenant_id]
+assert(tenant_data.is_a?(Array))
+assert_equal(2, tenant_data.size)

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# CurrentAttributes without any values set result in nil attributes during job execution
+
+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 TestCurrent < ActiveSupport::CurrentAttributes
+  attribute :user_id, :tenant_id
+end
+
+Shoryuken::ActiveJob::CurrentAttributes.persist(TestCurrent)
+
+class EmptyContextTestJob < ActiveJob::Base
+  def perform
+    DT[:executions] << {
+      user_id: TestCurrent.user_id,
+      tenant_id: TestCurrent.tenant_id
+    }
+  end
+end
+
+EmptyContextTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+EmptyContextTestJob.perform_later
+
+poll_queues_until(timeout: 30) { DT[:executions].size >= 1 }
+
+result = DT[:executions].first
+assert(result[:user_id].nil?)
+assert(result[:tenant_id].nil?)

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# CurrentAttributes with full context are persisted and restored during job execution
+
+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 TestCurrent < ActiveSupport::CurrentAttributes
+  attribute :user_id, :tenant_id, :request_id
+end
+
+class RequestContext < ActiveSupport::CurrentAttributes
+  attribute :locale, :timezone, :trace_id
+end
+
+Shoryuken::ActiveJob::CurrentAttributes.persist(TestCurrent, RequestContext)
+
+class FullContextTestJob < ActiveJob::Base
+  def perform
+    DT[:executions] << {
+      user_id: TestCurrent.user_id,
+      tenant_id: TestCurrent.tenant_id,
+      request_id: TestCurrent.request_id,
+      locale: RequestContext.locale,
+      timezone: RequestContext.timezone,
+      trace_id: RequestContext.trace_id
+    }
+  end
+end
+
+FullContextTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+TestCurrent.user_id = 42
+TestCurrent.tenant_id = 'acme-corp'
+TestCurrent.request_id = 'req-123-abc'
+RequestContext.locale = 'en-US'
+RequestContext.timezone = 'America/New_York'
+RequestContext.trace_id = 'trace-xyz-789'
+
+FullContextTestJob.perform_later
+
+TestCurrent.reset
+RequestContext.reset
+
+poll_queues_until(timeout: 30) { DT[:executions].size >= 1 }
+
+result = DT[:executions].first
+assert_equal(42, result[:user_id])
+assert_equal('acme-corp', result[:tenant_id])
+assert_equal('req-123-abc', result[:request_id])
+assert_equal('en-US', result[:locale])
+assert_equal('America/New_York', result[:timezone])
+assert_equal('trace-xyz-789', result[:trace_id])

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# CurrentAttributes with partial values set preserve only set attributes during job execution
+
+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 TestCurrent < ActiveSupport::CurrentAttributes
+  attribute :user_id, :tenant_id, :request_id
+end
+
+class RequestContext < ActiveSupport::CurrentAttributes
+  attribute :locale, :timezone
+end
+
+Shoryuken::ActiveJob::CurrentAttributes.persist(TestCurrent, RequestContext)
+
+class PartialContextTestJob < ActiveJob::Base
+  def perform
+    DT[:executions] << {
+      user_id: TestCurrent.user_id,
+      tenant_id: TestCurrent.tenant_id,
+      request_id: TestCurrent.request_id,
+      locale: RequestContext.locale,
+      timezone: RequestContext.timezone
+    }
+  end
+end
+
+PartialContextTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+TestCurrent.user_id = 99
+RequestContext.locale = 'fr-FR'
+
+PartialContextTestJob.perform_later
+
+TestCurrent.reset
+RequestContext.reset
+
+poll_queues_until(timeout: 30) { DT[:executions].size >= 1 }
+
+result = DT[:executions].first
+assert_equal(99, result[:user_id])
+assert(result[:tenant_id].nil?)
+assert(result[:request_id].nil?)
+assert_equal('fr-FR', result[:locale])
+assert(result[:timezone].nil?)

data/spec/integration/active_job/custom_attributes/number_attributes_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# ActiveJob custom numeric message attributes are sent to SQS with correct data type
+
+setup_sqs
+setup_active_job
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+
+class NumberAttributesTestJob < ActiveJob::Base
+  def perform
+    DT[:executions] << { job_id: job_id }
+  end
+end
+
+NumberAttributesTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+job = NumberAttributesTestJob.new
+job.sqs_send_message_parameters = {
+  message_attributes: {
+    'priority' => { string_value: '10', data_type: 'Number' },
+    'retry_count' => { string_value: '0', data_type: 'Number' }
+  }
+}
+ActiveJob::QueueAdapters::ShoryukenAdapter.enqueue(job)
+
+poll_queues_until(timeout: 30) { DT[:executions].size >= 1 }
+
+params = job.sqs_send_message_parameters
+assert(params[:message_attributes].key?('priority'))
+assert_equal('10', params[:message_attributes]['priority'][:string_value])
+assert_equal('Number', params[:message_attributes]['priority'][:data_type])

data/spec/integration/active_job/custom_attributes/string_attributes_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# ActiveJob custom string message attributes are sent to SQS and preserved
+
+setup_sqs
+setup_active_job
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+
+class StringAttributesTestJob < ActiveJob::Base
+  def perform
+    DT[:executions] << { job_id: job_id }
+  end
+end
+
+StringAttributesTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+job = StringAttributesTestJob.new
+job.sqs_send_message_parameters = {
+  message_attributes: {
+    'trace_id' => { string_value: 'trace-abc-123', data_type: 'String' },
+    'correlation_id' => { string_value: 'corr-xyz-789', data_type: 'String' }
+  }
+}
+ActiveJob::QueueAdapters::ShoryukenAdapter.enqueue(job)
+
+poll_queues_until(timeout: 30) { DT[:executions].size >= 1 }
+
+params = job.sqs_send_message_parameters
+assert(params[:message_attributes].key?('trace_id'))
+assert(params[:message_attributes].key?('correlation_id'))
+assert(params[:message_attributes].key?('shoryuken_class'))
+assert_equal('trace-abc-123', params[:message_attributes]['trace_id'][:string_value])
+assert_equal('corr-xyz-789', params[:message_attributes]['correlation_id'][:string_value])

data/spec/integration/active_job/error_handling/job_wrapper_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# This spec tests error handling including retry configuration,
+# discard configuration, and job processing through JobWrapper.
+
+setup_active_job
+
+class RetryableJob < ActiveJob::Base
+  queue_as :default
+  retry_on StandardError, wait: 1.second, attempts: 3
+
+  def perform(should_fail = true)
+    raise StandardError, 'Job failed!' if should_fail
+    'Job succeeded!'
+  end
+end
+
+class DiscardableJob < ActiveJob::Base
+  queue_as :default
+  discard_on ArgumentError
+
+  def perform(should_fail = false)
+    raise ArgumentError, 'Invalid argument' if should_fail
+    'Job succeeded!'
+  end
+end
+
+job_capture = JobCapture.new
+job_capture.start_capturing
+
+RetryableJob.perform_later(false)
+
+assert_equal(1, job_capture.job_count)
+job = job_capture.last_job
+message_body = job[:message_body]
+assert_equal('RetryableJob', message_body['job_class'])
+assert_equal([false], message_body['arguments'])
+
+job_capture2 = JobCapture.new
+job_capture2.start_capturing
+
+DiscardableJob.perform_later(false)
+
+assert_equal(1, job_capture2.job_count)
+job2 = job_capture2.last_job
+message_body2 = job2[:message_body]
+assert_equal('DiscardableJob', message_body2['job_class'])
+
+wrapper_class = Shoryuken::ActiveJob::JobWrapper
+options = wrapper_class.get_shoryuken_options
+
+assert_equal(:json, options['body_parser'])
+assert_equal(true, options['auto_delete'])

data/spec/integration/active_job/fifo_and_attributes/deduplication_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+# This spec tests FIFO queue support including message deduplication ID generation
+# and message attributes handling.
+
+setup_active_job
+
+class FifoTestJob < ActiveJob::Base
+  queue_as :test_fifo
+
+  def perform(order_id, action)
+    "Processed order #{order_id}: #{action}"
+  end
+end
+
+class AttributesTestJob < ActiveJob::Base
+  queue_as :attributes_test
+
+  def perform(data)
+    "Processed: #{data}"
+  end
+end
+
+fifo_queue_mock = Object.new
+fifo_queue_mock.define_singleton_method(:fifo?) { true }
+fifo_queue_mock.define_singleton_method(:name) { 'test_fifo.fifo' }
+
+captured_params = nil
+fifo_queue_mock.define_singleton_method(:send_message) do |params|
+  captured_params = params
+end
+
+Shoryuken::Client.define_singleton_method(:queues) do |queue_name = nil|
+  if queue_name
+    fifo_queue_mock
+  else
+    { test_fifo: fifo_queue_mock }
+  end
+end
+
+Shoryuken.define_singleton_method(:register_worker) { |*args| nil }
+
+FifoTestJob.perform_later('order-123', 'process')
+
+assert(captured_params.key?(:message_deduplication_id))
+assert_equal(64, captured_params[:message_deduplication_id].length)
+
+body = captured_params[:message_body]
+body_without_variable_fields = body.except('job_id', 'enqueued_at')
+expected_dedupe_id = Digest::SHA256.hexdigest(JSON.dump(body_without_variable_fields))
+assert_equal(expected_dedupe_id, captured_params[:message_deduplication_id])
+
+regular_queue_mock = Object.new
+regular_queue_mock.define_singleton_method(:fifo?) { false }
+regular_queue_mock.define_singleton_method(:name) { 'attributes_test' }
+
+captured_attrs = nil
+regular_queue_mock.define_singleton_method(:send_message) do |params|
+  captured_attrs = params
+end
+
+Shoryuken::Client.define_singleton_method(:queues) do |queue_name = nil|
+  regular_queue_mock
+end
+
+custom_attributes = {
+  'trace_id' => { string_value: 'trace-123', data_type: 'String' },
+  'priority' => { string_value: 'high', data_type: 'String' }
+}
+
+job = AttributesTestJob.new('test data')
+job.sqs_send_message_parameters = { message_attributes: custom_attributes }
+ActiveJob::QueueAdapters::ShoryukenAdapter.enqueue(job)
+
+attributes = captured_attrs[:message_attributes]
+assert_equal(custom_attributes['trace_id'], attributes['trace_id'])
+assert_equal(custom_attributes['priority'], attributes['priority'])
+
+# Should still include required Shoryuken attribute
+expected_shoryuken_class = {
+  string_value: "Shoryuken::ActiveJob::JobWrapper",
+  data_type: 'String'
+}
+assert_equal(expected_shoryuken_class, attributes['shoryuken_class'])

data/spec/integration/active_job/keyword_arguments/keyword_arguments_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Integration test for ActiveJob keyword arguments support
+# Regression test for: https://github.com/ruby-shoryuken/shoryuken/issues/961
+#
+# In Shoryuken 7.0, the SQSSendMessageParametersSupport module's initialize method
+# breaks keyword argument passing to ActiveJob jobs because it lacks ruby2_keywords.
+
+setup_sqs
+setup_active_job
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+
+# Job that accepts keyword arguments - this was broken in Shoryuken 7.0
+class KeywordArgumentsTestJob < ActiveJob::Base
+  def perform(name:, count:, enabled: false)
+    DT[:executions] << {
+      name: name,
+      count: count,
+      enabled: enabled,
+      job_id: job_id
+    }
+  end
+end
+
+KeywordArgumentsTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+# Enqueue jobs with keyword arguments
+# This is where the bug manifests - the job instantiation fails
+KeywordArgumentsTestJob.perform_later(name: 'first', count: 1)
+KeywordArgumentsTestJob.perform_later(name: 'second', count: 2, enabled: true)
+
+poll_queues_until(timeout: 30) do
+  DT[:executions].size >= 2
+end
+
+assert_equal(2, DT[:executions].size, "Expected 2 job executions, got #{DT[:executions].size}")
+
+# Find the executions by name
+first_exec = DT[:executions].find { |e| e[:name] == 'first' }
+second_exec = DT[:executions].find { |e| e[:name] == 'second' }
+
+assert(first_exec, "Expected to find 'first' job execution")
+assert(second_exec, "Expected to find 'second' job execution")
+
+# Verify keyword arguments were passed correctly
+assert_equal('first', first_exec[:name])
+assert_equal(1, first_exec[:count])
+assert_equal(false, first_exec[:enabled])
+
+assert_equal('second', second_exec[:name])
+assert_equal(2, second_exec[:count])
+assert_equal(true, second_exec[:enabled])
+
+# Verify job IDs
+job_ids = DT[:executions].map { |e| e[:job_id] }
+assert(job_ids.all? { |id| id && !id.empty? }, "All jobs should have job IDs")
+assert_equal(2, job_ids.uniq.size, "All job IDs should be unique")

data/spec/integration/active_job/retry/discard_on_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# ActiveJob discard_on discards jobs that raise specific errors without retry
+
+setup_sqs
+setup_active_job
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+
+class DiscardOnTestJob < ActiveJob::Base
+  discard_on ArgumentError
+
+  def perform(should_fail)
+    DT[:attempts] << { job_id: job_id, should_fail: should_fail }
+
+    if should_fail
+      raise ArgumentError, "This should be discarded"
+    end
+
+    DT[:successes] << { job_id: job_id }
+  end
+end
+
+DiscardOnTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+failing_job = DiscardOnTestJob.perform_later(true)
+success_job = DiscardOnTestJob.perform_later(false)
+
+poll_queues_until(timeout: 30) { DT[:attempts].size >= 2 }
+
+failing_attempts = DT[:attempts].select { |a| a[:job_id] == failing_job.job_id }
+assert_equal(1, failing_attempts.size, "Discarded job should only attempt once")
+
+failing_successes = DT[:successes].select { |s| s[:job_id] == failing_job.job_id }
+assert_equal(0, failing_successes.size, "Discarded job should not succeed")
+
+success_successes = DT[:successes].select { |s| s[:job_id] == success_job.job_id }
+assert_equal(1, success_successes.size, "Non-failing job should succeed")

data/spec/integration/active_job/retry/retry_on_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# ActiveJob retry_on re-enqueues failed jobs until they succeed or exhaust attempts
+
+setup_sqs
+setup_active_job
+
+queue_name = DT.queue
+create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '2' })
+
+class RetryOnTestJob < ActiveJob::Base
+  retry_on StandardError, wait: 0, attempts: 3
+
+  def perform
+    DT[:attempts] << { job_id: job_id, attempt: executions + 1, time: Time.now }
+
+    if DT[:attempts].count { |a| a[:job_id] == job_id } < 3
+      raise StandardError, "Simulated failure"
+    end
+
+    DT[:successes] << { job_id: job_id, final_attempt: executions + 1 }
+  end
+end
+
+RetryOnTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+RetryOnTestJob.perform_later
+
+poll_queues_until(timeout: 30) { DT[:successes].size >= 1 }
+
+assert(DT[:attempts].size >= 2, "Expected at least 2 retry attempts, got #{DT[:attempts].size}")
+assert_equal(1, DT[:successes].size)

data/spec/integration/active_job/roundtrip/roundtrip_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Full round-trip ActiveJob integration test
+# Enqueues a job via ActiveJob → sends to ElasticMQ SQS → processes via Shoryuken → verifies execution
+
+setup_sqs
+setup_active_job
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+
+class RoundtripTestJob < ActiveJob::Base
+  def perform(payload)
+    DT[:executions] << {
+      payload: payload,
+      executed_at: Time.now,
+      job_id: job_id
+    }
+  end
+end
+
+RoundtripTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+RoundtripTestJob.perform_later('first_payload')
+RoundtripTestJob.perform_later('second_payload')
+RoundtripTestJob.perform_later({ key: 'complex', data: [1, 2, 3] })
+
+poll_queues_until(timeout: 30) do
+  DT[:executions].size >= 3
+end
+
+assert_equal(3, DT[:executions].size, "Expected 3 job executions, got #{DT[:executions].size}")
+
+payloads = DT[:executions].map { |e| e[:payload] }
+assert_includes(payloads, 'first_payload')
+assert_includes(payloads, 'second_payload')
+
+complex_payload = payloads.find { |p| p.is_a?(Hash) }
+assert(complex_payload, "Expected to find complex payload")
+# Keys may be strings or symbols depending on serialization
+key_value = complex_payload['key'] || complex_payload[:key]
+data_value = complex_payload['data'] || complex_payload[:data]
+assert_equal('complex', key_value)
+assert_equal([1, 2, 3], data_value)
+
+job_ids = DT[:executions].map { |e| e[:job_id] }
+assert(job_ids.all? { |id| id && !id.empty? }, "All jobs should have job IDs")
+assert_equal(3, job_ids.uniq.size, "All job IDs should be unique")