bumbleworks 0.0.48 → 0.0.50

data/lib/bumbleworks/version.rb

@@ -1,3 +1,3 @@
 module Bumbleworks
-  VERSION = "0.0.48"
+  VERSION = "0.0.50"
 end

data/spec/fixtures/entities/furby.rb

@@ -0,0 +1,30 @@
+class Furby
+  include Bumbleworks::Entity
+
+  process :make_honey
+
+  attr_reader :identifier
+  attr_accessor :make_honey_process_identifier
+
+  def initialize(identifier)
+    @identifier = identifier
+  end
+
+  def ==(other)
+    other.identifier == identifier
+  end
+
+  def update(attributes)
+    attributes.each { |k, v| self.send(:"#{k}=", v) }
+  end
+
+  def cook_it_up(*foods)
+    foods.join(' and ')
+  end
+
+  class << self
+    def first_by_identifier(identifier)
+      new(identifier)
+    end
+  end
+end

data/spec/integration/entity_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.join(fixtures_path, 'entities', 'furby'))
+
+describe 'Entity Module' do
+  let(:app_root) {
+    File.expand_path(File.join(fixtures_path, 'apps', 'with_default_directories'))
+  }
+
+  before :each do
+    Bumbleworks.reset!
+    load File.join(app_root, 'full_initializer.rb')
+  end
+
+  describe 'launching a process' do
+    it 'assigns entity to process and subsequent tasks' do
+      furby = Furby.new('12345')
+      furby.launch_process(:make_honey)
+      Bumbleworks.dashboard.wait_for(:dave)
+      task = Bumbleworks::Task.for_role('dave').first
+      task.entity.should == furby
+    end
+
+    it 'links processes with identifiers' do
+      furby = Furby.new('12345')
+      process = furby.launch_process(:make_honey)
+      furby.processes_by_name.should == {
+        :make_honey => process
+      }
+    end
+
+    it 'persists process identifier' do
+      furby = Furby.new('12345')
+      process = furby.launch_process(:make_honey)
+      furby.make_honey_process_identifier.should == process.wfid
+    end
+  end
+
+  describe 'using the entity interactor participant' do
+    it 'calls a method on the entity' do
+      Bumbleworks.define_process 'here_we_go' do
+        tell_entity :to => 'cook_it_up', :with => [2, 'orange'], :and_save_as => 'yum'
+        critic :task => 'checkit_that_foods'
+      end
+      furby = Furby.new('12345')
+      process = Bumbleworks.launch!('here_we_go', :entity => furby)
+      Bumbleworks.dashboard.wait_for(:critic)
+      process.tasks.first['yum'].should == "2 and orange"
+    end
+  end
+end

data/spec/integration/history_storage_spec.rb

@@ -25,10 +25,10 @@ describe 'History storage' do
 
     it 'keeps history of messages' do
       Bumbleworks::Ruote.storage.get_many('history').should be_empty
-      wfid = Bumbleworks.launch!('make_honey')
+      process = Bumbleworks.launch!('make_honey')
       Bumbleworks.dashboard.wait_for(:dave)
       Bumbleworks::Ruote.storage.get_many('history').should_not be_empty
-      Bumbleworks.dashboard.history.wfids.should include(wfid)
+      Bumbleworks.dashboard.history.wfids.should include(process.wfid)
     end
   end
 
@@ -43,10 +43,10 @@ describe 'History storage' do
 
     it 'keeps history of messages' do
       Bumbleworks.dashboard.history.all.should be_empty
-      wfid = Bumbleworks.launch!('make_honey')
+      process = Bumbleworks.launch!('make_honey')
       Bumbleworks.dashboard.wait_for(:dave)
       Bumbleworks.dashboard.history.all.should_not be_empty
-      Bumbleworks.dashboard.history.wfids.should include(wfid)
+      Bumbleworks.dashboard.history.wfids.should include(process.wfid)
     end
   end
 end

data/spec/integration/sample_application_spec.rb

@@ -10,8 +10,14 @@ describe 'Bumbleworks Sample Application' do
 
   describe 'initializer' do
     it 'registers participants' do
