bumbleworks 0.0.74 → 0.0.76

data/spec/lib/bumbleworks/schedule_spec.rb

@@ -0,0 +1,124 @@
+require File.expand_path(File.join(fixtures_path, 'schedules'))
+
+describe Bumbleworks::Schedule do
+  let(:fake_schedule) { fake_schedules.first }
+  subject { described_class.new(fake_schedule) }
+
+  before(:each) do
+    allow(Bumbleworks.dashboard).to receive_messages(:schedules => fake_schedules)
+  end
+
+  describe '.all' do
+    it 'returns instances for each schedule in system' do
+      schedules = described_class.all
+      expect(schedules.all? { |t| t.class == Bumbleworks::Schedule }).to be_truthy
+      expect(schedules.map(&:id)).to match_array([
+        "at-0_0!d65a8006da6d9025d48fa916071a6dc1!20140710-1001-dirisoma-rebadihe-20140718000000",
+        "cron-0_0!48ec5a9db7d4c61da0ebaa968bd552c3!20140710-1016-nodemika-kudatsufu-20140710101857",
+        "cron-0_0!9103b81d6b2cc198ec44b1c7c6461d1e!20140710-1023-dobabako-jabufuso-20140713111500"
+      ])
+    end
+  end
+
+  describe '.count' do
+    it 'returns count of current schedules' do
+      expect(described_class.count).to eq 3
+    end
+  end
+
+  describe '.new' do
+    it 'sets schedule id and fetches original_hash from dashboard' do
+      expect(subject.id).to eq(fake_schedule['_id'])
+      expect(subject.original_hash).to eq(fake_schedule)
+    end
+  end
+
+  describe '#==' do
+    it 'returns true if other object has same original hash _id' do
+      schedule1 = described_class.new({ '_id' => 'snaggletooth', 'who' => 'cares' })
+      schedule2 = described_class.new({ '_id' => 'snaggletooth', 'yeah' => 'whatevs' })
+      expect(schedule1).to eq(schedule2)
+    end
+
+    it 'returns false if other object has different original hash _id' do
+      schedule1 = described_class.new({ '_id' => 'snaggletooth', 'who' => 'cares' })
+      schedule2 = described_class.new({ '_id' => 'snooglebunk', 'yeah' => 'whatevs' })
+      expect(schedule1).not_to eq(schedule2)
+    end
+  end
+
+  describe '#wfid' do
+    it 'returns wfid from original hash' do
+      expect(subject.wfid).to eq(fake_schedule['wfid'])
+    end
+  end
+
+  describe '#process' do
+    it 'returns process for wfid stored in msg' do
+      expect(subject.process).to eq(Bumbleworks::Process.new(fake_schedule['wfid']))
+    end
+  end
+
+  describe '#expression' do
+    it 'returns expression that triggered the schedule' do
+      allow(Bumbleworks::Expression).to receive(:from_fei).
+        with(:a_flow_expression).and_return(:the_expression)
+      expect(subject.expression).to eq(:the_expression)
+    end
+  end
+
+  describe '#repeating?' do
+    ['every', 'cron'].each do |exp_name|
+      it "returns true if expression is '#{exp_name}'" do
+        allow(subject).to receive(:expression).and_return(
+          double(Bumbleworks::Expression, :tree => [exp_name]))
+        expect(subject.repeating?).to be_truthy
+      end
+    end
+
+    ['once', 'as_soon_as', 'when'].each do |exp_name|
+      it "returns false if expression is '#{exp_name}'" do
+        allow(subject).to receive(:expression).and_return(
+          double(Bumbleworks::Expression, :tree => [exp_name]))
+        expect(subject.repeating?).to be_falsy
+      end
+    end
+  end
+
+  describe '#once?' do
+    it 'returns inverse of #repeating?' do
+      allow(subject).to receive_messages(:repeating? => true)
+      expect(subject.once?).to be_falsy
+      allow(subject).to receive_messages(:repeating? => false)
+      expect(subject.once?).to be_truthy
+    end
+  end
+
+  describe '#next_at' do
+    it 'returns time of next iteration' do
+      expect(subject.next_at).to eq(Time.parse('2014-07-18 04:00:00 UTC'))
+    end
+  end
+
+  describe '#original_plan' do
+    it 'returns original schedule plan' do
+      expect(subject.original_plan).to eq("2014-07-18 04:00:00")
+      second_fake_schedule = described_class.new(fake_schedules[1])
+      expect(second_fake_schedule.original_plan).to eq("1m")
+    end
+  end
+
+  describe '#test_clause' do
+    it 'returns test clause from expression' do
+      allow(subject).to receive_messages(
+        :expression => double(Bumbleworks::Expression, :tree => ['once', {'test' => 'pigeons'}, []]))
+      expect(subject.test_clause).to eq('pigeons')
+    end
+
+    it 'returns nil when expression does not include test clause' do
+      allow(subject).to receive_messages(
+        :expression => double(Bumbleworks::Expression, :tree => ['once', {}, []]))
+      expect(subject.test_clause).to be_nil
+    end
+  end
+end

