bumbleworks 0.0.74 → 0.0.76

data/spec/lib/bumbleworks/configuration_spec.rb

@@ -11,7 +11,7 @@ describe Bumbleworks::Configuration do
 
     it 'returns folder set by user' do
       configuration.root = '/what/about/that'
-      configuration.root.should == '/what/about/that'
+      expect(configuration.root).to eq('/what/about/that')
     end
 
     it 'uses Rails.root if Rails is defined' do
@@ -21,7 +21,7 @@ describe Bumbleworks::Configuration do
         end
       end
 
-      configuration.root.should == '/Rails/Root/lib/bumbleworks'
+      expect(configuration.root).to eq('/Rails/Root/lib/bumbleworks')
       Object.send(:remove_const, :Rails)
     end
 
@@ -32,7 +32,7 @@ describe Bumbleworks::Configuration do
         end
       end
 
-      configuration.root.should == '/Padrino/Root/lib/bumbleworks'
+      expect(configuration.root).to eq('/Padrino/Root/lib/bumbleworks')
       Object.send(:remove_const, :Padrino)
     end
 
@@ -45,7 +45,7 @@ describe Bumbleworks::Configuration do
         end
       end
 
-      configuration.root.should == '/Sinatra/Root/lib/bumbleworks'
+      expect(configuration.root).to eq('/Sinatra/Root/lib/bumbleworks')
       Object.send(:remove_const, :Sinatra)
     end
 
@@ -56,7 +56,7 @@ describe Bumbleworks::Configuration do
         end
       end
 
-      configuration.root.should == '/Rory/Root/lib/bumbleworks'
+      expect(configuration.root).to eq('/Rory/Root/lib/bumbleworks')
       Object.send(:remove_const, :Rory)
     end
 
@@ -74,27 +74,27 @@ describe Bumbleworks::Configuration do
 
   describe "#definitions_directory" do
     it 'returns the folder which was set by the client app' do
-      File.stub(:directory?).with('/dog/ate/my/homework').and_return(true)
+      allow(File).to receive(:directory?).with('/dog/ate/my/homework').and_return(true)
       configuration.definitions_directory = '/dog/ate/my/homework'
-      configuration.definitions_directory.should == '/dog/ate/my/homework'
+      expect(configuration.definitions_directory).to eq('/dog/ate/my/homework')
     end
 
     it 'returns the default folder if not set by client app' do
-      File.stub(:directory? => true)
+      allow(File).to receive_messages(:directory? => true)
       configuration.root = '/Root'
-      configuration.definitions_directory.should == '/Root/process_definitions'
+      expect(configuration.definitions_directory).to eq('/Root/process_definitions')
     end
 
     it 'returns the second default folder if first does not exist' do
-      File.stub(:directory?).with('/Root/process_definitions').and_return(false)
-      File.stub(:directory?).with('/Root/processes').and_return(true)
+      allow(File).to receive(:directory?).with('/Root/process_definitions').and_return(false)
+      allow(File).to receive(:directory?).with('/Root/processes').and_return(true)
       configuration.root = '/Root'
-      configuration.definitions_directory.should == '/Root/processes'
+      expect(configuration.definitions_directory).to eq('/Root/processes')
     end
 
     it 'returns nil if default folder not found' do
       configuration.root = '/Root'
-      configuration.definitions_directory.should be_nil
+      expect(configuration.definitions_directory).to be_nil
     end
 
     it 'raises error if specific folder not found' do
@@ -110,20 +110,20 @@ describe Bumbleworks::Configuration do
 
   describe "#participants_directory" do
     it 'returns the folder which was set by the client app' do
-      File.stub(:directory?).with('/dog/ate/my/homework').and_return(true)
+      allow(File).to receive(:directory?).with('/dog/ate/my/homework').and_return(true)
       configuration.participants_directory = '/dog/ate/my/homework'
