chore-core 1.5.10 → 1.7.2

data/spec/chore/manager_spec.rb

@@ -3,39 +3,35 @@ require 'timeout'
 
 describe Chore::Manager do
 
-  let(:fetcher) { mock(:start => nil) }
+  let(:fetcher) { double(:start => nil) }
   let(:opts) { { :num_workers => 4, :other_opt => 'hi', :fetcher => fetcher } }
 
   before(:each) do
     Chore.configure {|c| c.fetcher = fetcher; c.worker_strategy = Chore::Strategy::SingleWorkerStrategy }
-    fetcher.should_receive(:new).and_return(fetcher)
+    expect(fetcher).to receive(:new).and_return(fetcher)
   end
 
-  it 'should call create an instance of the defined fetcher' do
-    manager = Chore::Manager.new
-  end
-
-  
-
   describe 'running the manager' do
 
-    let(:manager) { Chore::Manager.new}
-    let(:work) { Chore::UnitOfWork.new(Chore::Encoder::JsonEncoder.encode({:class => 'MyClass',:args => []}),mock()) }
+    let(:manager) { Chore::Manager.new }
+    let(:work) do
+      Chore::UnitOfWork.new(Chore::Encoder::JsonEncoder.encode({ :class => 'MyClass', :args => [] }), double())
+    end
 
     it 'should start the fetcher when starting the manager' do
-      fetcher.should_receive(:start)
+      expect(fetcher).to receive(:start)
       manager.start
     end
 
     describe 'assigning messages' do
-      let(:worker) { mock() }
+      let(:worker) { double() }
 
       before(:each) do
-        worker.should_receive(:start).with()
+        expect(worker).to receive(:start).with no_args
       end
 
       it 'should create a worker if one is available' do
-        Chore::Worker.should_receive(:new).with(work,{}).and_return(worker)
+        expect(Chore::Worker).to receive(:new).with(work,{}).and_return(worker)
         manager.assign(work)
       end
     end

data/spec/chore/queues/filesystem/filesystem_consumer_spec.rb

@@ -11,15 +11,15 @@ describe Chore::Queues::Filesystem::Consumer do
 
   before do
     Chore.config.fs_queue_root = test_queues_dir
-    Chore.config.stub(:default_queue_timeout).and_return(60)
-    consumer.stub(:sleep)
+    expect(Chore.config).to receive(:default_queue_timeout).and_return(60)
+    allow(consumer).to receive(:sleep)
   end
-  
+
   after do
     FileUtils.rm_rf(test_queues_dir)
   end
-  
-  let!(:consumer_run_for_one_message) { consumer.stub(:running?).and_return(true, false) }
+
+  let!(:consumer_run_for_one_message) { expect(consumer).to receive(:running?).and_return(true, false) }
   let(:test_job_hash) {{:class => "TestClass", :args => "test-args"}}
 
   context "founding a published job" do
@@ -32,30 +32,30 @@ describe Chore::Queues::Filesystem::Consumer do
     end
 
     context "rejecting a job" do
-      let!(:consumer_run_for_two_messages) { consumer.stub(:running?).and_return(true, false,true,false) }
-    
+      let!(:consumer_run_for_two_messages) { allow(consumer).to receive(:running?).and_return(true, false,true,false) }
+
       it "should requeue a job that gets rejected" do
         rejected = false
         consumer.consume do |job_id, queue_name, job_hash|
           consumer.reject(job_id)
           rejected = true
         end
-        rejected.should be_true
+        expect(rejected).to be true
 
         expect { |b| consumer.consume(&b) }.to yield_with_args(anything, 'test-queue', 60, test_job_hash.to_json, 1)
       end
     end
-    
+
     context "completing a job" do
-      let!(:consumer_run_for_two_messages) { consumer.stub(:running?).and_return(true, false,true,false) }
-    
+      let!(:consumer_run_for_two_messages) { allow(consumer).to receive(:running?).and_return(true, false,true,false) }
+
       it "should remove job on completion" do
         completed = false
         consumer.consume do |job_id, queue_name, job_hash|
           consumer.complete(job_id)
           completed = true
         end
