bumbleworks 0.0.74 → 0.0.76

data/spec/lib/bumbleworks/tracker_spec.rb

@@ -1,22 +1,21 @@
-require File.expand_path(File.join(fixtures_path, 'entities', 'rainbow_loom'))
 require File.expand_path(File.join(fixtures_path, 'trackers'))
 
 describe Bumbleworks::Tracker do
   before(:each) do
-    Bumbleworks.dashboard.stub(:get_trackers => fake_trackers)
+    allow(Bumbleworks.dashboard).to receive_messages(:get_trackers => fake_trackers)
   end
 
   describe '.all' do
     it 'returns instances for each tracker in system' do
       trackers = described_class.all
-      trackers.all? { |t| t.class == Bumbleworks::Tracker }.should be_true
-      trackers.map(&:id).should =~ [
+      expect(trackers.all? { |t| t.class == Bumbleworks::Tracker }).to be_truthy
+      expect(trackers.map(&:id)).to match_array([
         'on_error',
         'global_tracker',
         'local_tracker',
         'local_error_intercept',
         'participant_tracker'
-      ]
+      ])
     end
   end
 
@@ -29,127 +28,127 @@ describe Bumbleworks::Tracker do
   describe '.new' do
     it 'sets tracker id and fetches original_hash from dashboard' do
       tr = described_class.new('global_tracker')
-      tr.id.should == 'global_tracker'
-      tr.original_hash.should == fake_trackers['global_tracker']
+      expect(tr.id).to eq('global_tracker')
+      expect(tr.original_hash).to eq(fake_trackers['global_tracker'])
     end
 
     it 'sets tracker id and original_hash if directly provided' do
       tr = described_class.new('global_tracker', 'snarfles')
-      tr.id.should == 'global_tracker'
-      tr.original_hash.should == 'snarfles'
+      expect(tr.id).to eq('global_tracker')
+      expect(tr.original_hash).to eq('snarfles')
     end
   end
 
   describe '#wfid' do
     it 'returns wfid from original hash' do
-      described_class.new('local_tracker').wfid.should == 'my_wfid'
+      expect(described_class.new('local_tracker').wfid).to eq('my_wfid')
     end
 
     it 'returns wfid from flow expression for global trackers' do
-      described_class.new('global_tracker').wfid.should == 'my_wfid'
+      expect(described_class.new('global_tracker').wfid).to eq('my_wfid')
     end
 
     it 'returns nil if no wfid' do
-      described_class.new('on_error').wfid.should be_nil
+      expect(described_class.new('on_error').wfid).to be_nil
     end
   end
 
   describe '#process' do
     it 'returns process for wfid stored in msg' do
       tr = described_class.new('global_tracker')
-      tr.process.should == Bumbleworks::Process.new('my_wfid')
+      expect(tr.process).to eq(Bumbleworks::Process.new('my_wfid'))
     end
 
     it 'returns nil if no wfid' do
       tr = described_class.new('on_error')
-      tr.process.should be_nil
+      expect(tr.process).to be_nil
     end
   end
 
   describe '#global?' do
     it 'returns true if not listening to events on a specific wfid' do
-      described_class.new('on_error').global?.should be_true
-      described_class.new('global_tracker').global?.should be_true
+      expect(described_class.new('on_error').global?).to be_truthy
+      expect(described_class.new('global_tracker').global?).to be_truthy
     end
 
     it 'returns false if listening to events on a specific wfid' do
-      described_class.new('local_tracker').global?.should be_false
+      expect(described_class.new('local_tracker').global?).to be_falsy
     end
   end
 
   describe '#conditions' do
     it 'returns conditions that this tracker is watching' do
