ruote 2.1.10 → 2.1.11

data/test/functional/ft_3_participant_registration.rb

@@ -7,6 +7,8 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
+require 'ruote'
+
 
 class FtParticipantRegistrationTest < Test::Unit::TestCase
   include FunctionalBase
@@ -28,6 +30,10 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
     assert_equal(
       [ 'inpa_:alpha' ],
       @engine.context.plist.instantiated_participants.collect { |e| e.first })
+
+    assert_equal(
+      [ [ '^alpha$', 'inpa_:alpha' ] ],
+      @engine.participant_list.collect { |pe| pe.to_a })
   end
 
   def test_double_registration
@@ -97,7 +103,7 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
 
   def test_participant_shutdown
 
-    alpha = @engine.register_participant :alpha, MyParticipant.new
+    alpha = @engine.register :alpha, MyParticipant.new
 
     @engine.context.plist.shutdown
 
@@ -109,7 +115,269 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
     pa = @engine.register_participant :alpha do |workitem|
     end
 
-    assert_equal ['^alpha$'], @engine.context.plist.names
+    assert_equal [ '^alpha$' ], @engine.context.plist.names
+  end
+
+  def test_register_require_path
+
+    rpath = File.join(
+      File.dirname(__FILE__), "#{Time.now.to_f}_#{$$}_required_participant")
+    path = "#{rpath}.rb"
+
+    File.open(path, 'wb') do |f|
+      f.write(%{
+        class RequiredParticipant
+          include Ruote::LocalParticipant
+          def initialize (opts)
+            @opts = opts
+          end
+          def consume (workitem)
+            workitem.fields['message'] = @opts['message']
+            reply(workitem)
+          end
+        end
+      })
+    end
+
+    @engine.register_participant(
+      :alfred,
+      'RequiredParticipant',
+      :require_path => rpath, :message => 'hello')
+
+    assert_equal [ '^alfred$' ], @engine.context.plist.names
+
+    # first run
+
+    assert_equal(
+      [ 'RequiredParticipant',
+        { 'require_path' => rpath, 'message' => 'hello' } ],
+      @engine.context.plist.lookup_info('alfred', nil))
+
+    wfid = @engine.launch(Ruote.define { alfred })
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'hello', r['workitem']['fields']['message']
+
+    # second run
+
+    File.open(path, 'wb') do |f|
+      f.write(%{
+        class RequiredParticipant
+          include Ruote::LocalParticipant
+          def initialize (opts)
+            @opts = opts
+          end
+          def consume (workitem)
+            workitem.fields['message'] = 'second run'
+            reply(workitem)
+          end
+        end
+      })
+    end
+
+    wfid = @engine.launch(Ruote.define { alfred })
+    r = @engine.wait_for(wfid)
+
+    # since it's a 'require', the code isn't reloaded
+
+    assert_equal 'hello', r['workitem']['fields']['message']
+
+    FileUtils.rm(path)
+  end
+
+  def test_reqister_load_path
+
+    path = File.join(
+      File.dirname(__FILE__), "#{Time.now.to_f}_#{$$}_loaded_participant.rb")
+
+    File.open(path, 'wb') do |f|
+      f.write(%{
+        class LoadedParticipant
+          include Ruote::LocalParticipant
+          def initialize (opts)
+            @opts = opts
+          end
+          def consume (workitem)
+            workitem.fields['message'] = @opts['message']
+            reply(workitem)
+          end
+        end
+      })
+    end
+
+    @engine.register_participant(
+      :alfred,
+      'LoadedParticipant',
+      :load_path => path, :message => 'bondzoi')
+
+    assert_equal [ '^alfred$' ], @engine.context.plist.names
+
+    # first run
+
+    assert_equal(
+      [ 'LoadedParticipant',
+        { 'load_path' => path, 'message' => 'bondzoi' } ],
+      @engine.context.plist.lookup_info('alfred', nil))
+
+    wfid = @engine.launch(Ruote.define { alfred })
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'bondzoi', r['workitem']['fields']['message']
+
+    # second run
+
+    File.open(path, 'wb') do |f|
+      f.write(%{
+        class LoadedParticipant
+          include Ruote::LocalParticipant
+          def initialize (opts)
+            @opts = opts
+          end
+          def consume (workitem)
+            workitem.fields['message'] = 'second run'
+            reply(workitem)
+          end
+        end
+      })
+    end
+
+    wfid = @engine.launch(Ruote.define { alfred })
+    r = @engine.wait_for(wfid)
+
+    # since it's a 'load', the code is reloaded
+
+    assert_equal 'second run', r['workitem']['fields']['message']
+
+    FileUtils.rm(path)
+  end
+
+  def test_participant_list
+
+    #noisy
+
+    @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    assert_equal(
+      [ '/^alpha$/ ==> Ruote::StorageParticipant {}' ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+
+    # launching a process with a missing participant
+
+    wfid = @engine.launch(Ruote.define { bravo })
+    @engine.wait_for(wfid)
+
+    assert_equal 1, @engine.process(wfid).errors.size
+
+    # fixing the error by updating the participant list
+
+    list = @engine.participant_list
+    list.first.regex = '^.+$' # instead of '^alpha$'
+    @engine.participant_list = list
+
+    # replay at error
+
+    @engine.replay_at_error(@engine.process(wfid).errors.first)
+    @engine.wait_for(:bravo)
+
+    # bravo should hold a workitem
+
+    assert_equal 1, @engine.storage_participant.size
+    assert_equal 'bravo', @engine.storage_participant.first.participant_name
+  end
+
+  def test_participant_list_update
+
+    @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    assert_equal(
+      [ '/^alpha$/ ==> Ruote::StorageParticipant {}' ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+
+    # 0
+
+    @engine.participant_list = [
+      { 'regex' => '^bravo$',
+        'classname' => 'Ruote::StorageParticipant',
+        'options' => {} },
+      { 'regex' => '^charly$',
+        'classname' => 'Ruote::StorageParticipant',
+        'options' => {} }
+    ]
+
+    assert_equal(
+      [
+        '/^bravo$/ ==> Ruote::StorageParticipant {}',
+        '/^charly$/ ==> Ruote::StorageParticipant {}'
+      ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+
+    # 1
+
+    @engine.participant_list = [
+      [ '^charly$', [ 'Ruote::StorageParticipant', {} ] ],
+      [ '^bravo$', [ 'Ruote::StorageParticipant', {} ] ]
+    ]
+
+    assert_equal(
+      [
+        '/^charly$/ ==> Ruote::StorageParticipant {}',
+        '/^bravo$/ ==> Ruote::StorageParticipant {}'
+      ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+
+    # 2
+
+    @engine.participant_list = [
+      [ '^delta$', Ruote::StorageParticipant, {} ],
+      [ '^echo$', 'Ruote::StorageParticipant', {} ]
+    ]
+
+    assert_equal(
+      [
+        '/^delta$/ ==> Ruote::StorageParticipant {}',
+        '/^echo$/ ==> Ruote::StorageParticipant {}'
+      ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+  end
+
+  class ParticipantCharlie; end
+
+  def test_register_block
+
+    @engine.register do
+      alpha 'Participants::Alpha', 'flavour' => 'vanilla'
+      participant 'bravo', 'Participants::Bravo', :flavour => 'peach'
+      participant 'charlie', 'Participants::Charlie'
+      catchall 'Participants::Zebda', 'flavour' => 'coconut'
+    end
+
+    assert_equal 4, @engine.participant_list.size
+
+    assert_equal(
+      %w[ ^alpha$ ^bravo$ ^charlie$ ^.+$ ],
+      @engine.participant_list.collect { |pe| pe.regex.to_s })
+
+    assert_equal(
+      %w[ Participants::Alpha
+          Participants::Bravo
+          Participants::Charlie
+          Participants::Zebda ],
+      @engine.participant_list.collect { |pe| pe.classname })
+
+    assert_equal(
+      %w[ vanilla peach nil coconut ],
+      @engine.participant_list.collect { |pe| pe.options['flavour'] || 'nil' })
+  end
+
+  def test_register_block_catchall_default
+
+    @engine.register do
+      catchall
+    end
+
+    assert_equal(
+      %w[ Ruote::StorageParticipant ],
+      @engine.participant_list.collect { |pe| pe.classname })
   end
 end
 

data/test/functional/ft_40_wait_logger.rb

@@ -0,0 +1,61 @@
+
+#
+# testing ruote
+#
+# Tue Apr 20 12:32:44 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/storage_participant'
+
+
+class FtWaitLoggerTest < Test::Unit::TestCase
+
+  def teardown
+
+    @engine.shutdown
+    @engine.context.storage.purge!
+  end
+
+  def test_wait_logger
+
+    @engine = Ruote::Engine.new(Ruote::Worker.new(determine_storage({})))
+
+    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    pdef = Ruote.process_definition { alpha }
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(:alpha)
+    assert_equal 'dispatch', r['action']
+
+    sp.reply(sp.first)
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+  end
+
+  def test_wait_logger_seen
+
+    @engine = Ruote::Engine.new(Ruote::Worker.new(determine_storage({})))
+
+    #@engine.noisy = true
+
+    pdef = Ruote.process_definition { }
+
+    wfid = @engine.launch(pdef)
+
+    sleep 1.400 # worst case is ruote-couch
+
+    assert_equal 2, @engine.context.logger.instance_variable_get(:@seen).size
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal 0, @engine.context.logger.instance_variable_get(:@seen).size
+  end
+end
+

data/test/functional/ft_42_storage_copy.rb

@@ -27,6 +27,8 @@ class FtStorageCopyTest < Test::Unit::TestCase
 
     wait_for(:alpha)
 
+    sleep 0.100 # making sure msgs have all been processed
+
     target = Ruote::HashStorage.new
     source = @engine.context.storage
 
@@ -53,6 +55,8 @@ class FtStorageCopyTest < Test::Unit::TestCase
 
     engine.wait_for(:alpha)
 
+    sleep 0.100 # making sure msgs have all been processed
+
     source = engine.context.storage
     target = @engine.context.storage
 

data/test/functional/{ft_40_participant_on_reply.rb → ft_43_participant_on_reply.rb}

@@ -41,6 +41,23 @@ class FtParticipantOnReplyTest < Test::Unit::TestCase
     assert_trace('hello', pdef)
   end
 
+  def test_instantiated_participant_on_reply
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo '${f:message}'
+      end
+    end
+
+    @engine.register_participant :alpha, MyParticipant.new(nil)
+      # instantiated participant :-(
+
+    #noisy
+
+    assert_trace('hello', pdef)
+  end
+
   class AwkwardParticipant
     include Ruote::LocalParticipant
     def initialize (opts)

data/test/functional/ft_44_var_participant.rb

@@ -0,0 +1,35 @@
+
+#
+# testing ruote
+#
+# Wed Jul 14 09:43:58 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtVarParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_var_participant
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:alpha' => [ 'Ruote::StorageParticipant', {} ]
+        alpha
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    assert_equal 1, @engine.storage_participant.size
+    assert_equal 'alpha', @engine.storage_participant.first.participant_name
+  end
+end
+

data/test/functional/ft_45_participant_accept.rb

@@ -0,0 +1,64 @@
+
+#
+# testing ruote
+#
+# Wed Jul 21 13:37:59 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtParticipantAcceptTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+
+    def initialize (opts)
+      @opts = opts
+    end
+
+    def accept? (workitem)
+      workitem.participant_name.match(@opts['filter'] || '.?')
+    end
+
+    def consume (workitem)
+      @context.tracer << 'filtered:'
+      @context.tracer << workitem.participant_name
+      @context.tracer << "\n"
+      reply(workitem)
+    end
+  end
+
+  class MyOtherParticipant
+    include Ruote::LocalParticipant
+
+    def consume (workitem)
+      @context.tracer << workitem.participant_name
+      @context.tracer << "\n"
+      reply(workitem)
+    end
+  end
+
+  def test_participant_on_reply
+
+    pdef = Ruote.process_definition do
+      sequence do
+        absolute
+        aberrant
+        aloof
+        nada
+      end
+    end
+
+    @engine.register_participant 'a.+', MyParticipant, 'filter' => '^ab'
+    @engine.register_participant '.+', MyOtherParticipant
+
+    #noisy
+
+    assert_trace %w[ filtered:absolute filtered:aberrant aloof nada ], pdef
+  end
+end
+

data/test/functional/ft_46_launch_single.rb

@@ -0,0 +1,49 @@
+
+#
+# testing ruote
+#
+# Sat Sep 25 23:24:16 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtLaunchSingleTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_no_name_singles_are_rejected
+
+    assert_raise ArgumentError do
+      @engine.launch_single(Ruote.process_definition do
+        wait '2y'
+        echo 'over.'
+      end)
+    end
+  end
+
+  def test_launch_single
+
+    pdef = Ruote.process_definition 'unique_process' do
+      wait '2y'
+      echo 'over.'
+    end
+
+    wfid = @engine.launch_single(pdef)
+
+    assert_equal(
+      wfid,
+      @engine.storage.get('variables', 'singles')['h']['unique_process'].first)
+
+    sleep 0.700
+
+    assert_not_nil @engine.process(wfid)
+
+    wfid1 = @engine.launch_single(pdef)
+
+    sleep 0.700
+
+    assert_equal wfid, wfid1
+    assert_equal 1, @engine.processes.size
+  end
+end
+

data/test/functional/ft_5_on_error.rb

@@ -7,6 +7,8 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
+require 'ruote/participant'
+
 
 class FtOnErrorTest < Test::Unit::TestCase
   include FunctionalBase
@@ -250,9 +252,45 @@ class FtOnErrorTest < Test::Unit::TestCase
     #puts er.trace
 
     assert_equal 'err...', @tracer.to_s
-    assert_equal 4, workitem.error.size
+    assert_equal 5, workitem.error.size
     assert_equal 'RuntimeError', workitem.error[2]
+    assert_equal 'Beijing, we have a problem !', workitem.error[3]
+    assert_equal Array, workitem.error[4].class
     assert_equal true, workitem.fields['seen']
   end
+
+  class Murphy
+    include Ruote::LocalParticipant
+
+    def cancel (fei, flavour)
+      # nothing to do
+    end
+    def consume (workitem)
+      raise "something got wrong"
+    end
+  end
+
+  def test_subprocess_on_error
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => 'error_path' do
+        murphy
+      end
+      define 'error_path' do
+        catcher
+      end
+    end
+
+    @engine.register do
+      murphy FtOnErrorTest::Murphy
+      catchall
+    end
+
+    #@engine.noisy = true
+
+    @engine.launch(pdef)
+
+    @engine.wait_for(:catcher)
+  end
 end
 

data/test/functional/storage_helper.rb

@@ -69,7 +69,13 @@ else uses the in-memory Ruote::Engine (fastest, but no persistence at all)
     begin
       load File.join(path, %w[ test functional_connection.rb ])
     rescue LoadError => le
-      load File.join(path, %w[ test integration_connection.rb ])
+      begin
+        load File.join(path, %w[ test integration_connection.rb ])
+      rescue LoadError => lee
+        p le
+        p lee
+        raise lee
+      end
     end
 
     new_storage(opts)

data/test/test_helper.rb

@@ -22,7 +22,7 @@ end
 def require_patron
   begin
     require 'patron'
-  rescue LoadError
+  rescue LoadError => le
     # stick with net/http
   end
 end