shoryuken 7.0.0.alpha2 → 7.0.0.rc1

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/helpers/timer_task_spec.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Helpers::TimerTask do
+  let(:execution_interval) { 0.1 }
+  let!(:timer_task) do
+    described_class.new(execution_interval: execution_interval) do
+      @execution_count = (@execution_count || 0) + 1
+    end
+  end
+
+  describe '#initialize' do
+    it 'creates a timer task with the specified interval' do
+      timer = described_class.new(execution_interval: 5) {}
+      expect(timer).to be_a(described_class)
+    end
+
+    it 'requires a block' do
+      expect { described_class.new(execution_interval: 5) }.to raise_error(ArgumentError, 'A block must be provided')
+    end
+
+    it 'requires a positive execution_interval' do
+      expect { described_class.new(execution_interval: 0) {} }.to raise_error(ArgumentError, 'execution_interval must be positive')
+      expect { described_class.new(execution_interval: -1) {} }.to raise_error(ArgumentError, 'execution_interval must be positive')
+    end
+
+    it 'accepts string numbers as execution_interval' do
+      timer = described_class.new(execution_interval: '5.5') {}
+      expect(timer.instance_variable_get(:@execution_interval)).to eq(5.5)
+    end
+
+    it 'raises ArgumentError for non-numeric execution_interval' do
+      expect { described_class.new(execution_interval: 'invalid') {} }.to raise_error(ArgumentError)
+      expect { described_class.new(execution_interval: nil) {} }.to raise_error(TypeError)
+      expect { described_class.new(execution_interval: {}) {} }.to raise_error(TypeError)
+    end
+
+    it 'stores the task block in @task instance variable' do
+      task_proc = proc { puts 'test' }
+      timer = described_class.new(execution_interval: 1, &task_proc)
+      expect(timer.instance_variable_get(:@task)).to eq(task_proc)
+    end
+
+    it 'stores the execution interval' do
+      timer = described_class.new(execution_interval: 5) {}
+      expect(timer.instance_variable_get(:@execution_interval)).to eq(5)
+    end
+
+    it 'initializes state variables correctly' do
+      timer = described_class.new(execution_interval: 1) {}
+      expect(timer.instance_variable_get(:@running)).to be false
+      expect(timer.instance_variable_get(:@killed)).to be false
+      expect(timer.instance_variable_get(:@thread)).to be_nil
+    end
+  end
+
+  describe '#execute' do
+    it 'returns self for method chaining' do
+      result = timer_task.execute
+      expect(result).to eq(timer_task)
+      timer_task.kill
+    end
+
+    it 'sets @running to true when executed' do
+      timer_task.execute
+      expect(timer_task.instance_variable_get(:@running)).to be true
+      timer_task.kill
+    end
+
+    it 'creates a new thread' do
+      timer_task.execute
+      thread = timer_task.instance_variable_get(:@thread)
+      expect(thread).to be_a(Thread)
+      timer_task.kill
+    end
+
+    it 'does not start multiple times' do
+      timer_task.execute
+      first_thread = timer_task.instance_variable_get(:@thread)
+      timer_task.execute
+      second_thread = timer_task.instance_variable_get(:@thread)
+      expect(first_thread).to eq(second_thread)
+      timer_task.kill
+    end
+
+    it 'does not execute if already killed' do
+      timer_task.instance_variable_set(:@killed, true)
+      result = timer_task.execute
+      expect(result).to eq(timer_task)
+      expect(timer_task.instance_variable_get(:@thread)).to be_nil
+    end
+  end
+
+  describe '#kill' do
+    it 'returns true when successfully killed' do
+      timer_task.execute
+      expect(timer_task.kill).to be true
+    end
+
+    it 'returns false when already killed' do
+      timer_task.execute
+      timer_task.kill
+      expect(timer_task.kill).to be false
+    end
+
+    it 'sets @killed to true' do
+      timer_task.execute
+      timer_task.kill
+      expect(timer_task.instance_variable_get(:@killed)).to be true
+    end
+
+    it 'sets @running to false' do
+      timer_task.execute
+      timer_task.kill
+      expect(timer_task.instance_variable_get(:@running)).to be false
+    end
+
+    it 'kills the thread if alive' do
+      timer_task.execute
+      thread = timer_task.instance_variable_get(:@thread)
+      timer_task.kill
+      sleep(0.01) # Give time for thread to be killed
+      expect(thread.alive?).to be false
+    end
+
+    it 'is safe to call multiple times' do
+      timer_task.execute
+      expect { timer_task.kill }.not_to raise_error
+      expect { timer_task.kill }.not_to raise_error
+    end
+
+    it 'handles case when thread is nil' do
+      timer = described_class.new(execution_interval: 1) {}
+      result = nil
+      expect { result = timer.kill }.not_to raise_error
+      expect(result).to be true
+    end
+  end
+
+  describe 'execution behavior' do
+    it 'executes the task at the specified interval' do
+      execution_count = 0
+      timer = described_class.new(execution_interval: 0.05) do
+        execution_count += 1
+      end
+
+      timer.execute
+      sleep(0.15) # Should allow for ~3 executions
+      timer.kill
+
+      expect(execution_count).to be >= 2
+      expect(execution_count).to be <= 4 # Allow some timing variance
+    end
+
+    it 'calls the task block correctly' do
+      task_called = false
+      timer = described_class.new(execution_interval: 0.05) do
+        task_called = true
+      end
+
+      timer.execute
+      sleep(0.1)
+      timer.kill
+
+      expect(task_called).to be true
+    end
+
+    it 'handles exceptions in the task gracefully' do
+      error_count = 0
+      timer = described_class.new(execution_interval: 0.05) do
+        error_count += 1
+        raise StandardError, 'Test error'
+      end
+
+      # Capture stderr to check for error messages
+      original_stderr = $stderr
+      captured_stderr = StringIO.new
+      $stderr = captured_stderr
+
+      # Mock warn method to prevent warning gem from raising exceptions
+      # but still capture the output
+      allow_any_instance_of(Object).to receive(:warn) do |*args|
+        captured_stderr.puts(*args)
+      end
+
+      timer.execute
+      sleep(0.15)
+      timer.kill
+
+      error_output = captured_stderr.string
+      $stderr = original_stderr
+
+      expect(error_count).to be >= 2
+      expect(error_output).to include('Test error')
+    end
+
+    it 'continues execution after exceptions' do
+      execution_count = 0
+      timer = described_class.new(execution_interval: 0.05) do
+        execution_count += 1
+        raise StandardError, 'Test error' if execution_count == 1
+      end
+
+      # Mock warn method to prevent warning gem from raising exceptions
+      allow_any_instance_of(Object).to receive(:warn)
+
+      timer.execute
+      sleep(0.15)
+      timer.kill
+
+      expect(execution_count).to be >= 2 # Should continue after first error
+    end
+
+    it 'stops execution when killed' do
+      execution_count = 0
+      timer = described_class.new(execution_interval: 0.05) do
+        execution_count += 1
+      end
+
+      timer.execute
+      sleep(0.1)
+      initial_count = execution_count
+      timer.kill
+      sleep(0.1)
+      final_count = execution_count
+
+      expect(final_count).to eq(initial_count)
+    end
+
+    it 'respects the execution interval' do
+      execution_times = []
+      timer = described_class.new(execution_interval: 0.1) do
+        execution_times << Time.now
+      end
+
+      timer.execute
+      sleep(0.35) # Allow for ~3 executions
+      timer.kill
+
+      expect(execution_times.length).to be >= 2
+      if execution_times.length >= 2
+        interval = execution_times[1] - execution_times[0]
+        expect(interval).to be_within(0.05).of(0.1)
+      end
+    end
+  end
+
+  describe 'thread safety' do
+    it 'can be safely accessed from multiple threads' do
+      timer = described_class.new(execution_interval: 0.1) {}
+
+      threads = 10.times.map do
+        Thread.new do
+          timer.execute
+          sleep(0.01)
+          timer.kill
+        end
+      end
+
+      threads.each(&:join)
+      # Timer should be stopped after all threads complete
+      expect(timer.instance_variable_get(:@killed)).to be true
+    end
+
+    it 'handles concurrent execute calls safely' do
+      timer = described_class.new(execution_interval: 0.1) {}
+
+      threads = 5.times.map do
+        Thread.new { timer.execute }
+      end
+
+      threads.each(&:join)
+
+      # Should only have one thread created
+      expect(timer.instance_variable_get(:@thread)).to be_a(Thread)
+      timer.kill
+    end
+
+    it 'handles concurrent kill calls safely' do
+      timer = described_class.new(execution_interval: 0.1) {}
+      timer.execute
+
+      threads = 5.times.map do
+        Thread.new { timer.kill }
+      end
+
+      results = threads.map(&:value)
+
+      # Only one kill should return true, others should return false
+      true_count = results.count(true)
+      false_count = results.count(false)
+
+      expect(true_count).to eq(1)
+      expect(false_count).to eq(4)
+    end
+  end
+end

