shoryuken 2.1.1 → 3.1.3

data/spec/shoryuken/manager_spec.rb

@@ -1,122 +1,109 @@
 require 'spec_helper'
 require 'shoryuken/manager'
 
-RSpec.describe Shoryuken::Manager do
-  subject do
-    condvar = double(:condvar)
-    allow(condvar).to receive(:signal).and_return(nil)
-    Shoryuken::Manager.new(condvar)
-  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) }
-        .to raise_error(ArgumentError, 'Concurrency value -1 is invalid, it needs to be a positive number')
-    end
-
+RSpec::Matchers.define :queue_config_of do |expected|
+  match do |actual|
+    actual.name == expected
   end
+end
 
-  describe 'Auto Scaling' do
-    it 'decreases weight' do
-      queue1 = 'shoryuken'
-      queue2 = 'uppercut'
+RSpec.describe Shoryuken::Manager do
+  let(:queue) { 'default' }
+  let(:queues) { [queue] }
+  let(:polling_strategy) { Shoryuken::Polling::WeightedRoundRobin.new(queues) }
+  let(:fetcher) { double Shoryuken::Fetcher }
+  let(:concurrency) { 1 }
+  let(:executor) { Concurrent::ImmediateExecutor.new }
 
-      Shoryuken.queues.clear
-      # [shoryuken, 2]
-      # [uppercut,  1]
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue2
+  subject { Shoryuken::Manager.new(fetcher, polling_strategy, concurrency, executor) }
 
-      expect(subject.instance_variable_get('@queues')).to eq [queue1, queue2]
+  before do
+    allow(fetcher).to receive(:fetch).and_return([])
+  end
 
-      subject.pause_queue!(queue1)
+  after do
+    Shoryuken.options[:concurrency] = 1
+    TestWorker.get_shoryuken_options['batch'] = false
+  end
 
-      expect(subject.instance_variable_get('@queues')).to eq [queue2]
+  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
 
-    it 'increases weight' do
-      queue1 = 'shoryuken'
-      queue2 = 'uppercut'
-
-      Shoryuken.queues.clear
-      # [shoryuken, 3]
-      # [uppercut,  1]
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue2
-
-      expect(subject.instance_variable_get('@queues')).to eq [queue1, queue2]
-      subject.pause_queue!(queue1)
-      expect(subject.instance_variable_get('@queues')).to eq [queue2]
-
-      subject.rebalance_queue_weight!(queue1)
-      expect(subject.instance_variable_get('@queues')).to eq [queue2, queue1]
-
-      subject.rebalance_queue_weight!(queue1)
-      expect(subject.instance_variable_get('@queues')).to eq [queue2, queue1, queue1]
-
-      subject.rebalance_queue_weight!(queue1)
-      expect(subject.instance_variable_get('@queues')).to eq [queue2, queue1, queue1, queue1]
+  describe '#start' do
+    before do
+      # prevent dispatch loop
+      allow(subject).to receive(:running?).and_return(true, true, false)
     end
 
-    it 'adds queue back' do
-      queue1 = 'shoryuken'
-      queue2 = 'uppercut'
-
-      Shoryuken.queues.clear
-      # [shoryuken, 2]
-      # [uppercut,  1]
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue2
-
-      Shoryuken.options[:delay] = 0.1
-
-      fetcher = double('Fetcher').as_null_object
-      subject.fetcher = fetcher
-
-      subject.pause_queue!(queue1)
-      expect(subject.instance_variable_get('@queues')).to eq [queue2]
+    it 'pauses when there are no active queues' do
+      expect(polling_strategy).to receive(:next_queue).and_return(nil)
+      expect(subject).to receive(:dispatch).and_call_original
+      subject.start
+    end
 
-      sleep 0.5
+    it 'calls dispatch_batch if worker wants batches' do
+      TestWorker.get_shoryuken_options['batch'] = true
+      expect(subject).to receive(:dispatch_batch).with(queue_config_of(queue))
+      subject.start
+    end
 
-      expect(subject.instance_variable_get('@queues')).to eq [queue2, queue1]
+    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 '#next_queue' do
-    it 'returns queues' do
-      queue1 = 'shoryuken'
-      queue2 = 'uppercut'
-
-      Shoryuken.queues.clear
+  describe '#dispatch' do
+    before do
+      allow(subject).to receive(:running?).and_return(true, true, false)
+    end
 
