shoryuken 7.0.0.alpha2 → 7.0.0

data/spec/lib/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 → lib/shoryuken}/helpers_integration_spec.rb

@@ -2,7 +2,7 @@
 
 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
@@ -12,12 +12,12 @@ RSpec.describe 'Helpers Integration' do
                    '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
 
@@ -34,7 +34,7 @@ RSpec.describe 'Helpers Integration' do
       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
@@ -43,7 +43,7 @@ RSpec.describe 'Helpers Integration' do
   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
@@ -75,20 +75,20 @@ RSpec.describe 'Helpers Integration' do
           '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

data/spec/{shoryuken → lib/shoryuken}/launcher_spec.rb

@@ -101,4 +101,26 @@ RSpec.describe Shoryuken::Launcher do
       expect(second_group_manager).to have_received(:stop_new_dispatching)
     end
   end
+
+  describe '#stopping?' do
+    it 'returns false by default' do
+      expect(subject.stopping?).to be false
+    end
+
+    it 'returns true after stop is called' do
+      allow(first_group_manager).to receive(:stop_new_dispatching)
+      allow(first_group_manager).to receive(:await_dispatching_in_progress)
+      allow(second_group_manager).to receive(:stop_new_dispatching)
+      allow(second_group_manager).to receive(:await_dispatching_in_progress)
+
+      expect { subject.stop }.to change { subject.stopping? }.from(false).to(true)
+    end
+
+    it 'returns true after stop! is called' do
+      allow(first_group_manager).to receive(:stop_new_dispatching)
+      allow(second_group_manager).to receive(:stop_new_dispatching)
+
+      expect { subject.stop! }.to change { subject.stopping? }.from(false).to(true)
+    end
+  end
 end

