shoryuken 7.0.0.alpha2 → 7.0.0

data/spec/lib/shoryuken/message_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Message do
+  let(:client) { instance_double('Aws::SQS::Client') }
+  let(:queue) { instance_double('Shoryuken::Queue', name: 'test-queue', url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue') }
+  let(:data) do
+    instance_double('Aws::SQS::Types::Message',
+                    message_id: 'msg-123',
+                    receipt_handle: 'handle-456',
+                    md5_of_body: 'abcd1234',
+                    body: '{"test": "data"}',
+                    attributes: { 'ApproximateReceiveCount' => '1' },
+                    md5_of_message_attributes: 'efgh5678',
+                    message_attributes: { 'type' => 'test' })
+  end
+
+  subject { described_class.new(client, queue, data) }
+
+  describe '#initialize' do
+    it 'sets client, queue_url, queue_name, and data' do
+      expect(subject.client).to eq(client)
+      expect(subject.queue_url).to eq('https://sqs.us-east-1.amazonaws.com/123456789/test-queue')
+      expect(subject.queue_name).to eq('test-queue')
+      expect(subject.data).to eq(data)
+    end
+  end
+
+  describe 'delegated methods' do
+    it 'delegates message_id to data' do
+      expect(subject.message_id).to eq('msg-123')
+    end
+
+    it 'delegates receipt_handle to data' do
+      expect(subject.receipt_handle).to eq('handle-456')
+    end
+
+    it 'delegates md5_of_body to data' do
+      expect(subject.md5_of_body).to eq('abcd1234')
+    end
+
+    it 'delegates body to data' do
+      expect(subject.body).to eq('{"test": "data"}')
+    end
+
+    it 'delegates attributes to data' do
+      expect(subject.attributes).to eq({ 'ApproximateReceiveCount' => '1' })
+    end
+
+    it 'delegates md5_of_message_attributes to data' do
+      expect(subject.md5_of_message_attributes).to eq('efgh5678')
+    end
+
+    it 'delegates message_attributes to data' do
+      expect(subject.message_attributes).to eq({ 'type' => 'test' })
+    end
+  end
+
+  describe '#delete' do
+    it 'calls delete_message on the client with correct parameters' do
+      expect(client).to receive(:delete_message).with(
+        queue_url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        receipt_handle: 'handle-456'
+      )
+
+      subject.delete
+    end
+  end
+
+  describe '#change_visibility' do
+    it 'calls change_message_visibility on the client with merged parameters' do
+      options = { visibility_timeout: 300 }
+
+      expect(client).to receive(:change_message_visibility).with(hash_including(
+        visibility_timeout: 300,
+        queue_url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        receipt_handle: 'handle-456'
+      ))
+
+      subject.change_visibility(options)
+    end
+
+    it 'merges queue_url and receipt_handle into provided options' do
+      options = { visibility_timeout: 120, custom_param: 'value' }
+
+      expect(client).to receive(:change_message_visibility).with(hash_including(
+        visibility_timeout: 120,
+        custom_param: 'value',
+        queue_url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        receipt_handle: 'handle-456'
+      ))
+
+      subject.change_visibility(options)
+    end
+  end
+
+  describe '#visibility_timeout=' do
+    it 'calls change_message_visibility on the client with the timeout' do
+      expect(client).to receive(:change_message_visibility).with(
+        queue_url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        receipt_handle: 'handle-456',
+        visibility_timeout: 600
+      )
+
+      subject.visibility_timeout = 600
+    end
+  end
+end

data/spec/lib/shoryuken/middleware/entry_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'shoryuken/middleware/entry'
+
+RSpec.describe Shoryuken::Middleware::Entry do
+  describe '#initialize' do
+    it 'stores the middleware class' do
+      entry = described_class.new(String)
+      expect(entry.klass).to eq String
+    end
+
+    it 'stores initialization arguments' do
+      entry = described_class.new(String, 'arg1', 'arg2')
+      expect(entry.instance_variable_get(:@args)).to eq ['arg1', 'arg2']
+    end
+  end
+
+  describe '#make_new' do
+    let(:test_class) do
+      Class.new do
+        attr_reader :args
+
+        def initialize(*args)
+          @args = args
+        end
+      end
+    end
+
+    it 'creates a new instance of the stored class without arguments' do
+      entry = described_class.new(test_class)
+      instance = entry.make_new
+
+      expect(instance).to be_a test_class
+      expect(instance.args).to eq []
+    end
+
+    it 'creates a new instance with stored arguments' do
+      entry = described_class.new(test_class, 'arg1', 42, { key: 'value' })
+      instance = entry.make_new
+
+      expect(instance).to be_a test_class
+      expect(instance.args).to eq ['arg1', 42, { key: 'value' }]
+    end
+
+    it 'creates a new instance each time it is called' do
+      entry = described_class.new(test_class, 'shared_arg')
+      instance1 = entry.make_new
+      instance2 = entry.make_new
+
+      expect(instance1).to be_a test_class
+      expect(instance2).to be_a test_class
+      expect(instance1).not_to be instance2
+      expect(instance1.args).to eq instance2.args
+    end
+  end
+
+  describe '#klass' do
+    it 'returns the stored class' do
+      entry = described_class.new(Array)
+      expect(entry.klass).to eq Array
+    end
+
+    it 'is readable' do
+      entry = described_class.new(Hash)
+      expect(entry.klass).to eq Hash
+    end
+  end
+end

data/spec/lib/shoryuken/middleware/server/active_record_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Middleware::Server::ActiveRecord do
+  subject { described_class.new }
+
+  # Mock ActiveRecord to avoid requiring the actual gem in tests
+  before do
+    # Create mock ActiveRecord module
+    active_record_module = Module.new
+
+    # Create mock Base class with simplified methods
+    active_record_base = Class.new do
+      @connection_handler = nil
+
+      def self.clear_active_connections!
+        # Mock implementation for Rails < 7.1
+      end
+
+      def self.connection_handler
+        @connection_handler ||= Object.new.tap do |handler|
+          def handler.clear_active_connections!(_pool_key)
+            # Mock implementation for Rails 7.1+
+          end
+        end
+      end
+    end
+
+    active_record_module.const_set('Base', active_record_base)
+    stub_const('ActiveRecord', active_record_module)
+
+    # Mock version checking - start with a simple approach
+    def active_record_module.version
+      @version ||= Object.new.tap do |v|
+        def v.>=(other)
+          # For our tests, we'll control this with instance variables
+          @is_rails_71_or_higher ||= false
+        end
+
+        def v.rails_71_or_higher!
+          @is_rails_71_or_higher = true
+        end
+
+        def v.rails_70!
+          @is_rails_71_or_higher = false
+        end
+      end
+    end
+
+    # Mock Gem::Version
+    unless defined?(Gem::Version)
+      gem_module = Module.new
+      gem_version_class = Class.new do
+        def initialize(_version)
+          # Simple mock
+        end
+      end
+      gem_module.const_set('Version', gem_version_class)
+      stub_const('Gem', gem_module)
+    end
+  end
+
+  describe '#call' do
+    it 'yields to the block' do
+      block_called = false
+      subject.call do
+        block_called = true
+      end
+      expect(block_called).to be true
+    end
+
+    it 'returns the value from the block' do
+      result = subject.call { 'block_result' }
+      expect(result).to eq('block_result')
+    end
+
+    context 'when ActiveRecord version is 7.1 or higher' do
+      before do
+        # Mock Rails 7.1+ behavior
+        allow(ActiveRecord).to receive(:version).and_return(double('>=' => true))
+      end
+
+      it 'calls clear_active_connections! on connection_handler with :all parameter' do
+        connection_handler = ActiveRecord::Base.connection_handler
+        expect(connection_handler).to receive(:clear_active_connections!).with(:all)
+
+        subject.call { 'test' }
+      end
+
+      it 'clears connections even when an exception is raised' do
+        connection_handler = ActiveRecord::Base.connection_handler
+        expect(connection_handler).to receive(:clear_active_connections!).with(:all)
+
+        expect do
+          subject.call { raise StandardError, 'test error' }
+        end.to raise_error(StandardError, 'test error')
+      end
+    end
+
+    context 'when ActiveRecord version is lower than 7.1' do
+      before do
+        # Mock Rails < 7.1 behavior
+        allow(ActiveRecord).to receive(:version).and_return(double('>=' => false))
+      end
+
+      it 'calls clear_active_connections! directly on ActiveRecord::Base' do
+        expect(ActiveRecord::Base).to receive(:clear_active_connections!)
+
+        subject.call { 'test' }
+      end
+
+      it 'clears connections even when an exception is raised' do
+        expect(ActiveRecord::Base).to receive(:clear_active_connections!)
+
+        expect do
+          subject.call { raise StandardError, 'test error' }
+        end.to raise_error(StandardError, 'test error')
+      end
+    end
+
+    it 'works with middleware arguments (ignores them)' do
+      allow(ActiveRecord).to receive(:version).and_return(double('>=' => false))
+      expect(ActiveRecord::Base).to receive(:clear_active_connections!)
+
+      worker = double('worker')
+      message = double('message')
+
+      result = subject.call(worker, message) { 'middleware_result' }
+      expect(result).to eq('middleware_result')
+    end
+  end
+end

data/spec/{shoryuken → lib/shoryuken}/middleware/server/auto_extend_visibility_spec.rb

@@ -64,4 +64,54 @@ RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
 
     Runner.new.run_and_sleep(TestWorker.new, queue, sqs_msg, visibility_timeout)
   end
+
+  context 'when batch worker with auto_visibility_timeout' do
+    it 'warns and does not extend visibility for batch workers' do
+      TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
+
+      expect(Shoryuken.logger).to receive(:warn) do |&block|
+        expect(block.call).to include("Auto extend visibility isn't supported for batch workers")
+      end
+
+      expect { |b| subject.call(TestWorker.new, queue, [sqs_msg], nil, &b) }.to yield_control
+    end
+  end
+
+  context 'when visibility extension fails' do
+    it 'logs error when change_visibility raises an exception' do
+      TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
+
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
+      allow(sqs_msg).to receive(:message_id).and_return('test-message-id')
+      allow(sqs_msg).to receive(:change_visibility).and_raise(StandardError, 'AWS error')
+
+      expect(Shoryuken.logger).to receive(:error) do |&block|
+        msg = block.call
+        expect(msg).to include('Could not auto extend the message')
+        expect(msg).to include('test-message-id')
+        expect(msg).to include('AWS error')
+      end
+
+      Runner.new.run_and_sleep(TestWorker.new, queue, sqs_msg, visibility_timeout)
+    end
+  end
+
+  context 'debug logging' do
+    it 'logs debug message when extending visibility' do
+      TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
+
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
+      allow(sqs_msg).to receive(:message_id).and_return('test-message-id')
+      allow(sqs_msg).to receive(:change_visibility)
+
+      expect(Shoryuken.logger).to receive(:debug) do |&block|
+        msg = block.call
+        expect(msg).to include('Extending message')
+        expect(msg).to include('test-message-id')
+        expect(msg).to include("by #{visibility_timeout}s")
+      end
+
+      Runner.new.run_and_sleep(TestWorker.new, queue, sqs_msg, visibility_timeout)
+    end
+  end
 end

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

@@ -188,8 +188,8 @@ RSpec.describe Shoryuken::Options do
       end
 
       specify do
-        expect { Shoryuken.polling_strategy('default') }.to raise_error(ArgumentError)
-        expect { Shoryuken.polling_strategy('group1') }.to raise_error(ArgumentError)
+        expect { Shoryuken.polling_strategy('default') }.to raise_error(Shoryuken::Errors::InvalidPollingStrategyError)
+        expect { Shoryuken.polling_strategy('group1') }.to raise_error(Shoryuken::Errors::InvalidPollingStrategyError)
       end
     end
 

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

@@ -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/lib/shoryuken/worker_registry_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::WorkerRegistry do
+  subject { described_class.new }
+
+  describe '#batch_receive_messages?' do
+    it 'raises NotImplementedError' do
+      expect { subject.batch_receive_messages?('test-queue') }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#clear' do
+    it 'raises NotImplementedError' do
+      expect { subject.clear }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#fetch_worker' do
+    it 'raises NotImplementedError' do
+      queue = 'test-queue'
+      message = double('message')
+      expect { subject.fetch_worker(queue, message) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#queues' do
+    it 'raises NotImplementedError' do
+      expect { subject.queues }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#register_worker' do
+    it 'raises NotImplementedError' do
+      queue = 'test-queue'
+      worker_class = Class.new
+      expect { subject.register_worker(queue, worker_class) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#workers' do
+    it 'raises NotImplementedError' do
+      expect { subject.workers('test-queue') }.to raise_error(NotImplementedError)
+    end
+  end
+
+  context 'interface documentation' do
+    it 'defines the required interface methods' do
+      expect(subject).to respond_to(:batch_receive_messages?)
+      expect(subject).to respond_to(:clear)
+      expect(subject).to respond_to(:fetch_worker)
+      expect(subject).to respond_to(:queues)
+      expect(subject).to respond_to(:register_worker)
+      expect(subject).to respond_to(:workers)
+    end
+
+    it 'is designed to be subclassed' do
+      expect(described_class).to be < Object
+      expect(described_class.ancestors).to include(described_class)
+    end
+  end
+end

data/spec/shared_examples_for_active_job.rb

@@ -1,5 +1,5 @@
 require 'active_job'
-require 'shoryuken/extensions/active_job_extensions'
+require 'active_job/extensions'
 
 # Stand-in for a job class specified by the user
 class TestJob < ActiveJob::Base; end
@@ -23,11 +23,11 @@ RSpec.shared_examples 'active_job_adapters' do
     specify do
       expect(queue).to receive(:send_message) do |hash|
         expect(hash[:message_deduplication_id]).to_not be
-        expect(hash[:message_attributes]['shoryuken_class'][:string_value]).to eq(described_class::JobWrapper.to_s)
+        expect(hash[:message_attributes]['shoryuken_class'][:string_value]).to eq(Shoryuken::ActiveJob::JobWrapper.to_s)
         expect(hash[:message_attributes]['shoryuken_class'][:data_type]).to eq('String')
         expect(hash[:message_attributes].keys).to eq(['shoryuken_class'])
       end
-      expect(Shoryuken).to receive(:register_worker).with(job.queue_name, described_class::JobWrapper)
+      expect(Shoryuken).to receive(:register_worker).with(job.queue_name, Shoryuken::ActiveJob::JobWrapper)
 
       subject.enqueue(job)
     end
@@ -50,7 +50,7 @@ RSpec.shared_examples 'active_job_adapters' do
 
           expect(hash[:message_deduplication_id]).to eq(message_deduplication_id)
         end
-        expect(Shoryuken).to receive(:register_worker).with(job.queue_name, described_class::JobWrapper)
+        expect(Shoryuken).to receive(:register_worker).with(job.queue_name, Shoryuken::ActiveJob::JobWrapper)
 
         subject.enqueue(job)
       end
@@ -132,12 +132,12 @@ RSpec.shared_examples 'active_job_adapters' do
         }
 
         expect(queue).to receive(:send_message) do |hash|
-          expect(hash[:message_attributes]['shoryuken_class'][:string_value]).to eq(described_class::JobWrapper.to_s)
+          expect(hash[:message_attributes]['shoryuken_class'][:string_value]).to eq(Shoryuken::ActiveJob::JobWrapper.to_s)
           expect(hash[:message_attributes]['shoryuken_class'][:data_type]).to eq('String')
           expect(hash[:message_attributes]['tracer_id'][:string_value]).to eq(custom_message_attributes['tracer_id'][:string_value])
           expect(hash[:message_attributes]['tracer_id'][:data_type]).to eq('String')
         end
-        expect(Shoryuken).to receive(:register_worker).with(job.queue_name, described_class::JobWrapper)
+        expect(Shoryuken).to receive(:register_worker).with(job.queue_name, Shoryuken::ActiveJob::JobWrapper)
 
         subject.enqueue(job, message_attributes: custom_message_attributes)
       end
@@ -158,7 +158,7 @@ RSpec.shared_examples 'active_job_adapters' do
           expect(queue).to receive(:send_message) do |hash|
             expect(hash[:message_attributes]['tracer_id']).to eq({ data_type: 'String', string_value: 'job-value' })
             expect(hash[:message_attributes]['shoryuken_class']).to eq({ data_type: 'String',
-                                                                         string_value: described_class::JobWrapper.to_s })
+                                                                         string_value: Shoryuken::ActiveJob::JobWrapper.to_s })
           end
           subject.enqueue job
         end
@@ -189,7 +189,7 @@ RSpec.shared_examples 'active_job_adapters' do
             expect(hash[:message_attributes]['options_tracer_id']).to eq({ data_type: 'String',
                                                                            string_value: 'options-value' })
             expect(hash[:message_attributes]['shoryuken_class']).to eq({ data_type: 'String',
-                                                                         string_value: described_class::JobWrapper.to_s })
+                                                                         string_value: Shoryuken::ActiveJob::JobWrapper.to_s })
           end
           subject.enqueue job, message_attributes: custom_message_attributes
         end
