shoryuken 6.2.1 → 7.0.2

data/spec/lib/shoryuken/inline_message_spec.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+RSpec.describe Shoryuken::InlineMessage do
+  let(:body) { '{"message": "test"}' }
+  let(:attributes) { { 'SentTimestamp' => '1234567890' } }
+  let(:md5_of_body) { 'abc123def456' }
+  let(:md5_of_message_attributes) { 'def456abc123' }
+  let(:message_attributes) { { 'CustomAttribute' => { string_value: 'value', data_type: 'String' } } }
+  let(:message_id) { 'msg-12345' }
+  let(:receipt_handle) { 'receipt-handle-12345' }
+  let(:delete) { nil }
+  let(:queue_name) { 'test-queue' }
+
+  describe '#new' do
+    context 'with positional arguments' do
+      subject do
+        described_class.new(
+          body: body,
+          attributes: attributes,
+          md5_of_body: md5_of_body,
+          md5_of_message_attributes: md5_of_message_attributes,
+          message_attributes: message_attributes,
+          message_id: message_id,
+          receipt_handle: receipt_handle,
+          delete: delete,
+          queue_name: queue_name
+        )
+      end
+
+      it 'initializes with all attributes' do
+        expect(subject.body).to eq(body)
+        expect(subject.attributes).to eq(attributes)
+        expect(subject.md5_of_body).to eq(md5_of_body)
+        expect(subject.md5_of_message_attributes).to eq(md5_of_message_attributes)
+        expect(subject.message_attributes).to eq(message_attributes)
+        expect(subject.message_id).to eq(message_id)
+        expect(subject.receipt_handle).to eq(receipt_handle)
+        expect(subject.delete).to eq(delete)
+        expect(subject.queue_name).to eq(queue_name)
+      end
+    end
+
+    context 'with keyword arguments' do
+      subject do
+        described_class.new(
+          body: body,
+          attributes: attributes,
+          md5_of_body: md5_of_body,
+          md5_of_message_attributes: md5_of_message_attributes,
+          message_attributes: message_attributes,
+          message_id: message_id,
+          receipt_handle: receipt_handle,
+          delete: delete,
+          queue_name: queue_name
+        )
+      end
+
+      it 'initializes with all attributes' do
+        expect(subject.body).to eq(body)
+        expect(subject.attributes).to eq(attributes)
+        expect(subject.md5_of_body).to eq(md5_of_body)
+        expect(subject.md5_of_message_attributes).to eq(md5_of_message_attributes)
+        expect(subject.message_attributes).to eq(message_attributes)
+        expect(subject.message_id).to eq(message_id)
+        expect(subject.receipt_handle).to eq(receipt_handle)
+        expect(subject.delete).to eq(delete)
+        expect(subject.queue_name).to eq(queue_name)
+      end
+    end
+
+    context 'with nil values' do
+      subject do
+        described_class.new(
+          body: body,
+          attributes: nil,
+          md5_of_body: nil,
+          md5_of_message_attributes: nil,
+          message_attributes: message_attributes,
+          message_id: nil,
+          receipt_handle: nil,
+          delete: nil,
+          queue_name: queue_name
+        )
+      end
+
+      it 'handles nil values correctly' do
+        expect(subject.body).to eq(body)
+        expect(subject.attributes).to be_nil
+        expect(subject.md5_of_body).to be_nil
+        expect(subject.md5_of_message_attributes).to be_nil
+        expect(subject.message_attributes).to eq(message_attributes)
+        expect(subject.message_id).to be_nil
+        expect(subject.receipt_handle).to be_nil
+        expect(subject.delete).to be_nil
+        expect(subject.queue_name).to eq(queue_name)
+      end
+    end
+
+    context 'with minimal required attributes' do
+      subject { described_class.new(body: body, queue_name: queue_name) }
+
+      it 'initializes with only required attributes' do
+        expect(subject.body).to eq(body)
+        expect(subject.queue_name).to eq(queue_name)
+        expect(subject.attributes).to be_nil
+        expect(subject.md5_of_body).to be_nil
+        expect(subject.md5_of_message_attributes).to be_nil
+        expect(subject.message_attributes).to be_nil
+        expect(subject.message_id).to be_nil
+        expect(subject.receipt_handle).to be_nil
+        expect(subject.delete).to be_nil
+      end
+    end
+  end
+
+  describe 'attribute accessors' do
+    subject do
+      described_class.new(
+        body: body,
+        attributes: attributes,
+        md5_of_body: md5_of_body,
+        md5_of_message_attributes: md5_of_message_attributes,
+        message_attributes: message_attributes,
+        message_id: message_id,
+        receipt_handle: receipt_handle,
+        delete: delete,
+        queue_name: queue_name
+      )
+    end
+
+    it 'provides read access to all attributes' do
+      expect(subject.body).to eq(body)
+      expect(subject.attributes).to eq(attributes)
+      expect(subject.md5_of_body).to eq(md5_of_body)
+      expect(subject.md5_of_message_attributes).to eq(md5_of_message_attributes)
+      expect(subject.message_attributes).to eq(message_attributes)
+      expect(subject.message_id).to eq(message_id)
+      expect(subject.receipt_handle).to eq(receipt_handle)
+      expect(subject.delete).to eq(delete)
+      expect(subject.queue_name).to eq(queue_name)
+    end
+
+    it 'provides write access to all attributes' do
+      new_body = '{"updated": "message"}'
+      new_queue_name = 'updated-queue'
+
+      subject.body = new_body
+      subject.queue_name = new_queue_name
+
+      expect(subject.body).to eq(new_body)
+      expect(subject.queue_name).to eq(new_queue_name)
+    end
+  end
+
+  describe 'struct behavior' do
+    subject { described_class.new(body: body, queue_name: queue_name) }
+
+    it 'behaves like a struct' do
+      expect(subject).to be_a(Struct)
+      expect(subject.class.superclass).to eq(Struct)
+    end
+
+    it 'supports array-like access' do
+      expect(subject[0]).to eq(body)  # body is first attribute
+      expect(subject[-1]).to eq(queue_name)  # queue_name is last attribute
+    end
+
+    it 'supports enumeration' do
+      values = subject.to_a
+      expect(values.first).to eq(body)
+      expect(values.last).to eq(queue_name)
+      expect(values.length).to eq(9)  # 9 attributes total
+    end
+
+    it 'supports hash conversion' do
+      hash = subject.to_h
+      expect(hash[:body]).to eq(body)
+      expect(hash[:queue_name]).to eq(queue_name)
+      expect(hash.keys).to contain_exactly(
+        :body, :attributes, :md5_of_body, :md5_of_message_attributes,
+        :message_attributes, :message_id, :receipt_handle, :delete, :queue_name
+      )
+    end
+  end
+
+  describe 'equality' do
+    let(:message1) { described_class.new(body: body, queue_name: queue_name) }
+    let(:message2) { described_class.new(body: body, queue_name: queue_name) }
+    let(:message3) { described_class.new(body: 'different', queue_name: queue_name) }
+
+    it 'compares messages by attribute values' do
+      expect(message1).to eq(message2)
+      expect(message1).not_to eq(message3)
+    end
+  end
+end

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

