shoryuken 7.0.0.alpha2 → 7.0.0

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_localstack
+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_localstack
+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_localstack
+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_localstack
+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/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_localstack
+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_localstack
+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 LocalStack SQS → processes via Shoryuken → verifies execution
+
+setup_localstack
+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")

data/spec/integration/active_job/scheduled/scheduled_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Scheduled ActiveJob integration test
+# Tests jobs scheduled with set(wait:) are delivered after the delay
+
+setup_localstack
+setup_active_job
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+
+class ScheduledTestJob < ActiveJob::Base
+  def perform(label)
+    DT[:executions] << {
+      label: label,
+      job_id: job_id,
+      executed_at: Time.now
+    }
+  end
+end
+
+ScheduledTestJob.queue_as(queue_name)
+
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+Shoryuken.register_worker(queue_name, Shoryuken::ActiveJob::JobWrapper)
+
+immediate_enqueue_time = Time.now
+ScheduledTestJob.perform_later('immediate')
+DT[:timestamps] << { label: 'immediate', time: immediate_enqueue_time }
+
+delayed_enqueue_time = Time.now
+ScheduledTestJob.set(wait: 3.seconds).perform_later('delayed_3s')
+DT[:timestamps] << { label: 'delayed_3s', time: delayed_enqueue_time }
+
+delayed_5s_enqueue_time = Time.now
+ScheduledTestJob.set(wait: 5.seconds).perform_later('delayed_5s')
+DT[:timestamps] << { label: 'delayed_5s', time: delayed_5s_enqueue_time }
+
+poll_queues_until(timeout: 30) do
+  DT[:executions].size >= 3
+end
+
+assert_equal(3, DT[:executions].size, "Expected 3 job executions")
+
+# Find each job's execution
+immediate_job = DT[:executions].find { |e| e[:label] == 'immediate' }
+delayed_3s_job = DT[:executions].find { |e| e[:label] == 'delayed_3s' }
+delayed_5s_job = DT[:executions].find { |e| e[:label] == 'delayed_5s' }
+
+assert(immediate_job, "Immediate job should have executed")
+assert(delayed_3s_job, "3s delayed job should have executed")
+assert(delayed_5s_job, "5s delayed job should have executed")
+
+def enqueue_time(label)
+  DT[:timestamps].find { |t| t[:label] == label }[:time]
+end
+
+immediate_delay = immediate_job[:executed_at] - enqueue_time('immediate')
+assert(immediate_delay < 10, "Immediate job should execute within 10 seconds, took #{immediate_delay}s")
+
+# Using 2 seconds tolerance for SQS delivery variation
+delayed_3s_actual_delay = delayed_3s_job[:executed_at] - enqueue_time('delayed_3s')
+assert(delayed_3s_actual_delay >= 2, "3s delayed job should execute after at least 2s, took #{delayed_3s_actual_delay}s")
+
+delayed_5s_actual_delay = delayed_5s_job[:executed_at] - enqueue_time('delayed_5s')
+assert(delayed_5s_actual_delay >= 4, "5s delayed job should execute after at least 4s, took #{delayed_5s_actual_delay}s")
+
+assert(
+  immediate_job[:executed_at] <= delayed_3s_job[:executed_at],
+  "Immediate job should execute before 3s delayed job"
+)
+assert(
+  delayed_3s_job[:executed_at] <= delayed_5s_job[:executed_at],
+  "3s delayed job should execute before 5s delayed job"
+)

data/spec/integration/active_record_middleware/active_record_middleware_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# This spec tests the ActiveRecord middleware functionality.
+# The middleware clears database connections after each message is processed.
+
+setup_localstack
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+# Mock ActiveRecord module to track connection clearing
+module ActiveRecord
+  VERSION = Gem::Version.new('7.2.0')
+
+  def self.version
+    VERSION
+  end
+
+  class Base
+    class << self
+      attr_accessor :connections_cleared
+
+      def connection_handler
+        @connection_handler ||= ConnectionHandler.new
+      end
+    end
+
+    self.connections_cleared = []
+  end
+
+  class ConnectionHandler
+    def clear_active_connections!(scope)
+      ActiveRecord::Base.connections_cleared << { scope: scope, time: Time.now }
+    end
+  end
+end
+
+# Add the ActiveRecord middleware to the chain
+require 'shoryuken/middleware/server/active_record'
+Shoryuken.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Shoryuken::Middleware::Server::ActiveRecord
+  end
+end
+
+worker_class = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: true, batch: false
+
+  def perform(sqs_msg, body)
+    DT[:processed] << { message_id: sqs_msg.message_id, body: body }
+  end
+end
+
+worker_class.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, worker_class)
+
+# Clear any prior connection clearing records
+ActiveRecord::Base.connections_cleared.clear
+
+# Send multiple messages
+3.times { |i| Shoryuken::Client.queues(queue_name).send_message(message_body: "ar-test-#{i}") }
+
+sleep 1
+
+poll_queues_until { DT[:processed].size >= 3 }
+
+# Verify all messages were processed
+assert_equal(3, DT[:processed].size)
+
+# Verify ActiveRecord connections were cleared after each message
+# The middleware should have called clear_active_connections! for each message
+assert(
+  ActiveRecord::Base.connections_cleared.size >= 3,
+  "ActiveRecord connections should be cleared after each message (cleared #{ActiveRecord::Base.connections_cleared.size} times)"
+)
+
+# Verify the :all scope was used (Rails 7.1+ behavior)
+ActiveRecord::Base.connections_cleared.each do |record|
+  assert_equal(:all, record[:scope], 'Should use :all scope for Rails 7.1+')
+end

data/spec/integration/auto_delete/auto_delete_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# This spec tests the auto_delete middleware functionality.
+# When auto_delete: true, messages should be automatically deleted after successful processing.
+
+setup_localstack
+
+queue_name = DT.queue
+create_test_queue(queue_name)
+Shoryuken.add_group('default', 1)
+Shoryuken.add_queue(queue_name, 1, 'default')
+
+auto_delete_worker = Class.new do
+  include Shoryuken::Worker
+
+  shoryuken_options auto_delete: true
+
+  def perform(sqs_msg, body)
+    DT[:auto_delete_processed] << { message_id: sqs_msg.message_id, body: body }
+  end
+end
+
+auto_delete_worker.get_shoryuken_options['queue'] = queue_name
+Shoryuken.register_worker(queue_name, auto_delete_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: 'auto delete test'
+)
+
+sleep 1
+
+# Process the message
+poll_queues_until { DT[:auto_delete_processed].size >= 1 }
+
+assert_equal(1, DT[:auto_delete_processed].size)
+assert_equal('auto delete test', DT[:auto_delete_processed].first[:body])
+
+# 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 should be deleted when auto_delete: true")