-      Shoryuken.register_worker queue1, TestWorker
-      Shoryuken.register_worker queue2, TestWorker
+    specify do
+      message  = ['test1']
+      messages = [message]
+      q = Shoryuken::Polling::QueueConfiguration.new(queue, {})
 
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue2
+      expect(fetcher).to receive(:fetch).with(q, concurrency).and_return(messages)
+      expect(subject).to receive(:fire_event).with(:dispatch)
+      expect(Shoryuken::Processor).to receive(:process).with(q, message)
+      expect(Shoryuken.logger).to_not receive(:info)
 
-      expect(subject.send :next_queue).to eq queue1
-      expect(subject.send :next_queue).to eq queue2
+      subject.send(:dispatch)
     end
 
-    it 'skips when no worker' do
-      queue1 = 'shoryuken'
-      queue2 = 'uppercut'
+    context 'when batch' do
+      specify do
+        messages = %w(test1 test2 test3)
+        q = Shoryuken::Polling::QueueConfiguration.new(queue, {})
 
-      Shoryuken.queues.clear
+        expect(fetcher).to receive(:fetch).with(q, described_class::BATCH_LIMIT).and_return(messages)
+        expect(subject).to receive(:fire_event).with(:dispatch)
+        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)
 
-      Shoryuken.register_worker queue2, TestWorker
-
-      Shoryuken.queues << queue1
-      Shoryuken.queues << queue2
+        subject.send(:dispatch)
+      end
+    end
+  end
 
-      expect(subject.send :next_queue).to eq queue2
-      expect(subject.send :next_queue).to eq queue2
+  describe '#dispatch_single_messages' do
+    let(:concurrency) { 3 }
+
+    it 'assings messages from batch one by one' do
+      q = polling_strategy.next_queue
+      messages = [1, 2, 3]
+      expect(fetcher).to receive(:fetch).with(q, concurrency).and_return(messages)
+      expect_any_instance_of(described_class).to receive(:assign).with(q.name, 1)
+      expect_any_instance_of(described_class).to receive(:assign).with(q.name, 2)
+      expect_any_instance_of(described_class).to receive(:assign).with(q.name, 3)
+      subject.send(:dispatch_single_messages, q)
     end
   end
 end

data/spec/shoryuken/middleware/chain_spec.rb

@@ -44,28 +44,4 @@ describe Shoryuken::Middleware::Chain do
     expect(final_action).to eq nil
     expect(recorder).to eq []
   end
-
-  class DeprecatedMiddleware
-    def call(worker_instance, queue, sqs_msg)
-      @@success = true
-    end
-
-    def self.success?
-      !!@@success
-    end
-  end
-
-  it 'patches deprecated middleware' do
-    subject.clear
-
-    expect(Shoryuken.logger).to receive(:warn) do |&block|
-      expect(block.call).to eq('[DEPRECATION] DeprecatedMiddleware#call(worker_instance, queue, sqs_msg) is deprecated. Please use DeprecatedMiddleware#call(worker_instance, queue, sqs_msg, body)')
-    end
-
-    subject.add DeprecatedMiddleware
-
-    subject.invoke TestWorker, 'test', double('SQS msg', body: 'test'), 'test'
-
-    expect(DeprecatedMiddleware.success?).to eq true
-  end
 end

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

@@ -55,8 +55,8 @@ describe Shoryuken::Middleware::Server::AutoDelete do
       expect(sqs_queue).to_not receive(:delete_messages)
 
       expect {
-        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'Error' }
-      }.to raise_error(RuntimeError, 'Error')
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' }
+      }.to raise_error('failed')
     end
   end
 end

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Shoryuken::Middleware::Server::AutoExtendVisibility do
+RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
   let(:queue) { 'default' }
   let(:visibility_timeout) { 3 }
   let(:extend_upfront) { 1 }
@@ -12,8 +12,6 @@ describe Shoryuken::Middleware::Server::AutoExtendVisibility do
 
   # We need to run our worker inside actor context.
   class Runner
