shoryuken 6.2.1 → 7.0.2

data/spec/lib/shoryuken/polling/base_strategy_spec.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+RSpec.describe Shoryuken::Polling::BaseStrategy do
+  # Create a concrete implementation for testing
+  let(:test_strategy_class) do
+    Class.new(described_class) do
+      def initialize(queues, delay = nil)
+        @queues = queues
+        @delay = delay
+      end
+
+      def next_queue
+        @queues.first
+      end
+
+      def messages_found(queue, messages_found)
+        # Test implementation - store the call
+        @last_messages_found = { queue: queue, count: messages_found }
+      end
+
+      def active_queues
+        @queues
+      end
+
+      attr_reader :last_messages_found
+    end
+  end
+
+  let(:strategy) { test_strategy_class.new(['queue1', 'queue2']) }
+
+  describe 'abstract interface' do
+    it 'includes Util module' do
+      expect(described_class.included_modules).to include(Shoryuken::Util)
+    end
+
+    describe '#next_queue' do
+      it 'raises NotImplementedError in base class' do
+        base_strategy = described_class.new
+
+        expect { base_strategy.next_queue }.to raise_error(NotImplementedError)
+      end
+
+      it 'can be implemented by subclasses' do
+        expect(strategy.next_queue).to eq('queue1')
+      end
+    end
+
+    describe '#messages_found' do
+      it 'raises NotImplementedError in base class' do
+        base_strategy = described_class.new
+
+        expect { base_strategy.messages_found('queue', 5) }.to raise_error(NotImplementedError)
+      end
+
+      it 'can be implemented by subclasses' do
+        strategy.messages_found('test_queue', 3)
+
+        expect(strategy.last_messages_found).to eq({ queue: 'test_queue', count: 3 })
+      end
+
+      it 'accepts zero messages found' do
+        strategy.messages_found('empty_queue', 0)
+
+        expect(strategy.last_messages_found).to eq({ queue: 'empty_queue', count: 0 })
+      end
+    end
+
+    describe '#message_processed' do
+      it 'has default empty implementation' do
+        base_strategy = described_class.new
+
+        expect { base_strategy.message_processed('queue') }.not_to raise_error
+      end
+
+      it 'can be overridden by subclasses' do
+        # Default implementation should do nothing
+        expect { strategy.message_processed('queue') }.not_to raise_error
+      end
+    end
+
+    describe '#active_queues' do
+      it 'raises NotImplementedError in base class' do
+        base_strategy = described_class.new
+
+        expect { base_strategy.active_queues }.to raise_error(NotImplementedError)
+      end
+
+      it 'can be implemented by subclasses' do
+        expect(strategy.active_queues).to eq(['queue1', 'queue2'])
+      end
+    end
+  end
+
+  describe '#==' do
+    context 'when comparing with Array' do
+      it 'compares against @queues instance variable' do
+        expect(strategy).to eq(['queue1', 'queue2'])
+      end
+
+      it 'returns false for different arrays' do
+        expect(strategy).not_to eq(['queue3', 'queue4'])
+      end
+
+      it 'returns false for arrays with different order' do
+        expect(strategy).not_to eq(['queue2', 'queue1'])
+      end
+    end
+
+    context 'when comparing with another strategy' do
+      it 'compares active_queues when other responds to active_queues' do
+        other_strategy = test_strategy_class.new(['queue1', 'queue2'])
+
+        expect(strategy).to eq(other_strategy)
+      end
+
+      it 'returns false when active_queues differ' do
+        other_strategy = test_strategy_class.new(['queue3', 'queue4'])
+
+        expect(strategy).not_to eq(other_strategy)
+      end
+
+      it 'handles strategies with different active_queues order' do
+        other_strategy = test_strategy_class.new(['queue2', 'queue1'])
+
+        expect(strategy).not_to eq(other_strategy)
+      end
+    end
+
+    context 'when comparing with objects that do not respond to active_queues' do
+      it 'returns false for strings' do
+        expect(strategy).not_to eq('some_string')
+      end
+
+      it 'returns false for numbers' do
+        expect(strategy).not_to eq(123)
+      end
+
+      it 'returns false for hashes' do
+        expect(strategy).not_to eq({ queues: ['queue1', 'queue2'] })
+      end
+
+      it 'returns false for objects without active_queues method' do
+        plain_object = Object.new
+
+        expect(strategy).not_to eq(plain_object)
+      end
+    end
+
+    context 'when @queues is not set' do
+      let(:strategy_without_queues) { test_strategy_class.new(nil) }
+
+      it 'handles nil @queues when comparing with nil' do
+        # nil is not an Array, so this goes to the else branch
+        # nil doesn't respond to active_queues, so it returns false
+        expect(strategy_without_queues == nil).to be false
+      end
+
+      it 'handles nil @queues when comparing with empty array' do
+        expect(strategy_without_queues == []).to be false
+      end
+    end
+  end
+
+  describe '#delay' do
+    context 'when delay is set on strategy' do
+      let(:strategy_with_delay) { test_strategy_class.new(['queue1'], 5.0) }
+
+      it 'returns the strategy-specific delay' do
+        expect(strategy_with_delay.delay).to eq(5.0)
+      end
+    end
+
+    context 'when delay is not set on strategy' do
+      before do
+        allow(Shoryuken.options).to receive(:[]).with(:delay).and_return(3.5)
+      end
+
+      it 'returns the global Shoryuken delay converted to float' do
+        expect(strategy.delay).to eq(3.5)
+      end
+    end
+
+    context 'when global delay is a string' do
+      before do
+        allow(Shoryuken.options).to receive(:[]).with(:delay).and_return('2.5')
+      end
+
+      it 'converts string delay to float' do
+        expect(strategy.delay).to eq(2.5)
+      end
+    end
+
+    context 'when global delay is an integer' do
+      before do
+        allow(Shoryuken.options).to receive(:[]).with(:delay).and_return(4)
+      end
+
+      it 'converts integer delay to float' do
+        expect(strategy.delay).to eq(4.0)
+      end
+    end
+
+    context 'when delay is explicitly set to nil' do
+      let(:strategy_with_nil_delay) { test_strategy_class.new(['queue1'], nil) }
+
+      before do
+        allow(Shoryuken.options).to receive(:[]).with(:delay).and_return(1.5)
+      end
+
+      it 'falls back to global delay' do
+        expect(strategy_with_nil_delay.delay).to eq(1.5)
+      end
+    end
+  end
+
+  describe 'inheritance patterns' do
+    it 'allows subclasses to call super for implemented methods' do
+      subclass = Class.new(described_class) do
+        def next_queue
+          begin
+            super
+          rescue NotImplementedError
+            'fallback'
+          end
+        end
+
+        def active_queues
+          []
+        end
+
+        def messages_found(queue, count)
+          # Implementation required
+        end
+      end
+
+      instance = subclass.new
+      expect(instance.next_queue).to eq('fallback')
+    end
+
+    it 'supports method chaining in subclasses' do
+      chainable_strategy = Class.new(described_class) do
+        def initialize(queues)
+          @queues = queues
+          @call_chain = []
+        end
+
+        def next_queue
+          @call_chain << :next_queue
+          @queues.first
+        end
+
+        def messages_found(queue, count)
+          @call_chain << :messages_found
+          self
+        end
+
+        def active_queues
+          @call_chain << :active_queues
+          @queues
+        end
+
+        attr_reader :call_chain
+      end
+
+      strategy = chainable_strategy.new(['test'])
+      result = strategy.messages_found('queue', 1)
+
+      expect(result).to be(strategy)
+      expect(strategy.call_chain).to eq([:messages_found])
+    end
+  end
+
+  describe 'utility method access' do
+    it 'provides access to utility methods through Util module' do
+      # Verify that utility methods are available
+      expect(strategy).to respond_to(:unparse_queues)
+      expect(strategy).to respond_to(:logger)
+    end
+  end
+end

