bumbleworks 0.0.4

data/spec/lib/bumbleworks/storage_adapter_spec.rb

@@ -0,0 +1,41 @@
+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
+    end
+
+    it 'returns false if auto_register is not true' do
+      described_class.auto_register = :ghosts
+      described_class.auto_register?.should be_false
+    end
+
+    it 'is true by default' do
+      described_class.auto_register = nil
+      described_class.auto_register?.should be_true
+    end
+  end
+
+  describe '.display_name' do
+    it 'is a subclass responsibility' do
+      expect { described_class.display_name }.to raise_error
+    end
+  end
+
+  describe '.driver' do
+    it 'is a subclass responsibility' do
+      expect { described_class.driver }.to raise_error
+    end
+  end
+
+  describe '.use?' do
+    before :each do
+      described_class.stub(:display_name).and_return('String')
+    end
+
+    it 'returns true if argument class name matches display name' do
+      described_class.use?('a string').should be_true
+      described_class.use?(:not_a_string).should be_false
+    end
+  end
+end

data/spec/lib/bumbleworks/support_spec.rb

@@ -0,0 +1,40 @@
+describe Bumbleworks::Support do
+  describe '.camelize' do
+    it 'turns underscored string into camelcase' do
+      described_class.camelize('foo_bar_One_two_3').should == 'FooBarOneTwo3'
+    end
+
+    it 'deals with nested classes' do
+      described_class.camelize('foo_bar/bar_foo').should == 'FooBar::BarFoo'
+    end
+  end
+
+  describe ".all_files" do
+    let(:test_directory) { File.join(fixtures_path, 'definitions').to_s }
+
+    it "for given directory, yields given block with path and name params" do
+      assembled_hash = {}
+      described_class.all_files(test_directory) do |path, name|
+        assembled_hash[name] = path
+      end
+
+      assembled_hash['test_process'].should ==
+        File.join(fixtures_path, 'definitions', 'test_process.rb').to_s
+      assembled_hash['test_nested_process'].should ==
+        File.join(fixtures_path, 'definitions', 'nested_folder', 'test_nested_process.rb').to_s
+    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) do |path, name|
+        assembled_hash[name] = path
+      end
+
+      assembled_hash['TestProcess'].should ==
+        File.join(fixtures_path, 'definitions', 'test_process.rb').to_s
+      assembled_hash['TestNestedProcess'].should ==
+        File.join(fixtures_path, 'definitions', 'nested_folder', 'test_nested_process.rb').to_s
+    end
+  end
+end

data/spec/lib/bumbleworks/task_spec.rb