-      described_class.new('global_tracker').conditions.should == { "tag" => [ "the_event" ] }
-      described_class.new('local_tracker').conditions.should == { "tag" => [ "local_event" ] }
-      described_class.new('local_error_intercept').conditions.should == { "message" => [ "/bad/" ] }
-      described_class.new('participant_tracker').conditions.should == { "participant_name" => [ "goose","bunnies" ] }
+      expect(described_class.new('global_tracker').conditions).to eq({ "tag" => [ "the_event" ] })
+      expect(described_class.new('local_tracker').conditions).to eq({ "tag" => [ "local_event" ] })
+      expect(described_class.new('local_error_intercept').conditions).to eq({ "message" => [ "/bad/" ] })
+      expect(described_class.new('participant_tracker').conditions).to eq({ "participant_name" => [ "goose","bunnies" ] })
     end
 
     it 'returns empty hash when no conditions' do
-      described_class.new('on_error').conditions.should == {}
+      expect(described_class.new('on_error').conditions).to eq({})
     end
   end
 
   describe '#tags' do
     it 'returns array of tags' do
-      described_class.new('global_tracker').tags.should == [ "the_event" ]
-      described_class.new('local_tracker').tags.should == [ "local_event" ]
+      expect(described_class.new('global_tracker').tags).to eq([ "the_event" ])
+      expect(described_class.new('local_tracker').tags).to eq([ "local_event" ])
     end
 
     it 'returns empty array if no tags' do
-      described_class.new('local_error_intercept').tags.should == []
-      described_class.new('participant_tracker').tags.should == []
+      expect(described_class.new('local_error_intercept').tags).to eq([])
+      expect(described_class.new('participant_tracker').tags).to eq([])
     end
   end
 
   describe '#action' do
     it 'returns action being awaited' do
-      described_class.new('global_tracker').action.should == 'left_tag'
-      described_class.new('local_error_intercept').action.should == 'error_intercepted'
-      described_class.new('participant_tracker').action.should == 'dispatch'
+      expect(described_class.new('global_tracker').action).to eq('left_tag')
+      expect(described_class.new('local_error_intercept').action).to eq('error_intercepted')
+      expect(described_class.new('participant_tracker').action).to eq('dispatch')
     end
   end
 
-  describe '#waiting_expression' do      
+  describe '#waiting_expression' do
     it 'returns nil when no expression is waiting' do
-      described_class.new('on_error').waiting_expression.should be_nil
+      expect(described_class.new('on_error').waiting_expression).to be_nil
     end
 
-    it 'returns expression awaiting reply' do        
+    it 'returns expression awaiting reply' do
       process = Bumbleworks::Process.new('my_wfid')
       expression1 = double(:expid => '0_0_0', :tree => :a_global_expression)
       expression2 = double(:expid => '0_0_1', :tree => :a_local_expression)
-      process.stub(:expressions => [expression1, expression2])
+      allow(process).to receive_messages(:expressions => [expression1, expression2])
 
       tracker1 = described_class.new('global_tracker')
-      tracker1.stub(:process => process)
-      tracker1.waiting_expression.should == :a_global_expression
+      allow(tracker1).to receive_messages(:process => process)
+      expect(tracker1.waiting_expression).to eq(:a_global_expression)
 
       tracker2 = described_class.new('local_tracker')
-      tracker2.stub(:process => process)
-      tracker2.waiting_expression.should == :a_local_expression
+      allow(tracker2).to receive_messages(:process => process)
+      expect(tracker2.waiting_expression).to eq(:a_local_expression)
     end
   end
 
   describe '#where_clause' do
     it 'returns where clause from waiting expression' do
       tracker = described_class.new('global_tracker')
