shoryuken 7.0.0.alpha1 → 7.0.0.rc1

data/spec/integration/active_job_continuation_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'active_job'
+require 'shoryuken/extensions/active_job_adapter'
+require 'shoryuken/extensions/active_job_extensions'
+
+RSpec.describe 'ActiveJob Continuations Integration' do
+  # Skip all tests in this suite if ActiveJob::Continuable is not available (Rails < 8.0)
+  before(:all) do
+    skip 'ActiveJob::Continuable not available (Rails < 8.0)' unless defined?(ActiveJob::Continuable)
+  end
+
+  # Test job that uses ActiveJob Continuations
+  class ContinuableTestJob < ActiveJob::Base
+    include ActiveJob::Continuable if defined?(ActiveJob::Continuable)
+
+    queue_as :default
+
+    class_attribute :executions_log, default: []
+    class_attribute :checkpoints_reached, default: []
+
+    def perform(max_iterations: 10)
+      self.class.executions_log << { execution: executions, started_at: Time.current }
+
+      step :initialize_work do
+        self.class.checkpoints_reached << "initialize_work_#{executions}"
+      end
+
+      step :process_items, start: cursor || 0 do
+        (cursor..max_iterations).each do |i|
+          self.class.checkpoints_reached << "processing_item_#{i}"
+
+          # Check if we should stop (checkpoint)
+          checkpoint
+
+          # Simulate some work
+          sleep 0.01
+
+          # Advance cursor
+          cursor.advance!
+        end
+      end
+
+      step :finalize_work do
+        self.class.checkpoints_reached << 'finalize_work'
+      end
+
+      self.class.executions_log.last[:completed] = true
+    end
+  end
+
+  describe 'stopping? method (unit tests)' do
+    it 'returns false when launcher is not initialized' do
+      adapter = ActiveJob::QueueAdapters::ShoryukenAdapter.new
+      expect(adapter.stopping?).to be false
+    end
+
+    it 'returns true when launcher is stopping' do
+      launcher = Shoryuken::Launcher.new
+      runner = Shoryuken::Runner.instance
+      runner.instance_variable_set(:@launcher, launcher)
+
+      adapter = ActiveJob::QueueAdapters::ShoryukenAdapter.new
+      expect(adapter.stopping?).to be false
+
+      launcher.instance_variable_set(:@stopping, true)
+      expect(adapter.stopping?).to be true
+    end
+  end
+
+  describe 'timestamp handling for continuation retries' do
+    it 'handles past timestamps for continuation retries' do
+      adapter = ActiveJob::QueueAdapters::ShoryukenAdapter.new
+      job = ContinuableTestJob.new
+      job.sqs_send_message_parameters = {}
+
+      # Mock the queue
+      queue = instance_double(Shoryuken::Queue, fifo?: false)
+      allow(Shoryuken::Client).to receive(:queues).and_return(queue)
+      allow(Shoryuken).to receive(:register_worker)
+      allow(queue).to receive(:send_message) do |params|
+        # Verify past timestamp results in immediate delivery (delay_seconds <= 0)
+        expect(params[:delay_seconds]).to be <= 0
+      end
+
+      # Enqueue with past timestamp (simulating continuation retry)
+      past_timestamp = Time.current.to_f - 60
+      adapter.enqueue_at(job, past_timestamp)
+    end
+  end
+
+  describe 'enqueue_at with continuation timestamps (unit tests)' do
+    let(:adapter) { ActiveJob::QueueAdapters::ShoryukenAdapter.new }
+    let(:job) do
+      job = ContinuableTestJob.new
+      job.sqs_send_message_parameters = {}
+      job
+    end
+    let(:queue) { instance_double(Shoryuken::Queue, fifo?: false) }
+
+    before do
+      allow(Shoryuken::Client).to receive(:queues).and_return(queue)
+      allow(Shoryuken).to receive(:register_worker)
+      @sent_messages = []
+      allow(queue).to receive(:send_message) do |params|
+        @sent_messages << params
+      end
+    end
+
+    it 'accepts past timestamps without error' do
+      past_timestamp = Time.current.to_f - 30
+
+      expect {
+        adapter.enqueue_at(job, past_timestamp)
+      }.not_to raise_error
+
+      expect(@sent_messages.size).to eq(1)
+      expect(@sent_messages.first[:delay_seconds]).to be <= 0
+    end
+
+    it 'accepts current timestamp' do
+      current_timestamp = Time.current.to_f
+
+      expect {
+        adapter.enqueue_at(job, current_timestamp)
+      }.not_to raise_error
+
+      expect(@sent_messages.size).to eq(1)
+      expect(@sent_messages.first[:delay_seconds]).to be_between(-1, 1)
+    end
+
+    it 'accepts future timestamp' do
+      future_timestamp = Time.current.to_f + 30
+
+      expect {
+        adapter.enqueue_at(job, future_timestamp)
+      }.not_to raise_error
+
+      expect(@sent_messages.size).to eq(1)
+      expect(@sent_messages.first[:delay_seconds]).to be > 0
+      expect(@sent_messages.first[:delay_seconds]).to be <= 30
+    end
+  end
+end

