perfectqueue 0.8.44.1 → 0.8.45

data/spec/multiprocess/child_process_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe PerfectQueue::Multiprocess::ChildProcess do
+  let (:runner_insntace){  double('runner') }
+  let (:runner) do
+    runner = double('Runner')
+    allow(runner).to receive(:new).and_return(runner_insntace)
+    runner
+  end
+  let (:processor_id){ double('processor_id') }
+  let (:logger){ double('logger').as_null_object }
+  let (:config){ {logger: logger} }
+  let (:wpipe){ double('wpipe', sync: true, :'sync=' => true) }
+  let (:pr){ Multiprocess::ChildProcess.new(runner, processor_id, config, wpipe) }
+  describe '.run' do
+    let (:pr){ double('child_process') }
+    before do
+      expect(Multiprocess::ChildProcess).to receive(:new).exactly(:once) \
+        .with(runner, processor_id, config, wpipe).and_return(pr)
+      expect(pr).to receive(:run).exactly(:once)
+    end
+    it 'runs an instance' do
+      Multiprocess::ChildProcess.run(runner, processor_id, config, wpipe)
+    end
+  end
+
+  describe '.new' do
+    it 'returns a Multiprocess::ChildProcess' do
+      pr = Multiprocess::ChildProcess.new(runner, processor_id, config, wpipe)
+      expect(pr).to be_an_instance_of(Multiprocess::ChildProcess)
+      expect(pr.instance_variable_get(:@wpipe)).to eq(wpipe)
+      expect(pr.instance_variable_get(:@sig)).to be_a(SignalThread)
+    end
+  end
+
+  describe '#stop' do
+    it 'call super' do
+      pr.stop(true)
+    end
+  end
+
+  describe '#keepalive' do
+    it { pr.keepalive }
+  end
+
+  describe '#logrotated' do
+    it do
+      expect(logger).to receive(:reopen!).with(no_args).exactly(:once)
+      pr.logrotated
+    end
+  end
+
+  describe '#child_heartbeat' do
+    let (:packet){ Multiprocess::ChildProcess::HEARTBEAT_PACKET }
+    it 'write HEARTBEAT_PACKET' do
+      expect(wpipe).to receive(:write).with(packet).exactly(:once)
+      pr.child_heartbeat
+    end
+    it 'rescue an error' do
+      expect(wpipe).to receive(:write).with(packet).exactly(:once) \
+        .and_raise(RuntimeError)
+      expect(pr).to receive(:force_stop).exactly(:once)
+      pr.child_heartbeat
+    end
+  end
+
+  describe '#force_stop' do
+    it 'calls exit! 137' do
+      expect(Process).to receive(:kill).with(:KILL, Process.pid)
+      expect(pr).to receive(:exit!).with(137).exactly(:once)
+      pr.force_stop
+    end
+  end
+
+  describe '#process' do
+    let (:task){ double('task', key: double) }
+    before do
+      expect(runner_insntace).to receive(:run)
+    end
+    context 'max_request_per_child is nil' do
+      it 'runs' do
+        pr.process(task)
+      end
+    end
+    context 'max_request_per_child is set' do
+      before do
+        pr.instance_variable_set(:@max_request_per_child, 2)
+      end
+      it 'counts children if request_per_child is still small' do
+        expect(pr).not_to receive(:stop)
+        pr.instance_variable_set(:@request_per_child, 1)
+        pr.process(task)
+        expect(pr.instance_variable_get(:@request_per_child)).to eq(2)
+      end
+      it 'stops children if request_per_child exceeds the limit' do
+        expect(pr).to receive(:stop).with(false).exactly(:once)
+        pr.instance_variable_set(:@request_per_child, 2)
+        pr.process(task)
+        expect(pr.instance_variable_get(:@request_per_child)).to eq(3)
+      end
+    end
+  end
+
+  context 'signal handling' do
+    before do
+      allow(PerfectQueue).to receive(:open) do
+        flag = pr.instance_variable_get(:@finish_flag)
+        Thread.pass until flag.set?
+      end
+    end
+
+    it 'calls stop(false) SIGTERM' do
+      expect(pr).to receive(:stop).with(false).and_call_original
+      Process.kill(:TERM, Process.pid)
+      pr.run
+    end
+
+    it 'calls stop(false) SIGINT' do
+      expect(pr).to receive(:stop).with(false).and_call_original
+      Process.kill(:INT, Process.pid)
+      pr.run
+    end
+
+    it 'calls stop(true) SIGQUIT' do
+      expect(pr).to receive(:stop).with(true).and_call_original
+      Process.kill(:QUIT, Process.pid)
+      pr.run
+    end
+
+    it 'calls stop(false) SIGUSR1' do
+      expect(pr).to receive(:stop).with(false).and_call_original
+      Process.kill(:USR1, Process.pid)
+      pr.run
+    end
+
+    it 'calls stop(true) SIGHUP' do
+      expect(pr).to receive(:stop).with(true).and_call_original
+      Process.kill(:HUP, Process.pid)
+      pr.run
+    end
+
+    it 'calls stop(false) on SIGCONT' do
+      expect(pr).to receive(:stop).with(false).and_call_original
+      Process.kill(:CONT, Process.pid)
+      pr.run
+    end
+
+    it 'calls stop(true) on SIGWINCH' do
+      expect(pr).to receive(:stop).with(true).and_call_original
+      Process.kill(:WINCH, Process.pid)
+      pr.run
+    end
+
+    it 'calls logrotated on SIGUSR2' do
+      expect(pr).to receive(:logrotated){ pr.stop(true) }
+      Process.kill(:USR2, Process.pid)
+      pr.run
+    end
+  end
+end

