ruote 2.1.11 → 2.2.0

data/test/functional/ft_3_participant_registration.rb

@@ -20,22 +20,53 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
     @engine.register_participant :alpha do |workitem|
       @tracer << 'alpha'
     end
+    @engine.register_participant /^user_/, Ruote::NullParticipant
 
-    wait_for(1)
+    wait_for(2)
 
-    msg = logger.log.last
-    assert_equal 'participant_registered', msg['action']
-    assert_equal 'alpha', msg['regex']
+    assert_equal(
+      'participant_registered',
+      logger.log[0]['action'])
 
     assert_equal(
-      [ 'inpa_:alpha' ],
-      @engine.context.plist.instantiated_participants.collect { |e| e.first })
+      %w[ alpha /^user_/ ],
+      logger.log.collect { |msg| msg['regex'] })
 
     assert_equal(
-      [ [ '^alpha$', 'inpa_:alpha' ] ],
+      [ [ "^alpha$",
+          [ "Ruote::BlockParticipant",
+            { "block" => "proc { |workitem| (@tracer << \"alpha\") }" } ] ],
+        [ "^user_",
+          [ "Ruote::NullParticipant",
+            {} ] ] ],
       @engine.participant_list.collect { |pe| pe.to_a })
   end
 
+  def test_participant_register_position
+
+    @engine.register_participant :ur, Ruote::StorageParticipant
+
+    assert_equal(
+      %w[ ^ur$ ],
+      @engine.participant_list.collect { |pe| pe.regex.to_s })
+
+    @engine.register_participant(
+      :first, Ruote::StorageParticipant, :position => :first)
+    @engine.register_participant(
+      :last, Ruote::StorageParticipant, :position => :last)
+
+    assert_equal(
+      %w[ ^first$ ^ur$ ^last$ ],
+      @engine.participant_list.collect { |pe| pe.regex.to_s })
+
+    @engine.register_participant(
+      :x, Ruote::StorageParticipant, :position => -2)
+
+    assert_equal(
+      %w[ ^first$ ^ur$ ^x$ ^last$ ],
+      @engine.participant_list.collect { |pe| pe.regex.to_s })
+  end
+
   def test_double_registration
 
     @engine.register_participant :alpha do |workitem|
@@ -48,12 +79,14 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
     assert_equal 1, @engine.context.plist.send(:get_list)['list'].size
   end
 
-  def test_register_and_return_participant
+  def test_register_and_return_something
 
     pa = @engine.register_participant :alpha do |workitem|
     end
+    pb = @engine.register_participant :bravo, Ruote::StorageParticipant
 
-    assert_kind_of Ruote::BlockParticipant, pa
+    assert_nil pa
+    assert_equal Ruote::StorageParticipant, pb.class
   end
 
   def test_participant_unregister_by_name
@@ -63,7 +96,7 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
     @engine.register_participant :alpha do |workitem|
     end
 
-    @engine.unregister_participant :alpha
+    @engine.unregister_participant(:alpha)
 
     wait_for(2)
     Thread.pass
@@ -71,16 +104,14 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
     msg = logger.log.last
     assert_equal 'participant_unregistered', msg['action']
     assert_equal '^alpha$', msg['regex']
-
-    assert_equal 0, @engine.context.plist.instantiated_participants.size
   end
 
   def test_participant_unregister
 
-    pa = @engine.register_participant :alpha do |workitem|
+    @engine.register_participant :alpha do |workitem|
     end
 
-    @engine.unregister_participant pa
+    @engine.unregister_participant('alpha')
 
     wait_for(2)
 
@@ -88,26 +119,28 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
     assert_equal 'participant_unregistered', msg['action']
     assert_equal '^alpha$', msg['regex']
 
-    assert_equal 0, @engine.context.plist.instantiated_participants.size
+    assert_equal 0, @engine.context.plist.list.size
   end
 
   class MyParticipant
-    attr_reader :down
+    @@down = false
+    def self.down
+      @@down
+    end
     def initialize
-      @down = false
     end
     def shutdown
-      @down = true
+      @@down = true
     end
   end
 
   def test_participant_shutdown
 
-    alpha = @engine.register :alpha, MyParticipant.new
+    alpha = @engine.register :alpha, MyParticipant
 
     @engine.context.plist.shutdown
 
-    assert_equal true, alpha.down
+    assert_equal true, MyParticipant.down
   end
 
   def test_participant_list_of_names
