bumbleworks 0.0.74 → 0.0.76

data/spec/lib/bumbleworks/process_spec.rb

@@ -10,6 +10,7 @@ describe Bumbleworks::Process do
       concurrence do
         admin :task => 'eat_a_hat'
         hatter :task => 'weep'
+        wait '40m'
       end
     end
 
@@ -24,6 +25,10 @@ describe Bumbleworks::Process do
       concurrence do
         wait_for_event :rock_caliper_delivery
         wait_for_event :speedos
+        wait '15m'
+        every '20m' do
+          magician :task => 'fancy_rabbit_maneuvers'
+        end
       end
     end
     Bumbleworks.define_process 'i_wait_for_nobody' do
@@ -54,44 +59,44 @@ describe Bumbleworks::Process do
     end
 
     it 'returns all process wfids' do
-      described_class.ids.should == @sorted_processes.map(&:wfid)
+      expect(described_class.ids).to eq(@sorted_processes.map(&:wfid))
     end
 
     it 'allows pagination options' do
-      described_class.ids(:limit => 2).should == @sorted_processes[0, 2].map(&:wfid)
-      described_class.ids(:offset => 2).should == @sorted_processes[2, 5].map(&:wfid)
-      described_class.ids(:limit => 2, :offset => 1).should == @sorted_processes[1, 2].map(&:wfid)
+      expect(described_class.ids(:limit => 2)).to eq(@sorted_processes[0, 2].map(&:wfid))
+      expect(described_class.ids(:offset => 2)).to eq(@sorted_processes[2, 5].map(&:wfid))
+      expect(described_class.ids(:limit => 2, :offset => 1)).to eq(@sorted_processes[1, 2].map(&:wfid))
     end
 
     it 'allows reverse order' do
-      described_class.ids(:reverse => true).should == @sorted_processes.reverse.map(&:wfid)
+      expect(described_class.ids(:reverse => true)).to eq(@sorted_processes.reverse.map(&:wfid))
     end
 
     it 'allows combined reverse and pagination' do
-      described_class.ids(:reverse => true, :limit => 2).should == @sorted_processes.reverse[0, 2].map(&:wfid)
-      described_class.ids(:reverse => true, :offset => 2).should == @sorted_processes.reverse[2, 5].map(&:wfid)
-      described_class.ids(:reverse => true, :limit => 2, :offset => 1).should == @sorted_processes.reverse[1, 2].map(&:wfid)
+      expect(described_class.ids(:reverse => true, :limit => 2)).to eq(@sorted_processes.reverse[0, 2].map(&:wfid))
+      expect(described_class.ids(:reverse => true, :offset => 2)).to eq(@sorted_processes.reverse[2, 5].map(&:wfid))
+      expect(described_class.ids(:reverse => true, :limit => 2, :offset => 1)).to eq(@sorted_processes.reverse[1, 2].map(&:wfid))
     end
   end
 
   describe '.count' do
     it 'returns number of processes' do
       allow(described_class).to receive(:ids).and_return([:a, :b, :c, :d])
-      described_class.count.should == 4
+      expect(described_class.count).to eq(4)
     end
   end
 
   describe '.new' do
     it 'sets workflow id' do
       bp = described_class.new('apples')
-      bp.id.should == 'apples'
+      expect(bp.id).to eq('apples')
     end
   end
 
   describe '#wfid' do
     it 'is aliased to id' do
       bp = described_class.new('smorgatoof')
-      bp.wfid.should == 'smorgatoof'
+      expect(bp.wfid).to eq('smorgatoof')
     end
   end
 
@@ -106,13 +111,13 @@ describe Bumbleworks::Process do
       bp = Bumbleworks.launch!('error_process')
       Bumbleworks.dashboard.wait_for('error_intercepted')
       errors = bp.errors
-      errors.map(&:class).uniq.should == [
+      expect(errors.map(&:class).uniq).to eq([
         Bumbleworks::Process::ErrorRecord
-      ]
-      errors.map(&:message).should =~ [
+      ])
+      expect(errors.map(&:message)).to match_array([
         'first error',
         'second error'
-      ]
+      ])
     end
   end
 
@@ -122,8 +127,8 @@ describe Bumbleworks::Process do
       l1 = double(:workitem => 'w1')
       l2 = double(:workitem => 'w2')
       l3 = double(:workitem => 'w3')
-      bp.stub(:leaves => [l1, l2, l3])
-      bp.workitems.should == ['w1','w2','w3']
+      allow(bp).to receive_messages(:leaves => [l1, l2, l3])
+      expect(bp.workitems).to eq(['w1','w2','w3'])
     end
   end
 
