shoryuken 3.0.6 → 4.0.0

data/spec/shoryuken/client_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe Shoryuken::Client do
     end
 
     it 'memoizes queues' do
-      sqs.stub_responses(:get_queue_url, { queue_url: queue_url }, { queue_url: 'xyz' })
+      sqs.stub_responses(:get_queue_url, { queue_url: queue_url }, queue_url: 'xyz')
 
       expect(Shoryuken::Client.queues(queue_name).url).to eq queue_url
       expect(Shoryuken::Client.queues(queue_name).url).to eq queue_url

data/spec/shoryuken/core_ext_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe 'Core Extensions' do
 
     describe '#symbolize_keys' do
       it 'converts keys into symbols' do
-        expect({ :key1 => 'value1', 'key2' => 'value2' }.symbolize_keys).to eq(:key1 => 'value1', key2: 'value2')
+        expect({ :key1 => 'value1', 'key2' => 'value2' }.symbolize_keys).to eq(key1: 'value1', key2: 'value2')
       end
     end
 
@@ -20,11 +20,11 @@ RSpec.describe 'Core Extensions' do
                  'key2' => 'value2',
                  'key3' => {
                    'key31' => { 'key311' => 'value311' },
-                   'key32' => 'value32' } }.deep_symbolize_keys).to eq({ :key1 => 'value1',
-                                                                         :key2 => 'value2',
-                                                                         :key3 => { :key31 =>
-                                                                                    { :key311 => 'value311' },
-                                                                                      :key32 => 'value32' } })
+                   'key32' => 'value32'
+                 } }.deep_symbolize_keys).to eq(key1: 'value1',
+                                                key2: 'value2',
+                                                key3: { key31:                                                                                     { key311: 'value311' },
+                                                        key32: 'value32' })
       end
     end
   end

data/spec/shoryuken/default_worker_registry_spec.rb

@@ -43,12 +43,10 @@ RSpec.describe Shoryuken::DefaultWorkerRegistry do
   end
 
   describe 'a registry with workers is handling messages' do
-    def build_message(queue, explicit_worker = nil)
+    def build_message(_queue, explicit_worker = nil)
       attributes = {}
 