data/spec/shoryuken/launcher_spec.rb

@@ -101,4 +101,26 @@ RSpec.describe Shoryuken::Launcher do
       expect(second_group_manager).to have_received(:stop_new_dispatching)
     end
   end
+
+  describe '#stopping?' do
+    it 'returns false by default' do
+      expect(subject.stopping?).to be false
+    end
+
+    it 'returns true after stop is called' do
+      allow(first_group_manager).to receive(:stop_new_dispatching)
+      allow(first_group_manager).to receive(:await_dispatching_in_progress)
+      allow(second_group_manager).to receive(:stop_new_dispatching)
+      allow(second_group_manager).to receive(:await_dispatching_in_progress)
+
+      expect { subject.stop }.to change { subject.stopping? }.from(false).to(true)
+    end
+
+    it 'returns true after stop! is called' do
+      allow(first_group_manager).to receive(:stop_new_dispatching)
+      allow(second_group_manager).to receive(:stop_new_dispatching)
+
+      expect { subject.stop! }.to change { subject.stopping? }.from(false).to(true)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shoryuken
 version: !ruby/object:Gem::Version
-  version: 7.0.0.alpha2
+  version: 7.0.0.rc1
 platform: ruby
 authors:
 - Pablo Cantero
@@ -152,10 +152,9 @@ files:
 - examples/bootstrap_queues.rb
 - examples/default_worker.rb
 - gemfiles/.gitignore
