bumbleworks 0.0.74 → 0.0.76

data/spec/lib/bumbleworks/error_handler_spec.rb

@@ -3,7 +3,7 @@ describe Bumbleworks::ErrorHandler do
   let(:workitem) { double }
   describe '#initialize' do
     it 'sets workitem' do
-      subject.workitem.should == workitem
+      expect(subject.workitem).to eq(workitem)
     end
   end
 

data/spec/lib/bumbleworks/error_logger_spec.rb

@@ -8,7 +8,7 @@ describe Bumbleworks::ErrorLogger do
   end
 
   it 'calls registered logger and logs error information' do
-    Bumbleworks.logger.should_receive(:error).with({
+    expect(Bumbleworks.logger).to receive(:error).with({
       :actor => 'armadillo',
       :action => 'process error',
       :target_type => nil,
@@ -20,8 +20,8 @@ describe Bumbleworks::ErrorLogger do
   end
 
   it 'sets target to entity if found' do
-    workitem.stub(:fields => {:entity_id => 1234, :entity_type => 'Lizards'})
-    Bumbleworks.logger.should_receive(:error).with(hash_including({
+    allow(workitem).to receive_messages(:fields => {:entity_id => 1234, :entity_type => 'Lizards'})
+    expect(Bumbleworks.logger).to receive(:error).with(hash_including({
       :target_type => 'Lizards',
       :target_id => 1234,
     }))
@@ -30,7 +30,7 @@ describe Bumbleworks::ErrorLogger do
   end
 
   it 'does nothing if logger is not registered' do
-    Bumbleworks.stub(:logger)
-    subject.on_error.should == nil
+    allow(Bumbleworks).to receive(:logger)
+    expect(subject.on_error).to eq(nil)
   end
 end

data/spec/lib/bumbleworks/expression_spec.rb

@@ -3,15 +3,37 @@ describe Bumbleworks::Expression do
   let(:fexp) { double('FlowExpression', :fei => fei, :tree => :a_tree) }
   subject { described_class.new(fexp) }
 
+  describe '.from_fei' do
+    it 'returns instance generated from FlowExpressionId' do
+      allow(::Ruote::Exp::FlowExpression).to receive(:fetch).
+        with(Bumbleworks.dashboard.context, fei).and_return(fexp)
+      expect(described_class.from_fei(fei)).to eq(described_class.new(fexp))
+    end
+  end
+
+  describe '#==' do
+    it 'returns true if other object has same flow expression id' do
+      exp1 = described_class.new(fexp)
+      exp2 = described_class.new(double('FlowExpression', :fei => fei))
+      expect(exp1).to eq(exp2)
+    end
+
+    it 'returns false if other object has different flow expression id' do
+      exp1 = described_class.new(fexp)
+      exp2 = described_class.new(double('FlowExpression', :fei => double(:expid => '4')))
+      expect(exp1).not_to eq(exp2)
+    end
+  end
+
   describe '#expid' do
     it 'returns expid from fei' do
-      subject.expid.should == '1_2_3'
+      expect(subject.expid).to eq('1_2_3')
     end
   end
 
   describe '#process' do
     it 'returns process for expression wfid' do
-      subject.process.should == Bumbleworks::Process.new('snooks')
+      expect(subject.process).to eq(Bumbleworks::Process.new('snooks'))
     end
   end
 
@@ -24,44 +46,44 @@ describe Bumbleworks::Expression do
   describe '#error' do
     it 'returns error from process that matches fei' do
       process = double
-      process.stub(:errors => [
+      allow(process).to receive_messages(:errors => [
         double(:fei => :not_me, :message => 'alarming!'),
         double(:fei => fei, :message => 'boo!'),
         double(:fei => :also_not_me, :message => 'yippee!')
       ])
-      subject.stub(:process => process)
-      subject.error.message.should == 'boo!'
+      allow(subject).to receive_messages(:process => process)
+      expect(subject.error.message).to eq('boo!')
     end
 
     it 'returns nil if no error during this expression' do
       process = double
-      process.stub(:errors => [
+      allow(process).to receive_messages(:errors => [
         double(:fei => :not_me, :message => 'alarming!'),
         double(:fei => :also_not_me, :message => 'yippee!')
       ])
-      subject.stub(:process => process)
-      subject.error.should be_nil
+      allow(subject).to receive_messages(:process => process)
+      expect(subject.error).to be_nil
     end
   end
 
   describe '#cancel!' do
     it 'cancels the expression' do
-      Bumbleworks.dashboard.should_receive(:cancel_expression).with(fei)
+      expect(Bumbleworks.dashboard).to receive(:cancel_expression).with(fei)
       subject.cancel!
     end
   end
 
   describe '#kill!' do
     it 'kills the expression' do
-      Bumbleworks.dashboard.should_receive(:kill_expression).with(fei)
+      expect(Bumbleworks.dashboard).to receive(:kill_expression).with(fei)
       subject.kill!
     end
   end
 
   describe '#workitem' do
     it 'returns the workitem as applied to this expression' do
-      fexp.stub(:applied_workitem).and_return(:something_raw)
-      subject.workitem.should == Bumbleworks::Workitem.new(:something_raw)
+      allow(fexp).to receive(:applied_workitem).and_return(:something_raw)
+      expect(subject.workitem).to eq(Bumbleworks::Workitem.new(:something_raw))
     end
   end
 end

data/spec/lib/bumbleworks/hash_storage_spec.rb

@@ -1,11 +1,11 @@
 describe Bumbleworks::HashStorage do
   describe '.allow_history_storage?' do
     it 'returns false' do
-      described_class.allow_history_storage?.should be_false
+      expect(described_class.allow_history_storage?).to be_falsy
     end
 
     it 'is a Bumbleworks::StorageAdapter' do
-      described_class.superclass.should == Bumbleworks::StorageAdapter
+      expect(described_class.superclass).to eq(Bumbleworks::StorageAdapter)
     end
   end
 end

data/spec/lib/bumbleworks/participant/base_spec.rb

@@ -1,6 +1,6 @@
 describe Bumbleworks::Participant do
   it 'includes Bumbleworks::LocalParticipant' do
-    described_class.included_modules.should include(Bumbleworks::LocalParticipant)
+    expect(described_class.included_modules).to include(Bumbleworks::LocalParticipant)
   end
 
   it 'defines #on_cancel' do

data/spec/lib/bumbleworks/participant/entity_interactor_spec.rb

@@ -1,89 +1,89 @@
 describe Bumbleworks::EntityInteractor do
   let(:entity) { double('entity', :cheek_depth => 'crazy deep') }
   let(:workitem) { Ruote::Workitem.new('fields' => { 'params' => { 'method' => 'cheek_depth' }}) }
-  subject { part = described_class.new; part.stub(:entity => entity, :reply => nil); part }
+  subject { part = described_class.new; allow(part).to receive_messages(:entity => entity, :reply => nil); part }
 
   describe '#on_workitem' do
     it 'calls method then replies' do
-      subject.should_receive(:call_method).ordered
-      subject.should_receive(:reply).ordered
+      expect(subject).to receive(:call_method).ordered
+      expect(subject).to receive(:reply).ordered
       subject._on_workitem(workitem)
     end
 
     it 'saves the requested attribute to a workitem field' do
       workitem.fields['params']['and_save_as'] = 'entity_cheek_depth'
       subject._on_workitem(workitem)
-      workitem.fields['entity_cheek_depth'].should == 'crazy deep'
+      expect(workitem.fields['entity_cheek_depth']).to eq('crazy deep')
     end
 
     it 'overwrites an existing workitem field value' do
       workitem.fields['entity_cheek_depth'] = '14'
       workitem.fields['params']['and_save_as'] = 'entity_cheek_depth'
       subject._on_workitem(workitem)
-      workitem.fields['entity_cheek_depth'].should == 'crazy deep'
+      expect(workitem.fields['entity_cheek_depth']).to eq('crazy deep')
     end
 
     it 'calls the method even if no save_as to store the result' do
-      subject.entity.should_receive(:cheek_depth)
+      expect(subject.entity).to receive(:cheek_depth)
       subject._on_workitem(workitem)
-      workitem.fields['entity_cheek_depth'].should be_nil
+      expect(workitem.fields['entity_cheek_depth']).to be_nil
     end
 
     it 'passes arguments to method' do
       workitem.fields['params']['arguments'] = [1, 3, ['apple', 'fish']]
       workitem.fields['params']['and_save_as'] = 'entity_cheek_depth'
-      subject.entity.should_receive(:cheek_depth).with(1, 3, ['apple', 'fish']).and_return('what')
+      expect(subject.entity).to receive(:cheek_depth).with(1, 3, ['apple', 'fish']).and_return('what')
       subject._on_workitem(workitem)
-      workitem.fields['entity_cheek_depth'].should == 'what'
+      expect(workitem.fields['entity_cheek_depth']).to eq('what')
     end
 
     it 'can accept "with" for arguments' do
       workitem.fields['params']['with'] = { :regular => 'joes' }
-      subject.entity.should_receive(:cheek_depth).with({ :regular => 'joes' })
+      expect(subject.entity).to receive(:cheek_depth).with({ :regular => 'joes' })
       subject._on_workitem(workitem)
     end
 
     it 'can use "for" param for method' do
       workitem.fields['params'] = { 'for' => 'grass_seed', 'and_save_as' => 'how_tasty' }
-      entity.should_receive(:grass_seed).and_return('tasty-o')
+      expect(entity).to receive(:grass_seed).and_return('tasty-o')
       subject._on_workitem(workitem)
-      workitem.fields['how_tasty'].should == 'tasty-o'
+      expect(workitem.fields['how_tasty']).to eq('tasty-o')
     end
 
     it 'can use "to" param for method' do
       workitem.fields['params'] = { 'to' => 'chew_things' }
-      entity.should_receive(:chew_things).and_return(nil)
+      expect(entity).to receive(:chew_things).and_return(nil)
       subject._on_workitem(workitem)
-      workitem.fields['who_cares'].should be_nil
+      expect(workitem.fields['who_cares']).to be_nil
     end
 
     it 'defaults to "method" when multiple options exist' do
       workitem.fields['params'] = { 'method' => 'really_do_this', 'to' => 'not_this', 'for' => 'definitely_not_this' }
-      entity.should_receive(:really_do_this)
+      expect(entity).to receive(:really_do_this)
       subject._on_workitem(workitem)
     end
 
     it 'defaults to "to" when both "to" and "for"' do
       workitem.fields['params'] = { 'to' => 'please_call_me', 'for' => 'call_me_maybe' }
-      entity.should_receive(:please_call_me)
+      expect(entity).to receive(:please_call_me)
       subject._on_workitem(workitem)
     end
   end
 
   describe '#call_method' do
     it 'calls the requested method on the entity' do
-      subject.call_method('cheek_depth').should == 'crazy deep'
+      expect(subject.call_method('cheek_depth')).to eq('crazy deep')
     end
 
     it 'saves the result if given a target' do
       subject.workitem = workitem
       subject.call_method('cheek_depth', :save_as => 'entity_cheek_depth')
-      workitem.fields['entity_cheek_depth'].should == 'crazy deep'
+      expect(workitem.fields['entity_cheek_depth']).to eq('crazy deep')
     end
 
     it 'raises an exception if no method on entity' do
-      subject.stub(:entity).and_return('just an unassuming little string!')
-      expect { 
+      allow(subject).to receive(:entity).and_return('just an unassuming little string!')
+      expect {
         subject.call_method('eat_television')
       }.to raise_error(NoMethodError)
     end

data/spec/lib/bumbleworks/participant/error_dispatcher_spec.rb

@@ -6,9 +6,9 @@ describe Bumbleworks::ErrorDispatcher do
 
     it 'calls all error handlers passing in workitem' do
       Bumbleworks.error_handlers = error_handlers
-      error_handlers[0].should_receive(:new).ordered.with(workitem).and_return(instances[0])
-      error_handlers[1].should_receive(:new).ordered.with(workitem).and_return(instances[1])
-      subject.stub(:reply => nil, :workitem => workitem)
+      expect(error_handlers[0]).to receive(:new).ordered.with(workitem).and_return(instances[0])
+      expect(error_handlers[1]).to receive(:new).ordered.with(workitem).and_return(instances[1])
+      allow(subject).to receive_messages(:reply => nil, :workitem => workitem)
       subject.on_workitem
     end
   end

data/spec/lib/bumbleworks/participant/local_participant_spec.rb

@@ -10,7 +10,7 @@ describe Bumbleworks::LocalParticipant do
   }
 
   it 'includes Ruote::LocalParticipant' do
-    described_class.included_modules.should include(Ruote::LocalParticipant)
+    expect(described_class.included_modules).to include(Ruote::LocalParticipant)
   end
 
   it_behaves_like "an entity holder" do

data/spec/lib/bumbleworks/participant_registration_spec.rb

@@ -5,9 +5,9 @@ describe Bumbleworks::ParticipantRegistration do
 
   describe '.autoload_all' do
     it 'autoloads all participants in directory' do
-      Object.should_receive(:autoload).with(:HoneyParticipant,
+      expect(Object).to receive(:autoload).with(:HoneyParticipant,
         File.join(Bumbleworks.root, 'participants', 'honey_participant.rb'))
-      Object.should_receive(:autoload).with(:MolassesParticipant,
+      expect(Object).to receive(:autoload).with(:MolassesParticipant,
         File.join(Bumbleworks.root, 'participants', 'molasses_participant.rb'))
       described_class.autoload_all
     end
@@ -27,13 +27,13 @@ describe Bumbleworks::ParticipantRegistration do
 
   describe '.register!' do
     it 'loads registration file' do
-      Kernel.should_receive(:load).with(File.join(Bumbleworks.root, 'participants.rb'))
+      expect(Kernel).to receive(:load).with(File.join(Bumbleworks.root, 'participants.rb'))
       described_class.register!
     end
 
     it 'registers default participants if using default path and file does not exist' do
       Bumbleworks.root = File.join(fixtures_path, 'apps', 'minimal')
-      Bumbleworks.should_receive(:register_default_participants)
+      expect(Bumbleworks).to receive(:register_default_participants)
       described_class.register!
     end
 

data/spec/lib/bumbleworks/process/error_record_spec.rb

@@ -15,6 +15,19 @@ describe Bumbleworks::Process::ErrorRecord do
     @error = @process.errors.first
   end
 
+  describe '#replay' do
+    it 'replays the process at the error' do
+      expect(Bumbleworks.dashboard).to receive(:replay_at_error).with(@error.process_error)
+      @error.replay
+    end
+  end
+
+  describe '#workitem' do
+    it 'returns the workitem where the error occurred' do
+      expect(@error.workitem).to eq(@error.process_error.workitem)
+    end
+  end
+
   describe '#error_class_name' do
     it 'returns the class name of the recorded error (as a string)' do
       expect(@error.error_class_name).to eq 'NaughtyParticipant::StupidError'

data/spec/lib/bumbleworks/process_definition_spec.rb

@@ -7,25 +7,25 @@ describe Bumbleworks::ProcessDefinition do
 
   it "can be constructed with name and definition" do
     pdef = described_class.new(:name => 'zach', :definition => 'orbo')
-    pdef.name.should == 'zach'
-    pdef.definition.should == 'orbo'
+    expect(pdef.name).to eq('zach')
+    expect(pdef.definition).to eq('orbo')
   end
 
   it "can be constructed with name and tree" do
     pdef = described_class.new(:name => 'zach', :tree => ["define", {"your" => "face"}])
-    pdef.name.should == 'zach'
-    pdef.tree.should == ["define", {"your" => "face"}]
+    expect(pdef.name).to eq('zach')
+    expect(pdef.tree).to eq(["define", {"your" => "face"}])
   end
 
   describe '#build_tree!' do
     it "converts Bumbleworks definition to Ruote tree" do
       pdef = described_class.new(:name => 'monkeys', :definition => valid_definition)
-      pdef.build_tree!.should == [
+      expect(pdef.build_tree!).to eq([
         "define", {"name" => "monkeys"},
         [
           ["chocolate_covered_skis", {"are" => "awesome"}, []]
         ]
-      ]
+      ])
     end
 
     it "raises error if name in definition does not match" do
@@ -39,12 +39,12 @@ describe Bumbleworks::ProcessDefinition do
     it "adds name to tree when not specified in definition" do
       unnamed_def = valid_definition.gsub(/ 'monkeys'/, '')
       pdef = described_class.new(:name => 'spit_salad', :definition => unnamed_def)
-      pdef.build_tree!.should == [
+      expect(pdef.build_tree!).to eq([
         "define", {"name" => "spit_salad"},
         [
           ["chocolate_covered_skis", {"are" => "awesome"}, []]
         ]
-      ]
+      ])
     end
   end
 
@@ -72,7 +72,7 @@ describe Bumbleworks::ProcessDefinition do
   describe "#save!" do
     it "validates" do
       pdef = described_class.new
-      pdef.should_receive(:validate!)
+      expect(pdef).to receive(:validate!)
       pdef.save!
     end
 
@@ -85,16 +85,18 @@ describe Bumbleworks::ProcessDefinition do
     it "registers the process definition with the dashboard" do
       pdef = described_class.new(:name => 'monkeys', :definition => valid_definition)
       pdef.save!
-      Bumbleworks.dashboard.variables['monkeys'].should ==
+      expect(Bumbleworks.dashboard.variables['monkeys']).to eq(
         pdef.build_tree!
+      )
     end
 
     it "overwrites existing variable with new definition" do
       Bumbleworks.dashboard.variables['monkeys'] = 'A miraculous ingredient'
       pdef = described_class.new(:name => 'monkeys', :definition => valid_definition)
       pdef.save!
-      Bumbleworks.dashboard.variables['monkeys'].should ==
+      expect(Bumbleworks.dashboard.variables['monkeys']).to eq(
         pdef.build_tree!
+      )
     end
   end
 
@@ -102,24 +104,24 @@ describe Bumbleworks::ProcessDefinition do
     it "returns an instance with a previously registered definition" do
       Bumbleworks.dashboard.variables['foo'] = 'go to the bar'
       pdef = described_class.find_by_name('foo')
-      pdef.tree.should == 'go to the bar'
+      expect(pdef.tree).to eq('go to the bar')
     end
 
     it "raises an error if registered definition can't be found by given name" do
-      lambda { described_class.find_by_name('nerf') }.should raise_error(described_class::NotFound)
+      expect { described_class.find_by_name('nerf') }.to raise_error(described_class::NotFound)
     end
   end
 
   describe "#load_definition_from_file" do
     it "raises an error if given file can't be found" do
       pdef = described_class.new(:name => 'whatever')
-      lambda { pdef.load_definition_from_file('nerf') }.should raise_error(described_class::FileNotFound)
+      expect { pdef.load_definition_from_file('nerf') }.to raise_error(described_class::FileNotFound)
     end
 
     it "sets #definition to the parsed result of the file, if found" do
       pdef = described_class.new(:name => 'test_process')
       pdef.load_definition_from_file definition_path('test_process')
-      pdef.definition.should == File.read(definition_path('test_process'))
+      expect(pdef.definition).to eq(File.read(definition_path('test_process')))
     end
   end
 
@@ -133,7 +135,7 @@ describe Bumbleworks::ProcessDefinition do
     end
 
     it 'raises error if duplicate filenames are encountered' do
-      Bumbleworks::Support.stub(:all_files).and_return({
+      allow(Bumbleworks::Support).to receive(:all_files).and_return({
         'Rhubarb Derailleur' => 'popular_side_dish',
         'Cantonese Phrasebook' => 'popular_side_dish',
         'Beans' => 'unpopular_side_dish'
@@ -147,32 +149,35 @@ describe Bumbleworks::ProcessDefinition do
       Bumbleworks.dashboard.variables['keep_me'] = 'top_secret_cat_pics'
       # stubbing here so we can explicitly set an order which will
       # ensure we're testing rollback
-      Bumbleworks::Support.stub(:all_files).and_return({
+      allow(Bumbleworks::Support).to receive(:all_files).and_return({
         definition_path('test_process') => 'test_process',
         definition_path('a_list_of_jams') => 'a_list_of_jams'
       })
       expect {
         described_class.create_all_from_directory!(definitions_path)
       }.to raise_error
-      Bumbleworks.dashboard.variables['test_process'].should be_nil
-      Bumbleworks.dashboard.variables['keep_me'].should == 'top_secret_cat_pics'
+      expect(Bumbleworks.dashboard.variables['test_process']).to be_nil
+      expect(Bumbleworks.dashboard.variables['keep_me']).to eq('top_secret_cat_pics')
     end
 
     it 'skips invalid files and loads all valid definitions when option specified' do
       described_class.create_all_from_directory!(definitions_path, :skip_invalid => true)
-      Bumbleworks.dashboard.variables['test_process'].should ==
+      expect(Bumbleworks.dashboard.variables['test_process']).to eq(
         ["define", { "name" => "test_process" }, [["nothing", {}, []]]]
-      Bumbleworks.dashboard.variables['test_nested_process'].should ==
+      )
+      expect(Bumbleworks.dashboard.variables['test_nested_process']).to eq(
         ["define", { "name" => "test_nested_process" }, [["nothing_nested", {}, []]]]
-      Bumbleworks.dashboard.variables['a_list_of_jams'].should be_nil
+      )
+      expect(Bumbleworks.dashboard.variables['a_list_of_jams']).to be_nil
     end
   end
 
   describe '.create!' do
     it 'builds and saves a new instance' do
       pdef = described_class.create!(:name => 'monkeys', :definition => valid_definition)
-      Bumbleworks.dashboard.variables['monkeys'].should ==
+      expect(Bumbleworks.dashboard.variables['monkeys']).to eq(
         pdef.build_tree!
+      )
     end
   end
 
@@ -181,8 +186,9 @@ describe Bumbleworks::ProcessDefinition do
       definition = described_class.define 'nammikins' do
         treefles
       end
-      Bumbleworks.dashboard.variables['nammikins'].should ==
+      expect(Bumbleworks.dashboard.variables['nammikins']).to eq(
         ["define", {"name" => "nammikins"}, [["treefles", {}, []]]]
+      )
     end
   end
 end