shoryuken 7.0.0.alpha2 → 7.0.0

data/spec/integrations_helper.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+# Integration test helper for process-isolated testing
+
+# Enable Ruby warnings to catch deprecations and potential issues
+Warning[:performance] = true if RUBY_VERSION >= '3.3'
+Warning[:deprecated] = true
+$VERBOSE = true
+
+require 'warning'
+
+# Process warnings and raise on unexpected ones from our code
+Warning.process do |warning|
+  # Only check warnings from our code (not dependencies)
+  next unless warning.include?(Dir.pwd)
+
+  # Filter out warnings we don't care about in specs
+  next if warning.include?('_spec')
+
+  # We redefine methods to simulate various scenarios in tests
+  next if warning.include?('previous definition of')
+  next if warning.include?('method redefined')
+
+  # Ignore vendor directory
+  next if warning.include?('vendor/')
+
+  # Ignore bundle path
+  next if warning.include?('bundle/')
+
+  raise "Warning in your code: #{warning}"
+end
+
+require 'timeout'
+require 'json'
+require 'securerandom'
+require 'aws-sdk-sqs'
+require 'shoryuken'
+require 'singleton'
+
+# Thread-safe data collector for integration tests
+# Inspired by Karafka's DataCollector pattern
+# Usage: DT[:key] << value, DT[:key].size, DT.clear
+class DataCollector
+  include Singleton
+
+  MUTEX = Mutex.new
+  private_constant :MUTEX
+
+  attr_reader :queues, :data
+
+  class << self
+    def queue
+      instance.queue
+    end
+
+    def queues
+      instance.queues
+    end
+
+    def data
+      instance.data
+    end
+
+    def [](key)
+      MUTEX.synchronize { data[key] }
+    end
+
+    def []=(key, value)
+      MUTEX.synchronize { data[key] = value }
+    end
+
+    def uuids(amount)
+      Array.new(amount) { uuid }
+    end
+
+    def uuid
+      "it-#{SecureRandom.uuid[0, 8]}"
+    end
+
+    def clear
+      MUTEX.synchronize { instance.clear }
+    end
+
+    def key?(key)
+      instance.data.key?(key)
+    end
+  end
+
+  def initialize
+    @mutex = Mutex.new
+    @queues = Array.new(100) { "it-#{SecureRandom.hex(6)}" }
+    @data = Hash.new do |hash, key|
+      @mutex.synchronize do
+        break hash[key] if hash.key?(key)
+
+        hash[key] = []
+      end
+    end
+  end
+
+  def queue
+    queues.first
+  end
+
+  def clear
+    @mutex.synchronize do
+      @queues.clear
+      @queues.concat(Array.new(100) { "it-#{SecureRandom.hex(6)}" })
+      @data.clear
+    end
+  end
+end
+
+# Short alias for DataCollector
+DT = DataCollector
+
+module IntegrationsHelper
+  class TestFailure < StandardError; end
+
+  # Assertions
+  def assert(condition, message = "Assertion failed")
+    raise TestFailure, message unless condition
+  end
+
+  def assert_equal(expected, actual, message = nil)
+    message ||= "Expected #{expected.inspect}, got #{actual.inspect}"
+    assert(expected == actual, message)
+  end
+
+  def assert_includes(collection, item, message = nil)
+    message ||= "Expected #{collection.inspect} to include #{item.inspect}"
+    assert(collection.include?(item), message)
+  end
+
+  def refute(condition, message = "Refutation failed")
+    assert(!condition, message)
+  end
+
+  # Configure ActiveJob with Shoryuken adapter
+  def setup_active_job
+    require 'active_job'
+    require 'active_job/queue_adapters/shoryuken_adapter'
+    require 'active_job/extensions'
+
+    ActiveJob::Base.queue_adapter = :shoryuken
+  end
+
+  # Configure Shoryuken to use LocalStack for real SQS integration tests
+  def setup_localstack
+    Aws.config[:stub_responses] = false
+
+    sqs_client = Aws::SQS::Client.new(
+      region: 'us-east-1',
+      endpoint: 'http://localhost:4566',
+      access_key_id: 'fake',
+      secret_access_key: 'fake'
+    )
+
+    Shoryuken.options[:concurrency] = 25
+    Shoryuken.options[:delay] = 0
+    Shoryuken.options[:timeout] = 8
+
+    executor = Concurrent::CachedThreadPool.new(auto_terminate: true)
+    Shoryuken.define_singleton_method(:launcher_executor) { executor }
+
+    Shoryuken.configure_client { |config| config.sqs_client = sqs_client }
+    Shoryuken.configure_server { |config| config.sqs_client = sqs_client }
+  end
+
+  # Queue helpers
+  def create_test_queue(queue_name, attributes: {})
+    Shoryuken::Client.sqs.create_queue(queue_name: queue_name, attributes: attributes)
+  end
+
+  def delete_test_queue(queue_name)
+    queue_url = Shoryuken::Client.sqs.get_queue_url(queue_name: queue_name).queue_url
+    Shoryuken::Client.sqs.delete_queue(queue_url: queue_url)
+  rescue Aws::SQS::Errors::NonExistentQueue
+  end
+
+  def create_fifo_queue(queue_name)
+    create_test_queue(queue_name, attributes: {
+      'FifoQueue' => 'true',
+      'ContentBasedDeduplication' => 'true'
+    })
+  end
+
+  # Poll until condition met
+  def poll_queues_until(timeout: 15)
+    launcher = Shoryuken::Launcher.new
+    launcher.start
+    Timeout.timeout(timeout) { sleep 0.5 until yield }
+  ensure
+    launcher.stop
+  end
+
+  # Simple mock object
+  def double(_name = nil)
+    Object.new
+  end
+
+  # Job capture for ActiveJob tests
+  class JobCapture
+    attr_reader :jobs
+
+    def initialize
+      @jobs = []
+    end
+
+    def start_capturing
+      @jobs.clear
+      capture = self
+
+      queue_mock = Object.new
+      queue_mock.define_singleton_method(:fifo?) { false }
+      queue_mock.define_singleton_method(:send_message) do |params|
+        capture.jobs << {
+          queue: params[:queue_name] || :default,
+          message_body: params[:message_body],
+          delay_seconds: params[:delay_seconds],
+          message_attributes: params[:message_attributes]
+        }
+      end
+
+      Shoryuken::Client.define_singleton_method(:queues) do |queue_name = nil|
+        queue_mock.define_singleton_method(:name) { queue_name } if queue_name
+        queue_name ? queue_mock : { default: queue_mock }
+      end
+
+      Shoryuken.define_singleton_method(:register_worker) { |*| nil }
+    end
+
+    def last_job
+      @jobs.last
+    end
+
+    def job_count
+      @jobs.size
+    end
+  end
+end
+
+include IntegrationsHelper