-    include Celluloid
-
     def run_and_sleep(worker, queue, sqs_msg, interval)
       Shoryuken::Middleware::Server::AutoExtendVisibility.new.call(worker, queue, sqs_msg, sqs_msg.body) do
         sleep interval
@@ -34,6 +32,12 @@ describe Shoryuken::Middleware::Server::AutoExtendVisibility do
     stub_const('Shoryuken::Middleware::Server::AutoExtendVisibility::EXTEND_UPFRONT_SECONDS', extend_upfront)
   end
 
+  context 'when batch worker' do
+    it 'yields' do
+      expect { |b| subject.call(TestWorker.new, nil, [], nil, &b) }.to yield_control
+    end
+  end
+
   it 'extends message visibility if jobs takes a long time' do
     TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
 

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

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
-describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
+# rubocop:disable Metrics/BlockLength, Metrics/BlockDelimiters
+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,
@@ -10,8 +11,14 @@ describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
     allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
   end
 
-  context 'when a job succeeds' do
-    it 'does not retry the job' do
+  context 'when batch worker' do
+    it 'yields' do
+      expect { |b| subject.call(TestWorker.new, nil, [], nil, &b) }.to yield_control
+    end
+  end
+
+  context 'when no exception' do
+    it 'does not retry' do
       TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
 
       expect(sqs_msg).not_to receive(:change_visibility)
@@ -20,62 +27,78 @@ describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
     end
   end
 
-  context 'when a job throws an exception' do
+  context 'when an error' do
+    context "and retry_intervals isn't set" do
+      it 'does not retry' do
+        expect(sqs_msg).not_to receive(:change_visibility)
 
-    it 'does not retry the job by default' do
-      expect(sqs_msg).not_to receive(:change_visibility)
+        expect {
+          subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'Error' }
+        }.to raise_error(RuntimeError, 'Error')
+      end
+    end
 
-      expect {
-        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'Error' }
-      }.to raise_error(RuntimeError, 'Error')
+    context 'and retry_intervals is a lambda' do
+      it 'retries' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = ->(_attempts) { 500 }
+
+        allow(sqs_msg).to receive(:queue) { sqs_queue }
+        expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 500)
+
+        expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
+      end
     end
 
-    it 'does not retry the job if :retry_intervals is empty' do
-      TestWorker.get_shoryuken_options['retry_intervals'] = []
+    context 'and retry_intervals is empty' do
+      it 'does not retry' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = []
 
-      expect(sqs_msg).not_to receive(:change_visibility)
+        expect(sqs_msg).not_to receive(:change_visibility)
 
-      expect {
-        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'Error' }
-      }.to raise_error(RuntimeError, 'Error')
+        expect {
+          subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'Error' }
+        }.to raise_error(RuntimeError, 'Error')
+      end
     end
 
-    it 'retries the job if :retry_intervals is non-empty' do
+    it 'uses first interval ' do
       TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
 
-      allow(sqs_msg).to receive(:queue){ sqs_queue }
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
       expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 300)
 
-      expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise } }.not_to raise_error
+      expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
     end
 
-    it 'retries the job with exponential backoff' do
+    it 'uses matching interval' do
       TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
 
-      allow(sqs_msg).to receive(:attributes){ {'ApproximateReceiveCount' => 2 } }
-      allow(sqs_msg).to receive(:queue){ sqs_queue }
+      allow(sqs_msg).to receive(:attributes) { { 'ApproximateReceiveCount' => 2 } }
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
       expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 1800)
 
-      expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise } }.not_to raise_error
+      expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
     end
 
-    it 'uses the last retry interval when :receive_count exceeds the size of :retry_intervals' do
-      TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+    context 'when attempts exceeds retry_intervals' do
+      it 'uses last interval' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
 
-      allow(sqs_msg).to receive(:attributes){ {'ApproximateReceiveCount' => 3 } }
-      allow(sqs_msg).to receive(:queue){ sqs_queue }
-      expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 1800)
+        allow(sqs_msg).to receive(:attributes) { { 'ApproximateReceiveCount' => 3 } }
+        allow(sqs_msg).to receive(:queue) { sqs_queue }
+        expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 1800)
 
-      expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise } }.not_to raise_error
+        expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
+      end
     end
 