data/spec/integration/launcher_spec.rb

@@ -1,6 +1,5 @@
-require 'spec_helper'
-require 'shoryuken/manager'
-require 'shoryuken/launcher'
+# frozen_string_literal: true
+
 require 'securerandom'
 
 RSpec.describe Shoryuken::Launcher do

data/spec/shared_examples_for_active_job.rb

@@ -24,7 +24,7 @@ RSpec.shared_examples 'active_job_adapters' 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'][:data_type]).to eq("String")
+        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)
@@ -133,9 +133,9 @@ 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'][:data_type]).to eq("String")
+          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")
+          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)
 
@@ -157,7 +157,8 @@ RSpec.shared_examples 'active_job_adapters' do
         it 'should enqueue a message with the message_attributes specified on the job' 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 })
+            expect(hash[:message_attributes]['shoryuken_class']).to eq({ data_type: 'String',
+                                                                         string_value: described_class::JobWrapper.to_s })
           end
           subject.enqueue job
         end
@@ -185,8 +186,10 @@ RSpec.shared_examples 'active_job_adapters' do
 
           expect(queue).to receive(:send_message) do |hash|
             expect(hash[:message_attributes]['tracer_id']).to be_nil
-            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 })
+            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 })
           end
           subject.enqueue job, message_attributes: custom_message_attributes
         end
@@ -225,7 +228,8 @@ RSpec.shared_examples 'active_job_adapters' do
 
       it 'should enqueue a message with the message_system_attributes specified on the job' do
         expect(queue).to receive(:send_message) do |hash|
-          expect(hash[:message_system_attributes]['AWSTraceHeader']).to eq({ data_type: 'String', string_value: 'job-value' })
+          expect(hash[:message_system_attributes]['AWSTraceHeader']).to eq({ data_type: 'String',
+                                                                             string_value: 'job-value' })
         end
         subject.enqueue job
       end
@@ -253,7 +257,8 @@ RSpec.shared_examples 'active_job_adapters' do
 
         expect(queue).to receive(:send_message) do |hash|
           expect(hash[:message_system_attributes]['job_trace_header']).to be_nil
-          expect(hash[:message_system_attributes]['options_trace_header']).to eq({ data_type: 'String', string_value: 'options-value' })
+          expect(hash[:message_system_attributes]['options_trace_header']).to eq({ data_type: 'String',
+                                                                                   string_value: 'options-value' })
         end
         subject.enqueue job, message_system_attributes: custom_message_attributes
       end

data/spec/shoryuken/body_parser_spec.rb

@@ -1,5 +1,4 @@
-require 'spec_helper'
-require 'shoryuken/body_parser'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::BodyParser do
   let(:sqs_msg) { double }

data/spec/shoryuken/client_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Client do
   let(:credentials) { Aws::Credentials.new('access_key_id', 'secret_access_key') }

data/spec/shoryuken/default_exception_handler_spec.rb

@@ -1,12 +1,11 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::DefaultExceptionHandler do
   class CustomErrorHandler
     extend Shoryuken::Util
 
     def self.call(_ex, queue, _msg)
-      logger.error("#{queue.to_s} failed to process the message")
+      logger.error("#{queue} failed to process the message")
     end
   end
 
@@ -38,31 +37,31 @@ RSpec.describe Shoryuken::DefaultExceptionHandler do
 
   subject { Shoryuken::Processor.new(queue, sqs_msg) }
 