data/spec/lib/active_job/extensions_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Skip this spec if ActiveSupport is not available, as the extensions require it
+if defined?(ActiveSupport)
+  require 'active_job/extensions'
+
+  RSpec.describe Shoryuken::ActiveJob do
+    describe Shoryuken::ActiveJob::SQSSendMessageParametersAccessor do
+      let(:job_class) do
+        Class.new do
+          include Shoryuken::ActiveJob::SQSSendMessageParametersAccessor
+        end
+      end
+
+      let(:job_instance) { job_class.new }
+
+      describe 'included behavior' do
+        it 'adds sqs_send_message_parameters accessor' do
+          expect(job_instance).to respond_to(:sqs_send_message_parameters)
+          expect(job_instance).to respond_to(:sqs_send_message_parameters=)
+        end
+
+        it 'allows setting and getting sqs_send_message_parameters' do
+          params = { message_group_id: 'group1', message_deduplication_id: 'dedup1' }
+          job_instance.sqs_send_message_parameters = params
+          expect(job_instance.sqs_send_message_parameters).to eq(params)
+        end
+      end
+    end
+
+    describe Shoryuken::ActiveJob::SQSSendMessageParametersSupport do
+      let(:base_class) do
+        Class.new do
+          attr_accessor :sqs_send_message_parameters
+
+          def initialize(*arguments)
+            # Mock ActiveJob::Base initialization
+          end
+
+          def enqueue(options = {})
+            # Mock ActiveJob::Base enqueue method that returns remaining options
+            options
+          end
+        end
+      end
+
+      let(:job_class) do
+        Class.new(base_class) do
+          prepend Shoryuken::ActiveJob::SQSSendMessageParametersSupport
+        end
+      end
+
+      describe '#initialize' do
+        it 'initializes sqs_send_message_parameters to empty hash' do
+          job = job_class.new('arg1', 'arg2')
+          expect(job.sqs_send_message_parameters).to eq({})
+        end
+
+        it 'calls super with the provided arguments' do
+          expect_any_instance_of(base_class).to receive(:initialize).with('arg1', 'arg2')
+          job_class.new('arg1', 'arg2')
+        end
+
+        it 'handles ruby2_keywords compatibility' do
+          # Test that ruby2_keywords is called if available
+          if respond_to?(:ruby2_keywords, true)
+            expect(job_class.method(:new)).to respond_to(:ruby2_keywords) if RUBY_VERSION >= '2.7'
+          end
+        end
+      end
+
+      describe '#enqueue' do
+        let(:job_instance) { job_class.new }
+
+        it 'extracts SQS-specific options and merges them into sqs_send_message_parameters' do
+          options = {
+            wait: 5 * 60, # 5 minutes in seconds
+            message_attributes: { 'type' => 'important' },
+            message_system_attributes: { 'source' => 'api' },
+            message_deduplication_id: 'dedup123',
+            message_group_id: 'group456',
+            other_option: 'value'
+          }
+
+          remaining_options = job_instance.enqueue(options)
+
+          expect(job_instance.sqs_send_message_parameters).to eq({
+            message_attributes: { 'type' => 'important' },
+            message_system_attributes: { 'source' => 'api' },
+            message_deduplication_id: 'dedup123',
+            message_group_id: 'group456'
+          })
+
+          expect(remaining_options).to eq({
+            wait: 300,
+            other_option: 'value'
+          })
+        end
+
+        it 'handles empty options gracefully' do
+          remaining_options = job_instance.enqueue({})
+          expect(job_instance.sqs_send_message_parameters).to eq({})
+          expect(remaining_options).to eq({})
+        end
+
+        it 'merges new SQS options with existing ones' do
+          job_instance.sqs_send_message_parameters = { message_group_id: 'existing_group' }
+
+          options = { message_deduplication_id: 'new_dedup' }
+          job_instance.enqueue(options)
+
+          expect(job_instance.sqs_send_message_parameters).to eq({
+            message_group_id: 'existing_group',
+            message_deduplication_id: 'new_dedup'
+          })
+        end
+
+        it 'overwrites existing SQS options when the same key is provided' do
+          job_instance.sqs_send_message_parameters = { message_group_id: 'old_group' }
+
+          options = { message_group_id: 'new_group' }
+          job_instance.enqueue(options)
+
+          expect(job_instance.sqs_send_message_parameters).to eq({
+            message_group_id: 'new_group'
+          })
+        end
+      end
+    end
+
+    describe 'module constants' do
+      it 'defines SQSSendMessageParametersAccessor' do
+        expect(Shoryuken::ActiveJob::SQSSendMessageParametersAccessor).to be_a(Module)
+      end
+
+      it 'defines SQSSendMessageParametersSupport' do
+        expect(Shoryuken::ActiveJob::SQSSendMessageParametersSupport).to be_a(Module)
+      end
+    end
+  end
+else
+  RSpec.describe 'Shoryuken::ActiveJob (skipped - ActiveSupport not available)' do
+    it 'skips tests when ActiveSupport is not available' do
+      skip('ActiveSupport not available in test environment')
+    end
+  end
+end