-    it 'limits the visibility timeout to 12 hours from receipt of message' do
-      TestWorker.get_shoryuken_options['retry_intervals'] = [86400]
+    it 'limits the visibility timeout to 12 hours' do
+      TestWorker.get_shoryuken_options['retry_intervals'] = [86_400]
 
-      allow(sqs_msg).to receive(:queue){ sqs_queue }
-      expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 43198)
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
+      expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 43_198)
 
-      expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise } }.not_to raise_error
+      expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
     end
   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/)

data/spec/shoryuken/options_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Options do
+  describe '.add_group' do
+    before do
+      Shoryuken.groups.clear
+      Shoryuken.add_group('group1', 25)
+      Shoryuken.add_group('group2', 25)
+    end
+
+    specify do
+      described_class.add_queue('queue1', 1, 'group1')
+      described_class.add_queue('queue2', 2, 'group2')
+
+      expect(described_class.groups['group1'][:queues]).to eq(%w(queue1))
+      expect(described_class.groups['group2'][:queues]).to eq(%w(queue2 queue2))
+    end
+  end
+
+  describe '.ungrouped_queues' do
+    before do
+      Shoryuken.groups.clear
+      Shoryuken.add_group('group1', 25)
+      Shoryuken.add_group('group2', 25)
+    end
+
+    specify do
+      described_class.add_queue('queue1', 1, 'group1')
+      described_class.add_queue('queue2', 2, 'group2')
+
+      expect(described_class.ungrouped_queues).to eq(%w(queue1 queue2 queue2))
+    end
+  end
+
+  describe '.sqs_client_receive_message_opts' do
+    before do
+      Shoryuken.sqs_client_receive_message_opts
+    end
+
+    specify do
+      Shoryuken.sqs_client_receive_message_opts = { test: 1 }
+      expect(Shoryuken.sqs_client_receive_message_opts).to eq('default' => { test: 1 })
+
+      Shoryuken.sqs_client_receive_message_opts['group1'] = { test: 2 }
+
+      expect(Shoryuken.sqs_client_receive_message_opts).to eq(
+        'default' => { test: 1 },
+        'group1'  => { test: 2 },
+      )
+    end
+  end
+
+  describe '.register_worker' do
+    it 'registers a worker' do
+      described_class.worker_registry.clear
+      described_class.register_worker('default', TestWorker)
+      expect(described_class.worker_registry.workers('default')).to eq([TestWorker])
+    end
+
+    it 'registers a batchable worker' do
+      described_class.worker_registry.clear
+      TestWorker.get_shoryuken_options['batch'] = true
+      described_class.register_worker('default', TestWorker)
+      expect(described_class.worker_registry.workers('default')).to eq([TestWorker])
+    end
+
+    it 'allows multiple workers' do
+      described_class.worker_registry.clear
+      described_class.register_worker('default', TestWorker)
+      expect(described_class.worker_registry.workers('default')).to eq([TestWorker])
+
+      class Test2Worker
+        include Shoryuken::Worker
+
+        shoryuken_options queue: 'default'
+
+        def perform(sqs_msg, body); end
+      end
+
+      expect(described_class.worker_registry.workers('default')).to eq([Test2Worker])
+    end
+
+    it 'raises an exception when mixing batchable with non batchable' do
+      described_class.worker_registry.clear
+      TestWorker.get_shoryuken_options['batch'] = true
+      described_class.register_worker('default', TestWorker)
+
+      expect {
+        class BatchableWorker
+          include Shoryuken::Worker
+
+          shoryuken_options queue: 'default', batch: true
+
+          def perform(sqs_msg, body); end
+        end
+      }.to raise_error("Could not register BatchableWorker for default, because TestWorker is already registered for this queue, " \
+        "and Shoryuken doesn't support a batchable worker for a queue with multiple workers")
+    end
+  end
+end