data/spec/multiprocess/fork_processor_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe PerfectQueue::Multiprocess::ForkProcessor do
+  describe '.new' do
+    it 'returns a PerfectQueue::Multiprocess::ForkProcessor' do
+      runner = double('runner')
+      processor_id = double('processor_id')
+      config = {}
+      processor = Multiprocess::ForkProcessor.new(runner, processor_id, config)
+      expect(processor).to be_an_instance_of(Multiprocess::ForkProcessor)
+      expect(processor.instance_variable_get(:@processor_id)).to eq(processor_id)
+    end
+  end
+
+  describe '#restart' do
+    let (:config_keys){[
+      :child_heartbeat_limit,
+      :child_kill_interval,
+      :child_graceful_kill_limit,
+      :child_fork_frequency_limit,
+      :child_heartbeat_kill_delay,
+    ]}
+    let (:config){ {logger: double('logger').as_null_object} }
+    let (:processor) {
+      runner = double('runner')
+      processor_id = double('processor_id')
+      Multiprocess::ForkProcessor.new(runner, processor_id, config)
+    }
+    it 'sets config' do
+      config_keys.each do |key|
+        config[key] = double(key)
+      end
+      processor.restart(true, config)
+      config_keys.each do |key|
+        expect(processor.instance_variable_get("@#{key}".to_sym)).to eq(config[key])
+      end
+      expect(processor.instance_variable_get(:@config)).to eq(config)
+    end
+    it 'calls ChildProcessMonitor#start_killing if it has ChildProcessMonitor' do
+      immediate = double('immediate')
+      cpm = double('ChildProcessMonitor')
+      expect(cpm).to receive(:start_killing).with(immediate).exactly(:once)
+      processor.instance_variable_set(:@cpm, cpm)
+      processor.restart(immediate, config)
+    end
+  end
+
+  describe '#stop' do
+    let (:processor) {
+      runner = double('runner')
+      processor_id = double('processor_id')
+      config = {logger: double('logger').as_null_object}
+      Multiprocess::ForkProcessor.new(runner, processor_id, config)
+    }
+    it 'calls ChildProcessMonitor#start_killing if it has ChildProcessMonitor' do
+      immediate = double('immediate')
+      cpm = double('ChildProcessMonitor')
+      expect(cpm).to receive(:start_killing).with(immediate).exactly(:once)
+      processor.instance_variable_set(:@cpm, cpm)
+      processor.stop(immediate)
+      expect(processor.instance_variable_get(:@stop)).to be true
+    end
+  end
+
+  describe '#keepalive' do
+    let (:processor) do
+      config = {logger: double('logger').as_null_object}
+      Multiprocess::ForkProcessor.new(double('runner'), double('processor_id'), config)
+    end
+    it 'tries join on stopping without cpm' do
+      processor.stop(true)
+      processor.keepalive
+    end
+    it 'tries join on stopping with cpm' do
+      processor.stop(true)
+      cpm = double('ChildProcessMonitor', try_join: false)
+      processor.instance_variable_set(:@cpm, cpm)
+      processor.keepalive
+    end
+    it 'calls fork_child if it doesn\'t have ChildProcessMonitor' do
+      expect(processor.keepalive).to be_nil
+      expect(processor.instance_variable_get(:@cpm)).to be_an_instance_of(Multiprocess::ChildProcessMonitor)
+    end
+    it 'rascues fork_child\'s error if it doesn\'t have ChildProcessMonitor' do
+      allow(processor).to receive(:fork_child).and_raise(RuntimeError)
+      expect(processor.keepalive).to be_nil
+    end
+    it 'tries join if it has killed ChildProcessMonitor' do
+      cpm = double('ChildProcessMonitor', killing_status: true, try_join: true, cleanup: nil)
+      processor.instance_variable_set(:@cpm, cpm)
+      expect(processor.keepalive).to be_nil
+      expect(processor.instance_variable_get(:@cpm)).to be_an_instance_of(Multiprocess::ChildProcessMonitor)
+    end
+    it 'recues EOFError of ChildProcessMonitor#check_heartbeat' do
+      cpm = double('ChildProcessMonitor', killing_status: false, try_join: true, cleanup: nil, pid: 42)
+      allow(cpm).to receive(:check_heartbeat).and_raise(EOFError)
+      immediate = double('immediate')
+      expect(cpm).to receive(:start_killing).with(true, processor.instance_variable_get(:@child_heartbeat_kill_delay)).exactly(:once)
+      processor.instance_variable_set(:@cpm, cpm)
+      expect(processor.keepalive).to be_nil
+      expect(processor.instance_variable_get(:@cpm)).to be_an_instance_of(Multiprocess::ChildProcessMonitor)
+    end
+    it 'recues an error of ChildProcessMonitor#check_heartbeat' do
+      cpm = double('ChildProcessMonitor', killing_status: false, try_join: true, cleanup: nil, pid: 42)
+      allow(cpm).to receive(:check_heartbeat).and_raise(RuntimeError)
+      immediate = double('immediate')
+      expect(cpm).to receive(:start_killing).with(true, processor.instance_variable_get(:@child_heartbeat_kill_delay)).exactly(:once)
+      processor.instance_variable_set(:@cpm, cpm)
+      expect(processor.keepalive).to be_nil
+      expect(processor.instance_variable_get(:@cpm)).to be_an_instance_of(Multiprocess::ChildProcessMonitor)
+    end
+    it 'calls ChildProcessMonitor#start_killing if it is dead' do
+      cpm = double('ChildProcessMonitor', killing_status: false, check_heartbeat: false, try_join: true, cleanup: nil, pid: 42)
+      immediate = double('immediate')
+      expect(cpm).to receive(:start_killing).with(true).exactly(:once)
+      processor.instance_variable_set(:@cpm, cpm)
+      expect(processor.keepalive).to be_nil
+      expect(processor.instance_variable_get(:@cpm)).to be_an_instance_of(Multiprocess::ChildProcessMonitor)
+    end
+  end
+
+  describe '#join' do
+    let (:processor) {
+      config = {logger: double('logger').as_null_object, child_kill_interval: 0.1}
+      Multiprocess::ForkProcessor.new(double('runner'), double('processor_id'), config)
+    }
+    it 'calls ChildProcessMonitor#start_killing if it has ChildProcessMonitor' do
+      immediate = double('immediate')
+      cpm = double('ChildProcessMonitor', cleanup: nil)
+      allow(cpm).to receive(:try_join).and_return(false, true)
+      processor.instance_variable_set(:@cpm, cpm)
+      processor.join
+    end
+  end
+
+  describe '#logrotated' do
+    let (:processor) {
+      config = {logger: double('logger').as_null_object}
+      Multiprocess::ForkProcessor.new(double('runner'), double('processor_id'), config)
+    }
+    it 'calls ChildProcessMonitor#start_killing if it has ChildProcessMonitor' do
+      immediate = double('immediate')
+      cpm = double('ChildProcessMonitor')
+      allow(cpm).to receive(:send_signal).with(:CONT).exactly(:once)
+      processor.instance_variable_set(:@cpm, cpm)
+      processor.logrotated
+    end
+  end
+
+  describe '#fork_child' do
+    it 'calls ChildProcessMonitor#start_killing if it has ChildProcessMonitor' do
+      config = {logger: double('logger').as_null_object}
+      processor = Multiprocess::ForkProcessor.new(double('runner'), double('processor_id'), config)
+      processor.instance_variable_set(:@last_fork_time, Float::MAX)
+      expect(processor.__send__(:fork_child)).to be_nil
+    end
+    it 'runs child process' do
+      runner = double('runner')
+      processor_id = double('processor_id')
+      expect(runner).to receive(:after_fork).exactly(:once)
+      expect(runner).to receive(:after_child_end).exactly(:once)
+      config = {logger: double('logger').as_null_object}
+      processor = Multiprocess::ForkProcessor.new(runner, processor_id, config)
+      expect(processor).to receive(:fork).and_yield
+      e = Exception.new
+      allow(processor).to receive(:exit!).and_raise(e)
+      expect{processor.__send__(:fork_child)}.to raise_error(e)
+    end
+  end
+end

