shoryuken 7.0.0.alpha1 → 7.0.0.alpha2

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