shoryuken 7.0.0.alpha1 → 7.0.0.alpha2

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

data/spec/shoryuken/helpers/hash_utils_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Helpers::HashUtils do
+  describe '.deep_symbolize_keys' do
+    it 'converts string keys to symbols' do
+      input = { 'key1' => 'value1', 'key2' => 'value2' }
+      expected = { key1: 'value1', key2: 'value2' }
+      
+      expect(described_class.deep_symbolize_keys(input)).to eq(expected)
+    end
+
+    it 'leaves symbol keys unchanged' do
+      input = { key1: 'value1', key2: 'value2' }
+      expected = { key1: 'value1', key2: 'value2' }
+      
+      expect(described_class.deep_symbolize_keys(input)).to eq(expected)
+    end
+
+    it 'handles mixed key types' do
+      input = { 'string_key' => 'value1', :symbol_key => 'value2' }
+      expected = { string_key: 'value1', symbol_key: 'value2' }
+      
+      expect(described_class.deep_symbolize_keys(input)).to eq(expected)
+    end
+
+    it 'converts keys recursively in nested hashes' do
+      input = {
+        'level1' => {
+          'level2' => {
+            'level3' => 'deep_value'
+          },
+          'other_level2' => 'value'
+        },
+        'top_level' => 'value'
+      }
+      
+      expected = {
+        level1: {
+          level2: {
+            level3: 'deep_value'
+          },
+          other_level2: 'value'
+        },
+        top_level: 'value'
+      }
+      
+      expect(described_class.deep_symbolize_keys(input)).to eq(expected)
+    end
+
+    it 'preserves non-hash values in nested structures' do
+      input = {
+        'config' => {
+          'timeout' => 30,
+          'enabled' => true,
+          'tags' => ['tag1', 'tag2'],
+          'metadata' => nil
+        }
+      }
+      
+      expected = {
+        config: {
+          timeout: 30,
+          enabled: true,
+          tags: ['tag1', 'tag2'],
+          metadata: nil
+        }
+      }
+      
+      expect(described_class.deep_symbolize_keys(input)).to eq(expected)
+    end
+
+    it 'handles empty hash' do
+      expect(described_class.deep_symbolize_keys({})).to eq({})
+    end
+
+    it 'handles hash with empty nested hash' do
+      input = { 'key' => {} }
+      expected = { key: {} }
+      
+      expect(described_class.deep_symbolize_keys(input)).to eq(expected)
+    end
+
+    it 'returns non-hash input unchanged' do
+      expect(described_class.deep_symbolize_keys('string')).to eq('string')
+      expect(described_class.deep_symbolize_keys(123)).to eq(123)
+      expect(described_class.deep_symbolize_keys([])).to eq([])
+      expect(described_class.deep_symbolize_keys(nil)).to be_nil
+      expect(described_class.deep_symbolize_keys(true)).to be true
+    end
+
+    it 'handles keys that cannot be converted to symbols' do
+      # Create a key that will raise an exception when converted to symbol
+      problematic_key = Object.new
+      allow(problematic_key).to receive(:to_sym).and_raise(StandardError)
+      
+      input = { problematic_key => 'value', 'normal_key' => 'normal_value' }
+      result = described_class.deep_symbolize_keys(input)
+      
+      # The problematic key should remain as-is, normal key should be symbolized
+      expect(result[problematic_key]).to eq('value')
+      expect(result[:normal_key]).to eq('normal_value')
+    end
+
+    it 'does not modify the original hash' do
+      input = { 'key' => { 'nested' => 'value' } }
+      original_input = input.dup
+      
+      described_class.deep_symbolize_keys(input)
+      
+      expect(input).to eq(original_input)
+    end
+
+    context 'with configuration-like data' do
+      it 'processes typical YAML configuration' do
+        input = {
+          'database' => {
+            'host' => 'localhost',
+            'port' => 5432,
+            'ssl' => true
+          },
+          'queues' => {
+            'default' => { 'concurrency' => 5 },
+            'mailers' => { 'concurrency' => 2 }
+          }
+        }
+        
+        expected = {
+          database: {
+            host: 'localhost',
+            port: 5432,
+            ssl: true
+          },
+          queues: {
+            default: { concurrency: 5 },
+            mailers: { concurrency: 2 }
+          }
+        }
+        
+        expect(described_class.deep_symbolize_keys(input)).to eq(expected)
+      end
+    end
+  end
+end