@@ -274,13 +274,33 @@ RSpec.shared_examples 'active_job_adapters' do
         expect(hash[:delay_seconds]).to eq(delay)
       end
 
-      expect(Shoryuken).to receive(:register_worker).with(job.queue_name, described_class::JobWrapper)
+      expect(Shoryuken).to receive(:register_worker).with(job.queue_name, Shoryuken::ActiveJob::JobWrapper)
 
       # need to figure out what to require Time.current and N.minutes to remove the stub
       allow(subject).to receive(:calculate_delay).and_return(delay)
 
       subject.enqueue_at(job, nil)
     end
+
+    context 'when fifo' do
+      let(:fifo) { true }
+
+      it 'raises ArgumentError when delay is positive' do
+        allow(subject).to receive(:calculate_delay).and_return(3)
+        allow(queue).to receive(:name).and_return('test.fifo')
+        expect(queue).not_to receive(:send_message)
+
+        expect { subject.enqueue_at(job, nil) }.to raise_error(
+          ArgumentError, /FIFO queue.*does not support per-message delays/
+        )
+      end
+
+      it 'does not raise when delay is zero' do
+        allow(subject).to receive(:calculate_delay).and_return(0)
+        expect(queue).to receive(:send_message).with(hash_including(delay_seconds: 0))
+        expect { subject.enqueue_at(job, nil) }.not_to raise_error
+      end
+    end
   end
 end
 # rubocop:enable Metrics/BlockLength

