shoryuken 7.0.0.alpha1 → 7.0.0.rc1

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