shoryuken 6.2.1 → 7.0.0.alpha2

data/spec/shoryuken/inline_message_spec.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+RSpec.describe Shoryuken::InlineMessage do
+  let(:body) { '{"message": "test"}' }
+  let(:attributes) { { 'SentTimestamp' => '1234567890' } }
+  let(:md5_of_body) { 'abc123def456' }
+  let(:md5_of_message_attributes) { 'def456abc123' }
+  let(:message_attributes) { { 'CustomAttribute' => { string_value: 'value', data_type: 'String' } } }
+  let(:message_id) { 'msg-12345' }
+  let(:receipt_handle) { 'receipt-handle-12345' }
+  let(:delete) { nil }
+  let(:queue_name) { 'test-queue' }
+
+  describe '#new' do
+    context 'with positional arguments' do
+      subject do
+        described_class.new(
+          body: body,
+          attributes: attributes,
+          md5_of_body: md5_of_body,
+          md5_of_message_attributes: md5_of_message_attributes,
+          message_attributes: message_attributes,
+          message_id: message_id,
+          receipt_handle: receipt_handle,
+          delete: delete,
+          queue_name: queue_name
+        )
+      end
+
+      it 'initializes with all attributes' do
+        expect(subject.body).to eq(body)
+        expect(subject.attributes).to eq(attributes)
+        expect(subject.md5_of_body).to eq(md5_of_body)
+        expect(subject.md5_of_message_attributes).to eq(md5_of_message_attributes)
+        expect(subject.message_attributes).to eq(message_attributes)
+        expect(subject.message_id).to eq(message_id)
+        expect(subject.receipt_handle).to eq(receipt_handle)
+        expect(subject.delete).to eq(delete)
+        expect(subject.queue_name).to eq(queue_name)
+      end
+    end
+
+    context 'with keyword arguments' do
+      subject do
+        described_class.new(
+          body: body,
+          attributes: attributes,
+          md5_of_body: md5_of_body,
+          md5_of_message_attributes: md5_of_message_attributes,
+          message_attributes: message_attributes,
+          message_id: message_id,
+          receipt_handle: receipt_handle,
+          delete: delete,
+          queue_name: queue_name
+        )
+      end
+
+      it 'initializes with all attributes' do
+        expect(subject.body).to eq(body)
+        expect(subject.attributes).to eq(attributes)
+        expect(subject.md5_of_body).to eq(md5_of_body)
+        expect(subject.md5_of_message_attributes).to eq(md5_of_message_attributes)
+        expect(subject.message_attributes).to eq(message_attributes)
+        expect(subject.message_id).to eq(message_id)
+        expect(subject.receipt_handle).to eq(receipt_handle)
+        expect(subject.delete).to eq(delete)
+        expect(subject.queue_name).to eq(queue_name)
+      end
+    end
+
+    context 'with nil values' do
+      subject do
+        described_class.new(
+          body: body,
+          attributes: nil,
+          md5_of_body: nil,
+          md5_of_message_attributes: nil,
+          message_attributes: message_attributes,
+          message_id: nil,
+          receipt_handle: nil,
+          delete: nil,
+          queue_name: queue_name
+        )
+      end
+
+      it 'handles nil values correctly' do
+        expect(subject.body).to eq(body)
+        expect(subject.attributes).to be_nil
+        expect(subject.md5_of_body).to be_nil
+        expect(subject.md5_of_message_attributes).to be_nil
+        expect(subject.message_attributes).to eq(message_attributes)
+        expect(subject.message_id).to be_nil
+        expect(subject.receipt_handle).to be_nil
+        expect(subject.delete).to be_nil
+        expect(subject.queue_name).to eq(queue_name)
+      end
+    end
+
+    context 'with minimal required attributes' do
+      subject { described_class.new(body: body, queue_name: queue_name) }
+
+      it 'initializes with only required attributes' do
+        expect(subject.body).to eq(body)
+        expect(subject.queue_name).to eq(queue_name)
+        expect(subject.attributes).to be_nil
+        expect(subject.md5_of_body).to be_nil
+        expect(subject.md5_of_message_attributes).to be_nil
+        expect(subject.message_attributes).to be_nil
+        expect(subject.message_id).to be_nil
+        expect(subject.receipt_handle).to be_nil
+        expect(subject.delete).to be_nil
+      end
+    end
+  end
+
+  describe 'attribute accessors' do
+    subject do
+      described_class.new(
+        body: body,
+        attributes: attributes,
+        md5_of_body: md5_of_body,
+        md5_of_message_attributes: md5_of_message_attributes,
+        message_attributes: message_attributes,
+        message_id: message_id,
+        receipt_handle: receipt_handle,
+        delete: delete,
+        queue_name: queue_name
+      )
+    end
+
+    it 'provides read access to all attributes' do
+      expect(subject.body).to eq(body)
+      expect(subject.attributes).to eq(attributes)
+      expect(subject.md5_of_body).to eq(md5_of_body)
+      expect(subject.md5_of_message_attributes).to eq(md5_of_message_attributes)
+      expect(subject.message_attributes).to eq(message_attributes)
+      expect(subject.message_id).to eq(message_id)
+      expect(subject.receipt_handle).to eq(receipt_handle)
+      expect(subject.delete).to eq(delete)
+      expect(subject.queue_name).to eq(queue_name)
+    end
+
+    it 'provides write access to all attributes' do
+      new_body = '{"updated": "message"}'
+      new_queue_name = 'updated-queue'
+
+      subject.body = new_body
+      subject.queue_name = new_queue_name
+
+      expect(subject.body).to eq(new_body)
+      expect(subject.queue_name).to eq(new_queue_name)
+    end
+  end
+
+  describe 'struct behavior' do
+    subject { described_class.new(body: body, queue_name: queue_name) }
+
+    it 'behaves like a struct' do
+      expect(subject).to be_a(Struct)
+      expect(subject.class.superclass).to eq(Struct)
+    end
+
+    it 'supports array-like access' do
+      expect(subject[0]).to eq(body)  # body is first attribute
+      expect(subject[-1]).to eq(queue_name)  # queue_name is last attribute
+    end
+
+    it 'supports enumeration' do
+      values = subject.to_a
+      expect(values.first).to eq(body)
+      expect(values.last).to eq(queue_name)
+      expect(values.length).to eq(9)  # 9 attributes total
+    end
+
+    it 'supports hash conversion' do
+      hash = subject.to_h
+      expect(hash[:body]).to eq(body)
+      expect(hash[:queue_name]).to eq(queue_name)
+      expect(hash.keys).to contain_exactly(
+        :body, :attributes, :md5_of_body, :md5_of_message_attributes,
+        :message_attributes, :message_id, :receipt_handle, :delete, :queue_name
+      )
+    end
+  end
+
+  describe 'equality' do
+    let(:message1) { described_class.new(body: body, queue_name: queue_name) }
+    let(:message2) { described_class.new(body: body, queue_name: queue_name) }
+    let(:message3) { described_class.new(body: 'different', queue_name: queue_name) }
+
+    it 'compares messages by attribute values' do
+      expect(message1).to eq(message2)
+      expect(message1).not_to eq(message3)
+    end
+  end
+end

