ruote 2.2.0 → 2.3.0

data/test/functional/ft_75_context.rb

@@ -0,0 +1,66 @@
+
+#
+# testing ruote
+#
+# Mon Jul 30 17:27:22 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtContextTest < Test::Unit::TestCase
+
+  def teardown
+
+    @dashboard.shutdown
+    @dashboard.context.storage.purge!
+  end
+
+  def test_wait_for_goes_last
+
+    @dashboard = Ruote::Engine.new(Ruote::Worker.new(determine_storage({})))
+
+    log = []
+
+    c = Object.new
+    class << c
+      attr_accessor :log
+      def on_msg(msg)
+        log << 'c'
+      end
+      def wait_for # it's a waiter
+        raise 'never called anyway'
+      end
+    end
+    c.log = log
+
+    b = Object.new
+    class << b
+      attr_accessor :log
+      def on_msg(msg)
+        log << 'b'
+      end
+    end
+    b.log = log
+
+    a = Object.new
+    class << a
+      attr_accessor :log
+      def on_msg(msg)
+        log << 'a'
+      end
+    end
+    a.log = log
+
+    @dashboard.add_service('c', c) # waiter
+    @dashboard.add_service('b', b) # observer
+    @dashboard.add_service('a', a) # observer
+
+    wfid = @dashboard.launch(Ruote.define do
+    end)
+    @dashboard.wait_for(wfid)
+
+    assert_equal %w[ a b c a b c ], log
+  end
+end
+

data/test/functional/ft_76_observer.rb

@@ -0,0 +1,53 @@
+
+#
+# testing ruote
+#
+# Mon Jul 30 19:47:59 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+require 'ruote/observer'
+
+
+class FtObserverTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyObserver < Ruote::Observer
+    attr_reader :events
+    def initialize(context)
+      super
+      @events = []
+    end
+    def on_msg_launch(msg)
+      @events << [ 'launch', msg['wfid'] ]
+    end
+    def on_msg_terminated(msg)
+      @events << [ 'terminated', msg['wfid'] ]
+    end
+  end
+
+  def test_respark
+
+    @dashboard.register 'alpha', Ruote::NoOpParticipant
+
+    my_observer = MyObserver.new(@dashboard.context)
+    @dashboard.add_service 'my_observer', my_observer
+      #
+      # using an instantiated service for easier testing...
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    wfid = @dashboard.launch(pdef)
+    m = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', m['action']
+
+    assert_equal(
+      [ [ 'launch', wfid ], [ 'terminated', wfid ] ],
+      my_observer.events)
+  end
+end
+

data/test/functional/ft_77_process_observer.rb

