shoryuken 5.0.5 → 6.1.1

data/spec/shoryuken/extensions/active_job_wrapper_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'active_job'
+require 'shoryuken/extensions/active_job_extensions'
+require 'shoryuken/extensions/active_job_adapter'
+
+RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper do
+  subject { described_class.new }
+
+  describe '#perform' do
+    it 'sets executions to reflect approximate receive count' do
+      attributes = { 'ApproximateReceiveCount' => '42' }
+      sqs_msg = double Shoryuken::Message, attributes: attributes
+      job_hash = { 'arguments' => [1, 2, 3] }
+      job_hash_with_executions = { 'arguments' => [1, 2, 3], 'executions' => 41 }
+      expect(ActiveJob::Base).to receive(:execute).with(job_hash_with_executions)
+
+      subject.perform sqs_msg, job_hash
+    end
+  end
+end

data/spec/shoryuken/fetcher_spec.rb

@@ -28,12 +28,12 @@ RSpec.describe Shoryuken::Fetcher do
 
       Shoryuken.sqs_client_receive_message_opts[group] = { wait_time_seconds: 10 }
 
-      expect(queue).to receive(:receive_messages).with(
+      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([])
+      }).and_return([])
 
       subject.fetch(queue_config, limit)
     end
@@ -62,11 +62,11 @@ RSpec.describe Shoryuken::Fetcher do
 
         Shoryuken.sqs_client_receive_message_opts[queue_name] = { max_number_of_messages: 1 }
 