-      Bumbleworks.dashboard.participant_list.should have(4).items
-      Bumbleworks.dashboard.participant_list.map(&:classname).should =~ ['HoneyParticipant', 'MolassesParticipant', 'Bumbleworks::ErrorHandlerParticipant', 'Bumbleworks::StorageParticipant']
+      Bumbleworks.dashboard.participant_list.should have(5).items
+      Bumbleworks.dashboard.participant_list.map(&:classname).should == [
+        'Bumbleworks::Participant::ErrorHandler',
+        'Bumbleworks::Participant::EntityInteractor',
+        'HoneyParticipant',
+        'MolassesParticipant',
+        'Bumbleworks::Participant::StorageParticipant'
+      ]
     end
 
     it 'loads process definitions' do

data/spec/lib/bumbleworks/entity_spec.rb

@@ -0,0 +1,208 @@
+describe Bumbleworks::Entity do
+  let(:entity_class) { Class.new { include Bumbleworks::Entity } }
+
+  describe '#processes_by_name' do
+    it 'returns hash of process names and process instances' do
+      [:zoom, :foof, :nook].each do |pname|
+        entity_class.send(:attr_accessor, :"#{pname}_pid")
+        entity_class.process pname, :column => :"#{pname}_pid"
+      end
+
+      entity = entity_class.new
+      entity.foof_pid = '1234'
+      entity.nook_pid = 'pickles'
+      entity.processes_by_name.should == {
+        :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 == {}
+    end
+  end
+
+  describe '#processes' do
+    it 'returns array of process instances for all running processes' do
+      [:zoom, :foof, :nook].each do |pname|
+        entity_class.send(:attr_accessor, :"#{pname}_pid")
+        entity_class.process pname, :column => :"#{pname}_pid"
+      end
+      entity = entity_class.new
+      entity.foof_pid = '1234'
+      entity.nook_pid = 'pickles'
+      entity.processes.should =~ [
+        Bumbleworks::Process.new('1234'),
+        Bumbleworks::Process.new('pickles')
+      ]
+    end
+
+    it 'returns empty array if no processes' do
+      entity_class.new.processes.should == []
+    end
+  end
+
+  describe '#cancel_all_processes!' do
+    it 'cancels all processes with registered identifiers' do
+      entity = entity_class.new
+      bp1 = Bumbleworks::Process.new('1234')
+      bp2 = Bumbleworks::Process.new('pickles')
+      entity.stub(:processes).and_return([bp1, bp2])
+      bp1.should_receive(:cancel!)
+      bp2.should_receive(:cancel!)
+      entity.cancel_all_processes!
+    end
+  end
+
+  describe '#process_fields' do
+    it 'returns hash with entity' do
+      entity = entity_class.new
+      entity.process_fields.should == { :entity => entity }
+    end
+
+    it 'accepts but ignores process name argument' do
+      entity = entity_class.new
+      entity.process_fields('ignore_me').should == { :entity => entity }
+    end
+  end
+
+  describe '#process_variables' do
+    it 'returns empty hash' do
+      entity_class.new.process_variables.should == {}
+    end
+
+    it 'accepts but ignores process name argument' do
+      entity_class.new.process_variables('ignore me').should == {}
+    end
+  end
+
+  describe '#persist_process_identifier' do
+    it 'calls #update if method exists' do
+      entity = entity_class.new
+      entity.should_receive(:update).with(:a_column => :a_value)
+      entity.persist_process_identifier(:a_column, :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_column, :a_value)
+      }.to raise_error("Entity must define #persist_process_identifier method if missing #update method.")
+    end
+  end
+
+  describe '#launch_process' do
+    it 'launches process and return process if identifier not set' do
+      bp = Bumbleworks::Process.new('12345')
+      entity_class.process :noodles, :column => :noodles_pid
+      entity = entity_class.new
+      entity.stub(:noodles_pid)
+      entity.stub(:process_fields).with(:noodles).and_return('the_fields')
+      entity.stub(:process_variables).with(:noodles).and_return('the_variables')
+      Bumbleworks.stub(:launch!).with('noodles', 'the_fields', 'the_variables').and_return(bp)
+      entity.should_receive(:persist_process_identifier).with(:noodles_pid, '12345')
+      entity.launch_process('noodles').should == bp
+    end
+
+    it 'does nothing but returns existing process if identifier column already set' do
+      bp = Bumbleworks::Process.new('already set')
+      entity_class.process :noodles, :column => :noodles_pid
+      entity = entity_class.new
+      entity.stub(:noodles_pid => 'already set')
+      Bumbleworks.should_receive(:launch!).never
+      entity.launch_process('noodles').should == bp
+    end
+
+    it 'launches new process anyway if identifier column already set but force is true' do
+      bp = Bumbleworks::Process.new('12345')
+      entity_class.process :noodles, :column => :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
+    end
+  end
+
+  describe '#subscribed_events' do
+    it 'returns aggregate of subscribed events from all processes' 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({
+        :zip => bp1,
+        :yip => bp2
+      })
+      entity.subscribed_events.should =~ ['chewing', 'moon', 'popping', 'yakking']
+    end
+  end
+
+  describe '#is_waiting_for?' do
+    it 'returns true if any processes are waiting for event' 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({
+        :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
+    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
+    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
+    end
+  end
+
+  describe '.process' do
+    it 'registers a new process' do
+      entity_class.stub(:process_identifier_column).with(:whatever).and_return('loob')
+      entity_class.process :whatever
+      entity_class.processes.should == {
+        :whatever => {
+          :column => 'loob'
+        }
+      }
+    end
+  end
+
+  describe '.process_identifier_column' do
+    it 'adds _process_identifier to end of given process name' do
+      entity_class.process_identifier_column('zoof').should == :zoof_process_identifier
+    end
+
+    it 'ensures no duplication of _process' do
+      entity_class.process_identifier_column('zoof_process').should == :zoof_process_identifier
+    end
+
+    it 'removes entity_type from beginning of identifier' do
+      entity_class.stub(:entity_type).and_return('zoof')
+      entity_class.process_identifier_column('zoof_process').should == :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'
+    end
+  end
+end

data/spec/lib/bumbleworks/{participant_spec.rb → 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)
+describe Bumbleworks::Participant::Base do
+  it 'includes Bumbleworks::Participant::LocalParticipant' do
+    described_class.included_modules.should include(Bumbleworks::Participant::LocalParticipant)
   end
 
   it 'defines #on_cancel' do

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

@@ -0,0 +1,91 @@
+describe Bumbleworks::Participant::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 }
+
+  describe '#on_workitem' do
+    it 'calls method then replies' do
+      subject.should_receive(:call_method).ordered
+      subject.should_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'
+    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'
+    end
+
+    it 'calls the method even if no save_as to store the result' do
+      subject.entity.should_receive(:cheek_depth)
+      subject._on_workitem(workitem)
+      workitem.fields['entity_cheek_depth'].should 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')
+      subject._on_workitem(workitem)
+      workitem.fields['entity_cheek_depth'].should == 'what'
+    end
+
+    it 'can accept "with" for arguments' do
+      workitem.fields['params']['with'] = { :regular => 'joes' }
+      subject.entity.should_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')
+      subject._on_workitem(workitem)
+      workitem.fields['how_tasty'].should == '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)
+      subject._on_workitem(workitem)
+      workitem.fields['who_cares'].should 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)
+      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)
+      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'
+    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'
+    end
+
+    it 'raises an exception if no method on entity' do
+      subject.stub(:entity).and_return('just an unassuming little string!')
+      expect { 
+        subject.call_method('eat_television')
+      }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/lib/bumbleworks/{error_handler_participant_spec.rb → participant/error_handler_spec.rb}

@@ -1,4 +1,4 @@
-describe Bumbleworks::ErrorHandlerParticipant do
+describe Bumbleworks::Participant::ErrorHandler do
   describe '#on_workitem' do
     let(:workitem) { double('workitem') }
     let(:instances) { [double(:on_error => nil), double(:on_error => nil)] }