data/spec/shoryuken/helpers/string_utils_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Helpers::StringUtils do
+  describe '.constantize' do
+    it 'returns a simple constant' do
+      expect(described_class.constantize('Object')).to eq(Object)
+      expect(described_class.constantize('String')).to eq(String)
+      expect(described_class.constantize('Hash')).to eq(Hash)
+    end
+
+    it 'returns nested constants' do
+      expect(described_class.constantize('Shoryuken::Helpers::StringUtils')).to eq(Shoryuken::Helpers::StringUtils)
+      expect(described_class.constantize('Shoryuken::Helpers::AtomicCounter')).to eq(Shoryuken::Helpers::AtomicCounter)
+    end
+
+    it 'handles leading double colon' do
+      expect(described_class.constantize('::Object')).to eq(Object)
+      expect(described_class.constantize('::String')).to eq(String)
+      expect(described_class.constantize('::Shoryuken::Helpers::StringUtils')).to eq(Shoryuken::Helpers::StringUtils)
+    end
+
+    it 'handles empty string' do
+      expect(described_class.constantize('')).to eq(Object)
+    end
+
+    it 'handles string with only double colons' do
+      expect(described_class.constantize('::')).to eq(Object)
+      expect(described_class.constantize('::::')).to eq(Object)
+    end
+
+    it 'raises NameError for non-existent constants' do
+      expect { described_class.constantize('NonExistentClass') }.to raise_error(NameError)
+      expect { described_class.constantize('Shoryuken::NonExistentClass') }.to raise_error(NameError)
+      expect { described_class.constantize('NonExistent::AlsoNonExistent') }.to raise_error(NameError)
+    end
+
+    it 'raises NameError for partially invalid nested constants' do
+      expect { described_class.constantize('Shoryuken::NonExistent::AlsoNonExistent') }.to raise_error(NameError)
+    end
+
+    context 'with dynamically defined constants' do
+      before do
+        # Define a temporary constant for testing
+        Object.const_set('TempTestClass', Class.new)
+        TempTestClass.const_set('NestedClass', Class.new)
+      end
+
+      after do
+        # Clean up the temporary constant
+        Object.send(:remove_const, 'TempTestClass') if Object.const_defined?('TempTestClass')
+      end
+
+      it 'finds dynamically defined constants' do
+        expect(described_class.constantize('TempTestClass')).to eq(TempTestClass)
+      end
+
+      it 'finds nested dynamically defined constants' do
+        expect(described_class.constantize('TempTestClass::NestedClass')).to eq(TempTestClass::NestedClass)
+      end
+    end
+
+    context 'with module constants' do
+      it 'returns module constants' do
+        expect(described_class.constantize('Shoryuken')).to eq(Shoryuken)
+        expect(described_class.constantize('Shoryuken::Helpers')).to eq(Shoryuken::Helpers)
+      end
+    end
+
+    context 'with worker class scenarios' do
+      before do
+        # Simulate typical worker class scenarios
+        unless Object.const_defined?('MyApp')
+          Object.const_set('MyApp', Module.new)
+        end
+        
+        unless MyApp.const_defined?('EmailWorker')
+          MyApp.const_set('EmailWorker', Class.new)
+        end
+      end
+
+      after do
+        # Clean up
+        MyApp.send(:remove_const, 'EmailWorker') if MyApp.const_defined?('EmailWorker')
+        Object.send(:remove_const, 'MyApp') if Object.const_defined?('MyApp')
+      end
+
+      it 'loads worker classes from string names' do
+        worker_class = described_class.constantize('MyApp::EmailWorker')
+        expect(worker_class).to eq(MyApp::EmailWorker)
+        expect(worker_class.new).to be_an_instance_of(MyApp::EmailWorker)
+      end
+    end
+
+    context 'edge cases' do
+      it 'handles constants with numbers' do
+        # Using existing constants that might have numbers
+        expect(described_class.constantize('Encoding::UTF_8')).to eq(Encoding::UTF_8)
+      end
+
+      it 'is case sensitive' do
+        expect { described_class.constantize('object') }.to raise_error(NameError)
+        expect { described_class.constantize('STRING') }.to raise_error(NameError)
+      end
+
+      it 'handles single character constant names' do
+        # Define a single character constant for testing
+        Object.const_set('A', Class.new) unless Object.const_defined?('A')
+        
+        expect(described_class.constantize('A')).to eq(A)
+        
+        # Clean up
+        Object.send(:remove_const, 'A') if Object.const_defined?('A')
+      end
+    end
+
+    context 'error messages' do
+      it 'provides meaningful error messages' do
+        expect { described_class.constantize('NonExistent') }.to raise_error(NameError, /NonExistent/)
+      end
+    end
+  end
+end