data/spec/lib/bumbleworks/simple_logger_spec.rb

@@ -6,7 +6,7 @@ describe Bumbleworks::SimpleLogger do
   [:info, :debug, :fatal, :warn, :error].each do |level|
     describe ".#{level}" do
       it "adds given object to the log with '#{level}' level" do
-        described_class.should_receive(:add).
+        expect(described_class).to receive(:add).
           with(level, :something => :happened)
         described_class.send(level.to_sym, :something => :happened)
       end
@@ -17,10 +17,10 @@ describe Bumbleworks::SimpleLogger do
     it 'adds given object to the log at given level' do
       described_class.add(:info, :super_serious_occurrence)
       described_class.add(:debug, :weird_thing)
-      described_class.entries.should == [
+      expect(described_class.entries).to eq([
         { :level => :info, :entry => :super_serious_occurrence },
         { :level => :debug, :entry => :weird_thing }
-      ]
+      ])
     end
   end
 
@@ -30,22 +30,22 @@ describe Bumbleworks::SimpleLogger do
       described_class.debug 'other thing'
       described_class.info 'third thing'
       described_class.fatal 'final thing'
-      described_class.entries.should == [
+      expect(described_class.entries).to eq([
         { :level => :info, :entry => 'thing' },
         { :level => :debug, :entry => 'other thing' },
         { :level => :info, :entry => 'third thing' },
         { :level => :fatal, :entry => 'final thing' }
-      ]
+      ])
     end
   end
 
   describe '.clear!' do
     it 'deletes all entries' do
-      described_class.entries.should be_empty
+      expect(described_class.entries).to be_empty
       described_class.info 'thing'
-      described_class.entries.should_not be_empty
+      expect(described_class.entries).not_to be_empty
       described_class.clear!
-      described_class.entries.should be_empty
+      expect(described_class.entries).to be_empty
     end
   end
 end

data/spec/lib/bumbleworks/storage_adapter_spec.rb

@@ -2,24 +2,24 @@ describe Bumbleworks::StorageAdapter do
   describe '.auto_register?' do
     it 'returns true if auto_register is true' do
       described_class.auto_register = true
-      described_class.auto_register?.should be_true
+      expect(described_class.auto_register?).to be_truthy
     end
 
     it 'returns false if auto_register is not true' do
       described_class.auto_register = :ghosts
-      described_class.auto_register?.should be_false
+      expect(described_class.auto_register?).to be_falsy
     end
 
     it 'is true by default' do
       described_class.auto_register = nil
-      described_class.auto_register?.should be_true
+      expect(described_class.auto_register?).to be_truthy
     end
   end
 
   describe '.display_name' do
     it 'returns storage class name as a string' do
-      described_class.stub(:storage_class).and_return(String)
-      described_class.display_name.should == 'String'
+      allow(described_class).to receive(:storage_class).and_return(String)
+      expect(described_class.display_name).to eq('String')
     end
   end
 
@@ -37,45 +37,45 @@ describe Bumbleworks::StorageAdapter do
 
   describe '.allow_history_storage?' do
     it 'defaults to true' do
-      described_class.allow_history_storage?.should be_true
+      expect(described_class.allow_history_storage?).to be_truthy
     end
   end
 
   describe '.use?' do
     before :each do