data/spec/lib/shoryuken/polling/queue_configuration_spec.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+RSpec.describe Shoryuken::Polling::QueueConfiguration do
+  describe '#initialize' do
+    it 'creates configuration with name and options' do
+      config = described_class.new('test_queue', { priority: :high })
+
+      expect(config.name).to eq('test_queue')
+      expect(config.options).to eq({ priority: :high })
+    end
+
+    it 'creates configuration with empty options' do
+      config = described_class.new('simple_queue', {})
+
+      expect(config.name).to eq('simple_queue')
+      expect(config.options).to eq({})
+    end
+
+    it 'accepts nil options' do
+      config = described_class.new('queue', nil)
+
+      expect(config.name).to eq('queue')
+      expect(config.options).to be_nil
+    end
+  end
+
+  describe '#hash' do
+    it 'returns hash based on queue name' do
+      config1 = described_class.new('queue', {})
+      config2 = described_class.new('queue', { weight: 5 })
+
+      expect(config1.hash).to eq(config2.hash)
+      expect(config1.hash).to eq('queue'.hash)
+    end
+
+    it 'returns different hash for different queue names' do
+      config1 = described_class.new('queue1', {})
+      config2 = described_class.new('queue2', {})
+
+      expect(config1.hash).not_to eq(config2.hash)
+    end
+  end
+
+  describe '#==' do
+    context 'when comparing with another QueueConfiguration' do
+      it 'returns true for same name and options' do
+        config1 = described_class.new('queue', { weight: 5 })
+        config2 = described_class.new('queue', { weight: 5 })
+
+        expect(config1).to eq(config2)
+      end
+
+      it 'returns false for same name but different options' do
+        config1 = described_class.new('queue', { weight: 5 })
+        config2 = described_class.new('queue', { weight: 10 })
+
+        expect(config1).not_to eq(config2)
+      end
+
+      it 'returns false for different names' do
+        config1 = described_class.new('queue1', {})
+        config2 = described_class.new('queue2', {})
+
+        expect(config1).not_to eq(config2)
+      end
+    end
+
+    context 'when comparing with a string' do
+      it 'returns true when options are empty and names match' do
+        config = described_class.new('test_queue', {})
+
+        expect(config).to eq('test_queue')
+      end
+
+      it 'returns false when options are not empty' do
+        config = described_class.new('test_queue', { weight: 5 })
+
+        expect(config).not_to eq('test_queue')
+      end
+
+      it 'returns false when names do not match' do
+        config = described_class.new('queue1', {})
+
+        expect(config).not_to eq('queue2')
+      end
+    end
+
+    context 'when comparing with other objects' do
+      it 'returns false for non-string, non-QueueConfiguration objects' do
+        config = described_class.new('queue', {})
+
+        expect(config).not_to eq(123)
+        expect(config).not_to eq([])
+        expect(config).not_to eq({ name: 'queue' })
+      end
+    end
+  end
+
+  describe '#eql?' do
+    it 'behaves the same as ==' do
+      config1 = described_class.new('queue', {})
+      config2 = described_class.new('queue', {})
+
+      expect(config1.eql?(config2)).to eq(config1 == config2)
+      expect(config1.eql?('queue')).to eq(config1 == 'queue')
+    end
+  end
+
+  describe '#to_s' do
+    context 'when options are empty' do
+      it 'returns just the queue name' do
+        config = described_class.new('simple_queue', {})
+
+        expect(config.to_s).to eq('simple_queue')
+      end
+    end
+
+    context 'when options are present' do
+      it 'returns detailed representation with options' do
+        config = described_class.new('complex_queue', { priority: :high, weight: 5 })
+
+        expect(config.to_s).to include('#<QueueConfiguration complex_queue options={')
+      end
+
+      it 'handles single option' do
+        config = described_class.new('weighted_queue', { weight: 10 })
+
+        expect(config.to_s).to include('#<QueueConfiguration weighted_queue options={')
+      end
+    end
+
+    context 'when options are nil' do
+      it 'returns detailed representation' do
+        config = described_class.new('nil_options_queue', nil)
+
+        expect(config.to_s).to eq('#<QueueConfiguration nil_options_queue options=nil>')
+      end
+    end
+  end
+
+  describe 'struct behavior' do
+    it 'provides attribute accessors' do
+      config = described_class.new('queue', { weight: 5 })
+
+      expect(config.name).to eq('queue')
+      expect(config.options).to eq({ weight: 5 })
+    end
+
+    it 'allows attribute modification' do
+      config = described_class.new('queue', {})
+
+      config.name = 'new_queue'
+      config.options = { priority: :low }
+
+      expect(config.name).to eq('new_queue')
+      expect(config.options).to eq({ priority: :low })
+    end
+
+    it 'supports array-like access' do
+      config = described_class.new('queue', { weight: 5 })
+
+      expect(config[0]).to eq('queue')
+      expect(config[1]).to eq({ weight: 5 })
+    end
+  end
+
+  describe 'usage as hash key' do
+    it 'can be used as hash keys' do
+      config1 = described_class.new('queue', {})
+      config2 = described_class.new('queue', {})  # Same config
+
+      hash = {}
+      hash[config1] = 'value1'
+      hash[config2] = 'value2'
+
+      # Same queue name and options should use same hash key
+      expect(hash[config1]).to eq('value2')
+      expect(hash[config2]).to eq('value2')
+      expect(hash.size).to eq(1)
+    end
+
+    it 'different queue names create different keys' do
+      config1 = described_class.new('queue1', {})
+      config2 = described_class.new('queue2', {})
+
+      hash = {}
+      hash[config1] = 'value1'
+      hash[config2] = 'value2'
+
+      expect(hash[config1]).to eq('value1')
+      expect(hash[config2]).to eq('value2')
+      expect(hash.size).to eq(2)
+    end
+  end
+end

