shoryuken 7.0.0.alpha1 → 7.0.0.rc1

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

data/spec/shoryuken/helpers/atomic_hash_spec.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+RSpec.describe Shoryuken::Helpers::AtomicHash do
+  subject { described_class.new }
+
+  describe '#initialize' do
+    it 'creates an empty hash' do
+      hash = described_class.new
+      expect(hash.keys).to eq([])
+    end
+  end
+
+  describe '#[]' do
+    it 'returns nil for missing keys' do
+      expect(subject['missing']).to be_nil
+    end
+
+    it 'returns stored values' do
+      subject['key'] = 'value'
+      expect(subject['key']).to eq('value')
+    end
+
+    it 'works with different key types' do
+      subject[:symbol] = 'symbol_value'
+      subject[42] = 'number_value'
+
+      expect(subject[:symbol]).to eq('symbol_value')
+      expect(subject[42]).to eq('number_value')
+    end
+  end
+
+  describe '#[]=' do
+    it 'stores values' do
+      subject['key'] = 'value'
+      expect(subject['key']).to eq('value')
+    end
+
+    it 'overwrites existing values' do
+      subject['key'] = 'old_value'
+      subject['key'] = 'new_value'
+      expect(subject['key']).to eq('new_value')
+    end
+
+    it 'returns the assigned value' do
+      result = (subject['key'] = 'value')
+      expect(result).to eq('value')
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all entries' do
+      subject['key1'] = 'value1'
+      subject['key2'] = 'value2'
+
+      expect(subject.keys.size).to eq(2)
+
+      subject.clear
+
+      expect(subject.keys).to eq([])
+      expect(subject['key1']).to be_nil
+      expect(subject['key2']).to be_nil
+    end
+
+    it 'returns the hash itself' do
+      subject['key'] = 'value'
+      result = subject.clear
+      expect(result).to eq({})
+    end
+  end
+
+  describe '#keys' do
+    it 'returns empty array for empty hash' do
+      expect(subject.keys).to eq([])
+    end
+
+    it 'returns all keys' do
+      subject['key1'] = 'value1'
+      subject[:key2] = 'value2'
+      subject[42] = 'value3'
+
+      keys = subject.keys
+      expect(keys).to contain_exactly('key1', :key2, 42)
+    end
+
+    it 'reflects changes after modifications' do
+      subject['key'] = 'value'
+      expect(subject.keys).to eq(['key'])
+
+      subject.clear
+      expect(subject.keys).to eq([])
+    end
+  end
+
+  describe '#fetch' do
+    it 'returns value for existing key' do
+      subject['key'] = 'value'
+      expect(subject.fetch('key')).to eq('value')
+    end
+
+    it 'returns default for missing key' do
+      expect(subject.fetch('missing', 'default')).to eq('default')
+    end
+
+    it 'returns nil as default when no default provided' do
+      expect(subject.fetch('missing')).to be_nil
+    end
+
+    it 'works with different default types' do
+      expect(subject.fetch('missing', [])).to eq([])
+      expect(subject.fetch('missing', {})).to eq({})
+      expect(subject.fetch('missing', 42)).to eq(42)
+    end
+  end
+
+  describe 'thread safety' do
+    it 'handles concurrent writes correctly' do
+      hash = described_class.new
+      threads = []
+
+      # 10 threads, each writing 100 different keys
+      10.times do |thread_id|
+        threads << Thread.new do
+          100.times do |i|
+            key = "thread_#{thread_id}_key_#{i}"
+            hash[key] = "value_#{i}"
+          end
+        end
+      end
+
+      threads.each(&:join)
+
+      # Verify all 1000 keys were written
+      expect(hash.keys.size).to eq(1000)
+
+      # Verify a sample of values
+      expect(hash['thread_0_key_0']).to eq('value_0')
+      expect(hash['thread_9_key_99']).to eq('value_99')
+    end
+
+    it 'handles concurrent reads correctly' do
+      hash = described_class.new
+
+      # Pre-populate hash
+      100.times { |i| hash["key_#{i}"] = "value_#{i}" }
+
+      read_results = []
+      threads = []
+
+      # 10 threads, each reading 100 times
+      10.times do
+        threads << Thread.new do
+          100.times do |i|
+            key = "key_#{i % 100}"
+            read_results << hash[key]
+          end
+        end
+      end
+
+      threads.each(&:join)
+
+      # All reads should succeed
+      expect(read_results.size).to eq(1000)
+      expect(read_results.compact.size).to eq(1000)
+    end
+
+    it 'handles mixed concurrent read/write operations' do
+      hash = described_class.new
+      threads = []
+
+      # Writer threads
+      5.times do |thread_id|
+        threads << Thread.new do
+          50.times do |i|
+            hash["writer_#{thread_id}_#{i}"] = "value_#{i}"
+          end
+        end
+      end
+
+      # Reader threads
+      5.times do
+        threads << Thread.new do
+          100.times do |i|
+            # Read existing keys
+            hash["writer_0_#{i % 50}"]
+          end
+        end
+      end
+
+      # Clear operations
+      2.times do
+        threads << Thread.new do
+          sleep(0.001) # Let some writes happen first
+          hash.clear
+        end
+      end
+
+      threads.each(&:join)
+
+      # The hash should be valid (not corrupted)
+      # After clear operations, it might be empty or have some keys
+      expect(hash.keys).to be_an(Array)
+    end
+
+    it 'provides thread-safe key enumeration' do
+      hash = described_class.new
+      threads = []
+      keys_snapshots = []
+
+      # Writer thread
+      writer = Thread.new do
+        100.times { |i| hash["key_#{i}"] = i }
+      end
+
+      # Reader threads taking snapshots of keys
+      5.times do
+        threads << Thread.new do
+          20.times do
+            keys_snapshots << hash.keys.dup
+          end
+        end
+      end
+
+      [writer, *threads].each(&:join)
+
+      # All snapshots should be valid arrays
+      keys_snapshots.each do |snapshot|
+        expect(snapshot).to be_an(Array)
+        # Keys should be valid
+        snapshot.each { |key| expect(key).to be_a(String) }
+      end
+    end
+  end
+
+  describe 'mutex synchronization' do
+    it 'ensures all operations are atomic' do
+      hash = described_class.new
+
+      # Verify basic operations work correctly
+      hash['key'] = 'value'
+      expect(hash['key']).to eq('value')
+      expect(hash.keys).to eq(['key'])
+
+      hash.clear
+      expect(hash.keys).to eq([])
+      expect(hash['key']).to be_nil
+    end
+  end
+
+  describe 'drop-in replacement for Concurrent::Hash' do
+    it 'provides the same basic API' do
+      # Test that our implementation has the same methods as Concurrent::Hash
+      expect(subject).to respond_to(:[])
+      expect(subject).to respond_to(:[]=)
+      expect(subject).to respond_to(:clear)
+      expect(subject).to respond_to(:keys)
+      expect(subject).to respond_to(:fetch)
+    end
+
+    it 'behaves identically to Concurrent::Hash for basic operations' do
+      # This test documents the expected behavior that matches Concurrent::Hash
+      hash = described_class.new
+
+      # Test assignment and retrieval
+      hash['queue1'] = 'Worker1'
+      expect(hash['queue1']).to eq('Worker1')
+
+      # Test keys
+      expect(hash.keys).to eq(['queue1'])
+
+      # Test fetch with default
+      expect(hash.fetch('queue1')).to eq('Worker1')
+      expect(hash.fetch('missing', 'default')).to eq('default')
+
+      # Test clear
+      hash.clear
+      expect(hash.keys).to eq([])
+      expect(hash['queue1']).to be_nil
+    end
+
+    it 'matches DefaultWorkerRegistry usage patterns' do
+      # Test the exact patterns used in DefaultWorkerRegistry
+      hash = described_class.new
+
+      # Pattern from register_worker method
+      queue = 'test_queue'
+      clazz = 'TestWorker'
+      hash[queue] = clazz
+
+      # Pattern from batch_receive_messages? method
+      expect(hash[queue]).to eq(clazz)
+
+      # Pattern from fetch_worker method  
+      expect(hash[queue]).to eq(clazz)
+
+      # Pattern from queues method
+      expect(hash.keys).to eq([queue])
+
+      # Pattern from workers method (with fetch and default)
+      expect(hash.fetch(queue, [])).to eq(clazz)
+      expect(hash.fetch('missing', [])).to eq([])
+
+      # Pattern from clear method
+      hash.clear
+      expect(hash.keys).to eq([])
+    end
+  end
+end