-      described_class.stub(:storage_class).and_return(String)
+      allow(described_class).to receive(:storage_class).and_return(String)
     end
 
     it 'returns true if argument class is_a storage class' do
-      described_class.use?('a string').should be_true
-      described_class.use?(:not_a_string).should be_false
+      expect(described_class.use?('a string')).to be_truthy
+      expect(described_class.use?(:not_a_string)).to be_falsy
     end
   end
 
   describe '.wrap_storage_with_driver' do
     before :each do
       storage_driver = double('storage_driver')
-      storage_driver.stub(:new).with(:awesome_stuff).and_return(:new_storage)
-      described_class.stub(:driver => storage_driver)
+      allow(storage_driver).to receive(:new).with(:awesome_stuff).and_return(:new_storage)
+      allow(described_class).to receive_messages(:driver => storage_driver)
     end
 
     it 'ignores options, and returns driven storage' do
-      described_class.wrap_storage_with_driver(:awesome_stuff, { :a => :b }).should == :new_storage
+      expect(described_class.wrap_storage_with_driver(:awesome_stuff, { :a => :b })).to eq(:new_storage)
     end
   end
 
   describe '.new_storage' do
     before :each do
-      described_class.stub(:wrap_storage_with_driver).with(:awesome_stuff, { :a => :b }).and_return(:new_storage)
+      allow(described_class).to receive(:wrap_storage_with_driver).with(:awesome_stuff, { :a => :b }).and_return(:new_storage)
     end
 
     it 'returns driven storage if driver can use storage' do
-      described_class.stub(:use?).with(:awesome_stuff).and_return(true)
-      described_class.new_storage(:awesome_stuff, { :a => :b }).should == :new_storage
+      allow(described_class).to receive(:use?).with(:awesome_stuff).and_return(true)
+      expect(described_class.new_storage(:awesome_stuff, { :a => :b })).to eq(:new_storage)
     end
 
     it "raises UnsupportedStorage if driver can't use storage" do
-      described_class.stub(:use?).with(:awesome_stuff).and_return(false)
+      allow(described_class).to receive(:use?).with(:awesome_stuff).and_return(false)
       expect {
         described_class.new_storage(:awesome_stuff, { :a => :b })
       }.to raise_error(Bumbleworks::StorageAdapter::UnsupportedStorage)

data/spec/lib/bumbleworks/support_spec.rb

@@ -1,11 +1,11 @@
 describe Bumbleworks::Support do
   describe '.camelize' do
     it 'turns underscored string into camelcase' do
-      described_class.camelize('foo_bar_One_two_3').should == 'FooBarOneTwo3'
+      expect(described_class.camelize('foo_bar_One_two_3')).to eq('FooBarOneTwo3')
     end
 
     it 'deals with nested classes' do
-      described_class.camelize('foo_bar/bar_foo').should == 'FooBar::BarFoo'
+      expect(described_class.camelize('foo_bar/bar_foo')).to eq('FooBar::BarFoo')
     end
   end
 
@@ -15,20 +15,24 @@ describe Bumbleworks::Support do
     it "for given directory, creates hash of basename => path pairs" do
       assembled_hash = described_class.all_files(test_directory)
 
-      assembled_hash[File.join(fixtures_path, 'definitions', 'test_process.rb').to_s].should ==
+      expect(assembled_hash[File.join(fixtures_path, 'definitions', 'test_process.rb').to_s]).to eq(
         'test_process'
-      assembled_hash[File.join(fixtures_path, 'definitions', 'nested_folder', 'test_nested_process.rb').to_s].should ==
+      )
+      expect(assembled_hash[File.join(fixtures_path, 'definitions', 'nested_folder', 'test_nested_process.rb').to_s]).to eq(
         'test_nested_process'
+      )
     end
 
     it "camelizes names if :camelize option is true " do
       path = File.join(fixtures_path, 'definitions')
       assembled_hash = described_class.all_files(test_directory, :camelize => true)
 
-      assembled_hash[File.join(fixtures_path, 'definitions', 'test_process.rb').to_s].should ==
+      expect(assembled_hash[File.join(fixtures_path, 'definitions', 'test_process.rb').to_s]).to eq(
         'TestProcess'
-      assembled_hash[File.join(fixtures_path, 'definitions', 'nested_folder', 'test_nested_process.rb').to_s].should ==
+      )
+      expect(assembled_hash[File.join(fixtures_path, 'definitions', 'nested_folder', 'test_nested_process.rb').to_s]).to eq(
         'TestNestedProcess'
+      )
     end
   end
 