data/spec/multiprocess/thread_processor_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe PerfectQueue::Multiprocess::ThreadProcessor do
+  describe '.new' do
+    it 'returns a Multiprocess::ThreadProcessor' do
+      runner = double('runner')
+      processor_id = double('processor_id')
+      config = {}
+      processor = Multiprocess::ThreadProcessor.new(runner, processor_id, config)
+      expect(processor).to be_an_instance_of(Multiprocess::ThreadProcessor)
+      expect(processor.instance_variable_get(:@processor_id)).to eq(processor_id)
+    end
+  end
+
+  describe '#force_stop' do
+    let (:processor) do
+      config = {logger: double('logger').as_null_object}
+      Multiprocess::ThreadProcessor.new(double('runner'), double('processor_id'), config)
+    end
+    it 'force_stop' do
+      processor.force_stop
+      expect(processor.instance_variable_get(:@finish_flag).set?).to be true
+    end
+  end
+
+  describe '#run_loop' do
+    let (:processor) do
+      config = {logger: double('logger').as_null_object}
+      Multiprocess::ThreadProcessor.new(double('runner'), double('processor_id'), config)
+    end
+    it 'rescues error' do
+      pq = object_double('PerfectQueue').as_stubbed_const
+      allow(pq).to receive(:open).and_raise(RuntimeError)
+      processor.__send__(:run_loop)
+    end
+  end
+
+  describe '#process' do
+    let (:runner) do
+      r = double('runner')
+      allow(r).to receive(:new).and_raise(RuntimeError)
+      r
+    end
+    let (:processor) do
+      config = {logger: double('logger').as_null_object}
+      Multiprocess::ThreadProcessor.new(runner, double('processor_id'), config)
+    end
+    it 'rescues error' do
+      expect{processor.__send__(:process, double('task', key: 1))}.to raise_error(RuntimeError)
+    end
+  end
+end