-      if explicit_worker
-        attributes['shoryuken_class'] = { string_value: explicit_worker.to_s, data_type: 'String' }
-      end
+      attributes['shoryuken_class'] = { string_value: explicit_worker.to_s, data_type: 'String' } if explicit_worker
 
       double(Shoryuken::Message,
              body: 'test',

data/spec/shoryuken/environment_loader_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
+require 'active_job'
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe Shoryuken::EnvironmentLoader do
   subject { described_class.new({}) }
 
   describe '#parse_queues' do
     before do
-      # TODO proper test other methods
-      allow(subject).to receive(:load_rails).with(anything)
+      allow(subject).to receive(:load_rails)
       allow(subject).to receive(:prefix_active_job_queue_names)
       allow(subject).to receive(:require_workers)
       allow(subject).to receive(:validate_queues)
@@ -15,20 +14,41 @@ RSpec.describe Shoryuken::EnvironmentLoader do
       allow(subject).to receive(:patch_deprecated_workers)
     end
 
-    it 'parses' do
-      Shoryuken.options[:queues] = ['queue_1']
+    specify do
+      Shoryuken.options[:queues] = ['queue1', ['queue2', 2]]
       subject.load
 
-      expect(Shoryuken.queues).to eq(%w(queue_1))
+      expect(Shoryuken.groups['default'][:queues]).to eq(%w[queue1 queue2 queue2])
     end
+  end
+
+  describe '#prefix_active_job_queue_names' do
+    before do
+      allow(subject).to receive(:load_rails)
+      allow(subject).to receive(:require_workers)
+      allow(subject).to receive(:validate_queues)
+      allow(subject).to receive(:validate_workers)
+      allow(subject).to receive(:patch_deprecated_workers)
 
-    context 'with priority' do
-      it 'parses' do
-        Shoryuken.options[:queues] = ['queue_1', ['queue_2', 2]]
-        subject.load
+      ActiveJob::Base.queue_name_prefix    = 'test'
+      ActiveJob::Base.queue_name_delimiter = '_'
+
+      allow(Shoryuken).to receive(:active_job?).and_return(true)
+    end
+
+    specify do
+      Shoryuken.active_job_queue_name_prefixing = true
+
+      Shoryuken.options[:queues] = ['queue1', ['queue2', 2]]
+
+      Shoryuken.options[:groups] = {
+        'group1' => { queues: %w[group1_queue1 group1_queue2] }
+      }
+
+      subject.load
 
-        expect(Shoryuken.queues).to eq(%w(queue_1 queue_2 queue_2))
-      end
+      expect(Shoryuken.groups['default'][:queues]).to eq(%w[test_queue1 test_queue2 test_queue2])
+      expect(Shoryuken.groups['group1'][:queues]).to eq(%w[test_group1_queue1 test_group1_queue2])
     end
   end
 end

data/spec/shoryuken/extensions/active_job_adapter_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'active_job'
+require 'shoryuken/extensions/active_job_adapter'
+
+RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter do
+  let(:job) { double 'Job', id: '123', queue_name: 'queue' }
+  let(:fifo) { false }
+  let(:queue) { double 'Queue', fifo?: fifo }
+
+  before do
+    allow(Shoryuken::Client).to receive(:queues).with(job.queue_name).and_return(queue)
+    allow(job).to receive(:serialize).and_return(
+      'job_class' => 'Worker',
+      'job_id'     => job.id,
+      'queue_name' => job.queue_name,
+      'arguments'  => nil,
+      'locale'     => nil
+    )
+  end
+
+  describe '#enqueue' do
+    specify do
+      expect(queue).to receive(:send_message) do |hash|
+        expect(hash[:message_deduplication_id]).to_not be
+      end
+      expect(Shoryuken).to receive(:register_worker).with(job.queue_name, described_class::JobWrapper)
+
+      subject.enqueue(job)
+    end
+
+    context 'when fifo' do
+      let(:fifo) { true }
+
+      it 'does not include job_id in the deduplication_id' do
+        expect(queue).to receive(:send_message) do |hash|
+          message_deduplication_id = Digest::SHA256.hexdigest(JSON.dump(job.serialize.except('job_id')))
+
+          expect(hash[:message_deduplication_id]).to eq(message_deduplication_id)
+        end
+        expect(Shoryuken).to receive(:register_worker).with(job.queue_name, described_class::JobWrapper)
+
+        subject.enqueue(job)
+      end
+    end
+  end
+
+  describe '#enqueue_at' do
+    specify do
+      delay = 1
+
+      expect(queue).to receive(:send_message) do |hash|
+        expect(hash[:message_deduplication_id]).to_not be
+        expect(hash[:delay_seconds]).to eq(delay)
+      end
+
+      expect(Shoryuken).to receive(:register_worker).with(job.queue_name, described_class::JobWrapper)
+
+      # need to figure out what to require Time.current and N.minutes to remove the stub
+      allow(subject).to receive(:calculate_delay).and_return(delay)
+
+      subject.enqueue_at(job, nil)
+    end
+  end
+end

data/spec/shoryuken/fetcher_spec.rb

@@ -2,36 +2,119 @@ require 'spec_helper'
 require 'shoryuken/manager'
 require 'shoryuken/fetcher'
 
-describe Shoryuken::Fetcher do
-  let(:queue)      { instance_double('Shoryuken::Queue') }
-  let(:queue_name) { 'default' }
+# rubocop:disable Metrics/BlockLength
+RSpec.describe Shoryuken::Fetcher do
+  let(:queue)        { instance_double('Shoryuken::Queue', fifo?: false) }
+  let(:queue_name)   { 'default' }
   let(:queue_config) { Shoryuken::Polling::QueueConfiguration.new(queue_name, {}) }
+  let(:group)        { 'default' }
 
   let(:sqs_msg) do
-    double(Shoryuken::Message,
+    double(
+      Shoryuken::Message,
       queue_url: queue_name,
       body: 'test',
-      message_id: 'fc754df79cc24c4196ca5996a44b771e',
-          )
+      message_id: 'fc754df79cc24c4196ca5996a44b771e'
+    )
   end
 
-  subject { described_class.new }
+  subject { described_class.new(group) }
 
   describe '#fetch' do
-    it 'calls Shoryuken::Client to receive messages' do
+    let(:limit) { 1 }
+
+    specify do
       expect(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
-      expect(queue).to receive(:receive_messages).
-        with(max_number_of_messages: 1, attribute_names: ['All'], message_attribute_names: ['All']).
-        and_return([])
-      subject.fetch(queue_config, 1)
+
+      Shoryuken.sqs_client_receive_message_opts[group] = { wait_time_seconds: 10 }
+
+      expect(queue).to receive(:receive_messages).with(
+        wait_time_seconds: 10,
+        max_number_of_messages: limit,
+        message_attribute_names: ['All'],
+        attribute_names: ['All']
+      ).and_return([])
+
+      subject.fetch(queue_config, limit)
+    end
+
+    it 'logs debug only' do
+      # See https://github.com/phstc/shoryuken/issues/435
+      logger = double 'logger'
+
+      allow(subject).to receive(:logger).and_return(logger)
+
+      expect(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
+
+      expect(queue).to receive(:receive_messages).and_return([double('SQS Msg')])
+
+      expect(logger).to receive(:debug).exactly(3).times
+      expect(logger).to_not receive(:info)
+
+      subject.fetch(queue_config, limit)
+    end
+
+    context 'when receive options per queue' do
+      let(:limit) { 5 }
+
+      specify do
+        expect(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
+
+        Shoryuken.sqs_client_receive_message_opts[queue_name] = { max_number_of_messages: 1 }
+
+        expect(queue).to receive(:receive_messages).with(
+          max_number_of_messages: 1,
+          message_attribute_names: ['All'],
+          attribute_names: ['All']
+        ).and_return([])
+
+        subject.fetch(queue_config, limit)
+      end
+    end
+
+    context 'when max_number_of_messages opt is great than limit' do
+      it 'uses limit' do
+        expect(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
+
+        Shoryuken.sqs_client_receive_message_opts[queue_name] = { max_number_of_messages: 20 }
+
+        expect(queue).to receive(:receive_messages).with(
+          max_number_of_messages: limit,
+          message_attribute_names: ['All'],
+          attribute_names: ['All']
+        ).and_return([])
+
+        subject.fetch(queue_config, limit)
+      end
     end
 
-    it 'maxes messages to receive to 10 (SQS limit)' do
-      allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
-      expect(queue).to receive(:receive_messages).
-        with(max_number_of_messages: 10, attribute_names: ['All'], message_attribute_names: ['All']).
-        and_return([])
-      subject.fetch(queue_config, 20)
+    context 'when limit is greater than FETCH_LIMIT' do
+      let(:limit) { 20 }
+
+      specify do
+        allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
+        expect(queue).to receive(:receive_messages).with(
+          max_number_of_messages: described_class::FETCH_LIMIT, attribute_names: ['All'], message_attribute_names: ['All']
+        ).and_return([])
+
+        subject.fetch(queue_config, limit)
+      end
+    end
+
+    context 'when FIFO' do
+      let(:limit) { 10 }
+      let(:queue) { instance_double('Shoryuken::Queue', fifo?: true) }
+
+      it 'polls one message at the time' do
+        # see https://github.com/phstc/shoryuken/pull/530
+
+        allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
+        expect(queue).to receive(:receive_messages).with(
+          max_number_of_messages: 1, attribute_names: ['All'], message_attribute_names: ['All']
+        ).and_return([])
+
+        subject.fetch(queue_config, limit)
+      end
     end
   end
 end

data/spec/shoryuken/manager_spec.rb

@@ -11,57 +11,85 @@ RSpec.describe Shoryuken::Manager do
   let(:queue) { 'default' }
   let(:queues) { [queue] }
   let(:polling_strategy) { Shoryuken::Polling::WeightedRoundRobin.new(queues) }
-  let(:fetcher) { Shoryuken::Fetcher.new }
+  let(:fetcher) { double Shoryuken::Fetcher }
   let(:concurrency) { 1 }
+  let(:executor) { Concurrent::ImmediateExecutor.new }
 
-  subject { Shoryuken::Manager.new(fetcher, polling_strategy) }
+  subject { Shoryuken::Manager.new(fetcher, polling_strategy, concurrency, executor) }
 
-  before(:each) do
-    Shoryuken.options[:concurrency] = concurrency
+  before do
+    allow(fetcher).to receive(:fetch).and_return([])
   end
 
-  after(:each) do
+  after do
     Shoryuken.options[:concurrency] = 1
     TestWorker.get_shoryuken_options['batch'] = false
   end
 
-  describe 'Invalid concurrency setting' do
-    it 'raises ArgumentError if concurrency is not positive number' do
-      Shoryuken.options[:concurrency] = -1
-      expect { Shoryuken::Manager.new(nil, nil) }
-        .to raise_error(ArgumentError, 'Concurrency value -1 is invalid, it needs to be a positive number')
+  describe '#stop' do
+    specify do
+      allow(subject).to receive(:running?).and_return(true, true, false)
+      expect(subject).to receive(:dispatch).once.and_call_original
+      expect(subject).to receive(:dispatch_loop).twice.and_call_original
+      subject.start
     end
   end
 
   describe '#start' do
-    xit 'pauses when there are no active queues' do
+    before do
+      # prevent dispatch loop
+      allow(subject).to receive(:running?).and_return(true, true, false)
+    end
+
+    it 'pauses when there are no active queues' do
       expect(polling_strategy).to receive(:next_queue).and_return(nil)
-      expect_any_instance_of(described_class).to receive(:after)
+      expect(subject).to receive(:dispatch).and_call_original
       subject.start
     end
 
-    xit 'calls dispatch_batch if worker wants batches' do
+    it 'calls dispatch_batch if worker wants batches' do
       TestWorker.get_shoryuken_options['batch'] = true
-      expect_any_instance_of(described_class).to receive(:dispatch_batch).with(queue_config_of(queue))
-      expect(subject).to receive(:dispatch_later)
+      expect(subject).to receive(:dispatch_batch).with(queue_config_of(queue))
       subject.start
     end
 
-    xit 'calls dispatch_single_messages if worker wants single messages' do
-      expect_any_instance_of(described_class).to receive(:dispatch_single_messages).
-        with(queue_config_of(queue))
-      expect(subject).to receive(:dispatch_later)
+    it 'calls dispatch_single_messages if worker wants single messages' do
+      expect(subject).to receive(:dispatch_single_messages).with(queue_config_of(queue))
       subject.start
     end
   end
 
-  describe '#dispatch_batch' do
-    it 'assings batch as a single message' do
-      q = polling_strategy.next_queue
-      messages = [1, 2, 3]
-      expect(fetcher).to receive(:fetch).with(q, described_class::BATCH_LIMIT).and_return(messages)
-      expect_any_instance_of(described_class).to receive(:assign).with(q.name, messages)
-      subject.send(:dispatch_batch, q)
+  describe '#dispatch' do
+    before do
+      allow(subject).to receive(:running?).and_return(true, true, false)
+    end
+
+    specify do
+      message  = ['test1']
+      messages = [message]
+      q = Shoryuken::Polling::QueueConfiguration.new(queue, {})
+
+      expect(fetcher).to receive(:fetch).with(q, concurrency).and_return(messages)
+      expect(subject).to receive(:fire_event).with(:dispatch, false, queue_name: q.name)
+      expect(Shoryuken::Processor).to receive(:process).with(q, message)
+      expect(Shoryuken.logger).to_not receive(:info)
+
+      subject.send(:dispatch)
+    end
+
+    context 'when batch' do
+      specify do
+        messages = %w[test1 test2 test3]
+        q = Shoryuken::Polling::QueueConfiguration.new(queue, {})
+
+        expect(fetcher).to receive(:fetch).with(q, described_class::BATCH_LIMIT).and_return(messages)
+        expect(subject).to receive(:fire_event).with(:dispatch, false, queue_name: q.name)
+        allow(subject).to receive(:batched_queue?).with(q).and_return(true)
+        expect(Shoryuken::Processor).to receive(:process).with(q, messages)
+        expect(Shoryuken.logger).to_not receive(:info)
+
+        subject.send(:dispatch)
+      end
     end
   end
 

data/spec/shoryuken/middleware/chain_spec.rb

@@ -1,33 +1,45 @@
 require 'spec_helper'
 
-describe Shoryuken::Middleware::Chain do
+RSpec.describe Shoryuken::Middleware::Chain do
   class CustomMiddleware
     def initialize(name, recorder)
       @name     = name
       @recorder = recorder
     end
 
-    def call(*args)
+    def call(*_args)
       @recorder << [@name, 'before']
       yield
       @recorder << [@name, 'after']
     end
   end
 
+  class CustomMiddlewareB < CustomMiddleware; end
+
   it 'supports custom middleware' do
     subject.add CustomMiddleware, 1, []
 
     expect(CustomMiddleware).to eq subject.entries.last.klass
   end
 
+  it 'can add middleware to the front of chain' do
+    subject.prepend CustomMiddleware, 1, []
+
+    expect([CustomMiddleware]).to eq subject.entries.map(&:klass)
+
+    subject.prepend CustomMiddlewareB, 1, []
+
+    expect([CustomMiddlewareB, CustomMiddleware]).to eq subject.entries.map(&:klass)
+  end
+
   it 'invokes a middleware' do
     recorder = []
-    subject.add CustomMiddleware, 'Pablo', recorder
+    subject.add CustomMiddleware, 'custom', recorder
 
     final_action = nil
     subject.invoke { final_action = true }
     expect(final_action).to eq true
-    expect(recorder).to eq [%w[Pablo before], %w[Pablo after]]
+    expect(recorder).to eq [%w[custom before], %w[custom after]]
   end
 
   class NonYieldingMiddleware
@@ -37,7 +49,7 @@ describe Shoryuken::Middleware::Chain do
   it 'allows middleware to abruptly stop processing rest of chain' do
     recorder = []
     subject.add NonYieldingMiddleware
-    subject.add CustomMiddleware, 'Pablo', recorder
+    subject.add CustomMiddleware, 'custom', recorder
 
     final_action = nil
     subject.invoke { final_action = true }

data/spec/shoryuken/middleware/server/auto_delete_spec.rb

@@ -6,9 +6,9 @@ describe Shoryuken::Middleware::Server::AutoDelete do
 
   def build_message
     double Shoryuken::Message,
-      queue_url: queue,
-      body: 'test',
-      receipt_handle: SecureRandom.uuid
+           queue_url: queue,
+           body: 'test',
+           receipt_handle: SecureRandom.uuid
   end
 
   let(:sqs_msg) { build_message }
@@ -21,7 +21,8 @@ describe Shoryuken::Middleware::Server::AutoDelete do
     TestWorker.get_shoryuken_options['auto_delete'] = true
 
     expect(sqs_queue).to receive(:delete_messages).with(entries: [
-      { id: '0', receipt_handle: sqs_msg.receipt_handle }])
+                                                          { id: '0', receipt_handle: sqs_msg.receipt_handle }
+                                                        ])
 
     subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) {}
   end
@@ -35,9 +36,10 @@ describe Shoryuken::Middleware::Server::AutoDelete do
     sqs_msgs = [sqs_msg, sqs_msg2, sqs_msg3]
 
     expect(sqs_queue).to receive(:delete_messages).with(entries: [
-      { id: '0', receipt_handle: sqs_msg.receipt_handle },
-      { id: '1', receipt_handle: sqs_msg2.receipt_handle },
-      { id: '2', receipt_handle: sqs_msg3.receipt_handle }])
+                                                          { id: '0', receipt_handle: sqs_msg.receipt_handle },
+                                                          { id: '1', receipt_handle: sqs_msg2.receipt_handle },
+                                                          { id: '2', receipt_handle: sqs_msg3.receipt_handle }
+                                                        ])
 
     subject.call(TestWorker.new, queue, sqs_msgs, [sqs_msg.body, sqs_msg2.body, sqs_msg3.body]) {}
   end