-        expect(queue).to receive(:receive_messages).with(
+        expect(queue).to receive(:receive_messages).with({
           max_number_of_messages: 1,
           message_attribute_names: ['All'],
           attribute_names: ['All']
-        ).and_return([])
+        }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -78,11 +78,11 @@ RSpec.describe Shoryuken::Fetcher do
 
         Shoryuken.sqs_client_receive_message_opts[queue_name] = { max_number_of_messages: 20 }
 
-        expect(queue).to receive(:receive_messages).with(
+        expect(queue).to receive(:receive_messages).with({
           max_number_of_messages: limit,
           message_attribute_names: ['All'],
           attribute_names: ['All']
-        ).and_return([])
+        }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -93,9 +93,9 @@ RSpec.describe Shoryuken::Fetcher do
 
       specify do
         allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
-        expect(queue).to receive(:receive_messages).with(
+        expect(queue).to receive(:receive_messages).with({
           max_number_of_messages: described_class::FETCH_LIMIT, attribute_names: ['All'], message_attribute_names: ['All']
-        ).and_return([])
+        }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -109,9 +109,9 @@ RSpec.describe Shoryuken::Fetcher 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(
+        expect(queue).to receive(:receive_messages).with({
           max_number_of_messages: 1, attribute_names: ['All'], message_attribute_names: ['All']
-        ).and_return([])
+        }).and_return([])
 
         subject.fetch(queue_config, limit)
       end
@@ -123,9 +123,9 @@ RSpec.describe Shoryuken::Fetcher do
           allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
           allow(Shoryuken.worker_registry).to receive(:batch_receive_messages?).with(queue.name).and_return(true)
 
-          expect(queue).to receive(:receive_messages).with(
+          expect(queue).to receive(:receive_messages).with({
             max_number_of_messages: limit, attribute_names: ['All'], message_attribute_names: ['All']
-          ).and_return([])
+          }).and_return([])
 
           subject.fetch(queue_config, limit)
         end

data/spec/shoryuken/launcher_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'shoryuken/launcher'
+
+RSpec.describe Shoryuken::Launcher do
+  let(:executor) do
+    # We can't use Concurrent.global_io_executor in these tests since once you
+    # shut down a thread pool, you can't start it back up. Instead, we create
+    # one new thread pool executor for each spec. We use a new
+    # CachedThreadPool, since that most closely resembles
+    # Concurrent.global_io_executor
+    Concurrent::CachedThreadPool.new auto_terminate: true
+  end
+
+  let(:first_group_manager) { double(:first_group_manager, group: 'first_group') }
+  let(:second_group_manager) { double(:second_group_manager, group: 'second_group') }
+  let(:first_queue) { "launcher_spec_#{SecureRandom.uuid}" }
+  let(:second_queue) { "launcher_spec_#{SecureRandom.uuid}" }
+
+  before do
+    Shoryuken.add_group('first_group', 1)
+    Shoryuken.add_group('second_group', 1)
+    Shoryuken.add_queue(first_queue, 1, 'first_group')
+    Shoryuken.add_queue(second_queue, 1, 'second_group')
+    allow(Shoryuken).to receive(:launcher_executor).and_return(executor)
+    allow(Shoryuken::Manager).to receive(:new).with('first_group', any_args).and_return(first_group_manager)
+    allow(Shoryuken::Manager).to receive(:new).with('second_group', any_args).and_return(second_group_manager)
+    allow(first_group_manager).to receive(:running?).and_return(true)
+    allow(second_group_manager).to receive(:running?).and_return(true)
+  end
+
+  describe '#healthy?' do
+    context 'when all groups have managers' do
+      context 'when all managers are running' do
+        it 'returns true' do
+          expect(subject.healthy?).to be true
+        end
+      end
+
+      context 'when one manager is not running' do
+        before do
+          allow(second_group_manager).to receive(:running?).and_return(false)
+        end
+
+        it 'returns false' do
+          expect(subject.healthy?).to be false
+        end
+      end
+    end
+
+    context 'when all groups do not have managers' do
+      before do
+        allow(second_group_manager).to receive(:group).and_return('some_random_group')
+      end
+
+      it 'returns false' do
+        expect(subject.healthy?).to be false
+      end
+    end
+  end
+
+  describe '#stop' do
+    before 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)
+    end
+
+    it 'fires quiet, shutdown and stopped event' do
+      allow(subject).to receive(:fire_event)
+      subject.stop
+      expect(subject).to have_received(:fire_event).with(:quiet, true)
+      expect(subject).to have_received(:fire_event).with(:shutdown, true)
+      expect(subject).to have_received(:fire_event).with(:stopped)
+    end
+
+    it 'stops the managers' do
+      subject.stop
+      expect(first_group_manager).to have_received(:stop_new_dispatching)
+      expect(second_group_manager).to have_received(:stop_new_dispatching)
+    end
+  end
+
+  describe '#stop!' do
+    before 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)
+    end
+
+    it 'fires shutdown and stopped event' do
+      allow(subject).to receive(:fire_event)
+      subject.stop!
+      expect(subject).to have_received(:fire_event).with(:shutdown, true)
+      expect(subject).to have_received(:fire_event).with(:stopped)
+    end
+
+    it 'stops the managers' do
+      subject.stop!
+      expect(first_group_manager).to have_received(:stop_new_dispatching)
+      expect(second_group_manager).to have_received(:stop_new_dispatching)
+    end
+  end
+end

data/spec/shoryuken/manager_spec.rb

@@ -15,7 +15,7 @@ RSpec.describe Shoryuken::Manager do
   let(:concurrency) { 1 }
   let(:executor) { Concurrent::ImmediateExecutor.new }
 
-  subject { Shoryuken::Manager.new(fetcher, polling_strategy, concurrency, executor) }
+  subject { Shoryuken::Manager.new('default', fetcher, polling_strategy, concurrency, executor) }
 
   before do
     allow(fetcher).to receive(:fetch).and_return([])
@@ -71,6 +71,13 @@ RSpec.describe Shoryuken::Manager do
 
       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(subject).to receive(:fire_event).with(:utilization_update,
+                                                   false,
+                                                   {
+                                                     group: 'default',
+                                                     busy_processors: 1,
+                                                     max_processors: 1
+                                                   })
       expect(Shoryuken::Processor).to receive(:process).with(q, message)
       expect(Shoryuken.logger).to receive(:info).never
 
@@ -99,6 +106,13 @@ RSpec.describe Shoryuken::Manager do
         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(:utilization_update,
+                                                     false,
+                                                     {
+                                                       group: 'default',
+                                                       busy_processors: 1,
+                                                       max_processors: 1
+                                                     })
         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)