-        completed.should be_true
+        expect(completed).to be true
 
         expect { |b| consumer.consume(&b) }.to_not yield_control
       end

data/spec/chore/queues/sqs/consumer_spec.rb

@@ -11,27 +11,28 @@ describe Chore::Queues::SQS::Consumer do
   let(:message_data) {{:id=>message.id, :queue=>message.queue.url, :visibility_timeout=>message.queue.visibility_timeout}}
   let(:pool) { double("pool") }
   let(:sqs) { double('AWS::SQS') }
+  let(:backoff_func) { nil }
 
   before do
-    AWS::SQS.stub(:new).and_return(sqs)
-    sqs.stub(:queues).and_return { queues }
-     
-    queues.stub(:url_for) { queue_url }
-    queues.stub(:[]) { queue }
-    queue.stub(:receive_message) { message }
-    pool.stub(:empty!) { nil }
+    allow(AWS::SQS).to receive(:new).and_return(sqs)
+    allow(sqs).to receive(:queues) { queues }
+
+    allow(queues).to receive(:url_for) { queue_url }
+    allow(queues).to receive(:[]) { queue }
+    allow(queue).to receive(:receive_message) { message }
+    allow(pool).to receive(:empty!) { nil }
   end
 
   describe "consuming messages" do
-    let!(:consumer_run_for_one_message) { consumer.stub(:running?).and_return(true, false) }
-    let!(:messages_be_unique) { Chore::DuplicateDetector.any_instance.stub(:found_duplicate?).and_return(false) }
-    let!(:queue_contain_messages) { queue.stub(:receive_messages).and_return(message) }
+    let!(:consumer_run_for_one_message) { allow(consumer).to receive(:running?).and_return(true, false) }
+    let!(:messages_be_unique) { allow_any_instance_of(Chore::DuplicateDetector).to receive(:found_duplicate?).and_return(false) }
+    let!(:queue_contain_messages) { allow(queue).to receive(:receive_messages).and_return(message) }
 
     it 'should configure sqs' do
-      Chore.config.stub(:aws_access_key).and_return('key')
-      Chore.config.stub(:aws_secret_key).and_return('secret')
+      allow(Chore.config).to receive(:aws_access_key).and_return('key')
+      allow(Chore.config).to receive(:aws_secret_key).and_return('secret')
 
