shoryuken 6.2.1 → 7.0.2

data/spec/integration/non_retryable_exception/non_retryable_exception_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# This spec tests the non_retryable_exception middleware functionality.
+# When non_retryable_exceptions is configured, messages that raise those exceptions
+# should be deleted immediately instead of being retried.
+
+require 'timeout'
+
+setup_sqs
+
+# Reset DT state to prevent data leakage from previous tests
+DT.clear
+
+queue_name = DT.queue
+create_test_queue(queue_name, attributes: { 'VisibilityTimeout' => '2' })
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+# Define custom exception classes for testing
+InvalidInputError = Class.new(StandardError)
+RecordNotFoundError = Class.new(StandardError)
+RetryableError = Class.new(StandardError)
+
+# Worker that handles non-retryable exceptions
+non_retryable_worker = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: false,
+                    batch: false,
+                    non_retryable_exceptions: [InvalidInputError, RecordNotFoundError]
+
+  def perform(sqs_msg, body)
+    receive_count = sqs_msg.attributes['ApproximateReceiveCount'].to_i
+    DT[:attempts] << { receive_count: receive_count, body: body }
+
+    case body
+    when 'non_retryable_invalid'
+      raise InvalidInputError, 'Invalid input data'
+    when 'non_retryable_not_found'
+      raise RecordNotFoundError, 'Record not found'
+    when 'retryable_error'
+      # Fail on first attempt, succeed on retry
+      if receive_count < 2
+        raise RetryableError, 'Temporary failure'
+      end
+      DT[:successful_processing] << { body: body, final_receive_count: receive_count }
+      sqs_msg.delete
+    when 'success'
+      DT[:successful_processing] << { body: body, final_receive_count: receive_count }
+      sqs_msg.delete
+    end
+  end
+end
+
+non_retryable_worker.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, non_retryable_worker)
+
+queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+
+# Start launcher once for all tests
+launcher = Shoryuken::Launcher.new
+launcher.start
+
+begin
+  # Test 1: Non-retryable exception (InvalidInputError) should be deleted immediately
+  Shoryuken::Client.sqs.send_message(
+    queue_url: queue_url,
+    message_body: 'non_retryable_invalid'
+  )
+
+  # Wait for processing attempt
+  Timeout.timeout(10) { sleep 0.5 until DT[:attempts].size >= 1 }
+
+  # Verify it was only attempted once (not retried)
+  invalid_attempts = DT[:attempts].select { |a| a[:body] == 'non_retryable_invalid' }
+  assert_equal(1, invalid_attempts.size, 'Non-retryable exception should only be attempted once')
+  assert_equal(1, invalid_attempts.first[:receive_count], 'Should be first attempt')
+
+  # Wait a moment for deletion to complete
+  sleep 2
+
+  # Verify message was deleted - queue should be empty
+  attributes = Shoryuken::Client.sqs.get_queue_attributes(
+    queue_url: queue_url,
+    attribute_names: ['ApproximateNumberOfMessages', 'ApproximateNumberOfMessagesNotVisible']
+  ).attributes
+
+  total_messages = attributes['ApproximateNumberOfMessages'].to_i +
+                   attributes['ApproximateNumberOfMessagesNotVisible'].to_i
+  assert_equal(0, total_messages, 'Message with non-retryable exception should be deleted immediately')
+
+  # Test 2: Another non-retryable exception (RecordNotFoundError) should also be deleted immediately
+  Shoryuken::Client.sqs.send_message(
+    queue_url: queue_url,
+    message_body: 'non_retryable_not_found'
+  )
+
+  # Wait for processing attempt
+  Timeout.timeout(10) { sleep 0.5 until DT[:attempts].size >= 2 }
+
+  # Verify it was only attempted once
+  not_found_attempts = DT[:attempts].select { |a| a[:body] == 'non_retryable_not_found' }
+  assert_equal(1, not_found_attempts.size, 'Non-retryable exception should only be attempted once')
+
+  # Wait for deletion
+  sleep 2
+
+  # Verify queue is empty again
+  attributes = Shoryuken::Client.sqs.get_queue_attributes(
+    queue_url: queue_url,
+    attribute_names: ['ApproximateNumberOfMessages', 'ApproximateNumberOfMessagesNotVisible']
+  ).attributes
+
+  total_messages = attributes['ApproximateNumberOfMessages'].to_i +
+                   attributes['ApproximateNumberOfMessagesNotVisible'].to_i
+  assert_equal(0, total_messages, 'Message with non-retryable exception should be deleted immediately')
+
+  # Test 3: Retryable exception (not in non_retryable_exceptions list) should still retry
+  Shoryuken::Client.sqs.send_message(
+    queue_url: queue_url,
+    message_body: 'retryable_error'
+  )
+
+  # Wait for successful processing (after retry)
+  Timeout.timeout(15) { sleep 0.5 until DT[:successful_processing].size >= 1 }
+
+  # Verify it was retried
+  retryable_attempts = DT[:attempts].select { |a| a[:body] == 'retryable_error' }
+  assert(retryable_attempts.size >= 2, 'Retryable exception should be retried')
+  assert_equal(1, DT[:successful_processing].size, 'Message should eventually succeed after retry')
+  assert_equal('retryable_error', DT[:successful_processing].first[:body])
+
+  # Test 4: Successful message should process normally
+  Shoryuken::Client.sqs.send_message(
+    queue_url: queue_url,
+    message_body: 'success'
+  )
+
+  # Wait for successful processing
+  Timeout.timeout(10) { sleep 0.5 until DT[:successful_processing].size >= 2 }
+
+  # Verify successful processing
+  success_attempts = DT[:attempts].select { |a| a[:body] == 'success' }
+  assert_equal(1, success_attempts.size, 'Successful message should only be attempted once')
+  assert_equal(2, DT[:successful_processing].size, 'Both successful messages should be processed')
+ensure
+  launcher.stop
+end
+

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_sqs
+
+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_sqs
+
+# 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'

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# ActiveJob adapter integration tests for Rails 8.1
+
+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'])