-      configuration.participants_directory.should == '/dog/ate/my/homework'
+      expect(configuration.participants_directory).to eq('/dog/ate/my/homework')
     end
 
     it 'returns the default folder if not set by client app' do
-      File.stub(:directory?).with('/Root/participants').and_return(true)
+      allow(File).to receive(:directory?).with('/Root/participants').and_return(true)
       configuration.root = '/Root'
-      configuration.participants_directory.should == '/Root/participants'
+      expect(configuration.participants_directory).to eq('/Root/participants')
     end
 
     it 'returns nil if default folder not found' do
       configuration.root = '/Root'
-      configuration.participants_directory.should be_nil
+      expect(configuration.participants_directory).to be_nil
     end
 
     it 'raises error if specific folder not found' do
@@ -139,20 +139,20 @@ describe Bumbleworks::Configuration do
 
   describe "#tasks_directory" do
     it 'returns the folder which was set by the client app' do
-      File.stub(:directory?).with('/dog/ate/my/homework').and_return(true)
+      allow(File).to receive(:directory?).with('/dog/ate/my/homework').and_return(true)
       configuration.tasks_directory = '/dog/ate/my/homework'
-      configuration.tasks_directory.should == '/dog/ate/my/homework'
+      expect(configuration.tasks_directory).to eq('/dog/ate/my/homework')
     end
 
     it 'returns the default folder if not set by client app' do
-      File.stub(:directory?).with('/Root/tasks').and_return(true)
+      allow(File).to receive(:directory?).with('/Root/tasks').and_return(true)
       configuration.root = '/Root'
-      configuration.tasks_directory.should == '/Root/tasks'
+      expect(configuration.tasks_directory).to eq('/Root/tasks')
     end
 
     it 'returns nil if default folder not found' do
       configuration.root = '/Root'
-      configuration.tasks_directory.should be_nil
+      expect(configuration.tasks_directory).to be_nil
     end
 
     it 'raises error if specific folder not found' do
@@ -168,20 +168,20 @@ describe Bumbleworks::Configuration do
 
   describe "#participant_registration_file" do
     it 'returns the path which was set by the client app' do
-      File.stub(:file?).with('/can/i/get/a/rooster.rb').and_return(true)
+      allow(File).to receive(:file?).with('/can/i/get/a/rooster.rb').and_return(true)
       configuration.participant_registration_file = '/can/i/get/a/rooster.rb'
-      configuration.participant_registration_file.should == '/can/i/get/a/rooster.rb'
+      expect(configuration.participant_registration_file).to eq('/can/i/get/a/rooster.rb')
     end
 
     it 'returns the default folder if not set by client app' do
-      File.stub(:file?).with('/Root/participants.rb').and_return(true)
+      allow(File).to receive(:file?).with('/Root/participants.rb').and_return(true)
       configuration.root = '/Root'
-      configuration.participant_registration_file.should == '/Root/participants.rb'
+      expect(configuration.participant_registration_file).to eq('/Root/participants.rb')
     end
 
     it 'returns nil if default path not found' do
       configuration.root = '/Root'
-      configuration.participant_registration_file.should be_nil
+      expect(configuration.participant_registration_file).to be_nil
     end
 
     it 'raises error if specific path not found' do
@@ -198,35 +198,35 @@ describe Bumbleworks::Configuration do
   describe '#logger' do
     it 'returns the registered logger' do
       configuration.logger = :a_logger
-      configuration.logger.should == :a_logger
+      expect(configuration.logger).to eq(:a_logger)
     end
 
     it 'returns the default simple logger if no logger registered' do
-      configuration.logger.should == Bumbleworks::SimpleLogger
+      expect(configuration.logger).to eq(Bumbleworks::SimpleLogger)
     end
   end
 
   describe '#observers' do
     it 'is empty by default' do
-      configuration.observers.should be_empty
+      expect(configuration.observers).to be_empty
     end
 
     it 'returns the registered observers' do
       configuration.observers = [:smash, :pumpkin]
       configuration.observers << :rhubarb
