shoryuken 6.2.1 → 7.0.0.alpha2

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_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

data/spec/shoryuken/helpers/atomic_boolean_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+require 'shoryuken/helpers/atomic_boolean'
+
+RSpec.describe Shoryuken::Helpers::AtomicBoolean do
+  subject { described_class.new }
+
+  describe '#initialize' do
+    it 'initializes with default value of false' do
+      boolean = described_class.new
+      expect(boolean.value).to eq(false)
+    end
+
+    it 'initializes with true value' do
+      boolean = described_class.new(true)
+      expect(boolean.value).to eq(true)
+    end
+
+    it 'initializes with false value' do
+      boolean = described_class.new(false)
+      expect(boolean.value).to eq(false)
+    end
+
+    it 'converts truthy values to true' do
+      boolean = described_class.new('truthy')
+      expect(boolean.value).to eq(true)
+    end
+
+    it 'converts falsy values to false' do
+      boolean = described_class.new(nil)
+      expect(boolean.value).to eq(false)
+    end
+  end
+
+  describe '#value' do
+    it 'returns the current value' do
+      expect(subject.value).to eq(false)
+    end
+
+    it 'returns the updated value after operations' do
+      subject.make_true
+      expect(subject.value).to eq(true)
+
+      subject.make_false
+      expect(subject.value).to eq(false)
+    end
+  end
+
+  describe '#make_true' do
+    it 'sets the value to true' do
+      expect { subject.make_true }.to change { subject.value }.from(false).to(true)
+    end
+
+    it 'returns true' do
+      result = subject.make_true
+      expect(result).to eq(true)
+    end
+
+    it 'keeps the value true if already true' do
+      subject.make_true
+      expect { subject.make_true }.not_to change { subject.value }
+      expect(subject.value).to eq(true)
+    end
+  end
+
+  describe '#make_false' do
+    it 'sets the value to false' do
+      subject.make_true # Start with true
+      expect { subject.make_false }.to change { subject.value }.from(true).to(false)
+    end
+
+    it 'returns false' do
+      result = subject.make_false
+      expect(result).to eq(false)
+    end
+
+    it 'keeps the value false if already false' do
+      expect { subject.make_false }.not_to change { subject.value }
+      expect(subject.value).to eq(false)
+    end
+  end
+
+  describe '#true?' do
+    it 'returns true when value is true' do
+      subject.make_true
+      expect(subject.true?).to eq(true)
+    end
+
+    it 'returns false when value is false' do
+      expect(subject.true?).to eq(false)
+    end
+  end
+
+  describe '#false?' do
+    it 'returns true when value is false' do
+      expect(subject.false?).to eq(true)
+    end
+
+    it 'returns false when value is true' do
+      subject.make_true
+      expect(subject.false?).to eq(false)
+    end
+  end
+
+  describe 'thread safety' do
+    it 'handles concurrent make_true operations correctly' do
+      boolean = described_class.new(false)
+      threads = []
+
+      10.times do
+        threads << Thread.new do
+          100.times { boolean.make_true }
+        end
+      end
+
+      threads.each(&:join)
+      expect(boolean.value).to eq(true)
+    end
+
+    it 'handles concurrent make_false operations correctly' do
+      boolean = described_class.new(true)
+      threads = []
+
+      10.times do
+        threads << Thread.new do
+          100.times { boolean.make_false }
+        end
+      end
+
+      threads.each(&:join)
+      expect(boolean.value).to eq(false)
+    end
+
+    it 'handles mixed concurrent operations correctly' do
+      boolean = described_class.new(false)
+      threads = []
+      results = []
+
+      # Multiple threads setting to true and false
+      10.times do
+        threads << Thread.new do
+          50.times do
+            boolean.make_true
+            boolean.make_false
+          end
+        end
+      end
+
+      # Reader threads
+      5.times do
+        threads << Thread.new do
+          100.times { results << boolean.value }
+        end
+      end
+
+      threads.each(&:join)
+
+      # All read values should be valid booleans
+      expect(results).to all(satisfy { |v| v == true || v == false })
+    end
+  end
+
+  describe 'drop-in replacement for Concurrent::AtomicBoolean' do
+    it 'provides the same basic API' do
+      # Test that our implementation has the same methods as Concurrent::AtomicBoolean
+      expect(subject).to respond_to(:value)
+      expect(subject).to respond_to(:make_true)
+      expect(subject).to respond_to(:make_false)
+      expect(subject).to respond_to(:true?)
+      expect(subject).to respond_to(:false?)
+    end
+
+    it 'does not expose counter-specific methods' do
+      expect(subject).not_to respond_to(:increment)
+      expect(subject).not_to respond_to(:decrement)
+    end
+
+    it 'behaves identically to Concurrent::AtomicBoolean for basic operations' do
+      # This test documents the expected behavior that matches Concurrent::AtomicBoolean
+      boolean = described_class.new(false)
+
+      expect(boolean.value).to eq(false)
+      expect(boolean.false?).to eq(true)
+      expect(boolean.true?).to eq(false)
+
+      boolean.make_true
+      expect(boolean.value).to eq(true)
+      expect(boolean.true?).to eq(true)
+      expect(boolean.false?).to eq(false)
+
+      boolean.make_false
+      expect(boolean.value).to eq(false)
+      expect(boolean.false?).to eq(true)
+      expect(boolean.true?).to eq(false)
+    end
+  end
+end