@@ -0,0 +1,274 @@
+describe Bumbleworks::Task do
+  let(:workflow_item) {Ruote::Workitem.new('fields' => {'params' => {'task' => 'go_to_work'} })}
+
+  before :each do
+    Bumbleworks.reset!
+    Bumbleworks.autostart_worker = true
+    Bumbleworks.storage = {}
+    Bumbleworks::Ruote.register_participants
+  end
+
+  describe '.new' do
+    it 'raises an error if workitem is nil' do
+      expect {
+        described_class.new(nil)
+      }.to raise_error(ArgumentError, "Not a valid workitem")
+    end
+
+    it 'raises an error if workitem not a Ruote::Workitem' do
+      expect {
+        described_class.new('a string!')
+      }.to raise_error(ArgumentError, "Not a valid workitem")
+    end
+
+    it 'succeeds when given workitem' do
+      expect {
+        described_class.new(workflow_item)
+      }.not_to raise_error
+    end
+  end
+
+  describe '#id' do
+    it 'returns the sid from the workitem' do
+      workflow_item.stub(:sid).and_return(:an_exciting_id)
+      described_class.new(workflow_item).id.should == :an_exciting_id
+    end
+  end
+
+  describe '.find_by_id' do
+    it 'returns the task for the given id' do
+      Bumbleworks.define_process 'planting_a_noodle' do
+        concurrence do
+          noodle_gardener :task => 'plant_noodle_seed'
+          horse_feeder :task => 'give_the_horse_a_bon_bon'
+        end
+      end
+      Bumbleworks.launch!('planting_a_noodle')
+      Bumbleworks.dashboard.wait_for(:horse_feeder)
+      plant_noodle_seed_task = described_class.for_role('noodle_gardener').first
+      give_the_horse_a_bon_bon_task = described_class.for_role('horse_feeder').first
+
+      # checking for equality by comparing sid, which is the flow expression id
+      # that identifies not only the expression, but its instance
+      described_class.find_by_id(plant_noodle_seed_task.id).sid.should ==
+        plant_noodle_seed_task.sid
+      described_class.find_by_id(give_the_horse_a_bon_bon_task.id).sid.should ==
+        give_the_horse_a_bon_bon_task.sid
+    end
+
+    it 'raises an error if id is nil' do
+      expect {
+        described_class.find_by_id(nil)
+      }.to raise_error(described_class::MissingWorkitem)
+    end
+
+    it 'raises an error if workitem not found for given id' do
+      expect {
+        described_class.find_by_id('asdfasdf')
+      }.to raise_error(described_class::MissingWorkitem)
+    end
+
+    it 'raises an error if id is unparseable by storage participant' do
+      expect {
+        described_class.find_by_id(:unparseable_because_i_am_a_symbol)
+      }.to raise_error(described_class::MissingWorkitem)
+    end
+  end
+
+  describe '.for_roles' do
+    before :each do
+      Bumbleworks.define_process 'lowering_penguin_self_esteem' do
+        concurrence do
+          heckler :task => 'comment_on_dancing_ability'
+          mother :oh_no => 'this_is_not_a_task'
+          mother :task => 'ignore_pleas_for_attention'
+          father :task => 'sit_around_watching_penguin_tv'
+        end
+      end
+      Bumbleworks.launch!('lowering_penguin_self_esteem')
+    end
+
+    it 'returns tasks for all given roles' do
+      Bumbleworks.dashboard.wait_for(:father)
+      tasks = described_class.for_roles(['heckler', 'mother'])
+      tasks.should have(2).items
+      tasks.map(&:nickname).should == [
+        'comment_on_dancing_ability',
+        'ignore_pleas_for_attention'
+      ]
+    end
+
+    it 'returns empty array if no tasks found for given roles' do
+      Bumbleworks.dashboard.wait_for(:father)
+      described_class.for_roles(['elephant']).should be_empty
+    end
+
+    it 'returns empty array if given empty array' do
+      Bumbleworks.dashboard.wait_for(:father)
+      described_class.for_roles([]).should be_empty
+    end
+
+    it 'returns empty array if given nil' do
+      Bumbleworks.dashboard.wait_for(:father)
+      described_class.for_roles(nil).should be_empty
+    end
+  end
+
+  describe '.for_role' do
+    it 'delegates to #for_roles with single-item array' do
+      described_class.should_receive(:for_roles).with(['mister_mystery'])
+      described_class.for_role('mister_mystery')
+    end
+  end
+
+  describe '.all' do
+    before :each do
+      Bumbleworks.define_process 'dog-lifecycle' do
+        concurrence do
+          dog_teeth :task => 'eat'
+          dog_mouth :task => 'bark'
+          everyone :task => 'pet_dog'
+          the_universe_is_wonderful
+          dog_legs :task => 'skip_and_jump'
+        end
+        dog_brain :task => 'nap'
+      end
+      Bumbleworks.launch!('dog-lifecycle')
+    end
+
+    it 'returns all tasks (with task param) in queue regardless of role' do
+      Bumbleworks.dashboard.wait_for(:dog_legs)
+      tasks = described_class.all
+      tasks.should have(4).items
+      tasks.map { |t| [t.role, t.nickname] }.should == [
+        ['dog_teeth', 'eat'],
+        ['dog_mouth', 'bark'],
+        ['everyone', 'pet_dog'],
+        ['dog_legs', 'skip_and_jump']
+      ]
+    end
+  end
+
+  describe '#[], #[]=' do
+    subject{described_class.new(workflow_item)}
+    it 'sets values on workitem fields' do
+      subject['hive'] = 'bees at work'
+      workflow_item.fields['hive'].should == 'bees at work'
+    end
+
+    it 'retuns value from workitem params' do
+      workflow_item.fields['nest'] = 'queen resting'
+      subject['nest'].should == 'queen resting'
+    end
+  end
+
+  describe '#nickname' do
+    it 'returns the "task" param' do
+      described_class.new(workflow_item).nickname.should == 'go_to_work'
+    end
+
+    it 'is immutable; cannot be changed by modified the param' do
+      task = described_class.new(workflow_item)
+      task.nickname.should == 'go_to_work'
+      task.params['task'] = 'what_is_wrong_with_you?'
+      task.nickname.should == 'go_to_work'
+    end
+  end
+
+  describe '#role' do
+    it 'returns the workitem participant_name' do
+      Bumbleworks.define_process 'planting_a_noodle' do
+        noodle_gardener :task => 'plant_noodle_seed'
+      end
+      Bumbleworks.launch!('planting_a_noodle')
+      Bumbleworks.dashboard.wait_for(:noodle_gardener)
+      described_class.all.first.role.should == 'noodle_gardener'
+    end
+  end
+
+  context 'claiming things' do
+    subject{described_class.new(workflow_item)}
+    before :each do
+      subject.stub(:save)
+      workflow_item.params['claimant'] = nil
+      subject.claim('boss')
+    end
+
+    describe '#claim' do
+      it 'sets token on  "claimant" param' do
+        workflow_item.params['claimant'].should == 'boss'
+      end
+
+      it 'raises an error if already claimed by someone else' do
+        expect{subject.claim('peon')}.to raise_error described_class::AlreadyClaimed
+      end
+
+      it 'does not raise an error if attempting to claim by same token' do
+        expect{subject.claim('boss')}.not_to raise_error described_class::AlreadyClaimed
+      end
+    end
+
+    describe '#claimant' do
+      it 'returns token of who has claim' do
+        subject.claimant.should == 'boss'
+      end
+    end
+
+    describe '#claimed?' do
+      it 'returns true if claimed' do
+        subject.claimed?.should be_true
+      end
+
+      it 'false otherwise' do
+        workflow_item.params['claimant'] = nil
+        subject.claimed?.should be_false
+      end
+    end
+
+    describe '#release' do
+      it "release claim on workitem" do
+        subject.should be_claimed
+        subject.release
+        subject.should_not be_claimed
+      end
+    end
+  end
+
+  context 'updating workflow engine' do
+    before :each do
+      Bumbleworks.define_process 'dog-lifecycle' do
+        dog_mouth :task => 'eat_dinner', :state => 'still cooking'
+        dog_brain :task => 'cat_nap', :by => 'midnight'
+      end
+      Bumbleworks.launch!('dog-lifecycle')
+    end
+
+    describe '#save' do
+      it 'saves fields and params, but does not proceed process' do
+        event = Bumbleworks.dashboard.wait_for :dog_mouth
+        task = described_class.for_role('dog_mouth').first
+        task.params['state'] = 'is ready'
+        task.fields['meal'] = 'salted_rhubarb'
+        task.save
+        task = described_class.for_role('dog_mouth').first
+        task.params['state'].should == 'is ready'
+        task.fields['meal'].should == 'salted_rhubarb'
+      end
+    end
+
+    describe '#complete' do
+      it 'saves fields and proceeds to next expression' do
+        event = Bumbleworks.dashboard.wait_for :dog_mouth
+        task = described_class.for_role('dog_mouth').first
+        task.params['state'] = 'is ready'
+        task.fields['meal'] = 'root beer and a kite'
+        task.complete
+        described_class.for_role('dog_mouth').should be_empty
+        event = Bumbleworks.dashboard.wait_for :dog_brain
+        task = described_class.for_role('dog_brain').first
+        task.params['state'].should be_nil
+        task.fields['meal'].should == 'root beer and a kite'
+      end
+    end
+  end
+end