-      configuration.observers.should == [:smash, :pumpkin, :rhubarb]
+      expect(configuration.observers).to eq([:smash, :pumpkin, :rhubarb])
     end
   end
 
   describe '#entity_classes' do
     it 'is empty by default' do
-      configuration.entity_classes.should be_empty
+      expect(configuration.entity_classes).to be_empty
     end
 
     it 'returns the registered entity classes' do
       configuration.entity_classes = [:fumpin, :nuffin]
       configuration.entity_classes << :summin
-      configuration.entity_classes.should == [:fumpin, :nuffin, :summin]
+      expect(configuration.entity_classes).to eq([:fumpin, :nuffin, :summin])
     end
   end
 
@@ -234,18 +234,18 @@ describe Bumbleworks::Configuration do
     it 'can set storage directly' do
       storage = double("Storage")
       configuration.storage = storage
-      configuration.storage.should == storage
+      expect(configuration.storage).to eq(storage)
     end
   end
 
   describe '#storage_options' do
     it 'defaults to empty hash' do
-      subject.storage_options.should == {}
+      expect(subject.storage_options).to eq({})
     end
 
     it 'can be overridden' do
       subject.storage_options = { :smooshie => 'wubbles' }
-      subject.storage_options.should == { :smooshie => 'wubbles' }
+      expect(subject.storage_options).to eq({ :smooshie => 'wubbles' })
     end
   end
 
@@ -254,19 +254,19 @@ describe Bumbleworks::Configuration do
       right_adapter = double('right', :use? => true)
       wrong_adapter_1 = double('wrong1', :use? => false)
       wrong_adapter_2 = double('wrong2', :use? => false)
-      subject.stub(:storage_adapters => [wrong_adapter_1, right_adapter, wrong_adapter_2])
-      subject.storage_adapter.should == right_adapter
+      allow(subject).to receive_messages(:storage_adapters => [wrong_adapter_1, right_adapter, wrong_adapter_2])
+      expect(subject.storage_adapter).to eq(right_adapter)
     end
 
     it 'can be set storage directly' do
       storage = double("Storage Adapter")
       subject.storage_adapter = storage
-      subject.storage_adapter.should == storage
+      expect(subject.storage_adapter).to eq(storage)
     end
 
     it 'raises UndefinedSetting if no matching storage adapter' do
       wrong_adapter = double('wrong1', :use? => false, :display_name => 'Wrong')