data/spec/shoryuken/launcher_spec.rb

@@ -1,5 +1,4 @@
-require 'spec_helper'
-require 'shoryuken/launcher'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Launcher do
   let(:executor) do

data/spec/shoryuken/manager_spec.rb

@@ -1,5 +1,4 @@
-require 'spec_helper'
-require 'shoryuken/manager'
+# frozen_string_literal: true
 
 RSpec::Matchers.define :queue_config_of do |expected|
   match do |actual|

data/spec/shoryuken/middleware/chain_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Middleware::Chain do
   class CustomMiddleware

data/spec/shoryuken/middleware/server/auto_delete_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Shoryuken::Middleware::Server::AutoDelete do
   let(:queue)     { 'default' }

data/spec/shoryuken/middleware/server/auto_extend_visibility_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
   let(:queue) { 'default' }

data/spec/shoryuken/middleware/server/exponential_backoff_retry_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 # rubocop:disable /BlockLength, Metrics/
 RSpec.describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do

data/spec/shoryuken/middleware/server/timing_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Middleware::Server::Timing do
   let(:queue) { 'default' }

data/spec/shoryuken/options_spec.rb

@@ -1,11 +1,11 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Options do
   subject { Shoryuken.shoryuken_options }
 
   describe '.on_stop' do
     specify do
-      on_stop = Proc.new {}
+      on_stop = proc {}
       Shoryuken.on_stop(&on_stop)
 
       expect(Shoryuken.stop_callback).to eq(on_stop)
@@ -14,7 +14,7 @@ RSpec.describe Shoryuken::Options do
 
   describe '.on_start' do
     specify do
-      on_start = Proc.new {}
+      on_start = proc {}
       Shoryuken.on_start(&on_start)
 
       expect(Shoryuken.start_callback).to eq(on_start)
@@ -81,7 +81,7 @@ RSpec.describe Shoryuken::Options do
 
       expect(Shoryuken.sqs_client_receive_message_opts).to eq(
         'default' => { test: 1 },
-        'group1'  => { test: 2 }
+        'group1' => { test: 2 }
       )
     end
   end

data/spec/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