data/spec/{shoryuken → lib/shoryuken}/polling/strict_priority_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Polling::StrictPriority do
   let(:queue1) { 'shoryuken' }

data/spec/{shoryuken → lib/shoryuken}/polling/weighted_round_robin_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Polling::WeightedRoundRobin do
   let(:queue1) { 'shoryuken' }

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

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Processor do
   let(:manager)   { double Shoryuken::Manager }

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

@@ -1,6 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::Queue do
   let(:credentials) { Aws::Credentials.new('access_key_id', 'secret_access_key') }
   let(:sqs) { Aws::SQS::Client.new(stub_responses: true, credentials: credentials) }
@@ -30,7 +29,7 @@ RSpec.describe Shoryuken::Queue do
       let(:queue_url) { "http://localhost:4576/queue/#{queue_name}" }
 
       it 'instantiates by URL and validate the URL' do
-        # See https://github.com/phstc/shoryuken/pull/551
+        # See https://github.com/ruby-shoryuken/shoryuken/pull/551
         expect_any_instance_of(described_class).to receive(:fifo?).and_return(false)
 
         subject = described_class.new(sqs, queue_url)

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

@@ -1,7 +1,5 @@
-require 'spec_helper'
-require 'shoryuken/runner'
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::Runner do
   let(:cli) { Shoryuken::Runner.instance }
 

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

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe 'Shoryuken::Util' do
   subject do