@@ -46,11 +50,11 @@ describe Bumbleworks::Support do
     end
 
     it 'returns value of constant with given name' do
-      described_class.constantize('Whatever')::Smoothies.should == 'tasty'
+      expect(described_class.constantize('Whatever')::Smoothies).to eq('tasty')
     end
 
     it 'works with nested constants' do
-      described_class.constantize('Whatever::Smoothies').should == 'tasty'
+      expect(described_class.constantize('Whatever::Smoothies')).to eq('tasty')
     end
 
     it 'does not check inheritance tree' do
@@ -62,51 +66,51 @@ describe Bumbleworks::Support do
 
   describe '.tokenize' do
     it 'creates snake_case version of string' do
-      described_class.tokenize('Albus Dumbledore & his_friend').should == 'albus_dumbledore_and_his_friend'
+      expect(described_class.tokenize('Albus Dumbledore & his_friend')).to eq('albus_dumbledore_and_his_friend')
     end
 
     it 'uncamelizes' do
-      described_class.tokenize('thisStrangeJavalikeWord').should == 'this_strange_javalike_word'
+      expect(described_class.tokenize('thisStrangeJavalikeWord')).to eq('this_strange_javalike_word')
     end
 
     it 'returns nil if given nil' do
-      described_class.tokenize(nil).should be_nil
+      expect(described_class.tokenize(nil)).to be_nil
     end
 
     it 'also handles symbols' do
-      described_class.tokenize(:yourFaceIsNice).should == 'your_face_is_nice'
+      expect(described_class.tokenize(:yourFaceIsNice)).to eq('your_face_is_nice')
     end
   end
 
   describe '.humanize' do
     it 'creates humanized version of snaky string' do
-      described_class.humanize('mops_are_so_moppy').should == 'Mops are so moppy'
+      expect(described_class.humanize('mops_are_so_moppy')).to eq('Mops are so moppy')
     end
 
     it 'created humanized version of camely string' do
-      described_class.humanize('thisStrangeJavalikeWord').should == 'This strange javalike word'
+      expect(described_class.humanize('thisStrangeJavalikeWord')).to eq('This strange javalike word')
     end
 
     it 'returns nil if given nil' do
-      described_class.humanize(nil).should be_nil
+      expect(described_class.humanize(nil)).to be_nil
     end
   end
 
   describe '.titleize' do
     it 'creates titleized version of snaky string' do
-      described_class.titleize('mops_are_so_moppy').should == 'Mops Are So Moppy'
+      expect(described_class.titleize('mops_are_so_moppy')).to eq('Mops Are So Moppy')
     end
 
     it 'created titleized version of camely string' do
-      described_class.titleize('thisStrangeJavalikeWord').should == 'This Strange Javalike Word'
+      expect(described_class.titleize('thisStrangeJavalikeWord')).to eq('This Strange Javalike Word')
     end
 
     it 'created titleized version of humany string' do
-      described_class.titleize('You are a wonderful toothbrush').should == 'You Are A Wonderful Toothbrush'
+      expect(described_class.titleize('You are a wonderful toothbrush')).to eq('You Are A Wonderful Toothbrush')
     end
 
     it 'returns nil if given nil' do
-      described_class.titleize(nil).should be_nil
+      expect(described_class.titleize(nil)).to be_nil
     end
   end
 end

data/spec/lib/bumbleworks/task/finder_spec.rb

@@ -28,11 +28,11 @@ describe Bumbleworks::Task::Finder do
       finder = subject.add_query { |wi|
         wi['fields']['params']['task'] != 'pet_dog'
       }
-      finder.map(&:nickname).should =~ [
+      expect(finder.map(&:nickname)).to match_array([
         'eat',
         'bark',
         'skip_and_jump'
-      ]
+      ])
     end
   end
 
@@ -43,11 +43,11 @@ describe Bumbleworks::Task::Finder do
       finder = subject.add_filter { |task|
         task.nickname != 'pet_dog'
       }
