shoryuken 5.1.1 → 6.0.0

data/lib/shoryuken/options.rb

@@ -9,6 +9,7 @@ module Shoryuken
       lifecycle_events: {
         startup: [],
         dispatch: [],
+        utilization_update: [],
         quiet: [],
         shutdown: []
       }

data/lib/shoryuken/polling/strict_priority.rb

@@ -39,8 +39,10 @@ module Shoryuken
       end
 
       def message_processed(queue)
-        logger.debug "Unpausing #{queue}"
-        @paused_until[queue] = Time.now
+        if queue_paused?(queue)
+          logger.debug "Unpausing #{queue}"
+          @paused_until[queue] = Time.at 0
+        end
       end
 
       private

data/lib/shoryuken/polling/weighted_round_robin.rb

@@ -36,12 +36,10 @@ module Shoryuken
       end
 
       def message_processed(queue)
-        return if @paused_queues.empty?
+        paused_queue = @paused_queues.find { |_time, name| name == queue }
+        return unless paused_queue
 
-        logger.debug "Unpausing #{queue}"
-        @paused_queues.reject! { |_time, name| name == queue }
-        @queues << queue
-        @queues.uniq!
+        paused_queue[0] = Time.at 0
       end
 
       private

data/lib/shoryuken/runner.rb

@@ -30,9 +30,6 @@ module Shoryuken
 
       loader = EnvironmentLoader.setup_options(options)
 
-      # When cli args exist, override options in config file
-      Shoryuken.options.merge!(options)
-
       daemonize(Shoryuken.options)
       write_pid(Shoryuken.options)
 
@@ -55,6 +52,10 @@ module Shoryuken
       end
     end
 
+    def healthy?
+      (@launcher && @launcher.healthy?) || false
+    end
+
     private
 
     def initialize_concurrent_logger

data/lib/shoryuken/version.rb

@@ -1,3 +1,3 @@
 module Shoryuken
-  VERSION = '5.1.1'.freeze
+  VERSION = '6.0.0'.freeze
 end

data/lib/shoryuken.rb

@@ -45,6 +45,10 @@ module Shoryuken
     @_shoryuken_options ||= Shoryuken::Options.new
   end
 
+  def self.healthy?
+    Shoryuken::Runner.instance.healthy?
+  end
+
   def_delegators(
     :shoryuken_options,
     :active_job?,

data/spec/integration/launcher_spec.rb

@@ -4,10 +4,37 @@ require 'shoryuken/launcher'
 require 'securerandom'
 
 RSpec.describe Shoryuken::Launcher do
-  describe 'Consuming messages', slow: true do
+  let(:sqs_client) do
+    Aws::SQS::Client.new(
+      region: 'us-east-1',
+      endpoint: 'http://localhost:5000',
+      access_key_id: 'fake',
+      secret_access_key: 'fake'
+    )
+  end
+
+  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
+
+  describe 'Consuming messages' do
     before do
       Aws.config[:stub_responses] = false
-      Aws.config[:region] = 'us-east-1'
+
+      allow(Shoryuken).to receive(:launcher_executor).and_return(executor)
+
+      Shoryuken.configure_client do |config|
+        config.sqs_client = sqs_client
+      end
+
+      Shoryuken.configure_server do |config|
+        config.sqs_client = sqs_client
+      end
 
       StandardWorker.received_messages = 0
 

data/spec/shoryuken/environment_loader_spec.rb

@@ -4,11 +4,41 @@ require 'active_job'
 RSpec.describe Shoryuken::EnvironmentLoader do
   subject { described_class.new({}) }
 
-  describe '#parse_queues loads default queues' do
+  describe '#load' do
     before do
+      Shoryuken.groups.clear
+      # See issue: https://stackoverflow.com/a/63699568 for stubbing AWS errors
+      allow(Shoryuken::Client)
+        .to receive(:queues)
+        .with('stubbed_queue')
+        .and_raise(Aws::SQS::Errors::NonExistentQueue.new(nil, nil))
       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_workers)
+      allow(subject).to receive(:patch_deprecated_workers)
+      Shoryuken.options[:groups] = [['custom', { queues: ['stubbed_queue'] }]]
+    end
+
+    context "when given queues don't exist" do
+      specify do
+        expect { subject.load }.to raise_error(
+          ArgumentError,
+          <<-MSG.gsub(/^\s+/, '')
+            The specified queue(s) stubbed_queue do not exist.
+            Try 'shoryuken sqs create QUEUE-NAME' for creating a queue with default settings.
+            It's also possible that you don't have permission to access the specified queues.
+          MSG
+        )
+      end
+    end
+  end
+
+  describe '#parse_queues loads default queues' do
+    before do
+      allow(subject).to receive(:initialize_rails)
+      allow(subject).to receive(:prefix_active_job_queue_names)
+      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)
@@ -24,7 +54,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
 
   describe '#parse_queues includes delay per groups' do
     before do
-      allow(subject).to receive(:load_rails)
+      allow(subject).to receive(:initialize_rails)
       allow(subject).to receive(:prefix_active_job_queue_names)
       allow(subject).to receive(:require_workers)
       allow(subject).to receive(:validate_queues)