-      subject.stub(:storage_adapters => [wrong_adapter])
+      allow(subject).to receive_messages(:storage_adapters => [wrong_adapter])
       expect {
         subject.storage_adapter
       }.to raise_error(Bumbleworks::UndefinedSetting,
@@ -284,12 +284,12 @@ describe Bumbleworks::Configuration do
   describe '#add_storage_adapter' do
     it 'adds storage adapter to registered list' do
       GoodForNothingStorage = double('fake_storage', :respond_to? => true)
-      configuration.storage_adapters.should be_empty
+      expect(configuration.storage_adapters).to be_empty
       configuration.add_storage_adapter(GoodForNothingStorage)
       configuration.add_storage_adapter(Bumbleworks::HashStorage)
-      configuration.storage_adapters.should =~ [
+      expect(configuration.storage_adapters).to match_array([
         GoodForNothingStorage, Bumbleworks::HashStorage
-      ]
+      ])
     end
 
     it 'raises ArgumentError if object is not a storage adapter' do
@@ -307,41 +307,41 @@ describe Bumbleworks::Configuration do
     end
 
     it 'resets #definitions_directory' do
-      File.stub(:directory? => true)
+      allow(File).to receive_messages(:directory? => true)
       configuration.definitions_directory = '/One/Two'
-      configuration.definitions_directory.should == '/One/Two'
+      expect(configuration.definitions_directory).to eq('/One/Two')
       configuration.clear!
 
       configuration.root = '/Root'
-      configuration.definitions_directory.should == '/Root/process_definitions'
+      expect(configuration.definitions_directory).to eq('/Root/process_definitions')
     end
   end
 
   describe '#error_handlers', dev:true do
     let(:super_handler) {double('error_handler')}
     it 'sets default error handler' do
-      configuration.error_handlers.should == [Bumbleworks::ErrorLogger]
+      expect(configuration.error_handlers).to eq([Bumbleworks::ErrorLogger])
     end
 
     it 'replaces default handler' do
       configuration.error_handlers = [super_handler]
-      configuration.error_handlers.should == [super_handler]
+      expect(configuration.error_handlers).to eq([super_handler])
     end
 
     it 'adds to default handler' do
       configuration.error_handlers << super_handler
-      configuration.error_handlers.should =~ [Bumbleworks::ErrorLogger, super_handler]
+      expect(configuration.error_handlers).to match_array([Bumbleworks::ErrorLogger, super_handler])
     end
   end
 
   describe '#store_history' do
     it 'defaults to true' do
-      subject.store_history.should be_true
+      expect(subject.store_history).to be_truthy
     end
 
     it 'can be overridden' do
       subject.store_history = false
-      subject.store_history.should be_false
+      expect(subject.store_history).to be_falsy
     end
   end
 end

data/spec/lib/bumbleworks/entity_spec.rb

@@ -4,17 +4,17 @@ describe Bumbleworks::Entity do
   describe '#identifier' do
     it 'returns id by default' do
       entity = entity_class.new
-      entity.stub(:id => 'berf')
-      entity.identifier.should == 'berf'
+      allow(entity).to receive_messages(:id => 'berf')
+      expect(entity.identifier).to eq('berf')
     end
   end
 
   describe '#to_s' do
     it 'returns string with titleized class name and identifier' do
-      entity_class.stub(:name => 'GiantAngryPlum')
+      allow(entity_class).to receive_messages(:name => 'GiantAngryPlum')
       entity = entity_class.new
-      entity.stub(:identifier => 1490)
-      entity.to_s.should == 'Giant Angry Plum 1490'
+      allow(entity).to receive_messages(:identifier => 1490)
+      expect(entity.to_s).to eq('Giant Angry Plum 1490')
     end
   end
 
@@ -28,15 +28,15 @@ describe Bumbleworks::Entity do
       entity = entity_class.new
       entity.foof_pid = '1234'
       entity.nook_pid = 'pickles'
-      entity.processes_by_name.should == {
+      expect(entity.processes_by_name).to eq({
         :zoom => nil,
         :foof => Bumbleworks::Process.new('1234'),
         :nook => Bumbleworks::Process.new('pickles')
-      }
+      })
     end
 
     it 'returns empty hash if no processes' do
-      entity_class.new.processes_by_name.should == {}
+      expect(entity_class.new.processes_by_name).to eq({})
     end
   end
 
@@ -49,39 +49,39 @@ describe Bumbleworks::Entity do
       entity = entity_class.new
       entity.foof_pid = '1234'
       entity.nook_pid = 'pickles'
-      entity.processes.should =~ [
+      expect(entity.processes).to match_array([
         Bumbleworks::Process.new('1234'),
         Bumbleworks::Process.new('pickles')
-      ]
+      ])
     end
 
     it 'returns empty array if no processes' do
-      entity_class.new.processes.should == []
+      expect(entity_class.new.processes).to eq([])
     end
   end
 
   describe '#cancel_all_processes!' do
     it 'cancels all processes with registered identifiers' do
       entity = entity_class.new
-      entity.stub(:processes_by_name => {
+      allow(entity).to receive_messages(:processes_by_name => {
         :foof => bp1 = Bumbleworks::Process.new('1234'),
         :nook => bp2 = Bumbleworks::Process.new('pickles')
       })
-      bp1.should_receive(:cancel!)
-      bp2.should_receive(:cancel!)
-      entity.stub(:attribute_for_process_name) { |name| :"#{name}_pid" }
-      entity.should_receive(:update).with(:foof_pid => nil)
-      entity.should_receive(:update).with(:nook_pid => nil)
+      expect(bp1).to receive(:cancel!)
+      expect(bp2).to receive(:cancel!)
+      allow(entity).to receive(:attribute_for_process_name) { |name| :"#{name}_pid" }
+      expect(entity).to receive(:update).with(:foof_pid => nil)
+      expect(entity).to receive(:update).with(:nook_pid => nil)
       entity.cancel_all_processes!
     end
 
     it 'does not clear identifiers if clear_identifiers option is false' do
       entity = entity_class.new
-      entity.stub(:processes_by_name => {
+      allow(entity).to receive_messages(:processes_by_name => {
         :foof => bp = Bumbleworks::Process.new('1234')
       })
-      bp.should_receive(:cancel!)
-      entity.should_receive(:update).never
+      expect(bp).to receive(:cancel!)
+      expect(entity).to receive(:update).never
       entity.cancel_all_processes!(:clear_identifiers => false)
     end
   end
@@ -89,36 +89,34 @@ describe Bumbleworks::Entity do
   describe '#process_fields' do
     it 'returns hash with entity' do
       entity = entity_class.new
-      entity.process_fields.should == { :entity => entity }
+      expect(entity.process_fields).to eq({ :entity => entity })
     end
 
     it 'accepts but ignores process name argument' do
       entity = entity_class.new
-      entity.process_fields('ignore_me').should == { :entity => entity }
+      expect(entity.process_fields('ignore_me')).to eq({ :entity => entity })
     end
   end
 
   describe '#process_variables' do
     it 'returns empty hash' do
-      entity_class.new.process_variables.should == {}
+      expect(entity_class.new.process_variables).to eq({})
     end
 
     it 'accepts but ignores process name argument' do
-      entity_class.new.process_variables('ignore me').should == {}
+      expect(entity_class.new.process_variables('ignore me')).to eq({})
     end
   end
 
   describe '#persist_process_identifier' do
     it 'calls #update if method exists' do
       entity = entity_class.new
-      entity.should_receive(:update).with(:a_attribute => :a_value)
+      expect(entity).to receive(:update).with(:a_attribute => :a_value)
       entity.persist_process_identifier(:a_attribute, :a_value)
     end
 
     it 'raises exception if #update method does not exist' do
       entity = entity_class.new
-      entity.stub(:respond_to?).with(:update).and_return(false)
-      entity.should_receive(:update).never
       expect {
         entity.persist_process_identifier(:a_attribute, :a_value)
       }.to raise_error("Entity must define #persist_process_identifier method if missing #update method.")
@@ -130,39 +128,39 @@ describe Bumbleworks::Entity do
       bp = Bumbleworks::Process.new('12345')
       entity_class.process :noodles, :attribute => :noodles_pid
       entity = entity_class.new
-      entity.stub(:noodles_pid)
-      entity.stub(:process_fields).with(:noodles).and_return({:f => 1})
-      entity.stub(:process_variables).with(:noodles).and_return({:v => 2})
-      Bumbleworks.stub(:launch!).with('noodles', {:f => 1}, {:v => 2}).and_return(bp)
-      entity.should_receive(:persist_process_identifier).with(:noodles_pid, '12345')
-      entity.launch_process('noodles').should == bp
+      allow(entity).to receive(:noodles_pid)
+      allow(entity).to receive(:process_fields).with(:noodles).and_return({:f => 1})
+      allow(entity).to receive(:process_variables).with(:noodles).and_return({:v => 2})
+      allow(Bumbleworks).to receive(:launch!).with('noodles', {:f => 1}, {:v => 2}).and_return(bp)
+      expect(entity).to receive(:persist_process_identifier).with(:noodles_pid, '12345')
+      expect(entity.launch_process('noodles')).to eq(bp)
     end
 
     it 'does nothing but returns existing process if identifier attribute already set' do
       bp = Bumbleworks::Process.new('already set')
       entity_class.process :noodles, :attribute => :noodles_pid
       entity = entity_class.new
-      entity.stub(:noodles_pid => 'already set')
-      Bumbleworks.should_receive(:launch!).never
-      entity.launch_process('noodles').should == bp
+      allow(entity).to receive_messages(:noodles_pid => 'already set')
+      expect(Bumbleworks).to receive(:launch!).never
+      expect(entity.launch_process('noodles')).to eq(bp)
     end
 
     it 'launches new process anyway if identifier attribute already set but force is true' do
       bp = Bumbleworks::Process.new('12345')
       entity_class.process :noodles, :attribute => :noodles_pid
       entity = entity_class.new
-      entity.stub(:noodles_pid => 'already set')
-      Bumbleworks.stub(:launch! => bp)
-      entity.should_receive(:persist_process_identifier).with(:noodles_pid, '12345')
-      entity.launch_process('noodles', :force => true).should == bp
+      allow(entity).to receive_messages(:noodles_pid => 'already set')
+      allow(Bumbleworks).to receive_messages(:launch! => bp)
+      expect(entity).to receive(:persist_process_identifier).with(:noodles_pid, '12345')
+      expect(entity.launch_process('noodles', :force => true)).to eq(bp)
     end
 
     it 'sends additional fields and variables to launch' do
       entity_class.process :noodles, :attribute => :noodles_pid
       entity = entity_class.new
-      entity.stub(:noodles_pid)
-      entity.stub(:persist_process_identifier)
-      Bumbleworks.should_receive(:launch!).with(
+      allow(entity).to receive(:noodles_pid)
+      allow(entity).to receive(:persist_process_identifier)
+      expect(Bumbleworks).to receive(:launch!).with(
         'noodles',
         { :entity => entity, :drink => 'apathy smoothie', :berry => 'black' },
         { :so_you_said => :well_so_did_i }
@@ -176,17 +174,17 @@ describe Bumbleworks::Entity do
 
   describe '#attribute_for_process_name' do
     it 'returns attribute set for given process' do
-      entity_class.stub(:processes).and_return({
+      allow(entity_class).to receive(:processes).and_return({
         :goose => { :attribute => :goose_pid },
         :the_punisher => { :attribute => :your_skin }
       })
       entity = entity_class.new
-      entity.attribute_for_process_name(:goose).should == :goose_pid
-      entity.attribute_for_process_name(:the_punisher).should == :your_skin
+      expect(entity.attribute_for_process_name(:goose)).to eq(:goose_pid)
+      expect(entity.attribute_for_process_name(:the_punisher)).to eq(:your_skin)
     end
 
     it 'raises exception if no process found for given name' do
-      entity_class.stub(:processes).and_return({
+      allow(entity_class).to receive(:processes).and_return({
         :goose => { :attribute => :goose_pid },
       })
       entity = entity_class.new
@@ -201,11 +199,11 @@ describe Bumbleworks::Entity do
       bp1 = double('bp1', :subscribed_events => ['chewing', 'popping', 'yakking'])
       bp2 = double('bp2', :subscribed_events => ['moon', 'yakking'])
       entity = entity_class.new
-      entity.stub(:processes).and_return({
+      allow(entity).to receive(:processes).and_return({
         :zip => bp1,
         :yip => bp2
       })
-      entity.subscribed_events.should =~ ['chewing', 'moon', 'popping', 'yakking']
+      expect(entity.subscribed_events).to match_array(['chewing', 'moon', 'popping', 'yakking'])
     end
   end
 
@@ -214,42 +212,42 @@ describe Bumbleworks::Entity do
       bp1 = double('bp1', :subscribed_events => ['chewing', 'popping', 'yakking'])
       bp2 = double('bp2', :subscribed_events => ['moon', 'yakking'])
       entity = entity_class.new
-      entity.stub(:processes).and_return({
+      allow(entity).to receive(:processes).and_return({
         :zip => bp1,
         :yip => bp2
       })
-      entity.is_waiting_for?('chewing').should be_true
-      entity.is_waiting_for?('yakking').should be_true
-      entity.is_waiting_for?(:moon).should be_true
-      entity.is_waiting_for?('fruiting').should be_false
+      expect(entity.is_waiting_for?('chewing')).to be_truthy
+      expect(entity.is_waiting_for?('yakking')).to be_truthy
+      expect(entity.is_waiting_for?(:moon)).to be_truthy
+      expect(entity.is_waiting_for?('fruiting')).to be_falsy
     end
   end
 
   describe '#tasks' do
     it 'returns task query for all entity tasks by default' do
       entity = entity_class.new
-      Bumbleworks::Task.stub(:for_entity).with(entity).and_return(:full_task_query)
-      entity.tasks.should == :full_task_query
+      allow(Bumbleworks::Task).to receive(:for_entity).with(entity).and_return(:full_task_query)
+      expect(entity.tasks).to eq(:full_task_query)
     end
 
     it 'filters task query by nickname if provided' do
       entity = entity_class.new
       task_finder = double('task_finder')
-      task_finder.stub(:by_nickname).with(:smooface).and_return(:partial_task_query)
-      Bumbleworks::Task.stub(:for_entity).with(entity).and_return(task_finder)
-      entity.tasks(:smooface).should == :partial_task_query
+      allow(task_finder).to receive(:by_nickname).with(:smooface).and_return(:partial_task_query)
+      allow(Bumbleworks::Task).to receive(:for_entity).with(entity).and_return(task_finder)
+      expect(entity.tasks(:smooface)).to eq(:partial_task_query)
     end
   end
 
   describe '.process' do
     it 'registers a new process' do
-      entity_class.stub(:default_process_identifier_attribute).with(:whatever).and_return('loob')
+      allow(entity_class).to receive(:default_process_identifier_attribute).with(:whatever).and_return('loob')
       entity_class.process :whatever
-      entity_class.processes.should == {
+      expect(entity_class.processes).to eq({
         :whatever => {
           :attribute => 'loob'
         }
-      }
+      })
     end
   end
 
@@ -261,23 +259,23 @@ describe Bumbleworks::Entity do
 
   describe '.default_process_identifier_attribute' do
     it 'adds _process_identifier to end of given process name' do
-      entity_class.default_process_identifier_attribute('zoof').should == :zoof_process_identifier
+      expect(entity_class.default_process_identifier_attribute('zoof')).to eq(:zoof_process_identifier)
     end
 
     it 'ensures no duplication of _process' do
-      entity_class.default_process_identifier_attribute('zoof_process').should == :zoof_process_identifier
+      expect(entity_class.default_process_identifier_attribute('zoof_process')).to eq(:zoof_process_identifier)
     end
 
     it 'removes entity_type from beginning of identifier' do
-      entity_class.stub(:entity_type).and_return('zoof')
-      entity_class.default_process_identifier_attribute('zoof_process').should == :process_identifier
+      allow(entity_class).to receive(:entity_type).and_return('zoof')
+      expect(entity_class.default_process_identifier_attribute('zoof_process')).to eq(:process_identifier)
     end
   end
 
   describe '.entity_type' do
     it 'returns underscored version of class name' do
-      entity_class.stub(:name).and_return('MyClass')
-      entity_class.entity_type.should == 'my_class'
+      allow(entity_class).to receive(:name).and_return('MyClass')
+      expect(entity_class.entity_type).to eq('my_class')
     end
   end
 end