@@ -131,7 +136,7 @@ describe Bumbleworks::Process do
     let(:entity_workitem) { Bumbleworks::Workitem.new(:fake_workitem) }
     let(:holder) {
       holder = described_class.new('nothing')
-      holder.stub(:entity_workitem => entity_workitem)
+      allow(holder).to receive_messages(:entity_workitem => entity_workitem)
       holder
     }
     let(:storage_workitem) { entity_workitem }
@@ -142,7 +147,7 @@ describe Bumbleworks::Process do
       bp = Bumbleworks.launch!('food_is_an_illusion')
       Bumbleworks.dashboard.wait_for(:admin)
       expect(bp.expressions.map(&:expid)).to eq [
-        '0', '0_1', '0_1_0', '0_1_1'
+        '0', '0_1', '0_1_0', '0_1_1', '0_1_2'
       ]
       expect(bp.expressions.map(&:class).uniq).to eq [
         Bumbleworks::Expression
@@ -181,7 +186,7 @@ describe Bumbleworks::Process do
       bp = Bumbleworks.launch!('food_is_an_illusion')
       Bumbleworks.dashboard.wait_for(:admin)
       expect(bp.leaves.map(&:expid)).to eq [
-        '0_1_0', '0_1_1'
+        '0_1_0', '0_1_1', '0_1_2'
       ]
       expect(bp.leaves.map(&:class).uniq).to eq [
         Bumbleworks::Expression
@@ -194,13 +199,13 @@ describe Bumbleworks::Process do
       bp = described_class.new('nothing')
       w1 = double(:entity_fields => :some_fields)
       w2 = double(:entity_fields => :some_fields)
-      bp.stub(:workitems => [w1, w2])
-      bp.entity_workitem.should == w1
+      allow(bp).to receive_messages(:workitems => [w1, w2])
+      expect(bp.entity_workitem).to eq(w1)
     end
 
     it 'returns nil if no process' do
       bp = described_class.new('nothing')
-      bp.entity_workitem.should be_nil
+      expect(bp.entity_workitem).to be_nil
     end
 
     it 'returns workitem with entity reference from process launch' do
@@ -208,7 +213,7 @@ describe Bumbleworks::Process do
       bp = Bumbleworks.launch!('going_to_the_dance', :entity => rainbow_loom)
       wait_until { bp.reload.trackers.count > 0 }
       ew = bp.entity_workitem
-      ew.entity.should == rainbow_loom
+      expect(ew.entity).to eq(rainbow_loom)
     end
 
     it 'raises exception if multiple workitems have conflicting entity info' do
@@ -235,7 +240,7 @@ describe Bumbleworks::Process do
   describe '#entity' do
     it 'bubbles EntityConflict from entity_workitem' do
       bp = described_class.new('whatever')
-      bp.stub(:entity_workitem).and_raise(Bumbleworks::Process::EntityConflict)
+      allow(bp).to receive(:entity_workitem).and_raise(Bumbleworks::Process::EntityConflict)
       expect {
         bp.entity
       }.to raise_error(Bumbleworks::Process::EntityConflict)
@@ -245,8 +250,21 @@ describe Bumbleworks::Process do
   describe '#tasks' do
     it 'returns task query filtered for this process' do
       bp = described_class.new('chumpy')
-      Bumbleworks::Task.stub(:for_process).with('chumpy').and_return(:my_task_query)
-      bp.tasks.should == :my_task_query
+      allow(Bumbleworks::Task).to receive(:for_process).with('chumpy').and_return(:my_task_query)
+      expect(bp.tasks).to eq(:my_task_query)
+    end
+  end
+
+  describe '#schedules' do
+    it 'returns array of all schedules for this process' do
+      bp1 = Bumbleworks.launch!('food_is_an_illusion')
+      bp2 = Bumbleworks.launch!('straightening_the_rocks')
+      wait_until { bp1.reload.schedules.count == 1 && bp2.reload.schedules.count == 2 }
+      expect(bp1.schedules.map { |s| s.process }).to eq([bp1])
+      expect(bp2.schedules.map { |s| s.process }).to eq([bp2, bp2])
+      expect(bp1.schedules.map { |s| s.original_plan }).to eq(['40m'])
+      expect(bp2.schedules.map { |s| s.original_plan }).to eq(['15m', '20m'])
+      expect(bp2.schedules.map { |s| s.repeating? }).to eq([false, true])
     end
   end
 
@@ -255,12 +273,12 @@ describe Bumbleworks::Process do
       bp1 = Bumbleworks.launch!('going_to_the_dance')
       bp2 = Bumbleworks.launch!('straightening_the_rocks')
       wait_until { bp1.reload.trackers.count == 3 && bp2.reload.trackers.count == 2 }
-      bp1.trackers.map { |t| t.process }.should == [bp1, bp1, bp1]
-      bp2.trackers.map { |t| t.process }.should == [bp2, bp2]
-      bp1.trackers.map { |t| t.action }.should == ['left_tag', 'left_tag', 'dispatch']
-      bp2.trackers.map { |t| t.action }.should == ['left_tag', 'left_tag']
-      bp1.trackers.map { |t| t.conditions['tag'] }.should == [['an_invitation'], ['a_friend'], nil]
-      bp2.trackers.map { |t| t.conditions['tag'] }.should == [['rock_caliper_delivery'], ['speedos']]
+      expect(bp1.trackers.map { |t| t.process }).to eq([bp1, bp1, bp1])
+      expect(bp2.trackers.map { |t| t.process }).to eq([bp2, bp2])
+      expect(bp1.trackers.map { |t| t.action }).to eq(['left_tag', 'left_tag', 'dispatch'])
+      expect(bp2.trackers.map { |t| t.action }).to eq(['left_tag', 'left_tag'])
+      expect(bp1.trackers.map { |t| t.conditions['tag'] }).to eq([['an_invitation'], ['a_friend'], nil])
+      expect(bp2.trackers.map { |t| t.conditions['tag'] }).to eq([['rock_caliper_delivery'], ['speedos']])
     end
   end
 
@@ -269,14 +287,14 @@ describe Bumbleworks::Process do
       bp1 = Bumbleworks.launch!('going_to_the_dance')
       bp2 = Bumbleworks.launch!('straightening_the_rocks')
       wait_until { bp1.reload.trackers.count == 3 && bp2.reload.trackers.count == 2 }
-      bp1.all_subscribed_tags.should == { :global => ['an_invitation'], bp1.wfid => ['a_friend'] }
-      bp2.all_subscribed_tags.should == { :global => ['rock_caliper_delivery', 'speedos'] }
+      expect(bp1.all_subscribed_tags).to eq({ :global => ['an_invitation'], bp1.wfid => ['a_friend'] })
+      expect(bp2.all_subscribed_tags).to eq({ :global => ['rock_caliper_delivery', 'speedos'] })
     end
 
     it 'sets global tags to empty array by default' do
       bp = Bumbleworks.launch!('i_wait_for_nobody')
       wait_until { bp.reload.tasks.count == 1 }
-      bp.all_subscribed_tags.should == { :global => [] }
+      expect(bp.all_subscribed_tags).to eq({ :global => [] })
     end
   end
 
@@ -285,41 +303,41 @@ describe Bumbleworks::Process do
       bp1 = Bumbleworks.launch!('going_to_the_dance')
       bp2 = Bumbleworks.launch!('straightening_the_rocks')
       wait_until { bp1.reload.trackers.count == 3 && bp2.reload.trackers.count == 2 }
-      bp1.subscribed_events.should == ['an_invitation']
-      bp2.subscribed_events.should == ['rock_caliper_delivery', 'speedos']
+      expect(bp1.subscribed_events).to eq(['an_invitation'])
+      expect(bp2.subscribed_events).to eq(['rock_caliper_delivery', 'speedos'])
     end
 
     it 'returns empty array if no global tags' do
       bp = Bumbleworks.launch!('i_wait_for_nobody')
       wait_until { bp.reload.tasks.count == 1 }
-      bp.subscribed_events.should == []
+      expect(bp.subscribed_events).to eq([])
     end
   end
 
   describe '#is_waiting_for?' do
     it 'returns true if event is in subscribed events' do
       bp = described_class.new('whatever')
-      bp.stub(:subscribed_events => ['ghosts', 'mouses'])
-      bp.is_waiting_for?('mouses').should be_true
+      allow(bp).to receive_messages(:subscribed_events => ['ghosts', 'mouses'])
+      expect(bp.is_waiting_for?('mouses')).to be_truthy
     end
 
     it 'converts symbolized queries' do
       bp = described_class.new('whatever')
-      bp.stub(:subscribed_events => ['ghosts', 'mouses'])
-      bp.is_waiting_for?(:ghosts).should be_true
+      allow(bp).to receive_messages(:subscribed_events => ['ghosts', 'mouses'])
+      expect(bp.is_waiting_for?(:ghosts)).to be_truthy
     end
 
     it 'returns false if event is not in subscribed events' do
       bp = described_class.new('whatever')
-      bp.stub(:subscribed_events => ['ghosts', 'mouses'])
-      bp.is_waiting_for?('organs').should be_false
+      allow(bp).to receive_messages(:subscribed_events => ['ghosts', 'mouses'])
+      expect(bp.is_waiting_for?('organs')).to be_falsy
     end
   end
 
   describe '#kill!' do
     it 'kills process' do
       bp = described_class.new('frogheads')
-      Bumbleworks.should_receive(:kill_process!).with('frogheads')
+      expect(Bumbleworks).to receive(:kill_process!).with('frogheads')
       bp.kill!
     end
   end
@@ -327,7 +345,7 @@ describe Bumbleworks::Process do
   describe '#cancel!' do
     it 'cancels process' do
       bp = described_class.new('frogheads')
-      Bumbleworks.should_receive(:cancel_process!).with('frogheads')
+      expect(Bumbleworks).to receive(:cancel_process!).with('frogheads')
       bp.cancel!
     end
   end
@@ -336,7 +354,7 @@ describe Bumbleworks::Process do
     it 'returns true if other object has same wfid' do
       bp1 = described_class.new('in_da_sky')
       bp2 = described_class.new('in_da_sky')
-      bp1.should == bp2
+      expect(bp1).to eq(bp2)
     end
   end
 
@@ -351,26 +369,40 @@ describe Bumbleworks::Process do
     end
   end
 
+  describe '#running?' do
+    it 'returns true if process_status returns something' do
+      subject = described_class.new('frogheads')
+      allow(subject).to receive(:process_status).and_return(:the_status)
+      expect(subject.running?).to be_truthy
+    end
+
+    it 'returns false if process_status is nil' do
+      subject = described_class.new('frogheads')
+      allow(subject).to receive(:process_status).and_return(nil)
+      expect(subject.running?).to be_falsy
+    end
+  end
+
   describe '#process_status' do
     it 'returns a process_status instance for the wfid' do
       bp = described_class.new('frogheads')
-      Bumbleworks.dashboard.stub(:process).with('frogheads').and_return(:the_status)
-      bp.process_status.should == :the_status
+      allow(Bumbleworks.dashboard).to receive(:process).with('frogheads').and_return(:the_status)
+      expect(bp.process_status).to eq(:the_status)
     end
   end
 
   describe '#method_missing' do
     it 'calls method on object returned by #process_status' do
       ps = double('process_status')
-      ps.stub(:nuffle).with(:yay).and_return(:its_a_me)
+      allow(ps).to receive(:nuffle).with(:yay).and_return(:its_a_me)
       bp = described_class.new('frogheads')
-      bp.stub(:process_status => ps)
-      bp.nuffle(:yay).should == :its_a_me
+      allow(bp).to receive_messages(:process_status => ps)
+      expect(bp.nuffle(:yay)).to eq(:its_a_me)
     end
 
     it 'falls back to method missing if no process status method' do
       bp = described_class.new('blah')
-      bp.stub(:process_status => double('process status'))
+      allow(bp).to receive_messages(:process_status => double('process status'))
       expect {
         bp.kerplunk!(:oh_no)
       }.to raise_error

data/spec/lib/bumbleworks/ruote/exp/broadcast_event_expression_spec.rb

@@ -17,7 +17,7 @@ describe Ruote::Exp::BroadcastEventExpression do
     waiter = Bumbleworks.launch!('waiter')
     sender = Bumbleworks.launch!('sender')
     Bumbleworks.dashboard.wait_for(waiter.wfid)
-    @tracer.should == ['amazing']
+    expect(@tracer).to eq(['amazing'])
   end
 
   it 'appends entity info to tag when :for_entity is true' do
@@ -33,6 +33,6 @@ describe Ruote::Exp::BroadcastEventExpression do
     waiter = Bumbleworks.launch!('waiter')
     sender = Bumbleworks.launch!('sender', :entity_type => 'PigWidget', :entity_id => 15)
     Bumbleworks.dashboard.wait_for(waiter.wfid)
-    @tracer.should == ['amazing']
+    expect(@tracer).to eq(['amazing'])
   end
 end

data/spec/lib/bumbleworks/ruote/exp/wait_for_event_expression_spec.rb

@@ -32,7 +32,7 @@ describe Ruote::Exp::WaitForEventExpression do
     waiter = Bumbleworks.launch!('waiter')
     sender = Bumbleworks.launch!('sender')
     Bumbleworks.dashboard.wait_for(waiter.wfid)
-    @tracer.should == ['get ready', 'oh my gosh almost there', 'hello', 'yay', 'yay2']
+    expect(@tracer).to eq(['get ready', 'oh my gosh almost there', 'hello', 'yay', 'yay2'])
   end
 
   it 'checks where clause' do
@@ -52,7 +52,7 @@ describe Ruote::Exp::WaitForEventExpression do
     sender2 = Bumbleworks.launch!('sender', 'special' => 3)
 
     Bumbleworks.dashboard.wait_for(waiter3.wfid)
-    @tracer.should == ['specials! 3']
+    expect(@tracer).to eq(['specials! 3'])
   end
 
   it 'checks entity match' do
@@ -72,7 +72,7 @@ describe Ruote::Exp::WaitForEventExpression do
     sender2 = Bumbleworks.launch!('sender', 'entity_type' => 'Rhubarb', 'entity_id' => 'spitpickle-4boof')
 
     Bumbleworks.dashboard.wait_for(waiter3.wfid)
-    @tracer.should == ['entities! Rhubarb,spitpickle-4boof']
+    expect(@tracer).to eq(['entities! Rhubarb,spitpickle-4boof'])
   end
 
   it 'appends entity info to expected tag when :for_entity is true' do
@@ -89,6 +89,6 @@ describe Ruote::Exp::WaitForEventExpression do
     sender = Bumbleworks.launch!('sender')
 
     Bumbleworks.dashboard.wait_for(waiter.wfid)
-    @tracer.should == ['i found your tag, sucka']
+    expect(@tracer).to eq(['i found your tag, sucka'])
   end
 end

data/spec/lib/bumbleworks/ruote_spec.rb

@@ -10,9 +10,9 @@ describe Bumbleworks::Ruote do
       end
       process = Bumbleworks.launch!('do_nothing')
       Bumbleworks.dashboard.wait_for(:lazy_guy)
-      Bumbleworks.dashboard.process(process.wfid).should_not be_nil
+      expect(Bumbleworks.dashboard.process(process.wfid)).not_to be_nil
       described_class.cancel_process!(process.wfid)
-      Bumbleworks.dashboard.process(process.wfid).should be_nil
+      expect(Bumbleworks.dashboard.process(process.wfid)).to be_nil
     end
 
     it 'times out if process is not cancelled in time' do
@@ -26,7 +26,7 @@ describe Bumbleworks::Ruote do
       end
       process = Bumbleworks.launch!('time_hog')
       Bumbleworks.dashboard.wait_for(:pigheaded)
-      Bumbleworks.dashboard.process(process.wfid).should_not be_nil
+      expect(Bumbleworks.dashboard.process(process.wfid)).not_to be_nil
       expect {
         described_class.cancel_process!(process.wfid, :timeout => 0.5)
       }.to raise_error(Bumbleworks::Ruote::CancelTimeout)
@@ -49,21 +49,21 @@ describe Bumbleworks::Ruote do
       end
       process = Bumbleworks.launch!('do_nothing')
       Bumbleworks.dashboard.wait_for(:lazy_guy)
-      Bumbleworks.dashboard.process(process.wfid).should_not be_nil
+      expect(Bumbleworks.dashboard.process(process.wfid)).not_to be_nil
       described_class.kill_process!(process.wfid)
-      Bumbleworks.dashboard.process(process.wfid).should be_nil
+      expect(Bumbleworks.dashboard.process(process.wfid)).to be_nil
     end
 
     it 'times out if process is not killed in time' do
-      Bumbleworks.dashboard.stub(:process).with('woot').and_return(:i_exist)
+      allow(Bumbleworks.dashboard).to receive(:process).with('woot').and_return(:i_exist)
       expect {
         described_class.kill_process!('woot', :timeout => 0.5)
       }.to raise_error(Bumbleworks::Ruote::KillTimeout)
     end
 
     it 'uses storage.remove_process if force option is true' do
-      Bumbleworks.dashboard.storage.should_receive(:remove_process).with('woot')
-      Bumbleworks.dashboard.stub(:process).with('woot').and_return(nil)
+      expect(Bumbleworks.dashboard.storage).to receive(:remove_process).with('woot')
+      allow(Bumbleworks.dashboard).to receive(:process).with('woot').and_return(nil)
       described_class.kill_process!('woot', :force => true)
     end
   end
@@ -82,9 +82,9 @@ describe Bumbleworks::Ruote do
         Bumbleworks.launch!("do_nothing_#{i}")
         Bumbleworks.dashboard.wait_for("lazy_guy_#{i}".to_sym)
       end
-      Bumbleworks.dashboard.processes.count.should == 5
+      expect(Bumbleworks.dashboard.processes.count).to eq(5)
       described_class.cancel_all_processes!
-      Bumbleworks.dashboard.processes.count.should == 0
+      expect(Bumbleworks.dashboard.processes.count).to eq(0)
     end
 
 
@@ -121,12 +121,12 @@ describe Bumbleworks::Ruote do
         Bumbleworks.dashboard.wait_for("lazy_guy_#{i}".to_sym)
       end
 
-      Bumbleworks.dashboard.process_wfids.count.should == 5
+      expect(Bumbleworks.dashboard.process_wfids.count).to eq(5)
 
       described_class.cancel_all_processes!(:timeout => 30)
 
       # 4. When this is all done, all processes should be cancelled.
-      Bumbleworks.dashboard.process_wfids.count.should == 0
+      expect(Bumbleworks.dashboard.process_wfids.count).to eq(0)
     end
 
     it 'times out if processes are not cancelled in time' do
@@ -140,7 +140,7 @@ describe Bumbleworks::Ruote do
       end
       Bumbleworks.launch!('time_hog')
       Bumbleworks.dashboard.wait_for(:pigheaded)
-      Bumbleworks.dashboard.process_wfids.count.should == 1
+      expect(Bumbleworks.dashboard.process_wfids.count).to eq(1)
       expect {
         described_class.cancel_all_processes!(:timeout => 0.5)
       }.to raise_error(Bumbleworks::Ruote::CancelTimeout)
@@ -166,35 +166,35 @@ describe Bumbleworks::Ruote do
         Bumbleworks.launch!("do_nothing_#{i}")
         Bumbleworks.dashboard.wait_for("lazy_guy_#{i}".to_sym)
       end
-      Bumbleworks.dashboard.processes.count.should == 5
+      expect(Bumbleworks.dashboard.processes.count).to eq(5)
       described_class.kill_all_processes!
-      Bumbleworks.dashboard.processes.count.should == 0
+      expect(Bumbleworks.dashboard.processes.count).to eq(0)
     end
 
     it 'times out if processes are not killed in time' do
-      Bumbleworks.dashboard.stub(:process_wfids).and_return(['immortal_wfid'])
+      allow(Bumbleworks.dashboard).to receive(:process_wfids).and_return(['immortal_wfid'])
       expect {
         described_class.kill_all_processes!(:timeout => 0.5)
       }.to raise_error(Bumbleworks::Ruote::KillTimeout)
     end
 
     it 'uses storage.clear if force option is true' do
-      Bumbleworks.dashboard.stub(:process_wfids).and_return(['wfid'], [])
-      Bumbleworks.dashboard.storage.should_receive(:clear)
+      allow(Bumbleworks.dashboard).to receive(:process_wfids).and_return(['wfid'], [])
+      expect(Bumbleworks.dashboard.storage).to receive(:clear)
       described_class.kill_all_processes!(:force => true)
     end
   end
 
   describe '.send_cancellation_message' do
     it 'sends cancel message to given wfids if method is cancel' do
-      Bumbleworks.dashboard.should_receive(:cancel).with('wfid1')
-      Bumbleworks.dashboard.should_receive(:cancel).with('wfid2')
+      expect(Bumbleworks.dashboard).to receive(:cancel).with('wfid1')
+      expect(Bumbleworks.dashboard).to receive(:cancel).with('wfid2')
       described_class.send_cancellation_message(:cancel, ['wfid1', 'wfid2'])
     end
 
     it 'sends kill message to given wfids if method is kill' do
-      Bumbleworks.dashboard.should_receive(:kill).with('wfid1')
-      Bumbleworks.dashboard.should_receive(:kill).with('wfid2')
+      expect(Bumbleworks.dashboard).to receive(:kill).with('wfid1')
+      expect(Bumbleworks.dashboard).to receive(:kill).with('wfid2')
       described_class.send_cancellation_message(:kill, ['wfid1', 'wfid2'])
     end
   end
@@ -206,58 +206,58 @@ describe Bumbleworks::Ruote do
     end
 
     it 'creates a new dashboard' do
-      described_class.dashboard.should be_an_instance_of(Ruote::Dashboard)
+      expect(described_class.dashboard).to be_an_instance_of(Ruote::Dashboard)
     end
 
     it 'does not start a worker by default' do
-      described_class.dashboard.worker.should be_nil
+      expect(described_class.dashboard.worker).to be_nil
     end
   end
 
   describe '.start_worker!' do
     it 'adds new worker to dashboard and returns worker' do
-      described_class.dashboard.worker.should be_nil
+      expect(described_class.dashboard.worker).to be_nil
       new_worker = described_class.start_worker!
-      new_worker.should be_an_instance_of(Ruote::Worker)
-      described_class.dashboard.worker.should == new_worker
+      expect(new_worker).to be_an_instance_of(Ruote::Worker)
+      expect(described_class.dashboard.worker).to eq(new_worker)
     end
 
     it 'runs in current thread if :join option is true' do
-      ::Ruote::Worker.stub(:new).and_return(worker_double = double('worker'))
-      worker_double.should_receive(:run)
+      allow(::Ruote::Worker).to receive(:new).and_return(worker_double = double('worker'))
+      expect(worker_double).to receive(:run)
       described_class.start_worker!(:join => true)
     end
 
     it 'runs in new thread and returns worker if :join option not true' do
-      ::Ruote::Worker.stub(:new).and_return(worker_double = double('worker'))
-      worker_double.should_receive(:run_in_thread)
-      described_class.start_worker!.should == worker_double
+      allow(::Ruote::Worker).to receive(:new).and_return(worker_double = double('worker'))
+      expect(worker_double).to receive(:run_in_thread)
+      expect(described_class.start_worker!).to eq(worker_double)
     end
 
     it 'sets dashboard to noisy if :verbose option true' do
-      described_class.dashboard.should_receive(:noisy=).with(true)
+      expect(described_class.dashboard).to receive(:noisy=).with(true)
       described_class.start_worker!(:verbose => true)
     end
 
     it 'registers error handler' do
-      described_class.should_receive(:register_error_dispatcher)
+      expect(described_class).to receive(:register_error_dispatcher)
       described_class.start_worker!
     end
 
     it 'calls set_up_storage_history' do
-      described_class.should_receive(:set_up_storage_history)
+      expect(described_class).to receive(:set_up_storage_history)
       described_class.start_worker!
     end
 
     it 'does not add another error_dispatcher if already registered' do
       described_class.register_participants
       described_class.start_worker!
-      described_class.dashboard.participant_list.map(&:classname).should == [
+      expect(described_class.dashboard.participant_list.map(&:classname)).to eq([
         'Bumbleworks::ErrorDispatcher',
         'Bumbleworks::EntityInteractor',
         'Bumbleworks::StorageParticipant'
-      ]
-      Bumbleworks.dashboard.on_error.flatten[2].should == 'error_dispatcher'
+      ])
+      expect(Bumbleworks.dashboard.on_error.flatten[2]).to eq('error_dispatcher')
     end
   end
 
@@ -265,8 +265,8 @@ describe Bumbleworks::Ruote do
     it 'adds a storage history service to the dashboard if storage adapter allows it' do
       storage_adapter = double('adapter', :allow_history_storage? => true)
       Bumbleworks.storage_adapter = storage_adapter
-      described_class.stub(:storage => Ruote::HashStorage.new({}))
-      Bumbleworks.dashboard.should_receive(:add_service).with(
+      allow(described_class).to receive_messages(:storage => Ruote::HashStorage.new({}))
+      expect(Bumbleworks.dashboard).to receive(:add_service).with(
         'history', 'ruote/log/storage_history', 'Ruote::StorageHistory'
       )
       described_class.set_up_storage_history
@@ -275,16 +275,16 @@ describe Bumbleworks::Ruote do
     it 'does not add a storage history service to the dashboard if not allowed' do
       storage_adapter = double('adapter', :allow_history_storage? => false)
       Bumbleworks.storage_adapter = storage_adapter
-      described_class.stub(:storage => Ruote::HashStorage.new({}))
-      Bumbleworks.dashboard.should_receive(:add_service).never
+      allow(described_class).to receive_messages(:storage => Ruote::HashStorage.new({}))
+      expect(Bumbleworks.dashboard).to receive(:add_service).never
       described_class.set_up_storage_history
     end
 
     it 'does not add a storage history service to the dashboard if turned off in config' do
       storage_adapter = double('adapter', :allow_history_storage? => true)
       Bumbleworks.storage_adapter = storage_adapter
-      described_class.stub(:storage => Ruote::HashStorage.new({}))
-      Bumbleworks.dashboard.should_receive(:add_service).never
+      allow(described_class).to receive_messages(:storage => Ruote::HashStorage.new({}))
+      expect(Bumbleworks.dashboard).to receive(:add_service).never
       Bumbleworks.store_history = false
       described_class.set_up_storage_history
     end
@@ -298,15 +298,15 @@ describe Bumbleworks::Ruote do
         catchall 'NewCatchall'
       }
 
-      described_class.dashboard.participant_list.should be_empty
+      expect(described_class.dashboard.participant_list).to be_empty
       described_class.register_participants &registration_block
-      described_class.dashboard.participant_list.should have(6).items
-      described_class.dashboard.participant_list.map(&:classname).should == [
+      expect(described_class.dashboard.participant_list.size).to eq(6)
+      expect(described_class.dashboard.participant_list.map(&:classname)).to eq([
         'Bumbleworks::ErrorDispatcher',
         'Bumbleworks::EntityInteractor',
         'BeesHoney', 'MapleSyrup', 'NewCatchall',
         'Bumbleworks::StorageParticipant'
-      ]
+      ])
     end
 
     it 'does not add storage participant catchall if already exists' do
@@ -315,32 +315,33 @@ describe Bumbleworks::Ruote do
         catchall
       }
 
-      described_class.dashboard.participant_list.should be_empty
+      expect(described_class.dashboard.participant_list).to be_empty
       described_class.register_participants &registration_block
-      described_class.dashboard.participant_list.should have(4).items
-      described_class.dashboard.participant_list.map(&:classname).should == [
+      expect(described_class.dashboard.participant_list.size).to eq(4)
+      expect(described_class.dashboard.participant_list.map(&:classname)).to eq([
         'Bumbleworks::ErrorDispatcher', 'Bumbleworks::EntityInteractor', 'BeesHoney', 'Ruote::StorageParticipant'
-      ]
+      ])
     end
 
     it 'adds catchall and error_handler participants if block is nil' do
-      described_class.dashboard.participant_list.should be_empty
+      expect(described_class.dashboard.participant_list).to be_empty
       described_class.register_participants &nil
-      described_class.dashboard.participant_list.should have(3).item
-      described_class.dashboard.participant_list.map(&:classname).should ==
+      expect(described_class.dashboard.participant_list.size).to eq(3)
+      expect(described_class.dashboard.participant_list.map(&:classname)).to eq(
         ['Bumbleworks::ErrorDispatcher', 'Bumbleworks::EntityInteractor', 'Bumbleworks::StorageParticipant']
+      )
     end
   end
 
   describe '.register_error_dispatcher', dev:true do
     it 'registers the error handler participant' do
       described_class.register_error_dispatcher
-      Bumbleworks.dashboard.participant_list.map(&:classname).should include('Bumbleworks::ErrorDispatcher')
+      expect(Bumbleworks.dashboard.participant_list.map(&:classname)).to include('Bumbleworks::ErrorDispatcher')
     end
 
     it 'it sets the global Ruote on_error to the error_dispatcher' do
       described_class.register_error_dispatcher
-      Bumbleworks.dashboard.on_error.flatten[2].should == 'error_dispatcher'
+      expect(Bumbleworks.dashboard.on_error.flatten[2]).to eq('error_dispatcher')
     end
 
     it 'does not override existing error_dispatcher' do
@@ -348,8 +349,9 @@ describe Bumbleworks::Ruote do
         error_dispatcher 'Whatever'
       end
       described_class.register_error_dispatcher
-      Bumbleworks.dashboard.participant_list.map(&:classname).should ==
+      expect(Bumbleworks.dashboard.participant_list.map(&:classname)).to eq(
         ['Bumbleworks::EntityInteractor', 'Whatever', 'Bumbleworks::StorageParticipant']
+      )
 
     end
   end
@@ -365,11 +367,11 @@ describe Bumbleworks::Ruote do
       storage = {}
       adapter = double('Adapter')
       options = { :thing => 'yay' }
-      adapter.stub(:new_storage).with(storage, options).and_return(driven_storage)
+      allow(adapter).to receive(:new_storage).with(storage, options).and_return(driven_storage)
       Bumbleworks.storage = storage
       Bumbleworks.storage_adapter = adapter
       Bumbleworks.storage_options = options
-      described_class.storage.should == driven_storage
+      expect(described_class.storage).to eq(driven_storage)
     end
   end
 
@@ -379,15 +381,15 @@ describe Bumbleworks::Ruote do
     end
 
     it 'tells dashboard to launch process' do
-      described_class.dashboard.should_receive(:launch).with(@pdef.tree, 'variable' => 'neat')
+      expect(described_class.dashboard).to receive(:launch).with(@pdef.tree, 'variable' => 'neat')
       described_class.launch('foo', 'variable' => 'neat')
     end
 
     it 'sets catchall if needed' do
-      described_class.dashboard.participant_list.should be_empty
+      expect(described_class.dashboard.participant_list).to be_empty
       described_class.launch('foo')
-      described_class.dashboard.participant_list.should have(1).item
-      described_class.dashboard.participant_list.first.classname.should == 'Bumbleworks::StorageParticipant'
+      expect(described_class.dashboard.participant_list.size).to eq(1)
+      expect(described_class.dashboard.participant_list.first.classname).to eq('Bumbleworks::StorageParticipant')
     end
   end
 
@@ -395,11 +397,11 @@ describe Bumbleworks::Ruote do
     it 'purges and shuts down storage, then resets storage' do
       old_storage = double('Storage')
       allow(described_class).to receive(:initialize_storage_adapter).and_return(old_storage)
-      old_storage.should_receive(:purge!)
-      old_storage.should_receive(:shutdown)
+      expect(old_storage).to receive(:purge!)
+      expect(old_storage).to receive(:shutdown)
       described_class.reset!
       allow(described_class).to receive(:initialize_storage_adapter).and_return(:new_storage)
-      described_class.storage.should == :new_storage
+      expect(described_class.storage).to eq(:new_storage)
       # clean up
       described_class.instance_variable_set(:@storage, nil)
     end
@@ -413,9 +415,9 @@ describe Bumbleworks::Ruote do
 
     it 'shuts down dashboard and detaches' do
       old_dashboard = described_class.dashboard
-      old_dashboard.should_receive(:shutdown)
+      expect(old_dashboard).to receive(:shutdown)
       described_class.reset!
-      described_class.dashboard.should_not == old_dashboard
+      expect(described_class.dashboard).not_to eq(old_dashboard)
     end
 
     it 'skips shutting down dashboard if no dashboard' do
@@ -428,9 +430,9 @@ describe Bumbleworks::Ruote do
     it 'skips shutting down dashboard if dashboard can not be shutdown' do
       dashboard = double('dashboard', :respond_to? => false)
       described_class.instance_variable_set(:@dashboard, dashboard)
-      dashboard.should_receive(:shutdown).never
+      expect(dashboard).to receive(:shutdown).never
       described_class.reset!
-      described_class.dashboard.should_not == dashboard
+      expect(described_class.dashboard).not_to eq(dashboard)
     end
   end
 end