@@ -128,10 +161,10 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       f.write(%{
         class RequiredParticipant
           include Ruote::LocalParticipant
-          def initialize (opts)
+          def initialize(opts)
             @opts = opts
           end
-          def consume (workitem)
+          def consume(workitem)
             workitem.fields['message'] = @opts['message']
             reply(workitem)
           end
@@ -164,10 +197,10 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       f.write(%{
         class RequiredParticipant
           include Ruote::LocalParticipant
-          def initialize (opts)
+          def initialize(opts)
             @opts = opts
           end
-          def consume (workitem)
+          def consume(workitem)
             workitem.fields['message'] = 'second run'
             reply(workitem)
           end
@@ -194,10 +227,10 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       f.write(%{
         class LoadedParticipant
           include Ruote::LocalParticipant
-          def initialize (opts)
+          def initialize(opts)
             @opts = opts
           end
-          def consume (workitem)
+          def consume(workitem)
             workitem.fields['message'] = @opts['message']
             reply(workitem)
           end
@@ -230,10 +263,10 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       f.write(%{
         class LoadedParticipant
           include Ruote::LocalParticipant
-          def initialize (opts)
+          def initialize(opts)
             @opts = opts
           end
-          def consume (workitem)
+          def consume(workitem)
             workitem.fields['message'] = 'second run'
             reply(workitem)
           end
@@ -348,25 +381,31 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       alpha 'Participants::Alpha', 'flavour' => 'vanilla'
       participant 'bravo', 'Participants::Bravo', :flavour => 'peach'
       participant 'charlie', 'Participants::Charlie'
+      participant 'david' do |wi|
+        p wi
+      end
       catchall 'Participants::Zebda', 'flavour' => 'coconut'
     end
 
-    assert_equal 4, @engine.participant_list.size
+    assert_equal 5, @engine.participant_list.size
 
     assert_equal(
-      %w[ ^alpha$ ^bravo$ ^charlie$ ^.+$ ],
+      %w[ ^alpha$ ^bravo$ ^charlie$ ^david$ ^.+$ ],
       @engine.participant_list.collect { |pe| pe.regex.to_s })
 
     assert_equal(
       %w[ Participants::Alpha
           Participants::Bravo
           Participants::Charlie
+          Ruote::BlockParticipant
           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' })
+      %w[ vanilla peach nil nil coconut ],
+      @engine.participant_list.collect { |pe|
+        (pe.options['flavour'] || 'nil') rescue 'nil'
+      })
   end
 
   def test_register_block_catchall_default
@@ -379,5 +418,45 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       %w[ Ruote::StorageParticipant ],
       @engine.participant_list.collect { |pe| pe.classname })
   end
+
+  def test_argument_error_on_instantiated_participant
+
+    assert_raise ArgumentError do
+      @engine.register 'alpha', Ruote::StorageParticipant.new
+    end
+    assert_raise ArgumentError do
+      @engine.register 'alpha', Ruote::StorageParticipant.new, 'hello' => 'kitty'
+    end
+  end
+
+  class AaParticipant
+    include Ruote::LocalParticipant
+    attr_reader :opts
+    def initialize(opts)
+      @opts = opts
+    end
+  end
+  class BbParticipant < AaParticipant
+    def accept?(workitem)
+      false
+    end
+  end
+
+  def test_engine_participant
+
+    @engine.register do
+      alpha AaParticipant
+      bravo BbParticipant
+      catchall AaParticipant, :catch_all => 'oh yeah'
+    end
+
+    assert_equal AaParticipant, @engine.participant('alpha').class
+    assert_equal BbParticipant, @engine.participant('bravo').class
+
+    assert_equal AaParticipant, @engine.participant('charly').class
+    assert_equal 'oh yeah', @engine.participant('charly').opts['catch_all']
+
+    assert_equal Ruote::Context, @engine.participant('alpha').context.class
+  end
 end
 

data/test/functional/ft_40_wait_logger.rb

@@ -48,7 +48,8 @@ class FtWaitLoggerTest < Test::Unit::TestCase
 
     wfid = @engine.launch(pdef)
 
-    sleep 1.400 # worst case is ruote-couch
+    sleep 0.500
+    sleep 2.000 if @engine.storage.class.name.match(/Couch/)
 
     assert_equal 2, @engine.context.logger.instance_variable_get(:@seen).size
 

data/test/functional/ft_41_participants.rb

@@ -10,12 +10,12 @@ require File.join(File.dirname(__FILE__), 'base')
 require 'ruote/part/local_participant'
 
 
-class FtMiscParticipantTest < Test::Unit::TestCase
+class FtParticipantsTest < Test::Unit::TestCase
   include FunctionalBase
 
   class MyParticipant
     include Ruote::LocalParticipant
-    def consume (workitem)
+    def consume(workitem)
       workitem.fields['seen'] = true
       reply_to_engine(workitem)
     end
@@ -23,10 +23,10 @@ class FtMiscParticipantTest < Test::Unit::TestCase
 
   class MyMessageParticipant
     include Ruote::LocalParticipant
-    def initialize (opts)
+    def initialize(opts)
       @opts = opts
     end
-    def consume (workitem)
+    def consume(workitem)
       workitem.fields['message'] = @opts['message']
       reply_to_engine(workitem)
     end
@@ -61,5 +61,31 @@ class FtMiscParticipantTest < Test::Unit::TestCase
 
     assert_equal 'hi', r['workitem']['fields']['message']
   end
+
+  class MyOtherParticipant
+    include Ruote::LocalParticipant
+    def consume(wi)
+      wi.fields['hello'] = 'kitty'
+      reply_to_engine(wi)
+    end
+    def on_reply(wi)
+      @context.tracer << wi.fields['hello'] + "\n"
+      @context.tracer << applied_workitem(wi.fei).fields['hello'] + "\n"
+      @context.tracer << workitem(wi.fei).fields['hello']
+    end
+  end
+
+  def test_workitem_method
+
+    @engine.register 'alpha', MyOtherParticipant
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define { alpha }, 'hello' => 'world')
+
+    @engine.wait_for(wfid)
+
+    assert_equal %w[ kitty world world ], @tracer.to_a
+  end
 end
 

data/test/functional/ft_43_participant_on_reply.rb

@@ -15,12 +15,12 @@ class FtParticipantOnReplyTest < Test::Unit::TestCase
 
   class MyParticipant
     include Ruote::LocalParticipant
-    def initialize (opts)
+    def initialize(opts)
     end
-    def consume (workitem)
+    def consume(workitem)
       reply(workitem)
     end
-    def on_reply (workitem)
+    def on_reply(workitem)
       workitem.fields['message'] = 'hello'
     end
   end
@@ -41,31 +41,14 @@ 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)
+    def initialize(opts)
     end
-    def consume (workitem)
+    def consume(workitem)
       reply(workitem)
     end
-    def on_reply (workitem)
+    def on_reply(workitem)
       return if workitem.fields['pass']
       raise "something went wrong"
     end

data/test/functional/ft_45_participant_accept.rb

@@ -16,15 +16,15 @@ class FtParticipantAcceptTest < Test::Unit::TestCase
   class MyParticipant
     include Ruote::LocalParticipant
 
-    def initialize (opts)
+    def initialize(opts)
       @opts = opts
     end
 
-    def accept? (workitem)
+    def accept?(workitem)
       workitem.participant_name.match(@opts['filter'] || '.?')
     end
 
-    def consume (workitem)
+    def consume(workitem)
       @context.tracer << 'filtered:'
       @context.tracer << workitem.participant_name
       @context.tracer << "\n"
@@ -35,7 +35,7 @@ class FtParticipantAcceptTest < Test::Unit::TestCase
   class MyOtherParticipant
     include Ruote::LocalParticipant
 
-    def consume (workitem)
+    def consume(workitem)
       @context.tracer << workitem.participant_name
       @context.tracer << "\n"
       reply(workitem)

data/test/functional/ft_46_launch_single.rb

@@ -28,22 +28,56 @@ class FtLaunchSingleTest < Test::Unit::TestCase
       echo 'over.'
     end
 
+    #noisy
+
     wfid = @engine.launch_single(pdef)
 
     assert_equal(
       wfid,
       @engine.storage.get('variables', 'singles')['h']['unique_process'].first)
 
-    sleep 0.700
+    @engine.wait_for(2)
 
     assert_not_nil @engine.process(wfid)
 
     wfid1 = @engine.launch_single(pdef)
 
-    sleep 0.700
+    sleep 1
 
     assert_equal wfid, wfid1
     assert_equal 1, @engine.processes.size
   end
+
+  # Fighting the issue reported by Gonzalo in
+  # http://groups.google.com/group/openwferu-users/browse_thread/thread/fa9c8b414f355f79
+  #
+  def test_launch_single_cancel_launch_single
+
+    pdef = Ruote.process_definition 'unique_process' do
+      wait '2y'
+      echo 'over.'
+    end
+
+    #noisy
+
+    wfid0 = @engine.launch_single(pdef)
+
+    sleep 0.700
+    assert_not_nil @engine.process(wfid0)
+
+    @engine.cancel(wfid0)
+
+    @engine.wait_for(6)
+    assert_nil @engine.process(wfid0)
+
+    sleep 0.700
+    wfid1 = @engine.launch_single(pdef)
+
+    @engine.wait_for(2)
+
+    assert_not_equal wfid0, wfid1
+    assert_nil @engine.process(wfid0)
+    assert_not_nil @engine.process(wfid1)
+  end
 end