-      finder.map(&:nickname).should =~ [
+      expect(finder.map(&:nickname)).to match_array([
         'eat',
         'bark',
         'skip_and_jump'
-      ]
+      ])
     end
   end
 
@@ -58,9 +58,9 @@ describe Bumbleworks::Task::Finder do
       finder = subject.add_subfinder(
         Bumbleworks::Task::Finder.new.for_role(:cat)
       )
-      finder.map(&:nickname).should =~ [
+      expect(finder.map(&:nickname)).to match_array([
         'skip_and_jump'
-      ]
+      ])
     end
   end
 
@@ -69,7 +69,7 @@ describe Bumbleworks::Task::Finder do
       Bumbleworks.launch!('dog-lifecycle')
       Bumbleworks.dashboard.wait_for(:cat)
       tasks = subject.all
-      tasks.should be_all { |t| t.class == Bumbleworks::Task }
+      expect(tasks).to be_all { |t| t.class == Bumbleworks::Task }
     end
 
     it 'uses provided class for task generation' do
@@ -77,31 +77,31 @@ describe Bumbleworks::Task::Finder do
       Bumbleworks.launch!('dog-lifecycle')
       Bumbleworks.dashboard.wait_for(:cat)
       tasks = described_class.new(MyOwnTask).all
-      tasks.should be_all { |t| t.class == MyOwnTask }
+      expect(tasks).to be_all { |t| t.class == MyOwnTask }
       Object.send(:remove_const, :MyOwnTask)
     end
   end
 
   describe '#available' do
     it 'adds both unclaimed and completable filters' do
-      subject.should_receive(:where_all).with(:unclaimed => true, :completable => true).and_return(subject)
+      expect(subject).to receive(:where_all).with(:unclaimed => true, :completable => true).and_return(subject)
       subject.available
     end
 
     it 'adds OR-ed claimed and not-completable filters if passed false' do
-      subject.should_receive(:where_any).with(:claimed => true, :completable => false).and_return(subject)
+      expect(subject).to receive(:where_any).with(:claimed => true, :completable => false).and_return(subject)
       subject.available(false)
     end
   end
 
   describe '#unavailable' do
     it 'checks if not available' do
-      subject.should_receive(:available).with(false).and_return(subject)
+      expect(subject).to receive(:available).with(false).and_return(subject)
       subject.unavailable
     end
 
     it 'checks if available when passed false' do
-      subject.should_receive(:available).with(true).and_return(subject)
+      expect(subject).to receive(:available).with(true).and_return(subject)
       subject.unavailable(false)
     end
   end
@@ -109,12 +109,12 @@ describe Bumbleworks::Task::Finder do
   [:all, :any].each do |join_type|
     describe "#where_#{join_type}" do
       it "sets join to #{join_type} if no args" do
-        subject.should_receive(:join=).with(join_type)
+        expect(subject).to receive(:join=).with(join_type)
         subject.send(:"where_#{join_type}")
       end
 
       it "calls where with :#{join_type} type if args" do
-        subject.should_receive(:where).with(:filters, join_type)
+        expect(subject).to receive(:where).with(:filters, join_type)
         subject.send(:"where_#{join_type}", :filters)
       end
     end
@@ -124,22 +124,22 @@ describe Bumbleworks::Task::Finder do
     it 'creates a new finder and adds it to queries, when join type mismatch' do
       parent = described_class.new(:dummy_task_class).where_all
       child = described_class.new