data/spec/lib/active_job/queue_adapters/shoryuken_adapter_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'shared_examples_for_active_job'
+require 'active_job/queue_adapters/shoryuken_adapter'
+require 'active_support/core_ext/numeric/time'
+
+RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter do
+  include_examples 'active_job_adapters'
+
+  describe '#enqueue_after_transaction_commit?' do
+    it 'returns true to support Rails 7.2+ transaction commit behavior' do
+      adapter = described_class.new
+      expect(adapter.enqueue_after_transaction_commit?).to eq(true)
+    end
+  end
+
+  describe '.instance' do
+    it 'returns the same instance (singleton pattern)' do
+      instance1 = described_class.instance
+      instance2 = described_class.instance
+      expect(instance1).to be(instance2)
+    end
+
+    it 'returns a ShoryukenAdapter instance' do
+      expect(described_class.instance).to be_a(described_class)
+    end
+  end
+
+end

data/spec/{shoryuken/extensions/active_job_concurrent_send_adapter_spec.rb → lib/active_job/queue_adapters/shoryuken_concurrent_send_adapter_spec.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require 'shared_examples_for_active_job'
-require 'shoryuken/extensions/active_job_adapter'
-require 'shoryuken/extensions/active_job_concurrent_send_adapter'
+require 'active_job/queue_adapters/shoryuken_adapter'
+require 'active_job/queue_adapters/shoryuken_concurrent_send_adapter'
 
 RSpec.describe ActiveJob::QueueAdapters::ShoryukenConcurrentSendAdapter do
   include_examples 'active_job_adapters'
@@ -37,4 +37,4 @@ RSpec.describe ActiveJob::QueueAdapters::ShoryukenConcurrentSendAdapter do
       subject.enqueue(job, options)
     end
   end
-end
+end

data/spec/{shoryuken/extensions/active_job_wrapper_spec.rb → lib/shoryuken/active_job/job_wrapper_spec.rb}

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require 'active_job'
-require 'shoryuken/extensions/active_job_extensions'
-require 'shoryuken/extensions/active_job_adapter'
+require 'active_job/extensions'
+require 'active_job/queue_adapters/shoryuken_adapter'
 
-RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper do
+RSpec.describe Shoryuken::ActiveJob::JobWrapper do
   subject { described_class.new }
 
   describe '#perform' do
@@ -18,4 +18,4 @@ RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper do
       subject.perform sqs_msg, job_hash
     end
   end
-end
+end

data/spec/{shoryuken → lib/shoryuken}/environment_loader_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
     context "when given queues don't exist" do
       specify do
         expect { subject.load }.to raise_error(
-          ArgumentError,
+          Shoryuken::Errors::QueueNotFoundError,
           <<-MSG.gsub(/^\s+/, '')
             The specified queue(s) stubbed_queue do not exist.
             Try 'shoryuken sqs create QUEUE-NAME' for creating a queue with default settings.

data/spec/{shoryuken → lib/shoryuken}/helpers/hash_utils_spec.rb

@@ -7,21 +7,21 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
     it 'converts string keys to symbols' do
       input = { 'key1' => 'value1', 'key2' => 'value2' }
       expected = { key1: 'value1', key2: 'value2' }
-      
+
       expect(described_class.deep_symbolize_keys(input)).to eq(expected)
     end
 
     it 'leaves symbol keys unchanged' do
       input = { key1: 'value1', key2: 'value2' }
       expected = { key1: 'value1', key2: 'value2' }
-      
+
       expect(described_class.deep_symbolize_keys(input)).to eq(expected)
     end
 
     it 'handles mixed key types' do
       input = { 'string_key' => 'value1', :symbol_key => 'value2' }
       expected = { string_key: 'value1', symbol_key: 'value2' }
-      
+
       expect(described_class.deep_symbolize_keys(input)).to eq(expected)
     end
 
@@ -35,7 +35,7 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
         },
         'top_level' => 'value'
       }