data/spec/shoryuken/middleware/server/auto_extend_visibility_spec.rb

@@ -18,9 +18,9 @@ RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
       end
     end
 
-    def run_and_raise(worker, queue, sqs_msg, error_class)
+    def run_and_raise(worker, queue, sqs_msg)
       Shoryuken::Middleware::Server::AutoExtendVisibility.new.call(worker, queue, sqs_msg, sqs_msg.body) do
-        raise error_class.new
+        raise
       end
     end
   end
@@ -34,7 +34,7 @@ RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
 
   context 'when batch worker' do
     it 'yields' do
-      expect { |b| subject.call(nil, nil, [], nil, &b) }.to yield_control
+      expect { |b| subject.call(TestWorker.new, nil, [], nil, &b) }.to yield_control
     end
   end
 
@@ -53,7 +53,7 @@ RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
     allow(sqs_msg).to receive(:queue) { sqs_queue }
     expect(sqs_msg).to_not receive(:change_visibility)
 
-    expect { Runner.new.run_and_raise(TestWorker.new, queue, sqs_msg, StandardError) }.to raise_error(StandardError)
+    expect { Runner.new.run_and_raise(TestWorker.new, queue, sqs_msg) }.to raise_error
   end
 
   it 'does not extend message visibility if auto_visibility_timeout is not true' do