@@ -1,5 +1,4 @@
-require 'spec_helper'
-require 'shoryuken/launcher'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Launcher do
   let(:executor) do
@@ -102,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

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

@@ -1,5 +1,4 @@
-require 'spec_helper'
-require 'shoryuken/manager'
+# frozen_string_literal: true
 
 RSpec::Matchers.define :queue_config_of do |expected|
   match do |actual|

data/spec/lib/shoryuken/message_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Message do
+  let(:client) { instance_double('Aws::SQS::Client') }
+  let(:queue) { instance_double('Shoryuken::Queue', name: 'test-queue', url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue') }
+  let(:data) do
+    instance_double('Aws::SQS::Types::Message',
+                    message_id: 'msg-123',
+                    receipt_handle: 'handle-456',
+                    md5_of_body: 'abcd1234',
+                    body: '{"test": "data"}',
+                    attributes: { 'ApproximateReceiveCount' => '1' },
+                    md5_of_message_attributes: 'efgh5678',
+                    message_attributes: { 'type' => 'test' })
+  end
+
+  subject { described_class.new(client, queue, data) }
+
+  describe '#initialize' do
+    it 'sets client, queue_url, queue_name, and data' do
+      expect(subject.client).to eq(client)
+      expect(subject.queue_url).to eq('https://sqs.us-east-1.amazonaws.com/123456789/test-queue')
+      expect(subject.queue_name).to eq('test-queue')
+      expect(subject.data).to eq(data)
+    end
+  end
+
+  describe 'delegated methods' do
+    it 'delegates message_id to data' do
+      expect(subject.message_id).to eq('msg-123')
+    end
+
+    it 'delegates receipt_handle to data' do
+      expect(subject.receipt_handle).to eq('handle-456')
+    end
+
+    it 'delegates md5_of_body to data' do
+      expect(subject.md5_of_body).to eq('abcd1234')
+    end
+
+    it 'delegates body to data' do
+      expect(subject.body).to eq('{"test": "data"}')
+    end
+
+    it 'delegates attributes to data' do
+      expect(subject.attributes).to eq({ 'ApproximateReceiveCount' => '1' })
+    end
+
+    it 'delegates md5_of_message_attributes to data' do
+      expect(subject.md5_of_message_attributes).to eq('efgh5678')
+    end
+
+    it 'delegates message_attributes to data' do
+      expect(subject.message_attributes).to eq({ 'type' => 'test' })
+    end
+  end
+
+  describe '#delete' do
+    it 'calls delete_message on the client with correct parameters' do
+      expect(client).to receive(:delete_message).with(
+        queue_url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        receipt_handle: 'handle-456'
+      )
+
+      subject.delete
+    end
+  end
+
+  describe '#change_visibility' do
+    it 'calls change_message_visibility on the client with merged parameters' do
+      options = { visibility_timeout: 300 }
+
+      expect(client).to receive(:change_message_visibility).with(hash_including(
+        visibility_timeout: 300,
+        queue_url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        receipt_handle: 'handle-456'
+      ))
+
+      subject.change_visibility(options)
+    end
+
+    it 'merges queue_url and receipt_handle into provided options' do
+      options = { visibility_timeout: 120, custom_param: 'value' }
+
+      expect(client).to receive(:change_message_visibility).with(hash_including(
+        visibility_timeout: 120,
+        custom_param: 'value',
+        queue_url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        receipt_handle: 'handle-456'
+      ))
+
+      subject.change_visibility(options)
+    end
+  end
+
+  describe '#visibility_timeout=' do
+    it 'calls change_message_visibility on the client with the timeout' do
+      expect(client).to receive(:change_message_visibility).with(
+        queue_url: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        receipt_handle: 'handle-456',
+        visibility_timeout: 600
+      )
+
+      subject.visibility_timeout = 600
+    end
+  end
+end

data/spec/{shoryuken → lib/shoryuken}/middleware/chain_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Shoryuken::Middleware::Chain do
   class CustomMiddleware

data/spec/lib/shoryuken/middleware/entry_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'shoryuken/middleware/entry'
+
+RSpec.describe Shoryuken::Middleware::Entry do
+  describe '#initialize' do
+    it 'stores the middleware class' do
+      entry = described_class.new(String)
+      expect(entry.klass).to eq String
+    end
+
+    it 'stores initialization arguments' do
+      entry = described_class.new(String, 'arg1', 'arg2')
+      expect(entry.instance_variable_get(:@args)).to eq ['arg1', 'arg2']
+    end
+  end
+
+  describe '#make_new' do
+    let(:test_class) do
+      Class.new do
+        attr_reader :args
+
+        def initialize(*args)
+          @args = args
+        end
+      end
+    end
+
+    it 'creates a new instance of the stored class without arguments' do
+      entry = described_class.new(test_class)
+      instance = entry.make_new
+
+      expect(instance).to be_a test_class
+      expect(instance.args).to eq []
+    end
+
+    it 'creates a new instance with stored arguments' do
+      entry = described_class.new(test_class, 'arg1', 42, { key: 'value' })
+      instance = entry.make_new
+
+      expect(instance).to be_a test_class
+      expect(instance.args).to eq ['arg1', 42, { key: 'value' }]
+    end
+
+    it 'creates a new instance each time it is called' do
+      entry = described_class.new(test_class, 'shared_arg')
+      instance1 = entry.make_new
+      instance2 = entry.make_new
+
+      expect(instance1).to be_a test_class
+      expect(instance2).to be_a test_class
+      expect(instance1).not_to be instance2
+      expect(instance1.args).to eq instance2.args
+    end
+  end
+
+  describe '#klass' do
+    it 'returns the stored class' do
+      entry = described_class.new(Array)
+      expect(entry.klass).to eq Array
+    end
+
+    it 'is readable' do
+      entry = described_class.new(Hash)
+      expect(entry.klass).to eq Hash
+    end
+  end
+end