-- gemfiles/rails_7_0.gemfile
-- gemfiles/rails_7_1.gemfile
 - gemfiles/rails_7_2.gemfile
 - gemfiles/rails_8_0.gemfile
+- gemfiles/rails_8_1.gemfile
 - lib/shoryuken.rb
 - lib/shoryuken/body_parser.rb
 - lib/shoryuken/client.rb
@@ -171,12 +170,17 @@ files:
 - lib/shoryuken/helpers/atomic_hash.rb
 - lib/shoryuken/helpers/hash_utils.rb
 - lib/shoryuken/helpers/string_utils.rb
+- lib/shoryuken/helpers/timer_task.rb
 - lib/shoryuken/inline_message.rb
 - lib/shoryuken/launcher.rb
 - lib/shoryuken/logging.rb
+- lib/shoryuken/logging/base.rb
+- lib/shoryuken/logging/pretty.rb
+- lib/shoryuken/logging/without_timestamp.rb
 - lib/shoryuken/manager.rb
 - lib/shoryuken/message.rb
 - lib/shoryuken/middleware/chain.rb
+- lib/shoryuken/middleware/entry.rb
 - lib/shoryuken/middleware/server/active_record.rb
 - lib/shoryuken/middleware/server/auto_delete.rb
 - lib/shoryuken/middleware/server/auto_extend_visibility.rb