@@ -139,4 +153,50 @@ RSpec.describe Shoryuken::Manager do
       subject.send(:dispatch_single_messages, q)
     end
   end
+
+  describe '#processor_done' do
+    let(:sqs_queue)         { double Shoryuken::Queue }
+
+    before do
+      allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+    end
+
+    context 'when queue.fifo? is true' do
+      it 'calls message_processed on strategy' do
+        expect(sqs_queue).to receive(:fifo?).and_return(true)
+        expect(polling_strategy).to receive(:message_processed).with(queue)
+        subject.send(:processor_done, queue)
+      end
+    end
+
+    context 'when queue.fifo? is false' do
+      it 'does not call message_processed on strategy' do
+        expect(sqs_queue).to receive(:fifo?).and_return(false)
+        expect(polling_strategy).to_not receive(:message_processed)
+        subject.send(:processor_done, queue)
+      end
+    end
+  end
+
+  describe '#running?' do
+    context 'when the executor is running' do
+      before do
+        allow(executor).to receive(:running?).and_return(true)
+      end
+
+      it 'returns true' do
+        expect(subject.running?).to be true
+      end
+    end
+
+    context 'when the executor is not running' do
+      before do
+        allow(executor).to receive(:running?).and_return(false)
+      end
+
+      it 'returns false' do
+        expect(subject.running?).to be false
+      end
+    end
+  end
 end

data/spec/shoryuken/polling/strict_priority_spec.rb

@@ -145,4 +145,14 @@ RSpec.describe Shoryuken::Polling::StrictPriority do
       expect(subject.next_queue).to eq(queue3)
     end
   end
+
+  describe '#message_processed' do
+    it 'removes paused queue, adds to active queues' do
+      strategy = Shoryuken::Polling::StrictPriority.new([queue1, queue2])
+      strategy.send(:pause, queue1)
+      expect(strategy.active_queues).to eq([[queue2, 1]])
+      strategy.message_processed(queue1)
+      expect(strategy.active_queues).to eq([[queue1, 2], [queue2, 1]])
+    end
+  end
 end

data/spec/shoryuken/polling/weighted_round_robin_spec.rb

@@ -104,4 +104,39 @@ RSpec.describe Shoryuken::Polling::WeightedRoundRobin do
       expect(subject.delay).to eq(1.0)
     end
   end
+
+  describe '#message_processed' do
+    it 'removes delay from paused queue' do
+      queues << queue1
+      queues << queue2
+
+      expect(subject.next_queue).to eq(queue1)
+      subject.messages_found(queue1, 0) # pauses queue1
+
+      expect(subject.active_queues).to eq([[queue2, 1]])
+
+      subject.message_processed(queue1) # marks queue1 to be unpaused
+
+      expect(subject.next_queue).to eq(queue2) # implicitly unpauses queue1
+      expect(subject.active_queues).to eq([[queue1, 1], [queue2, 1]])
+    end
+
+    it 'preserves weight of queues when unpausing' do
+      queues << queue1
+      queues << queue1
+      queues << queue2
+
+      expect(subject.next_queue).to eq(queue1)
+      subject.messages_found(queue1, 1)
+
+      expect(subject.next_queue).to eq(queue2)
+      subject.messages_found(queue2, 0) # pauses queue2
+
+      expect(subject.active_queues).to eq([[queue1, 2]])
+      subject.message_processed(queue2) # marks queue2 to be unpaused
+
+      expect(subject.next_queue).to eq(queue1) # implicitly unpauses queue2
+      expect(subject.active_queues).to eq([[queue1, 2], [queue2, 1]])
+    end
+  end
 end

data/spec/shoryuken/queue_spec.rb

@@ -80,7 +80,8 @@ RSpec.describe Shoryuken::Queue do
     end
 
     it 'deletes' do
-      expect(sqs).to receive(:delete_message_batch).with(entries: entries, queue_url: queue_url).and_return(double(failed: []))
+      expect(sqs).to receive(:delete_message_batch).with({ entries: entries,
+                                                           queue_url: queue_url }).and_return(double(failed: []))
 
       subject.delete_messages(entries: entries)
     end