data/spec/queue_spec.rb

@@ -4,7 +4,7 @@ describe Queue do
   include QueueTest
 
   it 'is a Queue' do
-    queue.class.should == PerfectQueue::Queue
+    expect(queue.class).to eq(PerfectQueue::Queue)
   end
 
   it 'succeess submit' do
@@ -15,15 +15,17 @@ describe Queue do
     now = Time.now.to_i
     queue.submit('task01', 'type1', {}, :now=>now)
 
-    lambda {
+    expect {
+      allow(STDERR).to receive(:puts)
       queue.submit('task01', 'type1', {}, :now=>now+1)
-    }.should raise_error AlreadyExistsError
+    }.to raise_error AlreadyExistsError
 
     queue['task01'].cancel_request!(:now=>now+2)
 
-    lambda {
+    expect {
+      allow(STDERR).to receive(:puts)
       queue.submit('task01', 'type1', {}, :now=>now+10)
-    }.should raise_error AlreadyExistsError
+    }.to raise_error AlreadyExistsError
   end
 
   it 'list' do
@@ -36,24 +38,24 @@ describe Queue do
     a.sort_by! {|t| t.key }
 
     task01 = a.shift
-    task01.finished?.should == false
+    expect(task01.finished?).to eq(false)
     task01.type == 'type1'