data/spec/lib/bumbleworks/tree_builder_spec.rb

@@ -0,0 +1,95 @@
+describe Bumbleworks::TreeBuilder do
+  describe '.new' do
+    it 'raises error if no definition or tree' do
+      expect { described_class.new }.to raise_error(ArgumentError)
+    end
+
+    it 'raises error if both definition and tree' do
+      expect {
+        described_class.new(:definition => :foo, :tree => :bar)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'succeeds if only one of definition or tree specified' do
+      expect { described_class.new(:definition => :foo) }.not_to raise_error
+      expect { described_class.new(:tree => :foo) }.not_to raise_error
+    end
+  end
+
+  describe '#build!' do
+    it 'builds tree and sets name to given name' do
+      pdef = %q(
+        Bumbleworks.define_process do
+          order_pants_around
+        end
+      )
+      builder = described_class.new(:name => 'luigi', :definition => pdef)
+      builder.build!.should == [
+        "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 == 
+        ["define", {"name" => "guppies"}, [["swim", {}, []]]]
+    end
+
+    it 'normalizes and sets name from tree' do
+      pdef = %q(
+        Bumbleworks.define_process 'country_time_county_dime' do
+          do_the_fig_newton
+        end
+      )
+      builder = described_class.new(:definition => pdef)
+      builder.build!.should == [
+        "define", {"name" => "country_time_county_dime"},
+        [
+          ["do_the_fig_newton", {}, []]
+        ]
+      ]
+    end
+
+    it 'raises error if name conflicts with name in definition' do
+      pdef = %q(
+        Bumbleworks.define_process :name => 'stromboli' do
+          order_pants_around
+        end
+      )
+      builder = described_class.new(:name => 'contorti', :definition => pdef)
+      expect {
+        builder.build!
+      }.to raise_error(described_class::InvalidTree, "Name does not match name in definition" )
+    end
+
+    it 'raises error if process is unparseable' do
+      pdef = "A quiet evening with the deaf lemurs"
+      builder = described_class.new(:name => 'lemur_joy', :definition => pdef)
+      expect {
+        builder.build!
+      }.to raise_error(described_class::InvalidTree, "cannot read process definition" )
+    end
+  end
+
+  describe '.from_definition' do
+    it 'instantiates a TreeBuilder from a given block' do
+      builder = described_class.from_definition 'just_another_poodle_day' do
+        chew :on => 'dad'
+        construct :solution => 'to world conflict'
+      end
+      builder.build!
+      builder.tree.should ==
+        ["define", { "name" => "just_another_poodle_day" },
+          [
+            ["chew", {"on" => "dad"}, []],
+            ["construct", {"solution" => "to world conflict"}, []]
+          ]
+        ]
+      builder.name.should == 'just_another_poodle_day'
+    end
+  end
+end