@@ -198,6 +202,7 @@ files:
 - lib/shoryuken/worker_registry.rb
 - renovate.json
 - shoryuken.gemspec
+- spec/integration/active_job_continuation_spec.rb
 - spec/integration/launcher_spec.rb
 - spec/shared_examples_for_active_job.rb
 - spec/shoryuken.yml
@@ -209,6 +214,7 @@ files:
 - spec/shoryuken/extensions/active_job_adapter_spec.rb
 - spec/shoryuken/extensions/active_job_base_spec.rb
 - spec/shoryuken/extensions/active_job_concurrent_send_adapter_spec.rb
+- spec/shoryuken/extensions/active_job_continuation_spec.rb
 - spec/shoryuken/extensions/active_job_wrapper_spec.rb
 - spec/shoryuken/fetcher_spec.rb
 - spec/shoryuken/helpers/atomic_boolean_spec.rb
@@ -216,6 +222,7 @@ files:
 - spec/shoryuken/helpers/atomic_hash_spec.rb
 - spec/shoryuken/helpers/hash_utils_spec.rb
 - spec/shoryuken/helpers/string_utils_spec.rb
+- spec/shoryuken/helpers/timer_task_spec.rb
 - spec/shoryuken/helpers_integration_spec.rb
 - spec/shoryuken/inline_message_spec.rb
 - spec/shoryuken/launcher_spec.rb
@@ -263,6 +270,7 @@ rubygems_version: 3.6.9
 specification_version: 4
 summary: Shoryuken is a super efficient AWS SQS thread based message processor
 test_files:
+- spec/integration/active_job_continuation_spec.rb
 - spec/integration/launcher_spec.rb
 - spec/shared_examples_for_active_job.rb
 - spec/shoryuken.yml
@@ -274,6 +282,7 @@ test_files:
 - spec/shoryuken/extensions/active_job_adapter_spec.rb
 - spec/shoryuken/extensions/active_job_base_spec.rb
 - spec/shoryuken/extensions/active_job_concurrent_send_adapter_spec.rb
+- spec/shoryuken/extensions/active_job_continuation_spec.rb
 - spec/shoryuken/extensions/active_job_wrapper_spec.rb
 - spec/shoryuken/fetcher_spec.rb
 - spec/shoryuken/helpers/atomic_boolean_spec.rb
@@ -281,6 +290,7 @@ test_files:
 - spec/shoryuken/helpers/atomic_hash_spec.rb
 - spec/shoryuken/helpers/hash_utils_spec.rb
 - spec/shoryuken/helpers/string_utils_spec.rb
+- spec/shoryuken/helpers/timer_task_spec.rb
 - spec/shoryuken/helpers_integration_spec.rb
 - spec/shoryuken/inline_message_spec.rb
 - spec/shoryuken/launcher_spec.rb

data/gemfiles/rails_7_0.gemfile

@@ -1,19 +0,0 @@
-# This file was generated by Appraisal
-
-source 'https://rubygems.org'
-
-group :test do
-  gem 'activejob', '~> 7.0'
-  gem 'httparty'
-  gem 'multi_xml'
-  gem 'simplecov'
-  gem 'warning'
-end
-
-group :development do
-  gem 'appraisal', git: 'https://github.com/thoughtbot/appraisal.git'
-  gem 'pry-byebug'
-  gem 'rubocop'
-end
-
-gemspec path: '../'

data/gemfiles/rails_7_1.gemfile

@@ -1,19 +0,0 @@
-# This file was generated by Appraisal
-
-source 'https://rubygems.org'
-
-group :test do
-  gem 'activejob', '~> 7.1'
-  gem 'httparty'
-  gem 'multi_xml'
-  gem 'simplecov'
-  gem 'warning'
-end
-
-group :development do
-  gem 'appraisal', git: 'https://github.com/thoughtbot/appraisal.git'
-  gem 'pry-byebug'
-  gem 'rubocop'
-end
-
-gemspec path: '../'