-      tracker.stub(:waiting_expression => [
+      allow(tracker).to receive_messages(:waiting_expression => [
         'wait_for_event', { "where" => "some_stuff_matches" }, []
       ])
-      tracker.where_clause.should == 'some_stuff_matches'
+      expect(tracker.where_clause).to eq('some_stuff_matches')
     end
 
     it 'returns nil when waiting_expression does not include where clause' do
       tracker = described_class.new('global_tracker')
-      tracker.stub(:waiting_expression => [
+      allow(tracker).to receive_messages(:waiting_expression => [
         'wait_for_event', {}, []
       ])
-      tracker.where_clause.should be_nil
+      expect(tracker.where_clause).to be_nil
     end
 
     it 'returns nil when no waiting_expression' do
-      described_class.new('on_error').where_clause.should be_nil
+      expect(described_class.new('on_error').where_clause).to be_nil
     end
   end
 end

data/spec/lib/bumbleworks/tree_builder_spec.rb

@@ -24,19 +24,20 @@ describe Bumbleworks::TreeBuilder do
         end
       )
       builder = described_class.new(:name => 'luigi', :definition => pdef)
-      builder.build!.should == [
+      expect(builder.build!).to eq([
         "define", {"name" => "luigi"},
         [
           ["order_pants_around", {}, []]
         ]
-      ]
+      ])
     end
 
     it 'uses tree if given' do
       tree = ["define", {"guppies" => nil}, [["swim", {}, []]]]
       builder = described_class.new(:tree => tree)
-      builder.build!.should == 
+      expect(builder.build!).to eq( 
         ["define", {"name" => "guppies"}, [["swim", {}, []]]]
+      )
     end
 
     it 'normalizes and sets name from tree' do
@@ -46,12 +47,12 @@ describe Bumbleworks::TreeBuilder do
         end
       )
       builder = described_class.new(:definition => pdef)
-      builder.build!.should == [
+      expect(builder.build!).to eq([
         "define", {"name" => "country_time_county_dime"},
         [
           ["do_the_fig_newton", {}, []]
         ]
-      ]
+      ])
     end
 
     it 'raises error if name conflicts with name in definition' do
@@ -82,14 +83,15 @@ describe Bumbleworks::TreeBuilder do
         construct :solution => 'to world conflict'
       end
       builder.build!
-      builder.tree.should ==
+      expect(builder.tree).to eq(
         ["define", { "name" => "just_another_poodle_day" },
           [
             ["chew", {"on" => "dad"}, []],
             ["construct", {"solution" => "to world conflict"}, []]
           ]
         ]
-      builder.name.should == 'just_another_poodle_day'
+      )
+      expect(builder.name).to eq('just_another_poodle_day')
     end
   end
 end

data/spec/lib/bumbleworks/user_spec.rb

@@ -4,23 +4,23 @@ describe Bumbleworks::User do
 
   describe '#claim_token' do
     it 'returns username by default' do
-      subject.stub(:username => 'nerfobot')
-      subject.claim_token.should == 'nerfobot'
+      allow(subject).to receive_messages(:username => 'nerfobot')
+      expect(subject.claim_token).to eq('nerfobot')
     end
 
     it 'returns email if no username' do
-      subject.stub(:email => 'fromp@nougatcountry.com')
-      subject.claim_token.should == 'fromp@nougatcountry.com'
+      allow(subject).to receive_messages(:email => 'fromp@nougatcountry.com')
+      expect(subject.claim_token).to eq('fromp@nougatcountry.com')
     end
 
     it 'prefers username to email when both respond' do
-      subject.stub(:username => 'dumb', :email => 'moar dumb')
-      subject.claim_token.should == 'dumb'
+      allow(subject).to receive_messages(:username => 'dumb', :email => 'moar dumb')
+      expect(subject.claim_token).to eq('dumb')
     end
 
     it 'returns nil if method defined' do
-      subject.stub(:username)
-      subject.claim_token.should be_nil
+      allow(subject).to receive(:username)
+      expect(subject.claim_token).to be_nil
     end
 
     it 'raises exception if neither username nor email defined' do
@@ -32,19 +32,19 @@ describe Bumbleworks::User do
 
   describe '#claim' do
     before(:each) do
-      subject.stub(:role_identifiers => ['snoogat'])
-      subject.stub(:claim_token => "the umpire of snorts")
+      allow(subject).to receive_messages(:role_identifiers => ['snoogat'])
+      allow(subject).to receive_messages(:claim_token => "the umpire of snorts")
     end
 
     it 'claims a task if authorized' do
       task = double('task', :role => 'snoogat')
-      task.should_receive(:claim).with("the umpire of snorts")
+      expect(task).to receive(:claim).with("the umpire of snorts")
       subject.claim(task)
     end
 
     it 'raises exception if unauthorized' do
       task = double('task', :role => 'fashbone')
-      task.should_receive(:claim).never
+      expect(task).to receive(:claim).never
       expect {
         subject.claim(task)
       }.to raise_error(Bumbleworks::User::UnauthorizedClaimAttempt)
@@ -52,7 +52,7 @@ describe Bumbleworks::User do
 
     it 'raises exception if already claimed by another' do
       task = double('task', :role => 'snoogat')
-      task.should_receive(:claim).and_raise(Bumbleworks::Task::AlreadyClaimed)
+      expect(task).to receive(:claim).and_raise(Bumbleworks::Task::AlreadyClaimed)
       expect {
         subject.claim(task)
       }.to raise_error(Bumbleworks::Task::AlreadyClaimed)
@@ -61,15 +61,15 @@ describe Bumbleworks::User do
     describe '!' do
       it 'resets even if claimed by another' do
         task = double('task', :role => 'snoogat', :claimed? => true, :claimant => 'fumbo the monfey')
-        task.should_receive(:release).ordered
-        task.should_receive(:claim).with("the umpire of snorts").ordered
+        expect(task).to receive(:release).ordered
+        expect(task).to receive(:claim).with("the umpire of snorts").ordered
         subject.claim!(task)
       end
 
       it 'raises exception (and does not release) if unauthorized' do
         task = double('task', :role => 'fashbone')
-        task.should_receive(:release).never
-        task.should_receive(:claim).never
+        expect(task).to receive(:release).never
+        expect(task).to receive(:claim).never
         expect {
           subject.claim!(task)
         }.to raise_error(Bumbleworks::User::UnauthorizedClaimAttempt)
@@ -79,24 +79,24 @@ describe Bumbleworks::User do
 
   describe '#release' do
     before(:each) do
-      subject.stub(:claim_token => "the umpire of snorts")
+      allow(subject).to receive_messages(:claim_token => "the umpire of snorts")
     end
 
     it 'releases a claimed task if claimant' do
       task = double('task', :claimed? => true, :claimant => "the umpire of snorts")
-      task.should_receive(:release)
+      expect(task).to receive(:release)
       subject.release(task)
     end
 
     it 'does nothing if task not claimed' do
       task = double('task', :claimed? => false)
-      task.should_receive(:release).never
+      expect(task).to receive(:release).never
       subject.release(task)
     end
 
     it 'raises exception if not claimant' do
       task = double('task', :claimed? => true, :claimant => 'a castanet expert')
-      task.should_receive(:release).never
+      expect(task).to receive(:release).never
       expect {
         subject.release(task)
       }.to raise_error(Bumbleworks::User::UnauthorizedReleaseAttempt)
@@ -105,7 +105,7 @@ describe Bumbleworks::User do
     describe '!' do
       it 'releases even if not claimant' do
         task = double('task', :claimed? => true, :claimant => 'a castanet expert')
-        task.should_receive(:release)
+        expect(task).to receive(:release)
         subject.release!(task)
       end
     end
@@ -121,41 +121,41 @@ describe Bumbleworks::User do
 
   describe '#has_role?' do
     before(:each) do
-      subject.stub(:role_identifiers => ['role1', 'role2'])
+      allow(subject).to receive_messages(:role_identifiers => ['role1', 'role2'])
     end
 
     it 'returns true if role_identifiers includes given role' do
-      subject.has_role?('role1').should be_true
+      expect(subject.has_role?('role1')).to be_truthy
     end
 
     it 'returns false if role_identifiers does not include given role' do
-      subject.has_role?('role3').should be_false
+      expect(subject.has_role?('role3')).to be_falsy
     end
   end
 
   describe '#authorized_tasks' do
     it 'returns task query for all tasks for user roles' do
-      subject.stub(:role_identifiers => ['goose', 'midget'])
-      Bumbleworks::Task.stub(:for_roles).with(['goose', 'midget']).and_return(:all_the_tasks)
-      subject.authorized_tasks.should == :all_the_tasks
+      allow(subject).to receive_messages(:role_identifiers => ['goose', 'midget'])
+      allow(Bumbleworks::Task).to receive(:for_roles).with(['goose', 'midget']).and_return(:all_the_tasks)
+      expect(subject.authorized_tasks).to eq(:all_the_tasks)
     end
   end
 
   describe '#claimed_tasks' do
     it 'returns task query for all user claimed tasks' do
-      subject.stub(:claim_token => :yay_its_me)
-      Bumbleworks::Task.stub(:for_claimant).with(:yay_its_me).and_return(:my_tasks)
-      subject.claimed_tasks.should == :my_tasks
+      allow(subject).to receive_messages(:claim_token => :yay_its_me)
+      allow(Bumbleworks::Task).to receive(:for_claimant).with(:yay_its_me).and_return(:my_tasks)
+      expect(subject.claimed_tasks).to eq(:my_tasks)
     end
   end
 
   describe '#available_tasks' do
     it 'returns authorized tasks filtered by available' do
-      subject.stub(:role_identifiers => ['goose', 'midget'])
+      allow(subject).to receive_messages(:role_identifiers => ['goose', 'midget'])
       task_finder = double('task_finder')
-      task_finder.stub(:available => :only_the_available_tasks)
-      Bumbleworks::Task.stub(:for_roles).with(['goose', 'midget']).and_return(task_finder)
-      subject.available_tasks.should == :only_the_available_tasks
+      allow(task_finder).to receive_messages(:available => :only_the_available_tasks)
+      allow(Bumbleworks::Task).to receive(:for_roles).with(['goose', 'midget']).and_return(task_finder)
+      expect(subject.available_tasks).to eq(:only_the_available_tasks)
     end
   end
 end

data/spec/lib/bumbleworks/workitem_entity_storage_spec.rb

@@ -13,15 +13,15 @@ describe Bumbleworks::WorkitemEntityStorage do
 
   describe '#entity_storage_workitem' do
     it 'returns new Bumbleworks::Workitem instance with workitem' do
-      Bumbleworks::Workitem.stub(:new).with(:a_workitem).and_return(:the_workitem)
+      allow(Bumbleworks::Workitem).to receive(:new).with(:a_workitem).and_return(:the_workitem)
       feh = fake_entity_holder.new(:a_workitem)
-      feh.entity_storage_workitem.should == :the_workitem
+      expect(feh.entity_storage_workitem).to eq(:the_workitem)
     end
 
     it 'is memoized' do
       feh = fake_entity_holder.new(:a_workitem)
       esw = feh.entity_storage_workitem
-      feh.entity_storage_workitem.should be esw
+      expect(feh.entity_storage_workitem).to be esw
     end
   end
 
@@ -29,8 +29,8 @@ describe Bumbleworks::WorkitemEntityStorage do
     describe "##{method}" do
       it 'delegates to entity storage workitem' do
         feh = fake_entity_holder.new(:a_workitem)
-        feh.entity_storage_workitem.stub(method).with(1, 2, 3).and_return(:yay_for_bikes)
-        feh.send(method, 1, 2, 3).should == :yay_for_bikes
+        allow(feh.entity_storage_workitem).to receive(method).with(1, 2, 3).and_return(:yay_for_bikes)
+        expect(feh.send(method, 1, 2, 3)).to eq(:yay_for_bikes)
       end
     end
   end