@@ -0,0 +1,157 @@
+#
+# Testing process observers
+#
+# Made in Germany
+# by Hartog de Mik
+#
+
+require File.expand_path('../base', __FILE__)
+require 'ruote/util/process_observer'
+
+class FtProcessObservingTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_on_launch
+    observer = Class.new(Ruote::ProcessObserver) do
+      class << self
+        attr_accessor :started
+      end
+
+      def on_launch(wfid)
+        self.class.started = true
+      end
+
+      def on_error_intercepted(wfid, fields)
+        ex = fields[:error]
+        STDERR.puts "#{ex.class.name}: #{ex.message}"
+        STDERR.puts "\t#{ex.backtrace.join("\n\t")}"
+      end
+    end
+
+    @dashboard.add_service('start_subscriber', observer)
+
+    wfid = @dashboard.launch Ruote.define do; echo "hello"; end
+    res  = @dashboard.wait_for(wfid)
+
+    assert_equal true, observer.started
+  end
+
+  def test_on_sub_launch
+    observer = Class.new(Ruote::ProcessObserver) do
+      class << self
+        attr_accessor :opts, :launches
+      end
+
+      def on_launch(wfid, opts)
+        self.class.opts = opts.dup
+        self.class.launches += 1
+      end
+    end
+    observer.launches = 0
+
+    @dashboard.add_service("sub_launch_observer", observer)
+    pdef = Ruote.define do
+      sequence do
+        alpha
+      end
+
+      define :alpha do
+        echo "I am the sub"
+      end
+    end
+
+    wfid = @dashboard.launch pdef
+    @dashboard.wait_for(wfid)
+
+    assert_not_nil observer.opts
+    assert_equal 2, observer.launches
+    assert_equal true, observer.opts[:child]
+    assert_not_nil observer.opts[:pdef]
+  end
+
+  def test_on_end
+    observer = Class.new(Ruote::ProcessObserver) do
+      class << self
+        attr_accessor :stopped
+      end
+
+      def on_terminated(wfid)
+        self.class.stopped = true
+      end
+    end
+    @dashboard.add_service('stop_server', observer)
+
+    wfid = @dashboard.launch Ruote.define do; echo "hello"; end
+    res  = @dashboard.wait_for(wfid)
+
+    assert_equal true, observer.stopped
+  end
+
+  def test_on_error
+    observer = Class.new(Ruote::ProcessObserver) do
+      class << self
+        attr_accessor :flunked, :opts
+      end
+
+      def on_error_intercepted(wfid, opts)
+        self.class.flunked = true
+        self.class.opts    = opts
+      end
+    end
+
+    @dashboard.add_service('flunk_subscriber', observer)
+
+    @dashboard.register_participant :pinky do |wi|
+      raise "hell"
+    end
+
+    wfid = @dashboard.launch Ruote.define() { pinky }
+    res  = @dashboard.wait_for(wfid)
+
+    assert_equal true, observer.flunked
+    assert_not_nil observer.opts
+    assert_not_nil observer.opts[:error]
+    assert_equal "hell", observer.opts[:error].message
+  end
+
+  def test_on_cancel
+    observer = Class.new(Ruote::ProcessObserver) do
+      class << self
+        attr_accessor :canceled
+      end
+
+      def on_cancel(wfid)
+        self.class.canceled = true
+      end
+    end
+
+    @dashboard.add_service('cancel_subscriber', observer)
+
+    @dashboard.register_participant :brain do |wi|
+      context.dashboard.cancel(wi.wfid)
+    end
+
+    wfid = @dashboard.launch Ruote.define() { brain }
+    res  = @dashboard.wait_for(wfid)
+
+    assert_equal true, observer.canceled
+  end
+
+  def test_error_handling
+    observer = Class.new(Ruote::ProcessObserver) do
+      class << self; attr_accessor :flunked; end
+      def on_launch(wfid)
+        raise "Sit still! I'm trying to kill you!"
+      end
+      def on_error_intercepted(wfid)
+        self.class.flunked = true
+      end
+    end
+
+    @dashboard.add_service('process_timer', observer)
+    wfid = @dashboard.launch Ruote.define do; echo('hi'); end
+    res  = @dashboard.wait_for(wfid)
+
+    assert_equal nil, observer.flunked
+  end
+end

data/test/functional/ft_78_part_participant.rb

@@ -0,0 +1,37 @@
+
+#
+# testing ruote
+#
+# Mon Sep  3 06:29:08 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtPartParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyParticipant < Ruote::Participant
+    def on_workitem
+      (workitem.fields['seen'] ||= []) << workitem.participant_name
+      reply
+    end
+  end
+
+  def test_participant
+
+    @dashboard.register '.+', MyParticipant
+
+    pdef = Ruote.process_definition do
+      alpha
+      bravo
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal %w[ alpha bravo ], r['workitem']['fields']['seen']
+  end
+end
+

data/test/functional/ft_7_tags.rb

@@ -5,7 +5,7 @@
 # Wed Jun 10 11:03:26 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 require 'ruote/participant'
 
@@ -21,14 +21,12 @@ class FtTagsTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    #noisy
-
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     #p ps.variables
     #ps.expressions.each { |e| p [ e.fei, e.variables ] }
@@ -38,7 +36,7 @@ class FtTagsTest < Test::Unit::TestCase
     #logger.log.each { |e| puts e['action'] }
     assert_equal 2, logger.log.select { |e| e['action'] == 'entered_tag' }.size
 
-    alpha.reply(alpha.first)
+    alpha.proceed(alpha.first)
     wait_for(wfid)
 
     assert_equal 2, logger.log.select { |e| e['action'] == 'left_tag' }.size
@@ -48,43 +46,115 @@ class FtTagsTest < Test::Unit::TestCase
   #
   def test_on_cancel
 
+    @dashboard.register_participant '.+', Ruote::StorageParticipant
+
     pdef = Ruote.process_definition do
       sequence do
         sequence :tag => 'a', :on_cancel => 'decom' do
           alpha
         end
-        alpha
+        bravo
       end
       define 'decom' do