-    task01.key.should == 'task01'
-    task01.data["a"].should == 1
+    expect(task01.key).to eq('task01')
+    expect(task01.data["a"]).to eq(1)
 
     task02 = a.shift
-    task02.finished?.should == false
+    expect(task02.finished?).to eq(false)
     task02.type == 'type1'
-    task02.key.should == 'task02'
-    task02.data["a"].should == 2
+    expect(task02.key).to eq('task02')
+    expect(task02.data["a"]).to eq(2)
 
     task03 = a.shift
-    task03.finished?.should == false
+    expect(task03.finished?).to eq(false)
     task03.type == 'type1'
-    task03.key.should == 'task03'
-    task03.data["a"].should == 3
+    expect(task03.key).to eq('task03')
+    expect(task03.data["a"]).to eq(3)
 
-    a.empty?.should == true
+    expect(a.empty?).to eq(true)
   end
 
   it 'poll' do
@@ -63,16 +65,16 @@ describe Queue do
     queue.submit('task03', 'type1', {"a"=>3}, :now=>now+2)
 
     task01 = queue.poll(:now=>now+10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
     task02 = queue.poll(:now=>now+10)
-    task02.key.should == 'task02'
+    expect(task02.key).to eq('task02')
 
     task03 = queue.poll(:now=>now+10)
-    task03.key.should == 'task03'
+    expect(task03.key).to eq('task03')
 
     t4 = queue.poll(:now=>now+10)
-    t4.should == nil
+    expect(t4).to eq(nil)
   end
 
   it 'release' do
@@ -80,15 +82,15 @@ describe Queue do
     queue.submit('task01', 'type1', {"a"=>1}, :now=>now+0)
 
     task01 = queue.poll(:now=>now+10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
     task02 = queue.poll(:now=>now+10)
-    task02.should == nil
+    expect(task02).to eq(nil)
 
     task01.release!(:now=>now+10)
 
     task03 = queue.poll(:now=>now+11)
-    task03.key.should == 'task01'
+    expect(task03.key).to eq('task01')
   end
 
   it 'timeout' do
@@ -96,13 +98,13 @@ describe Queue do
     queue.submit('task01', 'type1', {"a"=>1}, :now=>now+0)
 
     task01 = queue.poll(:now=>now+10, :alive_time=>10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
     task02 = queue.poll(:now=>now+15)
-    task02.should == nil
+    expect(task02).to eq(nil)
 
     task03 = queue.poll(:now=>now+20)
-    task03.key.should == 'task01'
+    expect(task03.key).to eq('task01')
   end
 
   it 'heartbeat' do
@@ -110,15 +112,15 @@ describe Queue do
     queue.submit('task01', 'type1', {"a"=>1}, :now=>now+0)
 
     task01 = queue.poll(:now=>now+10, :alive_time=>10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
     task01.heartbeat!(:alive_time=>15, :now=>now+10)
 
     task02 = queue.poll(:now=>now+20)
-    task02.should == nil
+    expect(task02).to eq(nil)
 
     task03 = queue.poll(:now=>now+30)
-    task03.key.should == 'task01'
+    expect(task03.key).to eq('task01')
   end
 
   it 'retry' do
@@ -126,15 +128,15 @@ describe Queue do
     queue.submit('task01', 'type1', {"a"=>1}, :now=>now+0)
 
     task01 = queue.poll(:now=>now+10, :alive_time=>10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
     task01.retry!(:retry_wait=>15, :now=>now+10)
 
     task02 = queue.poll(:now=>now+20)
-    task02.should == nil
+    expect(task02).to eq(nil)
 
     task03 = queue.poll(:now=>now+30)
-    task03.key.should == 'task01'
+    expect(task03.key).to eq('task01')
   end
 
   it 'froce_finish' do
@@ -142,13 +144,13 @@ describe Queue do
     queue.submit('task01', 'type1', {"a"=>1}, :now=>now+0)
 
     task01 = queue.poll(:now=>now+10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
-    queue['task01'].metadata.running?.should == true
+    expect(queue['task01'].metadata.running?).to eq(true)
 
     queue['task01'].force_finish!(:now=>now+11)
 
-    queue['task01'].metadata.finished?.should == true
+    expect(queue['task01'].metadata.finished?).to eq(true)
   end
 
   it 'status' do
@@ -162,27 +164,27 @@ describe Queue do
     #queue['task01'].metadata.cancel_requested?.should == false
 
     task01 = queue.poll(:now=>now+10, :alive_time=>10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
-    queue['task01'].metadata.finished?.should == false
-    queue['task01'].metadata.running?.should == true
-    queue['task01'].metadata.waiting?.should == false
-    queue['task01'].metadata.cancel_requested?.should == false
+    expect(queue['task01'].metadata.finished?).to eq(false)
+    expect(queue['task01'].metadata.running?).to eq(true)
+    expect(queue['task01'].metadata.waiting?).to eq(false)
+    expect(queue['task01'].metadata.cancel_requested?).to eq(false)
 
     task01.cancel_request!
 
     # status of cancel_requested running tasks is cancel_requested
-    queue['task01'].metadata.finished?.should == false
-    queue['task01'].metadata.running?.should == false
-    queue['task01'].metadata.waiting?.should == false
-    queue['task01'].metadata.cancel_requested?.should == true
+    expect(queue['task01'].metadata.finished?).to eq(false)
+    expect(queue['task01'].metadata.running?).to eq(false)
+    expect(queue['task01'].metadata.waiting?).to eq(false)
+    expect(queue['task01'].metadata.cancel_requested?).to eq(true)
 
     task01.finish!
 
-    queue['task01'].metadata.finished?.should == true
-    queue['task01'].metadata.running?.should == false
-    queue['task01'].metadata.waiting?.should == false
-    queue['task01'].metadata.cancel_requested?.should == false
+    expect(queue['task01'].metadata.finished?).to eq(true)
+    expect(queue['task01'].metadata.running?).to eq(false)
+    expect(queue['task01'].metadata.waiting?).to eq(false)
+    expect(queue['task01'].metadata.cancel_requested?).to eq(false)
   end
 
   it 'fail canceling finished task' do
@@ -190,39 +192,42 @@ describe Queue do
     queue.submit('task01', 'type1', {"a"=>1}, :now=>now+0)
 
     task01 = queue.poll(:now=>now+10, :alive_time=>10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
     task01.finish!
 
-    lambda {
+    expect {
+      allow(STDERR).to receive(:puts)
       queue['task01'].cancel_request!
-    }.should raise_error AlreadyFinishedError
+    }.to raise_error AlreadyFinishedError
   end
 
   it 'retention_time' do
     now = Time.now.to_i
     queue.submit('task01', 'type1', {"a"=>1}, :now=>now+0)
 
-    queue['task01'].metadata.finished?.should == false
+    expect(queue['task01'].metadata.finished?).to eq(false)
 
     task01 = queue.poll(:now=>now+10, :alive_time=>10)
-    task01.key.should == 'task01'
+    expect(task01.key).to eq('task01')
 
     task01.finish!(:now=>now+11, :retention_time=>10)
 
     queue.poll(:now=>now+12)
 
-    queue['task01'].exists?.should == true
+    expect(queue['task01'].exists?).to eq(true)
 
     queue.poll(:now=>now+22)
 
-    queue['task01'].exists?.should == false
+    allow(STDERR).to receive(:puts)
+    expect(queue['task01'].exists?).to eq(false)
   end
 
   it 'get_task_metadata failed with NotFoundError' do
-    lambda {
+    expect {
+      allow(STDERR).to receive(:puts)
       queue['task99'].metadata
-    }.should raise_error NotFoundError
+    }.to raise_error NotFoundError
   end
 
   it 'prefetch' do
@@ -232,16 +237,16 @@ describe Queue do
     queue.submit('task03', 'type3', {"a"=>3}, :now=>now+2)
 
     tasks = queue.poll_multi(:now=>now+10, :alive_time=>10, :max_acquire=>2)
-    tasks.size.should == 2
-    tasks[0].key.should == 'task01'
-    tasks[1].key.should == 'task02'
+    expect(tasks.size).to eq(2)
+    expect(tasks[0].key).to eq('task01')
+    expect(tasks[1].key).to eq('task02')
 
     tasks = queue.poll_multi(:now=>now+10, :alive_time=>10, :max_acquire=>2)
-    tasks.size.should == 1
-    tasks[0].key.should == 'task03'
+    expect(tasks.size).to eq(1)
+    expect(tasks[0].key).to eq('task03')
 
     tasks = queue.poll_multi(:now=>now+10, :alive_time=>10, :max_acquire=>2)
-    tasks.should == nil
+    expect(tasks).to eq(nil)
   end
 
   it 'data' do
@@ -249,20 +254,20 @@ describe Queue do
     queue.submit('task01', 'type1', {"a"=>1}, :now=>now)
 
     task01 = queue.poll(:now=>now+10)
-    task01.key.should == 'task01'
-    task01.data.should == {"a"=>1}
+    expect(task01.key).to eq('task01')
+    expect(task01.data).to eq({"a"=>1})
 
     task01.update_data!({"b"=>2})
-    task01.data.should == {"a"=>1, "b"=>2}
+    expect(task01.data).to eq({"a"=>1, "b"=>2})
 
     task01.update_data!({"a"=>3,"c"=>4})
-    task01.data.should == {"a"=>3, "b"=>2, "c"=>4}
+    expect(task01.data).to eq({"a"=>3, "b"=>2, "c"=>4})
 
     task01.release!
 
     task01 = queue.poll(:now=>now+10)
-    task01.key.should == 'task01'
-    task01.data.should == {"a"=>3, "b"=>2, "c"=>4}
+    expect(task01.key).to eq('task01')
+    expect(task01.data).to eq({"a"=>3, "b"=>2, "c"=>4})
   end
 end