-      described_class.stub(:new).with(:dummy_task_class).and_return(child)
-      child.should_receive(:where_any)
-      child.should_receive(:available).and_return(child)
-      child.should_receive(:unavailable).and_return(child)
-      child.should_receive(:by_nickname).with(:nicholas).and_return(child)
-      child.should_receive(:for_roles).with([:dinner, :barca]).and_return(child)
-      child.should_receive(:unclaimed).and_return(child)
-      child.should_receive(:claimed).and_return(child)
-      child.should_receive(:for_claimant).with(:dr_clam).and_return(child)
-      child.should_receive(:for_entity).with(:a_luffly_pirate).and_return(child)
-      child.should_receive(:for_processes).with([:jasmine, :mulan]).and_return(child)
-      child.should_receive(:completable).with(true).and_return(child)
-      child.should_receive(:with_fields).with(:horse => :giant_pony).and_return(child)
-      child.should_receive(:with_fields).with(:pie => :silly_cake).and_return(child)
-      parent.should_receive(:add_subfinder).with(child).and_return(parent)
-      parent.where({
+      allow(described_class).to receive(:new).with(:dummy_task_class).and_return(child)
+      expect(child).to receive(:where_any)
+      expect(child).to receive(:available).and_return(child)
+      expect(child).to receive(:unavailable).and_return(child)
+      expect(child).to receive(:by_nickname).with(:nicholas).and_return(child)
+      expect(child).to receive(:for_roles).with([:dinner, :barca]).and_return(child)
+      expect(child).to receive(:unclaimed).and_return(child)
+      expect(child).to receive(:claimed).and_return(child)
+      expect(child).to receive(:for_claimant).with(:dr_clam).and_return(child)
+      expect(child).to receive(:for_entity).with(:a_luffly_pirate).and_return(child)
+      expect(child).to receive(:for_processes).with([:jasmine, :mulan]).and_return(child)
+      expect(child).to receive(:completable).with(true).and_return(child)
+      expect(child).to receive(:with_fields).with(:horse => :giant_pony).and_return(child)
+      expect(child).to receive(:with_fields).with(:pie => :silly_cake).and_return(child)
+      expect(parent).to receive(:add_subfinder).with(child).and_return(parent)
+      expect(parent.where({
         :available => true,
         :unavailable => true,
         :nickname => :nicholas,
@@ -152,24 +152,24 @@ describe Bumbleworks::Task::Finder do
         :completable => true,
         :horse => :giant_pony,
         :pie => :silly_cake
-      }, :any).should == parent
+      }, :any)).to eq parent
     end
 
     it 'adds queries to current finder, when join type matches' do
-      subject.should_receive(:available).and_return(subject)
-      subject.should_receive(:unavailable).and_return(subject)
-      subject.should_receive(:by_nickname).with(:nicholas).and_return(subject)
-      subject.should_receive(:for_roles).with([:dinner, :barca]).and_return(subject)
-      subject.should_receive(:unclaimed).and_return(subject)
-      subject.should_receive(:claimed).and_return(subject)
-      subject.should_receive(:for_claimant).with(:dr_clam).and_return(subject)
-      subject.should_receive(:for_entity).with(:a_luffly_pirate).and_return(subject)
-      subject.should_receive(:for_processes).with([:jasmine, :mulan]).and_return(subject)
-      subject.should_receive(:completable).with(true).and_return(subject)
-      subject.should_receive(:with_fields).with(:horse => :giant_pony).and_return(subject)
-      subject.should_receive(:with_fields).with(:pie => :silly_cake).and_return(subject)
-      subject.should_receive(:add_subfinder).never
-      subject.where({
+      expect(subject).to receive(:available).and_return(subject)
+      expect(subject).to receive(:unavailable).and_return(subject)
+      expect(subject).to receive(:by_nickname).with(:nicholas).and_return(subject)
+      expect(subject).to receive(:for_roles).with([:dinner, :barca]).and_return(subject)
+      expect(subject).to receive(:unclaimed).and_return(subject)
+      expect(subject).to receive(:claimed).and_return(subject)
+      expect(subject).to receive(:for_claimant).with(:dr_clam).and_return(subject)
+      expect(subject).to receive(:for_entity).with(:a_luffly_pirate).and_return(subject)
+      expect(subject).to receive(:for_processes).with([:jasmine, :mulan]).and_return(subject)
+      expect(subject).to receive(:completable).with(true).and_return(subject)
+      expect(subject).to receive(:with_fields).with(:horse => :giant_pony).and_return(subject)
+      expect(subject).to receive(:with_fields).with(:pie => :silly_cake).and_return(subject)
+      expect(subject).to receive(:add_subfinder).never
+      expect(subject.where({
         :available => true,
         :unavailable => true,
         :nickname => :nicholas,
@@ -182,7 +182,7 @@ describe Bumbleworks::Task::Finder do
         :completable => true,
         :horse => :giant_pony,
         :pie => :silly_cake
-      }).should == subject
+      })).to eq subject
     end
   end
 end