-  context "with default handler" do
+  context 'with default handler' do
     before do
       Shoryuken.exception_handlers = described_class
     end
 
-    it "logs an error message" do
+    it 'logs an error message' do
       expect(Shoryuken::Logging.logger).to receive(:error).twice
 
-      allow_any_instance_of(TestWorker).to receive(:perform).and_raise(StandardError, "error")
+      allow_any_instance_of(TestWorker).to receive(:perform).and_raise(StandardError, 'error')
       allow(sqs_msg).to receive(:body)
 
       expect { subject.process }.to raise_error(StandardError)
     end
   end
 
-  context "with custom handler" do
+  context 'with custom handler' do
     before do
       Shoryuken.exception_handlers = [described_class, CustomErrorHandler]
     end
 
-    it "logs default and custom error messages" do
+    it 'logs default and custom error messages' do
       expect(Shoryuken::Logging.logger).to receive(:error).twice
-      expect(Shoryuken::Logging.logger).to receive(:error).with("default failed to process the message").once
+      expect(Shoryuken::Logging.logger).to receive(:error).with('default failed to process the message').once
 
-      allow_any_instance_of(TestWorker).to receive(:perform).and_raise(StandardError, "error")
+      allow_any_instance_of(TestWorker).to receive(:perform).and_raise(StandardError, 'error')
       allow(sqs_msg).to receive(:body)
 
       expect { subject.process }.to raise_error(StandardError)

data/spec/shoryuken/default_worker_registry_spec.rb

@@ -1,6 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::DefaultWorkerRegistry do
   class RegistryTestWorker
     include Shoryuken::Worker

data/spec/shoryuken/environment_loader_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'active_job'
 
 RSpec.describe Shoryuken::EnvironmentLoader do
@@ -63,7 +64,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
     end
 
     specify do
-      Shoryuken.options[:queues] = ['queue1', 'queue2'] # default queues
+      Shoryuken.options[:queues] = %w[queue1 queue2] # default queues
       Shoryuken.options[:groups] = [['custom', { queues: ['queue3'], delay: 25 }]]
       subject.load
 
@@ -124,11 +125,11 @@ RSpec.describe Shoryuken::EnvironmentLoader do
     end
   end
 
-  describe "#setup_options" do
-    let(:cli_queues) { { "queue1" => 10, "queue2" => 20 } }
-    let(:config_queues) { [["queue1", 8], ["queue2", 4]] }
+  describe '#setup_options' do
+    let(:cli_queues) { { 'queue1' => 10, 'queue2' => 20 } }
+    let(:config_queues) { [['queue1', 8], ['queue2', 4]] }
 
-    context "when given queues through config and CLI" do
+    context 'when given queues through config and CLI' do
       specify do
         allow_any_instance_of(Shoryuken::EnvironmentLoader).to receive(:config_file_options).and_return({ queues: config_queues })
         Shoryuken::EnvironmentLoader.setup_options(queues: cli_queues)
@@ -136,7 +137,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
       end
     end
 
-    context "when given queues through config only" do
+    context 'when given queues through config only' do
       specify do
         allow_any_instance_of(Shoryuken::EnvironmentLoader).to receive(:config_file_options).and_return({ queues: config_queues })
         Shoryuken::EnvironmentLoader.setup_options({})
@@ -144,7 +145,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
       end
     end
 
-    context "when given queues through CLI only" do
+    context 'when given queues through CLI only' do
       specify do
         Shoryuken::EnvironmentLoader.setup_options(queues: cli_queues)
         expect(Shoryuken.options[:queues]).to eq(cli_queues)

data/spec/shoryuken/extensions/active_job_adapter_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'shared_examples_for_active_job'
 require 'shoryuken/extensions/active_job_adapter'
 

data/spec/shoryuken/extensions/active_job_base_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'active_job'
 require 'shoryuken/extensions/active_job_extensions'
 require 'shoryuken/extensions/active_job_adapter'

data/spec/shoryuken/extensions/active_job_concurrent_send_adapter_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'shared_examples_for_active_job'
 require 'shoryuken/extensions/active_job_adapter'
 require 'shoryuken/extensions/active_job_concurrent_send_adapter'