@@ -91,7 +92,8 @@ RSpec.describe Shoryuken::Queue do
         logger = double 'Logger'
 
         expect(sqs).to(
-          receive(:delete_message_batch).with(entries: entries, queue_url: queue_url).and_return(double(failed: [failure]))
+          receive(:delete_message_batch).with({ entries: entries,
+                                                queue_url: queue_url }).and_return(double(failed: [failure]))
         )
         expect(subject).to receive(:logger).and_return(logger)
         expect(logger).to receive(:error)
@@ -157,7 +159,8 @@ RSpec.describe Shoryuken::Queue do
     it 'accepts SQS request parameters' do
       # https://docs.aws.amazon.com/sdkforruby/api/Aws/SQS/Client.html#send_message_batch-instance_method
       expect(sqs).to(
-        receive(:send_message_batch).with(hash_including(entries: [{ id: '0', message_body: 'msg1' }, { id: '1', message_body: 'msg2' }]))
+        receive(:send_message_batch).with(hash_including(entries: [{ id: '0', message_body: 'msg1' },
+                                                                   { id: '1', message_body: 'msg2' }]))
       )
 
       subject.send_messages(entries: [{ id: '0', message_body: 'msg1' }, { id: '1', message_body: 'msg2' }])
@@ -286,7 +289,8 @@ RSpec.describe Shoryuken::Queue do
         Shoryuken.cache_visibility_timeout = false
 
         expect(sqs).to(
-          receive(:get_queue_attributes).with(queue_url: queue_url, attribute_names: ['All']).and_return(attribute_response).exactly(3).times
+          receive(:get_queue_attributes).with(queue_url: queue_url,
+                                              attribute_names: ['All']).and_return(attribute_response).exactly(3).times
         )
         expect(subject.visibility_timeout).to eq(30)
         expect(subject.visibility_timeout).to eq(30)
@@ -299,7 +303,8 @@ RSpec.describe Shoryuken::Queue do
         Shoryuken.cache_visibility_timeout = true
 
         expect(sqs).to(
-          receive(:get_queue_attributes).with(queue_url: queue_url, attribute_names: ['All']).and_return(attribute_response).once
+          receive(:get_queue_attributes).with({ queue_url: queue_url,
+                                                attribute_names: ['All'] }).and_return(attribute_response).once
         )
         expect(subject.visibility_timeout).to eq(30)
         expect(subject.visibility_timeout).to eq(30)

data/spec/shoryuken/worker/default_executor_spec.rb

@@ -10,16 +10,16 @@ RSpec.describe Shoryuken::Worker::DefaultExecutor do
 
   describe '.perform_in' do
     it 'delays a message' do
-      expect(sqs_queue).to receive(:send_message).with(
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'message',
-        delay_seconds: 60
-      )
+      expect(sqs_queue).to receive(:send_message).with({
+                                                         message_attributes: {
+                                                           'shoryuken_class' => {
+                                                             string_value: TestWorker.to_s,
+                                                             data_type: 'String'
+                                                           }
+                                                         },
+                                                         message_body: 'message',
+                                                         delay_seconds: 60
+                                                       })
 
       TestWorker.perform_in(60, 'message')
     end
@@ -33,16 +33,16 @@ RSpec.describe Shoryuken::Worker::DefaultExecutor do
 
   describe '.perform_at' do
     it 'delays a message' do
-      expect(sqs_queue).to receive(:send_message).with(
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'message',
-        delay_seconds: 60
-      )
+      expect(sqs_queue).to receive(:send_message).with({
+                                                         message_attributes: {
+                                                           'shoryuken_class' => {
+                                                             string_value: TestWorker.to_s,
+                                                             data_type: 'String'
+                                                           }
+                                                         },
+                                                         message_body: 'message',
+                                                         delay_seconds: 60
+                                                       })
 
       TestWorker.perform_in(Time.now + 60, 'message')
     end
@@ -56,30 +56,30 @@ RSpec.describe Shoryuken::Worker::DefaultExecutor do
 
   describe '.perform_async' do
     it 'enqueues a message' do