data/spec/spec_helper.rb

@@ -7,9 +7,20 @@ $VERBOSE = true
 require 'warning'
 
 Warning.process do |warning|
+  # Only check warnings from our code (not dependencies)
   next unless warning.include?(Dir.pwd)
-  next if warning.include?('useless use of a variable in void context') && warning.include?('core_ext')
+
+  # 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 and bundle directories
   next if warning.include?('vendor/')
+  next if warning.include?('bundle/')
+  next if warning.include?('.bundle/')
 
   raise "Warning in your code: #{warning}"
 end
@@ -29,8 +40,28 @@ require 'securerandom'
 require 'ostruct'
 Dotenv.load
 
-require 'simplecov'
-SimpleCov.start
+unless ENV['SIMPLECOV_DISABLED']
+  require 'simplecov'
+  SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/test_workers/'
+  add_filter '/examples/'
+  add_filter '/vendor/'
+  add_filter '/.bundle/'
+
+  add_group 'Library', 'lib/'
+  add_group 'ActiveJob', 'lib/active_job'
+  add_group 'Middleware', 'lib/shoryuken/middleware'
+  add_group 'Polling', 'lib/shoryuken/polling'
+  add_group 'Workers', 'lib/shoryuken/worker'
+  add_group 'Helpers', 'lib/shoryuken/helpers'
+
+  enable_coverage :branch
+
+  minimum_coverage 89
+  minimum_coverage_by_file 60
+  end
+end
 
 config_file = File.join(File.expand_path('..', __dir__), 'spec', 'shoryuken.yml')