data/spec/shoryuken/extensions/active_job_continuation_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'active_job'
+require 'shared_examples_for_active_job'
+require 'shoryuken/extensions/active_job_adapter'
+require 'shoryuken/extensions/active_job_extensions'
+
+RSpec.describe 'ActiveJob Continuation support' do
+  let(:adapter) { ActiveJob::QueueAdapters::ShoryukenAdapter.new }
+  let(:job) do
+    job = TestJob.new
+    job.sqs_send_message_parameters = {}
+    job
+  end
+  let(:queue) { double('Queue', fifo?: false) }
+
+  before do
+    allow(Shoryuken::Client).to receive(:queues).with(job.queue_name).and_return(queue)
+    allow(Shoryuken).to receive(:register_worker)
+  end
+
+  describe '#stopping?' do
+    context 'when Launcher is not initialized' do
+      it 'returns false' do
+        runner = instance_double(Shoryuken::Runner, launcher: nil)
+        allow(Shoryuken::Runner).to receive(:instance).and_return(runner)
+
+        expect(adapter.stopping?).to be false
+      end
+    end
+
+    context 'when Launcher is initialized' do
+      let(:runner) { instance_double(Shoryuken::Runner) }
+      let(:launcher) { instance_double(Shoryuken::Launcher) }
+
+      before do
+        allow(Shoryuken::Runner).to receive(:instance).and_return(runner)
+        allow(runner).to receive(:launcher).and_return(launcher)
+      end
+
+      it 'returns false when not stopping' do
+        allow(launcher).to receive(:stopping?).and_return(false)
+        expect(adapter.stopping?).to be false
+      end
+
+      it 'returns true when stopping' do
+        allow(launcher).to receive(:stopping?).and_return(true)
+        expect(adapter.stopping?).to be true
+      end
+    end
+  end
+
+  describe '#enqueue_at with past timestamps' do
+    let(:past_timestamp) { Time.current.to_f - 60 } # 60 seconds ago
+
+    it 'enqueues with negative delay_seconds when timestamp is in the past' do
+      expect(queue).to receive(:send_message) do |hash|
+        expect(hash[:delay_seconds]).to be <= 0
+        expect(hash[:delay_seconds]).to be >= -61 # Allow for rounding and timing
+      end
+
+      adapter.enqueue_at(job, past_timestamp)
+    end
+
+    it 'does not raise an error for past timestamps' do
+      allow(queue).to receive(:send_message)
+
+      expect { adapter.enqueue_at(job, past_timestamp) }.not_to raise_error
+    end
+  end
+
+  describe '#enqueue_at with future timestamps' do
+    let(:future_timestamp) { Time.current.to_f + 60 } # 60 seconds from now
+
+    it 'enqueues with delay_seconds when timestamp is in the future' do
+      expect(queue).to receive(:send_message) do |hash|
+        expect(hash[:delay_seconds]).to be > 0
+        expect(hash[:delay_seconds]).to be <= 60
+      end
+
+      adapter.enqueue_at(job, future_timestamp)
+    end
+  end
+
+  describe '#enqueue_at with current timestamp' do
+    let(:current_timestamp) { Time.current.to_f }
+
+    it 'enqueues with delay_seconds close to 0' do
+      expect(queue).to receive(:send_message) do |hash|
+        expect(hash[:delay_seconds]).to be_between(-1, 1) # Allow for timing/rounding
+      end
+
+      adapter.enqueue_at(job, current_timestamp)
+    end
+  end
+
+  describe 'retry_on with zero wait' do
+    it 'allows immediate retries through continuation mechanism' do
+      # Simulate a job with retry_on configuration that uses zero wait
+      past_timestamp = Time.current.to_f - 1
+
+      expect(queue).to receive(:send_message) do |hash|
+        # Negative delay for past timestamp - SQS will handle immediate delivery
+        expect(hash[:delay_seconds]).to be <= 0
+      end
+
+      adapter.enqueue_at(job, past_timestamp)
+    end
+  end
+end

data/spec/shoryuken/extensions/active_job_wrapper_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
 require 'active_job'
 require 'shoryuken/extensions/active_job_extensions'
 require 'shoryuken/extensions/active_job_adapter'