data/spec/shoryuken/polling/strict_priority_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+RSpec.describe Shoryuken::Polling::StrictPriority do
+  let(:queue1) { 'shoryuken' }
+  let(:queue2) { 'uppercut' }
+  let(:queue3) { 'other' }
+  let(:queues) { Array.new }
+  subject { Shoryuken::Polling::StrictPriority.new(queues) }
+
+  describe '#next_queue' do
+    it 'cycles when declared desc' do
+      # [shoryuken, 2]
+      # [uppercut,  1]
+      queues << queue1
+      queues << queue1
+      queues << queue2
+
+      expect(subject.next_queue).to eq(queue1)
+      expect(subject.next_queue).to eq(queue2)
+      expect(subject.next_queue).to eq(queue1)
+      expect(subject.next_queue).to eq(queue2)
+    end
+
+    it 'cycles when declared asc' do
+      # [uppercut,  1]
+      # [shoryuken, 2]
+      queues << queue2
+      queues << queue1
+      queues << queue1
+
+      expect(subject.next_queue).to eq(queue1)
+      expect(subject.next_queue).to eq(queue2)
+      expect(subject.next_queue).to eq(queue1)
+      expect(subject.next_queue).to eq(queue2)
+    end
+
+    it 'returns nil if there are no active queues' do
+      expect(subject.next_queue).to eq(nil)
+    end
+
+    it 'unpauses queues whose pause is expired' do
+      # [shoryuken, 3]
+      # [uppercut,  2]
+      # [other,     1]
+      queues << queue1
+      queues << queue1
+      queues << queue1
+      queues << queue2
+      queues << queue2
+      queues << queue3
+
+      allow(subject).to receive(:delay).and_return(10)
+
+      now = Time.now
+      allow(Time).to receive(:now).and_return(now)
+
+      # pause the second queue, see it loop between 1 and 3
+      subject.messages_found(queue2, 0)
+      expect(subject.next_queue).to eq(queue1)
+      expect(subject.next_queue).to eq(queue3)
+      expect(subject.next_queue).to eq(queue1)
+
+      now += 5
+      allow(Time).to receive(:now).and_return(now)
+
+      # pause the first queue, see it repeat 3
+      subject.messages_found(queue1, 0)
+      expect(subject.next_queue).to eq(queue3)
+      expect(subject.next_queue).to eq(queue3)
+
+      # pause the third queue, see it have nothing
+      subject.messages_found(queue3, 0)
+      expect(subject.next_queue).to eq(nil)
+
+      # unpause queue 2
+      now += 6
+      allow(Time).to receive(:now).and_return(now)
+      expect(subject.next_queue).to eq(queue2)
+
+      # unpause queues 1 and 3
+      now += 6
+      allow(Time).to receive(:now).and_return(now)
+      expect(subject.next_queue).to eq(queue1)
+      expect(subject.next_queue).to eq(queue2)
+      expect(subject.next_queue).to eq(queue3)
+    end
+  end
+
+  describe '#messages_found' do
+    it 'pauses a queue if there are no messages found' do
+      # [shoryuken, 2]
+      # [uppercut,  1]
+      queues << queue1
+      queues << queue1
+      queues << queue2
+
+      expect(subject.active_queues).to eq([[queue1, 2], [queue2, 1]])
+      expect(subject).to receive(:pause).with(queue1).and_call_original
+      subject.messages_found(queue1, 0)
+      expect(subject.active_queues).to eq([[queue2, 1]])
+    end
+
+    it 'continues to queue the highest priority queue if messages are found' do
+      # [shoryuken, 3]
+      # [uppercut,  2]
+      # [other,     1]
+      queues << queue1
+      queues << queue1
+      queues << queue1
+      queues << queue2
+      queues << queue2
+      queues << queue3
+
+      expect(subject.next_queue).to eq(queue1)
+      subject.messages_found(queue1, 1)
+      expect(subject.next_queue).to eq(queue1)
+      subject.messages_found(queue1, 1)
+      expect(subject.next_queue).to eq(queue1)
+    end
+
+    it 'resets the priorities if messages are found part way' do
+      # [shoryuken, 3]
+      # [uppercut,  2]
+      # [other,     1]
+      queues << queue1
+      queues << queue1
+      queues << queue1
+      queues << queue2
+      queues << queue2
+      queues << queue3
+
+      expect(subject.next_queue).to eq(queue1)
+      expect(subject.next_queue).to eq(queue2)
+      subject.messages_found(queue2, 1)
+      expect(subject.next_queue).to eq(queue1)
+      expect(subject.next_queue).to eq(queue2)
+      expect(subject.next_queue).to eq(queue3)
+    end
+  end
+end