data/spec/shoryuken/helpers/atomic_counter_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+RSpec.describe Shoryuken::Helpers::AtomicCounter do
+  subject { described_class.new }
+
+  describe '#initialize' do
+    it 'initializes with default value of 0' do
+      counter = described_class.new
+      expect(counter.value).to eq(0)
+    end
+
+    it 'initializes with custom value' do
+      counter = described_class.new(42)
+      expect(counter.value).to eq(42)
+    end
+
+    it 'initializes with negative value' do
+      counter = described_class.new(-10)
+      expect(counter.value).to eq(-10)
+    end
+  end
+
+  describe '#value' do
+    it 'returns the current value' do
+      expect(subject.value).to eq(0)
+    end
+
+    it 'returns the updated value after operations' do
+      subject.increment
+      expect(subject.value).to eq(1)
+
+      subject.decrement
+      expect(subject.value).to eq(0)
+    end
+  end
+
+  describe '#increment' do
+    it 'increments the counter by 1' do
+      expect { subject.increment }.to change { subject.value }.from(0).to(1)
+    end
+
+    it 'returns the new value' do
+      result = subject.increment
+      expect(result).to eq(1)
+    end
+
+    it 'can be called multiple times' do
+      3.times { subject.increment }
+      expect(subject.value).to eq(3)
+    end
+
+    it 'works with negative initial values' do
+      counter = described_class.new(-5)
+      counter.increment
+      expect(counter.value).to eq(-4)
+    end
+  end
+
+  describe '#decrement' do
+    it 'decrements the counter by 1' do
+      subject.increment # Start at 1
+      expect { subject.decrement }.to change { subject.value }.from(1).to(0)
+    end
+
+    it 'returns the new value' do
+      subject.increment # Start at 1
+      result = subject.decrement
+      expect(result).to eq(0)
+    end
+
+    it 'can go negative' do
+      subject.decrement
+      expect(subject.value).to eq(-1)
+    end
+
+    it 'can be called multiple times' do
+      3.times { subject.decrement }
+      expect(subject.value).to eq(-3)
+    end
+  end
+
+  describe 'thread safety' do
+    it 'handles concurrent increments correctly' do
+      counter = described_class.new
+      threads = []
+
+      10.times do
+        threads << Thread.new do
+          100.times { counter.increment }
+        end
+      end
+
+      threads.each(&:join)
+      expect(counter.value).to eq(1000)
+    end
+
+    it 'handles concurrent decrements correctly' do
+      counter = described_class.new(1000)
+      threads = []
+
+      10.times do
+        threads << Thread.new do
+          100.times { counter.decrement }
+        end
+      end
+
+      threads.each(&:join)
+      expect(counter.value).to eq(0)
+    end
+
+    it 'handles mixed concurrent operations correctly' do
+      counter = described_class.new
+      threads = []
+
+      # 5 threads incrementing
+      5.times do
+        threads << Thread.new do
+          100.times { counter.increment }
+        end
+      end
+
+      # 3 threads decrementing
+      3.times do
+        threads << Thread.new do
+          100.times { counter.decrement }
+        end
+      end
+
+      threads.each(&:join)
+      expect(counter.value).to eq(200) # 500 increments - 300 decrements
+    end
+
+    it 'provides atomic read operations' do
+      counter = described_class.new
+      values_read = []
+
+      # Writer thread
+      writer = Thread.new do
+        1000.times { counter.increment }
+      end
+
+      # Reader threads
+      readers = 5.times.map do
+        Thread.new do
+          100.times { values_read << counter.value }
+        end
+      end
+
+      [writer, *readers].each(&:join)
+
+      # All read values should be valid integers (not partial writes)
+      expect(values_read).to all(be_an(Integer))
+      expect(values_read).to all(be >= 0)
+      expect(values_read).to all(be <= 1000)
+    end
+  end
+
+  describe 'drop-in replacement for Concurrent::AtomicFixnum' do
+    it 'provides the same basic API' do
+      # Test that our implementation has the same methods as Concurrent::AtomicFixnum
+      expect(subject).to respond_to(:value)
+      expect(subject).to respond_to(:increment)
+      expect(subject).to respond_to(:decrement)
+    end
+
+    it 'behaves identically to Concurrent::AtomicFixnum for basic operations' do
+      # This test documents the expected behavior that matches Concurrent::AtomicFixnum
+      counter = described_class.new(5)
+
+      expect(counter.value).to eq(5)
+      expect(counter.increment).to eq(6)
+      expect(counter.value).to eq(6)
+      expect(counter.decrement).to eq(5)
+      expect(counter.value).to eq(5)
+    end
+  end
+end