data/spec/shoryuken/middleware/server/exponential_backoff_retry_spec.rb

@@ -1,11 +1,13 @@
 require 'spec_helper'
 
-# rubocop:disable Metrics/BlockLength, Metrics/BlockDelimiters
+# rubocop:disable /BlockLength, Metrics/
 RSpec.describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
   let(:queue)     { 'default' }
   let(:sqs_queue) { double Shoryuken::Queue }
-  let(:sqs_msg)   { double Shoryuken::Message, queue_url: queue, body: 'test', receipt_handle: SecureRandom.uuid,
-                    attributes: {'ApproximateReceiveCount' => 1}, message_id: SecureRandom.uuid }
+  let(:sqs_msg)   {
+    double Shoryuken::Message, queue_url: queue, body: 'test', receipt_handle: SecureRandom.uuid,
+                               attributes: { 'ApproximateReceiveCount' => 1 }, message_id: SecureRandom.uuid
+  }
 
   before do
     allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
@@ -13,7 +15,7 @@ RSpec.describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
 
   context 'when batch worker' do
     it 'yields' do
-      expect { |b| subject.call(nil, nil, [], nil, &b) }.to yield_control
+      expect { |b| subject.call(TestWorker.new, nil, [], nil, &b) }.to yield_control
     end
   end
 

data/spec/shoryuken/middleware/server/timing_spec.rb

@@ -1,14 +1,16 @@
 require 'spec_helper'
 
-describe Shoryuken::Middleware::Server::Timing do
+RSpec.describe Shoryuken::Middleware::Server::Timing do
   let(:queue) { 'default' }
   let(:sqs_queue) { double Shoryuken::Queue, visibility_timeout: 60 }
 
   let(:sqs_msg) do
-    double Shoryuken::Message,
+    double(
+      Shoryuken::Message,
       queue_url: queue,
       body: 'test',
       message_id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e'
+    )
   end
 
   before do
@@ -28,7 +30,7 @@ describe Shoryuken::Middleware::Server::Timing do
 
   context 'when exceeded the `visibility_timeout`' do
     it 'logs exceeded' do
-      allow(subject).to receive(:elapsed).and_return(120000)
+      allow(subject).to receive(:elapsed).and_return(120_000)
 
       expect(Shoryuken.logger).to receive(:info) do |&block|
         expect(block.call).to match(/started at/)