@@ -34,7 +64,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
 
     specify do
       Shoryuken.options[:queues] = ['queue1', 'queue2'] # default queues
-      Shoryuken.options[:groups] = [[ 'custom', { queues: ['queue3'], delay: 25 }]]
+      Shoryuken.options[:groups] = [['custom', { queues: ['queue3'], delay: 25 }]]
       subject.load
 
       expect(Shoryuken.groups['default'][:queues]).to eq(%w[queue1 queue2])
@@ -44,10 +74,9 @@ RSpec.describe Shoryuken::EnvironmentLoader do
     end
   end
 
-
   describe '#prefix_active_job_queue_names' do
     before do
-      allow(subject).to receive(:load_rails)
+      allow(subject).to receive(:initialize_rails)
       allow(subject).to receive(:require_workers)
       allow(subject).to receive(:validate_queues)
       allow(subject).to receive(:validate_workers)
@@ -57,11 +86,11 @@ RSpec.describe Shoryuken::EnvironmentLoader do
       ActiveJob::Base.queue_name_delimiter = '_'
 
       allow(Shoryuken).to receive(:active_job?).and_return(true)
-    end
 
-    specify do
       Shoryuken.active_job_queue_name_prefixing = true
+    end
 
+    specify do
       Shoryuken.options[:queues] = ['queue1', ['queue2', 2]]
 
       Shoryuken.options[:groups] = {
@@ -73,10 +102,32 @@ RSpec.describe Shoryuken::EnvironmentLoader do
       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
+
+    it 'does not prefix url-based queues' do
+      Shoryuken.options[:queues] = ['https://example.com/test_queue1']
+      Shoryuken.options[:groups] = { 'group1' => { queues: ['https://example.com/test_group1_queue1'] } }
+
+      subject.load
+
+      expect(Shoryuken.groups['default'][:queues]).to(eq(['https://example.com/test_queue1']))
+      expect(Shoryuken.groups['group1'][:queues]).to(eq(['https://example.com/test_group1_queue1']))
+    end
+
+    it 'does not prefix arn-based queues' do
+      Shoryuken.options[:queues] = ['arn:aws:sqs:fake-region-1:1234:test_queue1']
+      Shoryuken.options[:groups] = { 'group1' => { queues: ['arn:aws:sqs:fake-region-1:1234:test_group1_queue1'] } }
+
+      subject.load
+
+      expect(Shoryuken.groups['default'][:queues]).to(eq(['arn:aws:sqs:fake-region-1:1234:test_queue1']))
+      expect(Shoryuken.groups['group1'][:queues]).to(eq(['arn:aws:sqs:fake-region-1:1234:test_group1_queue1']))
+    end
   end
+
   describe "#setup_options" do
-    let (:cli_queues) { { "queue1"=> 10, "queue2" => 20 } }
-    let (:config_queues) { [["queue1", 8], ["queue2", 4]] }
+    let(:cli_queues) { { "queue1" => 10, "queue2" => 20 } }
+    let(:config_queues) { [["queue1", 8], ["queue2", 4]] }
+
     context "when given queues through config and CLI" do
       specify do
         allow_any_instance_of(Shoryuken::EnvironmentLoader).to receive(:config_file_options).and_return({ queues: config_queues })
@@ -84,6 +135,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
         expect(Shoryuken.options[:queues]).to eq(cli_queues)
       end
     end
+
     context "when given queues through config only" do
       specify do
         allow_any_instance_of(Shoryuken::EnvironmentLoader).to receive(:config_file_options).and_return({ queues: config_queues })
@@ -91,6 +143,7 @@ RSpec.describe Shoryuken::EnvironmentLoader do
         expect(Shoryuken.options[:queues]).to eq(config_queues)
       end
     end
+
     context "when given queues through CLI only" do
       specify do
         Shoryuken::EnvironmentLoader.setup_options(queues: cli_queues)

data/spec/shoryuken/extensions/active_job_concurrent_send_adapter_spec.rb

@@ -10,6 +10,10 @@ RSpec.describe ActiveJob::QueueAdapters::ShoryukenConcurrentSendAdapter do
   let(:error_handler) { -> {} }
   let(:success_handler) { -> {} }
 
+  before do
+    allow(Concurrent).to receive(:global_io_executor).and_return(Concurrent::ImmediateExecutor.new)
+  end
+
   subject { described_class.new(success_handler, error_handler) }
 
   context 'when success' do

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/launcher_spec.rb

@@ -0,0 +1,60 @@
+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
+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)
@@ -163,4 +177,26 @@ RSpec.describe Shoryuken::Manager do
       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/weighted_round_robin_spec.rb

@@ -106,12 +106,37 @@ RSpec.describe Shoryuken::Polling::WeightedRoundRobin do
   end
 
   describe '#message_processed' do
-    it 'removes paused queue, adds to active queues' do
-      strategy = Shoryuken::Polling::WeightedRoundRobin.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([[queue2, 1], [queue1, 1]])
+    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

@@ -32,9 +32,6 @@ class TestWorker
 end
 
 RSpec.configure do |config|
-  # TODO: Run these tests again on CI
-  config.filter_run_excluding slow: true
-
   config.before do
     Shoryuken::Client.class_variable_set :@@queues, {}
 
@@ -63,7 +60,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