-        alpha
+        charly
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-
-    #noisy
-
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
 
-    assert_equal 1, @engine.process(wfid).tags.size
+    assert_equal 1, @dashboard.process(wfid).tags.size
 
-    fei = @engine.process(wfid).expressions.find { |e|
+    fei = @dashboard.process(wfid).expressions.find { |e|
       e.fei.expid == '0_1_0'
     }.fei
 
-    @engine.cancel_expression(fei)
+    @dashboard.cancel_expression(fei)
 
-    wait_for(:alpha)
+    wait_for(:charly)
 
-    assert_equal 0, @engine.process(wfid).tags.size
+    assert_equal 1, @dashboard.process(wfid).tags.size
 
-    alpha.reply(alpha.first)
+    @dashboard.storage_participant.proceed(@dashboard.storage_participant.first)
 
-    wait_for(:alpha)
+    wait_for(:bravo)
+
+    ps = @dashboard.process(wfid)
+
+    assert_equal 0, ps.tags.size
+    assert_equal 1, ps.past_tags.size
+    assert_equal 'a', ps.root_expression.variables['__past_tags__'].first.first
+
+    @dashboard.storage_participant.proceed(@dashboard.storage_participant.first)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+
+    assert_equal 1, r['variables']['__past_tags__'].size
+
+    a = r['variables']['__past_tags__'].first
+
+    assert_equal 'a', a[0]
+    assert_match /^0_1_0!/, a[1]
+    assert_match /!#{wfid}$/, a[1]
+    assert_equal 'cancelled', a[2]
+    assert_match /\sUTC$/, a[3]
+  end
+
+  def test_cancel_tag
+
+    @dashboard.register_participant :alpha, Ruote::StorageParticipant
+
+    pdef = Ruote.define do
+      sequence :tag => 'a' do
+        alpha
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(:alpha)
 
-    assert_equal 0, @engine.process(wfid).tags.size
+    ps = @dashboard.ps(wfid)
+    @dashboard.cancel(ps.expressions[1])
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal 1, r['variables']['__past_tags__'].size
+
+    a = r['variables']['__past_tags__'].first
+
+    assert_equal 'a', a[0]
+    assert_equal 'cancelled', a[2]
+  end
+
+  def test_kill_tag
+
+    @dashboard.register_participant :alpha, Ruote::StorageParticipant
+
+    pdef = Ruote.define do
+      sequence :tag => 'a' do
+        alpha
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(:alpha)
+
+    ps = @dashboard.ps(wfid)
+    @dashboard.kill(ps.expressions[1])
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal 1, r['variables']['__past_tags__'].size
+
+    a = r['variables']['__past_tags__'].first
+
+    assert_equal 'a', a[0]
+    assert_equal 'killed', a[2]
   end
 
   def test_unset_tag_when_parent_gone
@@ -99,16 +169,14 @@ class FtTagsTest < Test::Unit::TestCase
       end
     end
 
-    #@engine.noisy = true
-
-    @engine.register :alpha, Ruote::NullParticipant
-    @engine.register :bravo, Ruote::NoOpParticipant
+    @dashboard.register :alpha, Ruote::NullParticipant
+    @dashboard.register :bravo, Ruote::NoOpParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
-    @engine.wait_for(23)
+    @dashboard.wait_for(23)
 
-    assert_nil @engine.process(wfid)
+    assert_nil @dashboard.process(wfid)
   end
 
   def test_tags_and_workitems
@@ -124,54 +192,174 @@ class FtTagsTest < Test::Unit::TestCase
       david
     end
 
-    @engine.register { catchall }
+    @dashboard.register { catchall }
 
-    wfid = @engine.launch(pdef)
-    @engine.wait_for(:alpha)
-    wi = @engine.storage_participant.first
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(:alpha)
+    wi = @dashboard.storage_participant.first
 
     assert_equal %w[ first-stage ], wi.tags
 
-    @engine.storage_participant.reply(wi)
-    @engine.wait_for(:bravo)
-    wi = @engine.storage_participant.first
+    @dashboard.storage_participant.proceed(wi)
+    @dashboard.wait_for(:bravo)
+    wi = @dashboard.storage_participant.first
 
     assert_equal %w[ second-stage ], wi.tags
 
-    @engine.storage_participant.reply(wi)
-    @engine.wait_for(:charly)
-    wi = @engine.storage_participant.first
+    @dashboard.storage_participant.proceed(wi)
+    @dashboard.wait_for(:charly)
+    wi = @dashboard.storage_participant.first
 
     assert_equal %w[ second-stage third-stage ], wi.tags
 
-    @engine.storage_participant.reply(wi)
-    @engine.wait_for(:david)
-    wi = @engine.storage_participant.first
+    @dashboard.storage_participant.proceed(wi)
+    @dashboard.wait_for(:david)
+    wi = @dashboard.storage_participant.first
 
     assert_equal [], wi.tags
   end
 
+  # Cf http://groups.google.com/group/openwferu-users/browse_thread/thread/61f037bc491dcf4c
+  #
+  def test_tags_workitems_and_cursor
+
+    pdef = Ruote.define do
+      sequence :tag => 'phase1' do
+        concurrence :merge_type => :union do
+          alpha
+          bravo
+        end
+        charly
+      end
+    end
+
+    @dashboard.register_participant '.+' do |workitem|
+      if workitem.participant_name == 'charly'
+        workitem.fields['tags'] = workitem.fields['__tags__'].dup
+      end
+      nil
+    end
+
+    wfid = @dashboard.launch(pdef, 'my_array' => [ 1 ])
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal(%w[ phase1 ], r['workitem']['fields']['tags'])
+    assert_equal('phase1', r['workitem']['fields']['__left_tag__'])
+    assert_equal([], r['workitem']['fields']['__tags__'])
+  end
+
   def test_tag_and_define
 
     pdef = Ruote.define :tag => 'nada' do
       alpha
     end
 
-    @engine.register 'alpha', Ruote::StorageParticipant
-
-    #noisy
+    @dashboard.register 'alpha', Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
-    @engine.wait_for(:alpha)
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(:alpha)
 
     assert_equal 1, logger.log.select { |e| e['action'] == 'entered_tag' }.size
 
-    wi = @engine.storage_participant.first
-    @engine.storage_participant.reply(wi)
+    wi = @dashboard.storage_participant.first
+    @dashboard.storage_participant.proceed(wi)
 
-    @engine.wait_for(wfid)
+    @dashboard.wait_for(wfid)
 
     assert_equal 1, logger.log.select { |e| e['action'] == 'left_tag' }.size
   end
+
+  def test_absolute_tags
+
+    pdef = Ruote.define do
+      concurrence do
+        sequence do
+          listen :to => 'b', :upon => 'entering'
+          echo 'b'
+        end
+        sequence do
+          listen :to => 'a/b', :upon => 'entering'
+          echo 'a/b'
+        end
+        sequence :tag => 'a' do
+          wait '1s'
+          sequence :tag => 'b' do
+          end
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ a/b b ], @tracer.to_a.sort
+
+    past_tags = r['variables']['__past_tags__']
+
+    assert_equal(
+      %w[ a a/b ],
+      past_tags.collect(&:first).sort)
+
+    past_tag = past_tags.first
+
+    assert_equal(
+      [ String, String, NilClass, String, NilClass ], past_tag.collect(&:class))
+
+    assert_equal(
+      Ruote::FlowExpressionId, Ruote.extract_fei(past_tag[1]).class)
+    assert_match(
+      / UTC$/, past_tag[3])
+  end
+
+  def test_tags_and_re_apply
+
+    @dashboard.register_participant :look_at_tags do |workitem|
+      tracer << workitem.tags.join('/') + "\n"
+    end
+
+    pdef = Ruote.define do
+      sequence :tag => 'alpha' do
+        look_at_tags
+        error 'nada'
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for('error_intercepted')
+
+    seq = @dashboard.ps(wfid).expressions[1]
+    @dashboard.re_apply(seq)
+
+    r = @dashboard.wait_for('error_intercepted')
+
+    assert_equal %w[ alpha alpha ], @tracer.to_a
+  end
+
+  def test_tag_and_on_handler
+
+    pdef = Ruote.define do
+      define 'h' do
+        echo 'in_handler'
+        wait '1s'
+        echo 'handler_out'
+      end
+      concurrence do
+        sequence do
+          await :left_tag => 'alpha'
+          echo 'left_tag'
+        end
+        sequence :tag => 'alpha', :on_error => 'h' do
+          error 'nada'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+
+    assert_equal %w[ in_handler handler_out left_tag ], @tracer.to_a
+  end
 end