-      AWS::SQS.should_receive(:new).with(
+      expect(AWS::SQS).to receive(:new).with(
         :access_key_id => 'key',
         :secret_access_key => 'secret',
         :logger => Chore.logger,
@@ -41,38 +42,38 @@ describe Chore::Queues::SQS::Consumer do
     end
 
     it 'should not configure sqs multiple times' do
-      consumer.stub(:running?).and_return(true, true, false)
+      allow(consumer).to receive(:running?).and_return(true, true, false)
 
-      AWS::SQS.should_receive(:new).once.and_return(sqs)
+      expect(AWS::SQS).to receive(:new).once.and_return(sqs)
       consumer.consume
     end
 
     it 'should look up the queue url based on the queue name' do
-      queues.should_receive(:url_for).with('test').and_return(queue_url)
+      expect(queues).to receive(:url_for).with('test').and_return(queue_url)
       consumer.consume
     end
 
     it 'should look up the queue based on the queue url' do
-      queues.should_receive(:[]).with(queue_url).and_return(queue)
+      expect(queues).to receive(:[]).with(queue_url).and_return(queue)
       consumer.consume
     end
 
     context "should receive a message from the queue" do
 
       it 'should use the default size of 10 when no queue_polling_size is specified' do
-        queue.should_receive(:receive_messages).with(:limit => 10, :attributes => [:receive_count])
+        expect(queue).to receive(:receive_messages).with(:limit => 10, :attributes => [:receive_count])
         consumer.consume
       end
 
       it 'should respect the queue_polling_size when specified' do
-        Chore.config.stub(:queue_polling_size).and_return(5)
-        queue.should_receive(:receive_messages).with(:limit => 5, :attributes => [:receive_count])
+        allow(Chore.config).to receive(:queue_polling_size).and_return(5)
+        expect(queue).to receive(:receive_messages).with(:limit => 5, :attributes => [:receive_count])
         consumer.consume
       end
     end
 
     it "should check the uniqueness of the message" do
-      Chore::DuplicateDetector.any_instance.should_receive(:found_duplicate?).with(message_data).and_return(false)
+      allow_any_instance_of(Chore::DuplicateDetector).to receive(:found_duplicate?).with(message_data).and_return(false)
       consumer.consume
     end
 
@@ -81,55 +82,65 @@ describe Chore::Queues::SQS::Consumer do
     end
 
     it 'should not yield for a dupe message' do
-      Chore::DuplicateDetector.any_instance.should_receive(:found_duplicate?).with(message_data).and_return(true)
+      allow_any_instance_of(Chore::DuplicateDetector).to receive(:found_duplicate?).with(message_data).and_return(true)
       expect {|b| consumer.consume(&b) }.not_to yield_control
     end
 
     context 'with no messages' do
-      let!(:consumer_run_for_one_message) { consumer.stub(:running?).and_return(true, true, false) }
-      let!(:queue_contain_messages) { queue.stub(:receive_messages).and_return(message, nil) }
+      let!(:consumer_run_for_one_message) { allow(consumer).to receive(:running?).and_return(true, true, false) }
+      let!(:queue_contain_messages) { allow(queue).to receive(:receive_messages).and_return(message, nil) }
 
       it 'should sleep' do
-        consumer.should_receive(:sleep).with(1)
+        expect(consumer).to receive(:sleep).with(1)
         consumer.consume
       end
     end
 
     context 'with messages' do
-      let!(:consumer_run_for_one_message) { consumer.stub(:running?).and_return(true, true, false) }
-      let!(:queue_contain_messages) { queue.stub(:receive_messages).and_return(message, message) }
+      let!(:consumer_run_for_one_message) { allow(consumer).to receive(:running?).and_return(true, true, false) }
+      let!(:queue_contain_messages) { allow(queue).to receive(:receive_messages).and_return(message, message) }
 
       it 'should not sleep' do
-        consumer.should_not_receive(:sleep)
+        expect(consumer).to_not receive(:sleep)
         consumer.consume
       end
     end
   end
 
+  describe '#delay' do
+    let(:item) { Chore::UnitOfWork.new(message.id, message.queue, 60, message.body, 0, consumer) }
+    let(:backoff_func) { lambda { |item| 2 } }
+
+    it 'changes the visiblity of the message' do
+      expect(queue).to receive(:batch_change_visibility).with(2, [item.id])
+      consumer.delay(item, backoff_func)
+    end
+  end
+
   describe '#reset_connection!' do
     it 'should reset the connection after a call to reset_connection!' do
-      AWS::Core::Http::ConnectionPool.stub(:pools).and_return([pool])
-      pool.should_receive(:empty!)
+      expect(AWS::Core::Http::ConnectionPool).to receive(:pools).and_return([pool])
+      expect(pool).to receive(:empty!)
       Chore::Queues::SQS::Consumer.reset_connection!
       consumer.send(:queue)
     end
 
     it 'should not reset the connection between calls' do
       sqs = consumer.send(:queue)
-      sqs.should be consumer.send(:queue)
+      expect(sqs).to be consumer.send(:queue)
     end
 
     it 'should reconfigure sqs' do
-      consumer.stub(:running?).and_return(true, false)
-      Chore::DuplicateDetector.any_instance.stub(:found_duplicate?).and_return(false)
+      allow(consumer).to receive(:running?).and_return(true, false)
+      allow_any_instance_of(Chore::DuplicateDetector).to receive(:found_duplicate?).and_return(false)
 
-      queue.stub(:receive_messages).and_return(message)
+      allow(queue).to receive(:receive_messages).and_return(message)
       consumer.consume
 
       Chore::Queues::SQS::Consumer.reset_connection!
-      AWS::SQS.should_receive(:new).and_return(sqs)
+      allow(AWS::SQS).to receive(:new).and_return(sqs)
 
-      consumer.stub(:running?).and_return(true, false)
+      expect(consumer).to receive(:running?).and_return(true, false)
       consumer.consume
     end
   end

data/spec/chore/queues/sqs_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 module Chore
   describe Queues::SQS do
     context "when managing queues" do
@@ -8,30 +10,45 @@ module Chore
       let(:fake_queue) {double(Object)}
 
       before(:each) do
-        AWS::SQS.stub(:new).and_return(fake_sqs)
-        Chore.stub(:prefixed_queue_names) {[queue_name]}
-        fake_queue.stub(:delete)
-    
-        fake_queue_collection.stub(:[]) do |key|
-          fake_queue
-        end
-    
-        fake_queue_collection.stub(:create)
-        fake_sqs.stub(:queues).and_return(fake_queue_collection)
-        fake_queue_collection.stub(:url_for).with(queue_name).and_return(queue_url)
+        allow(AWS::SQS).to receive(:new).and_return(fake_sqs)
+        allow(Chore).to receive(:prefixed_queue_names).and_return([queue_name])
+        allow(fake_queue).to receive(:delete)
+
+        allow(fake_queue_collection).to receive(:[]).and_return(fake_queue)
+        allow(fake_queue_collection).to receive(:create)
+        allow(fake_queue_collection).to receive(:url_for).with(queue_name).and_return(queue_url)
+
+        allow(fake_sqs).to receive(:queues).and_return(fake_queue_collection)
       end
 
       it 'should create queues that are defined in its internal job name list' do
         #Only one job defined in the spec suite
-        fake_queue_collection.should_receive(:create)
+        expect(fake_queue_collection).to receive(:create)
         Chore::Queues::SQS.create_queues!
       end
 
       it 'should delete queues that are defined in its internal job name list' do
         #Only one job defined in the spec suite
-        fake_queue.should_receive(:delete)
+        expect(fake_queue).to receive(:delete)
         Chore::Queues::SQS.delete_queues!
       end
+
+      context 'and checking for existing queues' do
+        it 'checks for existing queues' do
+          expect(described_class).to receive(:existing_queues).and_return([])
+          Chore::Queues::SQS.create_queues!(true)
+        end
+
+        it 'raises an error if a queue does exist' do
+          allow(described_class).to receive(:existing_queues).and_return([queue_name])
+          expect{Chore::Queues::SQS.create_queues!(true)}.to raise_error(RuntimeError)
+        end
+
+        it 'does not raise an error if a queue does not exist' do
+          allow(described_class).to receive(:existing_queues).and_return([])
+          expect{Chore::Queues::SQS.create_queues!(true)}.not_to raise_error
+        end
+      end
     end
   end
 end

data/spec/chore/strategies/worker/forked_worker_strategy_spec.rb

@@ -5,7 +5,7 @@ describe Chore::Strategy::ForkedWorkerStrategy do
   let(:manager) { double('manager') }
   let(:forker) do
     strategy = Chore::Strategy::ForkedWorkerStrategy.new(manager)
-    strategy.stub(:exit!)
+    allow(strategy).to receive(:exit!)
     strategy
   end
   let(:job_timeout) { 60 }
@@ -14,72 +14,73 @@ describe Chore::Strategy::ForkedWorkerStrategy do
   let(:pid) { Random.rand(2048) }
 
   after(:each) do
-    Process.stub(:kill => nil, :wait => pid)
+    allow(Process).to receive(:kill) { nil }
+    allow(Process).to receive(:wait) { pid }
     forker.stop!
   end
 
   context "signal handling" do
     it 'should trap signals from terminating children and reap them' do
-      Chore::Signal.should_receive(:trap).with('CHLD').and_yield
-      Chore::Strategy::ForkedWorkerStrategy.any_instance.should_receive(:reap_terminated_workers!)
+      expect(Chore::Signal).to receive(:trap).with('CHLD').and_yield
+      allow_any_instance_of(Chore::Strategy::ForkedWorkerStrategy).to receive(:reap_terminated_workers!)
       forker
     end
   end
 
   context '#assign' do
     before(:each) do
-      forker.stub(:fork).and_yield.and_return(pid, pid + 1)
-      forker.stub(:after_fork)
+      allow(forker).to receive(:fork).and_yield.and_return(pid, pid + 1)
+      allow(forker).to receive(:after_fork)
     end
     after(:each) do
       Chore.clear_hooks!
     end
 
     it 'should pop off the worker queue when assignd a job' do
-      Queue.any_instance.should_receive(:pop)
+      allow_any_instance_of(Queue).to receive(:pop)
       forker.assign(job)
     end
 
     it 'should assign a job to a new worker' do
-      Chore::Worker.should_receive(:new).with(job, {}).and_return(worker)
-      worker.should_receive(:start)
+      expect(Chore::Worker).to receive(:new).with(job, {}).and_return(worker)
+      expect(worker).to receive(:start)
       forker.assign(job)
     end
 
     it 'should add an assigned worker to the worker list' do
-      forker.workers.should_receive(:[]=).with(pid,kind_of(Chore::Worker))
+      expect(forker.workers).to receive(:[]=).with(pid,kind_of(Chore::Worker))
       forker.assign(job)
     end
 
     it 'should fork a child for each new worker' do
-      forker.should_receive(:fork).and_yield.and_return(pid)
+      expect(forker).to receive(:fork).and_yield.and_return(pid)
       forker.assign(job)
     end
 
     it 'should remove the worker from the list when it has completed' do
       forker.assign(job)
 
-      Process.should_receive(:wait).with(pid, Process::WNOHANG).and_return(pid)
+      expect(Process).to receive(:wait).with(pid, Process::WNOHANG).and_return(pid)
       forker.send(:reap_terminated_workers!)
 
-      forker.workers.should_not include(pid)
+      expect(forker.workers).to_not include(pid)
     end
 
     it 'should not remove the worker from the list if it has not yet completed' do
       forker.assign(job)
 
-      Process.stub(:wait).and_return(nil)
+      expect(Process).to receive(:wait).and_return(nil)
       forker.send(:reap_terminated_workers!)
 
-      forker.workers.should include(pid)
+      expect(forker.workers).to include(pid)
     end
 
     it 'should add the worker back to the queue when it has completed' do
       2.times { forker.assign(job) }
 
-      Queue.any_instance.should_receive(:<<).twice.with(:worker)
+      allow_any_instance_of(Queue).to receive(:<<).with(:worker)
 
-      Process.stub(:wait).and_return(pid, pid + 1)
+      allow(Process).to receive(:wait).and_return(pid, pid + 1)
       forker.send(:reap_terminated_workers!)
     end
 
@@ -87,9 +88,9 @@ describe Chore::Strategy::ForkedWorkerStrategy do
       forker.assign(job)
       reaped = false
 
-      forker.should_receive(:release_worker).once
+      expect(forker).to receive(:release_worker).once
 
-      Process.should_receive(:wait).twice.with(pid, anything).and_return do
+      wait_proc = Proc.new do
         if !reaped
           reaped = true
           forker.send(:reap_terminated_workers!)
@@ -97,17 +98,19 @@ describe Chore::Strategy::ForkedWorkerStrategy do
 
         pid
       end
+
+      expect(Process).to receive(:wait).with(pid, anything).and_return(wait_proc)
       forker.send(:reap_terminated_workers!)
     end
 
     it 'should continue to allow reaping after an exception occurs' do
       2.times { forker.assign(job) }
 
-      Process.should_receive(:wait).and_raise(Errno::ECHILD)
-      Process.should_receive(:wait).and_return(pid + 1)
+      expect(Process).to receive(:wait).and_raise(Errno::ECHILD)
+      expect(Process).to receive(:wait).and_return(pid + 1)
       forker.send(:reap_terminated_workers!)
 
-      forker.workers.should be_empty
+      expect(forker.workers).to eq({})
     end
 
     [:before_fork, :after_fork, :within_fork, :before_fork_shutdown].each do |hook|
@@ -115,7 +118,7 @@ describe Chore::Strategy::ForkedWorkerStrategy do
         hook_called = false
         Chore.add_hook(hook) { hook_called = true }
         forker.assign(job)
-        hook_called.should be_true
+        expect(hook_called).to be true
       end
     end
 
@@ -123,26 +126,26 @@ describe Chore::Strategy::ForkedWorkerStrategy do
       hook_called = false
       Chore.add_hook(:around_fork) {|&blk| hook_called = true; blk.call }
       forker.assign(job)
-      hook_called.should be_true
+      expect(hook_called).to be true
     end
 
     it 'should run before_fork_shutdown hooks even if job errors' do
-      Chore::Worker.stub(:new).and_return(worker)
-      worker.stub(:start).and_raise(ArgumentError)
+      expect(Chore::Worker).to receive(:new).and_return(worker)
+      expect(worker).to receive(:start).and_raise(ArgumentError)
 
       hook_called = false
       Chore.add_hook(:before_fork_shutdown) { hook_called = true }
 
       begin
         forker.assign(job)
-      rescue ArgumentError => ex
+      rescue ArgumentError
       end
 
-      hook_called.should be_true
+      expect(hook_called).to be true
     end
 
     it 'should exit the process without running at_exit handlers' do
-      forker.should_receive(:exit!).with(true)
+      expect(forker).to receive(:exit!).with(true)
       forker.assign(job)
     end
 
@@ -150,19 +153,19 @@ describe Chore::Strategy::ForkedWorkerStrategy do
       let(:job_timeout) { 0.1 }
 
       before(:each) do
-        Process.stub(:kill)
-        Chore::Worker.stub(:new).and_return(worker)
+        allow(Process).to receive(:kill)
+        expect(Chore::Worker).to receive(:new).and_return(worker)
       end
 
       it 'should kill the process if it expires' do
-        Process.should_receive(:kill).with('KILL', pid)
+        expect(Process).to receive(:kill).with('KILL', pid)
         forker.assign(job)
         sleep 2
       end
 
       it 'should run the on_failure callback hook' do
         forker.assign(job)
-        Chore.should_receive(:run_hooks_for).with(:on_failure, anything, instance_of(Chore::TimeoutError))
+        expect(Chore).to receive(:run_hooks_for).with(:on_failure, anything, instance_of(Chore::TimeoutError))
         sleep 2
       end
     end
@@ -171,14 +174,14 @@ describe Chore::Strategy::ForkedWorkerStrategy do
       let(:job_timeout) { 0.1 }
 
       before(:each) do
-        Chore::Worker.stub(:new).and_return(worker)
+        expect(Chore::Worker).to receive(:new).and_return(worker)
       end
 
       it 'should not kill the process if does not expire' do
-        Process.should_not_receive(:kill)
+        expect(Process).to_not receive(:kill)
 
         forker.assign(job)
-        Process.stub(:wait).and_return(pid)
+        expect(Process).to receive(:wait).and_return(pid)
         forker.send(:reap_terminated_workers!)
         sleep 2
       end
@@ -187,7 +190,7 @@ describe Chore::Strategy::ForkedWorkerStrategy do
 
   context '#before_fork' do
     before(:each) do
-      Chore::Worker.stub(:new).and_return(worker)
+      expect(Chore::Worker).to receive(:new).and_return(worker)
     end
     after(:each) do
       Chore.clear_hooks!
@@ -195,14 +198,14 @@ describe Chore::Strategy::ForkedWorkerStrategy do
 
     it 'should release the worker if an exception occurs' do
       Chore.add_hook(:before_fork) { raise ArgumentError }
-      forker.should_receive(:release_worker)
+      expect(forker).to receive(:release_worker)
       forker.assign(job)
     end
   end
 
   context '#around_fork' do
     before(:each) do
-      Chore::Worker.stub(:new).and_return(worker)
+      expect(Chore::Worker).to receive(:new).and_return(worker)
     end
     after(:each) do
       Chore.clear_hooks!
@@ -210,7 +213,7 @@ describe Chore::Strategy::ForkedWorkerStrategy do
 
     it 'should release the worker if an exception occurs' do
       Chore.add_hook(:around_fork) {|worker, &block| raise ArgumentError}
-      forker.should_receive(:release_worker)
+      expect(forker).to receive(:release_worker)
       forker.assign(job)
     end
   end
@@ -219,61 +222,61 @@ describe Chore::Strategy::ForkedWorkerStrategy do
     let(:worker) { double('worker') }
 
     it 'should clear signals' do
-      forker.should_receive(:clear_child_signals)
+      expect(forker).to receive(:clear_child_signals)
       forker.send(:after_fork,worker)
     end
 
     it 'should trap signals' do
-      forker.should_receive(:trap_child_signals)
+      expect(forker).to receive(:trap_child_signals)
       forker.send(:after_fork,worker)
     end
 
     it 'should set the procline' do
-      forker.should_receive(:procline)
+      expect(forker).to receive(:procline)
       forker.send(:after_fork,worker)
     end
   end
 
   context '#stop!' do
     before(:each) do
-      Process.stub(:kill)
+      allow(Process).to receive(:kill)
 
-      forker.stub(:fork).and_yield.and_return(pid)
-      forker.stub(:after_fork)
+      expect(forker).to receive(:fork).and_yield.and_return(pid)
+      expect(forker).to receive(:after_fork)
       forker.assign(job)
     end
 
     it 'should send a quit signal to each child' do
-      Process.should_receive(:kill).once.with('QUIT', pid)
-      Process.stub(:wait).and_return(pid, nil)
+      expect(Process).to receive(:kill).once.with('QUIT', pid)
+      allow(Process).to receive(:wait).and_return(pid, nil)
       forker.stop!
     end
 
     it 'should reap each worker' do
-      Process.should_receive(:wait).and_return(pid)
+      expect(Process).to receive(:wait).and_return(pid)
       forker.stop!
-      forker.workers.should be_empty
+      expect(forker.workers).to eq({})
     end
 
     it 'should resend quit signal to children if workers are not reaped' do
-      Process.should_receive(:kill).twice.with('QUIT', pid)
-      Process.stub(:wait).and_return(nil, pid, nil)
+      expect(Process).to receive(:kill).with('QUIT', pid)
+      allow(Process).to receive(:wait).and_return(nil, pid, nil)
       forker.stop!
     end
 
     it 'should send kill signal to children if timeout is exceeded' do
-      Chore.config.stub(:shutdown_timeout).and_return(0.05)
-      Process.should_receive(:kill).once.with('QUIT', pid)
-      Process.stub(:wait).and_return(nil)
-      Process.should_receive(:kill).once.with('KILL', pid)
+      expect(Chore.config).to receive(:shutdown_timeout).and_return(0.05)
+      expect(Process).to receive(:kill).once.with('QUIT', pid)
+      expect(Process).to receive(:wait).and_return(nil)
+      expect(Process).to receive(:kill).once.with('KILL', pid)
       forker.stop!
     end
 
     it 'should not allow more work to be assigned' do
-      Process.stub(:wait).and_return(pid, nil)
+      allow(Process).to receive(:wait).and_return(pid, nil)
       forker.stop!
 
-      Chore::Worker.should_not_receive(:new)
+      expect(Chore::Worker).to_not receive(:new)
       forker.assign(job)
     end
   end