data/spec/shoryuken/fetcher_spec.rb

@@ -1,8 +1,5 @@
-require 'spec_helper'
-require 'shoryuken/manager'
-require 'shoryuken/fetcher'
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::Fetcher do
   let(:queue)        { instance_double('Shoryuken::Queue', fifo?: false) }
   let(:queue_name)   { 'default' }
@@ -29,17 +26,17 @@ RSpec.describe Shoryuken::Fetcher do
       Shoryuken.sqs_client_receive_message_opts[group] = { wait_time_seconds: 10 }
 
       expect(queue).to receive(:receive_messages).with({
-        wait_time_seconds: 10,
-        max_number_of_messages: limit,
-        message_attribute_names: ['All'],
-        attribute_names: ['All']
-      }).and_return([])
+                                                         wait_time_seconds: 10,
+                                                         max_number_of_messages: limit,
+                                                         message_attribute_names: ['All'],
+                                                         attribute_names: ['All']
+                                                       }).and_return([])
 
       subject.fetch(queue_config, limit)
     end
 
     it 'logs debug only' do
-      # See https://github.com/phstc/shoryuken/issues/435
+      # See https://github.com/ruby-shoryuken/shoryuken/issues/435
       logger = double 'logger'
 
       allow(subject).to receive(:logger).and_return(logger)
@@ -63,10 +60,10 @@ RSpec.describe Shoryuken::Fetcher do
         Shoryuken.sqs_client_receive_message_opts[queue_name] = { max_number_of_messages: 1 }
 
         expect(queue).to receive(:receive_messages).with({
-          max_number_of_messages: 1,
-          message_attribute_names: ['All'],
-          attribute_names: ['All']
-        }).and_return([])
+                                                           max_number_of_messages: 1,
+                                                           message_attribute_names: ['All'],
+                                                           attribute_names: ['All']
+                                                         }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -79,10 +76,10 @@ RSpec.describe Shoryuken::Fetcher do
         Shoryuken.sqs_client_receive_message_opts[queue_name] = { max_number_of_messages: 20 }
 
         expect(queue).to receive(:receive_messages).with({
-          max_number_of_messages: limit,
-          message_attribute_names: ['All'],
-          attribute_names: ['All']
-        }).and_return([])
+                                                           max_number_of_messages: limit,
+                                                           message_attribute_names: ['All'],
+                                                           attribute_names: ['All']
+                                                         }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -94,8 +91,8 @@ RSpec.describe Shoryuken::Fetcher do
       specify do
         allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
         expect(queue).to receive(:receive_messages).with({
-          max_number_of_messages: described_class::FETCH_LIMIT, attribute_names: ['All'], message_attribute_names: ['All']
-        }).and_return([])
+                                                           max_number_of_messages: described_class::FETCH_LIMIT, attribute_names: ['All'], message_attribute_names: ['All']
+                                                         }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -106,26 +103,26 @@ RSpec.describe Shoryuken::Fetcher do
       let(:queue) { instance_double('Shoryuken::Queue', fifo?: true, name: queue_name) }
 
       it 'polls one message at a time' do
-        # see https://github.com/phstc/shoryuken/pull/530
+        # see https://github.com/ruby-shoryuken/shoryuken/pull/530
 
         allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
         expect(queue).to receive(:receive_messages).with({
-          max_number_of_messages: 1, attribute_names: ['All'], message_attribute_names: ['All']
-        }).and_return([])
+                                                           max_number_of_messages: 1, attribute_names: ['All'], message_attribute_names: ['All']
+                                                         }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
 
       context 'with batch=true' do
         it 'polls the provided limit' do
-          # see https://github.com/phstc/shoryuken/pull/530
+          # see https://github.com/ruby-shoryuken/shoryuken/pull/530
 
           allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
           allow(Shoryuken.worker_registry).to receive(:batch_receive_messages?).with(queue.name).and_return(true)
 
           expect(queue).to receive(:receive_messages).with({
-            max_number_of_messages: limit, attribute_names: ['All'], message_attribute_names: ['All']
-          }).and_return([])
+                                                             max_number_of_messages: limit, attribute_names: ['All'], message_attribute_names: ['All']
+                                                           }).and_return([])
 
           subject.fetch(queue_config, limit)
         end