data/spec/shoryuken/helpers_integration_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Helpers Integration' do
+  # Integration tests for helper utility methods that replaced core extensions
+  
+  describe Shoryuken::Helpers::HashUtils do
+    describe '.deep_symbolize_keys' do
+      it 'converts keys into symbols recursively' do
+        input = { :key1 => 'value1',
+                 'key2' => 'value2',
+                 'key3' => {
+                   'key31' => { 'key311' => 'value311' },
+                   'key32' => 'value32'
+                 } }
+        
+        expected = { key1: 'value1',
+                    key2: 'value2',
+                    key3: { key31: { key311: 'value311' },
+                            key32: 'value32' } }
+        
+        expect(Shoryuken::Helpers::HashUtils.deep_symbolize_keys(input)).to eq(expected)
+      end
+
+      it 'handles non-hash input gracefully' do
+        expect(Shoryuken::Helpers::HashUtils.deep_symbolize_keys('string')).to eq('string')
+        expect(Shoryuken::Helpers::HashUtils.deep_symbolize_keys(123)).to eq(123)
+        expect(Shoryuken::Helpers::HashUtils.deep_symbolize_keys(nil)).to be_nil
+      end
+
+      it 'handles empty hash' do
+        expect(Shoryuken::Helpers::HashUtils.deep_symbolize_keys({})).to eq({})
+      end
+
+      it 'handles mixed value types' do
+        input = { 'key1' => 'string', 'key2' => 123, 'key3' => { 'nested' => true } }
+        expected = { key1: 'string', key2: 123, key3: { nested: true } }
+        
+        expect(Shoryuken::Helpers::HashUtils.deep_symbolize_keys(input)).to eq(expected)
+      end
+    end
+  end
+
+  describe Shoryuken::Helpers::StringUtils do
+    describe '.constantize' do
+      class HelloWorld; end
+      
+      it 'returns a class from a string' do
+        expect(Shoryuken::Helpers::StringUtils.constantize('HelloWorld')).to eq(HelloWorld)
+      end
+
+      it 'handles nested constants' do
+        expect(Shoryuken::Helpers::StringUtils.constantize('Shoryuken::Helpers::StringUtils')).to eq(Shoryuken::Helpers::StringUtils)
+      end
+
+      it 'raises NameError for non-existent constants' do
+        expect { Shoryuken::Helpers::StringUtils.constantize('NonExistentClass') }.to raise_error(NameError)
+      end
+
+      it 'handles empty string' do
+        expect(Shoryuken::Helpers::StringUtils.constantize('')).to eq(Object)
+      end
+
+      it 'handles leading double colon' do
+        expect(Shoryuken::Helpers::StringUtils.constantize('::Object')).to eq(Object)
+      end
+    end
+  end
+
+  describe 'Integration scenarios' do
+    it 'processes configuration data end-to-end' do
+      # Simulate loading YAML config and converting worker class names
+      config_data = {
+        'queues' => {
+          'default' => { 'worker_class' => 'Object' },
+          'mailers' => { 'worker_class' => 'String' }
+        }
+      }
+      
+      symbolized = Shoryuken::Helpers::HashUtils.deep_symbolize_keys(config_data)
+      
+      expect(symbolized).to eq({
+        queues: {
+          default: { worker_class: 'Object' },
+          mailers: { worker_class: 'String' }
+        }
+      })
+      
+      # Test constantizing the worker classes
+      default_worker = Shoryuken::Helpers::StringUtils.constantize(symbolized[:queues][:default][:worker_class])
+      mailer_worker = Shoryuken::Helpers::StringUtils.constantize(symbolized[:queues][:mailers][:worker_class])
+      
+      expect(default_worker).to eq(Object)
+      expect(mailer_worker).to eq(String)
+    end
+  end
+end