@@ -26,7 +26,7 @@ describe 'Shoryuken::Util' do
       end
 
       let(:message_attributes) do
-        { 'shoryuken_class' => { string_value: ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper.to_s } }
+        { 'shoryuken_class' => { string_value: 'Shoryuken::ActiveJob::JobWrapper' } }
       end
 
       let(:body) do

data/spec/lib/shoryuken/version_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::VERSION do
+  it 'has a version number' do
+    expect(Shoryuken::VERSION).not_to be_nil
+  end
+
+  it 'follows semantic versioning format' do
+    expect(Shoryuken::VERSION).to match(/^\d+\.\d+\.\d+/)
+  end
+
+  it 'is a string' do
+    expect(Shoryuken::VERSION).to be_a(String)
+  end
+end

data/spec/{shoryuken → lib/shoryuken}/worker/default_executor_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Worker::DefaultExecutor do
   let(:sqs_queue) { double 'SQS Queue' }

data/spec/lib/shoryuken/worker/inline_executor_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+RSpec.describe Shoryuken::Worker::InlineExecutor do
+  before do
+    Shoryuken.worker_executor = described_class
+  end
+
+  describe '.perform_async' do
+    specify do
+      expect_any_instance_of(TestWorker).to receive(:perform).with(anything, 'test')
+
+      TestWorker.perform_async('test')
+    end
+
+    it 'properly sets message_attributes' do
+      custom_attributes = {
+        'custom_key' => { string_value: 'custom_value', data_type: 'String' }
+      }
+
+      expect_any_instance_of(TestWorker).to receive(:perform) do |_, sqs_msg, _|
+        expect(sqs_msg.message_attributes).to include('shoryuken_class')
+        expect(sqs_msg.message_attributes).to include('custom_key')
+        expect(sqs_msg.message_attributes['custom_key'][:string_value]).to eq('custom_value')
+      end
+
+      TestWorker.perform_async('test', message_attributes: custom_attributes)
+    end
+  end
+
+  describe '.perform_in' do
+    specify do
+      expect_any_instance_of(TestWorker).to receive(:perform).with(anything, 'test')
+
+      TestWorker.perform_in(60, 'test')
+    end
+
+    it 'properly passes message_attributes to perform_async' do
+      custom_attributes = {
+        'custom_key' => { string_value: 'custom_value', data_type: 'String' }
+      }
+
+      expect_any_instance_of(TestWorker).to receive(:perform) do |_, sqs_msg, _|
+        expect(sqs_msg.message_attributes).to include('shoryuken_class')
+        expect(sqs_msg.message_attributes).to include('custom_key')
+        expect(sqs_msg.message_attributes['custom_key'][:string_value]).to eq('custom_value')
+      end
+
+      TestWorker.perform_in(60, 'test', message_attributes: custom_attributes)
+    end
+  end
+
+  context 'batch' do
+    before do
+      TestWorker.get_shoryuken_options['batch'] = true
+    end
+
+    after do
+      TestWorker.get_shoryuken_options['batch'] = false
+    end
+
+    describe '.perform_async' do
+      specify do
+        expect_any_instance_of(TestWorker).to receive(:perform).with(anything, ['test'])
+
+        TestWorker.perform_async('test')
+      end
+
+      it 'properly passes message_attributes with batch' do
+        custom_attributes = {
+          'custom_key' => { string_value: 'custom_value', data_type: 'String' }
+        }
+
+        expect_any_instance_of(TestWorker).to receive(:perform) do |_, sqs_msgs, _|
+          expect(sqs_msgs.first.message_attributes).to include('shoryuken_class')
+          expect(sqs_msgs.first.message_attributes).to include('custom_key')
+          expect(sqs_msgs.first.message_attributes['custom_key'][:string_value]).to eq('custom_value')
+        end
+
+        TestWorker.perform_async('test', message_attributes: custom_attributes)
+      end
+    end
+
+    describe '.perform_in' do
+      specify do
+        expect_any_instance_of(TestWorker).to receive(:perform).with(anything, ['test'])
+
+        TestWorker.perform_in(60, 'test')
+      end
+
+      it 'properly passes message_attributes with batch' do
+        custom_attributes = {
+          'custom_key' => { string_value: 'custom_value', data_type: 'String' }
+        }
+
+        expect_any_instance_of(TestWorker).to receive(:perform) do |_, sqs_msgs, _|
+          expect(sqs_msgs.first.message_attributes).to include('shoryuken_class')
+          expect(sqs_msgs.first.message_attributes).to include('custom_key')
+          expect(sqs_msgs.first.message_attributes['custom_key'][:string_value]).to eq('custom_value')
+        end
+
+        TestWorker.perform_in(60, 'test', message_attributes: custom_attributes)
+      end
+    end
+  end
+end