data/spec/lib/shoryuken/logging_spec.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Logging do
+  describe Shoryuken::Logging::Base do
+    let(:formatter) { described_class.new }
+
+    describe '#tid' do
+      it 'returns a string representing the thread ID' do
+        expect(formatter.tid).to be_a(String)
+      end
+
+      it 'returns the same value for the same thread' do
+        tid1 = formatter.tid
+        tid2 = formatter.tid
+        expect(tid1).to eq(tid2)
+      end
+
+      it 'caches the thread ID in thread-local storage' do
+        tid = formatter.tid
+        expect(Thread.current['shoryuken_tid']).to eq(tid)
+      end
+    end
+
+    describe '#context' do
+      after do
+        Shoryuken::Logging.context_storage[:shoryuken_context] = nil
+      end
+
+      it 'returns empty string when no context is set' do
+        Shoryuken::Logging.context_storage[:shoryuken_context] = nil
+        expect(formatter.context).to eq('')
+      end
+
+      it 'returns formatted context when context is set' do
+        Shoryuken::Logging.context_storage[:shoryuken_context] = 'test_context'
+        expect(formatter.context).to eq(' test_context')
+      end
+    end
+  end
+
+  describe Shoryuken::Logging::Pretty do
+    let(:formatter) { described_class.new }
+    let(:time) { Time.new(2023, 8, 15, 10, 30, 45, '+00:00') }
+
+    describe '#call' do
+      after do
+        Shoryuken::Logging.context_storage[:shoryuken_context] = nil
+      end
+
+      it 'formats log messages with timestamp' do
+        allow(formatter).to receive(:tid).and_return('abc123')
+        Shoryuken::Logging.context_storage[:shoryuken_context] = nil
+
+        result = formatter.call('INFO', time, 'program', 'test message')
+        expect(result).to eq("2023-08-15T10:30:45Z #{Process.pid} TID-abc123 INFO: test message\n")
+      end
+
+      it 'includes context when present' do
+        allow(formatter).to receive(:tid).and_return('abc123')
+        Shoryuken::Logging.context_storage[:shoryuken_context] = 'worker-1'
+
+        result = formatter.call('ERROR', time, 'program', 'error message')
+        expect(result).to eq("2023-08-15T10:30:45Z #{Process.pid} TID-abc123 worker-1 ERROR: error message\n")
+      end
+    end
+  end
+
+  describe Shoryuken::Logging::WithoutTimestamp do
+    let(:formatter) { described_class.new }
+
+    describe '#call' do
+      after do
+        Shoryuken::Logging.context_storage[:shoryuken_context] = nil
+      end
+
+      it 'formats log messages without timestamp' do
+        allow(formatter).to receive(:tid).and_return('xyz789')
+        Shoryuken::Logging.context_storage[:shoryuken_context] = nil
+
+        result = formatter.call('DEBUG', Time.now, 'program', 'debug message')
+        expect(result).to eq("pid=#{Process.pid} tid=xyz789 DEBUG: debug message\n")
+      end
+
+      it 'includes context when present' do
+        allow(formatter).to receive(:tid).and_return('xyz789')
+        Shoryuken::Logging.context_storage[:shoryuken_context] = 'queue-processor'
+
+        result = formatter.call('WARN', Time.now, 'program', 'warning message')
+        expect(result).to eq("pid=#{Process.pid} tid=xyz789 queue-processor WARN: warning message\n")
+      end
+    end
+  end
+
+  describe '.with_context' do
+    after do
+      described_class.context_storage[:shoryuken_context] = nil
+    end
+
+    it 'sets context for the duration of the block' do
+      described_class.with_context('test_context') do
+        expect(described_class.current_context).to eq('test_context')
+      end
+    end
+
+    it 'clears context after the block completes' do
+      described_class.with_context('test_context') do
+        # context is set
+      end
+      expect(described_class.current_context).to be_nil
+    end
+
+    it 'clears context even when an exception is raised' do
+      expect do
+        described_class.with_context('test_context') do
+          raise StandardError, 'test error'
+        end
+      end.to raise_error(StandardError, 'test error')
+
+      expect(described_class.current_context).to be_nil
+    end
+
+    it 'returns the value of the block' do
+      result = described_class.with_context('test_context') do
+        'block_result'
+      end
+      expect(result).to eq('block_result')
+    end
+
+    it 'preserves outer context in nested calls' do
+      described_class.with_context('outer') do
+        expect(described_class.current_context).to eq('outer')
+
+        described_class.with_context('inner') do
+          expect(described_class.current_context).to eq('inner')
+        end
+
+        expect(described_class.current_context).to eq('outer')
+      end
+      expect(described_class.current_context).to be_nil
+    end
+
+    it 'restores outer context even when inner block raises' do
+      described_class.with_context('outer') do
+        expect do
+          described_class.with_context('inner') do
+            raise StandardError, 'inner error'
+          end
+        end.to raise_error(StandardError, 'inner error')
+
+        expect(described_class.current_context).to eq('outer')
+      end
+    end
+  end
+
+  describe '.current_context' do
+    after do
+      described_class.context_storage[:shoryuken_context] = nil
+    end
+
+    it 'returns nil when no context is set' do
+      expect(described_class.current_context).to be_nil
+    end
+
+    it 'returns the current context value' do
+      described_class.context_storage[:shoryuken_context] = 'test_value'
+      expect(described_class.current_context).to eq('test_value')
+    end
+  end
+
+  describe '.context_storage' do
+    it 'returns Fiber for fiber-local storage' do
+      expect(described_class.context_storage).to eq(Fiber)
+    end
+  end
+
+  describe '.initialize_logger' do
+    it 'creates a new Logger instance' do
+      logger = described_class.initialize_logger
+      expect(logger).to be_a(Logger)
+    end
+
+    it 'sets default log level to INFO' do
+      logger = described_class.initialize_logger
+      expect(logger.level).to eq(Logger::INFO)
+    end
+
+    it 'uses Pretty formatter by default' do
+      logger = described_class.initialize_logger
+      expect(logger.formatter).to be_a(Shoryuken::Logging::Pretty)
+    end
+
+    it 'accepts custom log target' do
+      log_target = StringIO.new
+      logger = described_class.initialize_logger(log_target)
+      expect(logger.instance_variable_get(:@logdev).dev).to eq(log_target)
+    end
+  end
+
+  describe '.logger' do
+    after do
+      # Reset the instance variable to avoid affecting other tests
+      described_class.instance_variable_set(:@logger, nil)
+    end
+
+    it 'returns a logger instance' do
+      expect(described_class.logger).to be_a(Logger)
+    end
+
+    it 'memoizes the logger instance' do
+      logger1 = described_class.logger
+      logger2 = described_class.logger
+      expect(logger1).to be(logger2)
+    end
+
+    it 'initializes logger if not already set' do
+      expect(described_class).to receive(:initialize_logger).and_call_original
+      described_class.logger
+    end
+  end
+
+  describe '.logger=' do
+    after do
+      # Reset the instance variable to avoid affecting other tests
+      described_class.instance_variable_set(:@logger, nil)
+    end
+
+    it 'sets the logger instance' do
+      custom_logger = Logger.new('/dev/null')
+      described_class.logger = custom_logger
+      expect(described_class.logger).to be(custom_logger)
+    end
+
+    it 'sets null logger when passed nil' do
+      described_class.logger = nil
+      logger = described_class.logger
+      # The logger should be configured to output to /dev/null
+      expect(logger).to be_a(Logger)
+    end
+  end
+end