-      expect(sqs_queue).to receive(:send_message).with(
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'message'
-      )
+      expect(sqs_queue).to receive(:send_message).with({
+                                                         message_attributes: {
+                                                           'shoryuken_class' => {
+                                                             string_value: TestWorker.to_s,
+                                                             data_type: 'String'
+                                                           }
+                                                         },
+                                                         message_body: 'message'
+                                                       })
 
       TestWorker.perform_async('message')
     end
 
     it 'enqueues a message with options' do
-      expect(sqs_queue).to receive(:send_message).with(
-        delay_seconds: 60,
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'delayed message'
-      )
+      expect(sqs_queue).to receive(:send_message).with({
+                                                         delay_seconds: 60,
+                                                         message_attributes: {
+                                                           'shoryuken_class' => {
+                                                             string_value: TestWorker.to_s,
+                                                             data_type: 'String'
+                                                           }
+                                                         },
+                                                         message_body: 'delayed message'
+                                                       })
 
       TestWorker.perform_async('delayed message', delay_seconds: 60)
     end
@@ -89,15 +89,15 @@ RSpec.describe Shoryuken::Worker::DefaultExecutor do
 
       expect(Shoryuken::Client).to receive(:queues).with(new_queue).and_return(sqs_queue)
 
-      expect(sqs_queue).to receive(:send_message).with(
-        message_attributes: {
-          'shoryuken_class' => {
-            string_value: TestWorker.to_s,
-            data_type: 'String'
-          }
-        },
-        message_body: 'delayed message'
-      )
+      expect(sqs_queue).to receive(:send_message).with({
+                                                         message_attributes: {
+                                                           'shoryuken_class' => {
+                                                             string_value: TestWorker.to_s,
+                                                             data_type: 'String'
+                                                           }
+                                                         },
+                                                         message_body: 'delayed message'
+                                                       })
 
       TestWorker.perform_async('delayed message', queue: new_queue)
     end

data/spec/shoryuken_spec.rb

@@ -1,4 +1,13 @@
 require 'spec_helper'
 
 RSpec.describe Shoryuken do
+  describe '.healthy?' do
+    before do
+      allow(Shoryuken::Runner).to receive(:instance).and_return(double(:instance, healthy?: :some_result))
+    end
+
+    it 'delegates to the runner instance' do
+      expect(described_class.healthy?).to eq(:some_result)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,11 @@
 require 'bundler/setup'
 Bundler.setup
 
-require 'pry-byebug'
+begin
+  require 'pry-byebug'
+rescue LoadError
+end
+
 require 'shoryuken'
 require 'json'
 require 'dotenv'
@@ -28,13 +32,6 @@ class TestWorker
 end
 
 RSpec.configure do |config|
-  # Only run slow tests if SPEC_ALL=true and AWS_ACCESS_KEY_ID is present
-  # The AWS_ACCESS_KEY_ID checker is because Travis CI
-  # does not expose ENV variables to pull requests from forked repositories
-  # http://docs.travis-ci.com/user/pull-requests/
-  # config.filter_run_excluding slow: true if ENV['SPEC_ALL'] != 'true' || ENV['AWS_ACCESS_KEY_ID'].nil?
-  config.filter_run_excluding slow: true
-
   config.before do
     Shoryuken::Client.class_variable_set :@@queues, {}
 
@@ -49,6 +46,8 @@ RSpec.configure do |config|
     Shoryuken.options[:logfile]     = nil
     Shoryuken.options[:queues]      = nil
 
+    Shoryuken.options[:exception_handlers] = []
+
     TestWorker.get_shoryuken_options.clear
     TestWorker.get_shoryuken_options['queue'] = 'default'
 
@@ -63,7 +62,6 @@ RSpec.configure do |config|
 
     Shoryuken.cache_visibility_timeout = false
 
-    allow(Concurrent).to receive(:global_io_executor).and_return(Concurrent::ImmediateExecutor.new)
     allow(Shoryuken).to receive(:active_job?).and_return(false)
   end
 end