-      
+
       expected = {
         level1: {
           level2: {
@@ -45,7 +45,7 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
         },
         top_level: 'value'
       }
-      
+
       expect(described_class.deep_symbolize_keys(input)).to eq(expected)
     end
 
@@ -58,7 +58,7 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
           'metadata' => nil
         }
       }
-      
+
       expected = {
         config: {
           timeout: 30,
@@ -67,7 +67,7 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
           metadata: nil
         }
       }
-      
+
       expect(described_class.deep_symbolize_keys(input)).to eq(expected)
     end
 
@@ -78,7 +78,7 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
     it 'handles hash with empty nested hash' do
       input = { 'key' => {} }
       expected = { key: {} }
-      
+
       expect(described_class.deep_symbolize_keys(input)).to eq(expected)
     end
 
@@ -94,10 +94,10 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
       # Create a key that will raise an exception when converted to symbol
       problematic_key = Object.new
       allow(problematic_key).to receive(:to_sym).and_raise(StandardError)
-      
+
       input = { problematic_key => 'value', 'normal_key' => 'normal_value' }
       result = described_class.deep_symbolize_keys(input)
-      
+
       # The problematic key should remain as-is, normal key should be symbolized
       expect(result[problematic_key]).to eq('value')
       expect(result[:normal_key]).to eq('normal_value')
@@ -106,9 +106,9 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
     it 'does not modify the original hash' do
       input = { 'key' => { 'nested' => 'value' } }
       original_input = input.dup
-      
+
       described_class.deep_symbolize_keys(input)
-      
+
       expect(input).to eq(original_input)
     end
 
@@ -125,7 +125,7 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
             'mailers' => { 'concurrency' => 2 }
           }
         }
-        
+
         expected = {
           database: {
             host: 'localhost',
@@ -137,7 +137,7 @@ RSpec.describe Shoryuken::Helpers::HashUtils do
             mailers: { concurrency: 2 }
           }
         }
-        
+
         expect(described_class.deep_symbolize_keys(input)).to eq(expected)
       end
     end

data/spec/{shoryuken → lib/shoryuken}/helpers/string_utils_spec.rb

@@ -74,7 +74,7 @@ RSpec.describe Shoryuken::Helpers::StringUtils do
         unless Object.const_defined?('MyApp')
           Object.const_set('MyApp', Module.new)
         end
-        
+
         unless MyApp.const_defined?('EmailWorker')
           MyApp.const_set('EmailWorker', Class.new)
         end
@@ -107,9 +107,9 @@ RSpec.describe Shoryuken::Helpers::StringUtils do
       it 'handles single character constant names' do
         # Define a single character constant for testing
         Object.const_set('A', Class.new) unless Object.const_defined?('A')
-        
+
         expect(described_class.constantize('A')).to eq(A)
-        
+
         # Clean up
         Object.send(:remove_const, 'A') if Object.const_defined?('A')
       end