ruote 2.2.0 → 2.3.0

data/test/functional/ft_57_rev_participant.rb

@@ -0,0 +1,252 @@
+
+#
+# testing ruote
+#
+# Wed Apr  6 06:52:53 JST 2011
+#
+# Santa Barbara
+#
+
+require File.expand_path('../base', __FILE__)
+
+require 'ruote'
+#require 'ruote/participant'
+
+
+class FtRevParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_consume
+
+    dir = compute_dir_name
+
+    FileUtils.mkdir(dir)
+
+    File.open(dir + '/alpha.rb', 'wb') do |f|
+      f.write(%{
+def consume(workitem)
+  (workitem.fields['seen'] ||= []) << 'alpha'
+  reply_to_engine(workitem)
+end
+      })
+    end
+    File.open(dir + '/alpha__z.rb', 'wb') do |f|
+      f.write(%{
+def consume(workitem)
+  (workitem.fields['seen'] ||= []) << 'alpha__z'
+  reply_to_engine(workitem)
+end
+      })
+    end
+
+    @dashboard.register do
+      catchall Ruote::RevParticipant, :dir => dir
+    end
+
+    pdef = Ruote.process_definition 'x', :revision => 'y' do
+      alpha :rev => 'z'
+      alpha
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ alpha__z alpha ], r['workitem']['fields']['seen']
+
+  ensure
+    FileUtils.rm_rf(dir)
+  end
+
+  def test_cancel
+
+    dir = compute_dir_name
+
+    FileUtils.mkdir(dir)
+
+    $seen = false
+
+    File.open(dir + '/alpha.rb', 'wb') do |f|
+      f.write(%{
+def consume(workitem)
+  # do nothing
+end
+def cancel(fei, flavour)
+  $seen = true
+end
+      })
+    end
+
+    @dashboard.register do
+      catchall Ruote::RevParticipant, :dir => dir
+    end
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:alpha)
+
+    assert_equal false, $seen
+
+    @dashboard.cancel(wfid)
+
+    @dashboard.wait_for(wfid)
+
+    assert_equal true, $seen
+
+  ensure
+    FileUtils.rm_rf(dir)
+  end
+
+  def test_accept
+
+    dir = compute_dir_name
+
+    FileUtils.mkdir(dir)
+
+    File.open(dir + '/alpha.rb', 'wb') do |f|
+      f.write(%{
+def consume(workitem)
+  (workitem.fields['seen'] ||= []) << 'alpha'
+  reply_to_engine(workitem)
+end
+      })
+    end
+    File.open(dir + '/alpha__z.rb', 'wb') do |f|
+      f.write(%{
+def consume(workitem)
+  raise "I should never get raised !"
+end
+def accept?(workitem)
+  false
+end
+      })
+    end
+
+    @dashboard.register do
+      catchall Ruote::RevParticipant, :dir => dir
+    end
+
+    pdef = Ruote.process_definition do
+      alpha :rev => 'z'
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ alpha ], r['workitem']['fields']['seen']
+
+  ensure
+    FileUtils.rm_rf(dir)
+  end
+
+  def test_on_reply
+
+    dir = compute_dir_name
+
+    FileUtils.mkdir(dir)
+
+    File.open(dir + '/alpha.rb', 'wb') do |f|
+      f.write(%{
+def consume(workitem)
+  reply_to_engine(workitem)
+end
+def on_reply(workitem)
+  (workitem.fields['seen'] ||= []) << 'on_reply'
+end
+      })
+    end
+
+    @dashboard.register do
+      catchall Ruote::RevParticipant, :dir => dir
+    end
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ on_reply ], r['workitem']['fields']['seen']
+
+  ensure
+    FileUtils.rm_rf(dir)
+  end
+
+  def test_rtimeout
+
+    dir = compute_dir_name
+
+    FileUtils.mkdir(dir)
+
+    File.open(dir + '/alpha.rb', 'wb') do |f|
+      f.write(%{
+def consume(workitem)
+  #reply_to_engine(workitem)
+end
+      })
+    end
+    File.open(dir + '/bravo.rb', 'wb') do |f|
+      f.write(%{
+def consume(workitem)
+  #reply_to_engine(workitem)
+end
+def rtimeout(workitem)
+  '2d'
+end
+      })
+    end
+
+    @dashboard.register do
+      catchall Ruote::RevParticipant, :dir => dir
+    end
+
+    pdef = Ruote.process_definition do
+      alpha
+      bravo
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(:alpha)
+    sleep 0.350
+
+    assert_equal 0, @dashboard.storage.get_many('schedules').size
+
+    wi = @dashboard.ps(wfid).workitems.first
+
+    @dashboard.receive(wi)
+
+    r = @dashboard.wait_for(:bravo)
+    sleep 0.350
+
+    assert_equal 1, @dashboard.storage.get_many('schedules').size
+
+  ensure
+    FileUtils.rm_rf(dir)
+  end
+
+  protected
+
+  def compute_dir_name
+
+    [ 'rev_participant', $$, Time.now.to_f ].collect { |e| e.to_s }.join('_')
+  end
+end
+

data/test/functional/ft_58_workitem.rb

@@ -0,0 +1,150 @@
+
+#
+# testing ruote
+#
+# Wed Apr  6 08:39:36 JST 2011
+#
+# Santa Barbara
+#
+
+require File.expand_path('../base', __FILE__)
+
+require 'ruote'
+
+
+class FtWorkitemTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class TraceParticipant
+    include Ruote::LocalParticipant
+
+    def consume(wi)
+      @context.tracer << "#{wi.wf_name}/#{wi.wf_revision}\n"
+      reply_to_engine(wi)
+    end
+  end
+
+  def test_name_and_revision
+
+    @dashboard.register :alpha, TraceParticipant
+
+    assert_trace(
+      'x/y',
+      Ruote.process_definition(:name => 'x', :revision => 'y') do
+        alpha
+      end,
+      :clear)
+
+    assert_trace(
+      'x/y',
+      Ruote.process_definition('x', :revision => 'y') do
+        alpha
+      end,
+      :clear)
+
+    assert_trace(
+      'x/y',
+      Ruote.process_definition('x', :rev => 'y') do
+        alpha
+      end,
+      :clear)
+
+    assert_trace(
+      'x/',
+      Ruote.process_definition('x') do
+        alpha
+      end,
+      :clear)
+
+    assert_trace(
+      '/',
+      Ruote.process_definition do
+        alpha
+      end,
+      :clear)
+  end
+
+  def test_wf_launched_at
+
+    pdef = Ruote.define do
+      sub0
+      define 'sub0' do
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_not_nil r['workitem']['wf_launched_at']
+    assert_not_nil r['workitem']['sub_wf_launched_at']
+  end
+
+  class SubTraceParticipant
+    include Ruote::LocalParticipant
+
+    def consume(wi)
+      @context.tracer << "#{wi.sub_wf_name}/#{wi.sub_wf_revision}\n"
+      reply_to_engine(wi)
+    end
+  end
+
+  def test_sub_name_and_sub_revision
+
+    @dashboard.register :bravo, SubTraceParticipant
+
+    assert_trace(
+      'x/y',
+      Ruote.define('x', :revision => 'y') do
+        bravo
+      end,
+      :clear)
+
+    assert_trace(
+      'sub0/',
+      Ruote.define('x', :revision => 'y') do
+        sub0
+        define 'sub0' do
+          bravo
+        end
+      end,
+      :clear)
+
+    assert_trace(
+      'sub0/2.5',
+      Ruote.define('x', :revision => 'y') do
+        sub0
+        define 'sub0', :revision => '2.5' do
+          bravo
+        end
+      end,
+      :clear)
+
+    assert_trace(
+      'sub1/',
+      Ruote.define('x', :revision => 'y') do
+        sub0
+        define 'sub0', :revision => '2.5' do
+          sub1
+        end
+        define 'sub1' do
+          bravo
+        end
+      end,
+      :clear)
+
+    assert_trace(
+      'sub0/2.5',
+      Ruote.define('x', :revision => 'y') do
+        sub0
+        define 'sub0', :revision => '2.5' do
+          sub1
+          bravo
+        end
+        define 'sub1' do
+          noop
+        end
+      end,
+      :clear)
+  end
+end
+

data/test/functional/ft_59_pause.rb

@@ -0,0 +1,329 @@
+
+#
+# testing ruote
+#
+# Tue Apr 12 06:10:17 JST 2011
+#
+# Santa Barbara
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtPauseTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_pause_process
+
+    @dashboard.register { catchall }
+
+    pdef = Ruote.define { alice }
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:alice)
+
+    #
+    # pause the process
+
+    @dashboard.pause(wfid)
+
+    @dashboard.wait_for('dispatch_pause')
+
+    ps = @dashboard.ps(wfid)
+
+    assert_equal %w[ paused ], ps.expressions.collect { |fexp| fexp.state }.uniq
+
+    @dashboard.storage_participant.proceed(@dashboard.storage_participant.first)
+
+    @dashboard.wait_for('receive')
+
+    ps = @dashboard.ps(wfid)
+
+    exp = ps.expressions.last
+
+    assert_not_nil exp.h.paused_replies
+
+    #
+    # resume the process
+
+    @dashboard.resume(wfid)
+
+    @dashboard.wait_for(wfid)
+
+    assert_nil @dashboard.ps(wfid)
+  end
+
+  def test_pause_process_in_error
+
+    pdef = Ruote.process_definition do
+      nada
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(wfid)
+
+    @dashboard.pause(wfid)
+
+    @dashboard.wait_for(3)
+
+    ps = @dashboard.ps(wfid)
+
+    assert_equal(
+      %w[ paused failed ],
+      ps.expressions.collect { |fexp| fexp.state })
+
+    #
+    # cancel at error
+
+    @dashboard.cancel(ps.expressions.last.fei)
+
+    #
+    # resume the process
+
+    @dashboard.resume(wfid)
+
+    @dashboard.wait_for(wfid)
+
+    assert_nil @dashboard.ps(wfid)
+  end
+
+  def test_cancel_paused_branch
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alice
+      end
+      bob
+    end
+
+    @dashboard.register do
+      catchall
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:alice)
+
+    exp = @dashboard.ps(wfid).expressions.find { |e| e.name == 'sequence' }
+
+    @dashboard.pause(exp.fei)
+
+    @dashboard.wait_for('dispatch_pause')
+
+    assert_equal(
+      %w[ 0/ 0_0/paused 0_0_0/paused ],
+      @dashboard.ps(wfid).expressions.collect { |fe|
+        "#{fe.fei.expid}/#{fe.state}"
+      })
+
+    @dashboard.cancel(exp.fei)
+
+    @dashboard.wait_for(:bob)
+
+    assert_equal(
+      %w[ 0/ 0_1/ ],
+      @dashboard.ps(wfid).expressions.collect { |fe|
+        "#{fe.fei.expid}/#{fe.state}"
+      })
+  end
+
+  class AlphaParticipant
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      @context.tracer << "dispatched:#{workitem.fei.wfid}\n"
+    end
+    def on_pause(fei)
+      @context.tracer << "pause:#{fei.wfid}\n"
+    end
+    def on_resume(fei)
+      @context.tracer << "resume:#{fei.wfid}\n"
+    end
+  end
+
+  def test_propagation_to_participant
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    @dashboard.register do
+      alpha AlphaParticipant
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    #@dashboard.wait_for(:alpha)
+    @dashboard.wait_for('dispatched')
+
+    @dashboard.pause(wfid)
+
+    @dashboard.wait_for('dispatch_pause')
+
+    assert_equal(
+      [ "dispatched:#{wfid}", "pause:#{wfid}" ],
+      @tracer.to_a)
+
+    @dashboard.resume(wfid)
+
+    @dashboard.wait_for('dispatch_resume')
+
+    assert_equal(
+      [ "dispatched:#{wfid}", "pause:#{wfid}", "resume:#{wfid}" ],
+      @tracer.to_a)
+  end
+
+  def test_propagation_to_participant_when_participant_has_already_replied
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    @dashboard.register do
+      alpha AlphaParticipant
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:alpha)
+
+    @dashboard.pause(wfid)
+
+    @dashboard.wait_for('dispatch_pause')
+
+    wi = @dashboard.ps(wfid).expressions.last.h.applied_workitem
+
+    part = @dashboard.participant(:alpha.to_s)
+
+    part.instance_eval { reply_to_engine(Ruote::Workitem.new(wi)) }
+
+    @dashboard.wait_for(1)
+
+    assert_equal(
+      [ "dispatched:#{wfid}", "pause:#{wfid}" ],
+      @tracer.to_a)
+
+    @dashboard.resume(wfid)
+
+    @dashboard.wait_for(wfid)
+
+    assert_equal(
+      [ "dispatched:#{wfid}", "pause:#{wfid}" ],
+      @tracer.to_a)
+        #
+        # no 'resume:xxx'
+  end
+
+  def test_breakpoint
+
+    pdef = Ruote.define do
+      sequence do
+        alpha
+      end
+    end
+
+    @dashboard.register do
+      catchall
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:alpha)
+
+    sequence = @dashboard.ps(wfid).expressions[1]
+
+    @dashboard.pause(sequence.fei, :breakpoint => true)
+
+    @dashboard.storage_participant.proceed(@dashboard.storage_participant.first)
+
+    @dashboard.wait_for('reply')
+
+    assert_equal(
+      [ nil, 'paused' ],
+      @dashboard.ps(wfid).expressions.collect { |fexp| fexp.state })
+  end
+
+  def test_no_propagation_to_participant_when_breakpoint
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    @dashboard.register do
+      alpha AlphaParticipant
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    #@dashboard.wait_for(:alpha)
+    @dashboard.wait_for('dispatched')
+
+    alpha = @dashboard.ps(wfid).expressions.last
+
+    @dashboard.pause(alpha.fei, :breakpoint => true)
+
+    @dashboard.wait_for('pause')
+
+    assert_equal([ "dispatched:#{wfid}" ], @tracer.to_a)
+
+    @dashboard.resume(alpha.fei)
+
+    @dashboard.wait_for('resume')
+
+    assert_equal([ "dispatched:#{wfid}" ], @tracer.to_a)
+  end
+
+  def test_resume_anyway
+
+    pdef = Ruote.define do
+      concurrence do
+        alpha
+        sequence do
+          bravo
+        end
+      end
+    end
+
+    @dashboard.register do
+      catchall
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:alpha)
+    @dashboard.wait_for(:bravo)
+
+    exps = @dashboard.ps(wfid).expressions.select { |fexp|
+      fexp.fei.expid.match(/^0_0_[01]$/)
+    }
+
+    exps.each { |fexp| @dashboard.pause(fexp.fei) }
+
+    @dashboard.wait_for('dispatch_pause')
+    @dashboard.wait_for('dispatch_pause')
+
+    assert_equal(
+      [ nil, nil, 'paused', 'paused', 'paused' ],
+      @dashboard.ps(wfid).expressions.collect { |fexp| fexp.state })
+
+    @dashboard.resume(wfid)
+      # won't resume the process, since the root is not paused
+
+    @dashboard.wait_for(2)
+
+    assert_equal(
+      [ nil, nil, 'paused', 'paused', 'paused' ],
+      @dashboard.ps(wfid).expressions.collect { |fexp| fexp.state })
+
+    @dashboard.resume(wfid, :anyway => true)
+
+    @dashboard.wait_for('dispatch_resume')
+    @dashboard.wait_for('dispatch_resume')
+
+    assert_equal(
+      [ nil, nil, nil, nil, nil ],
+      @dashboard.ps(wfid).expressions.collect { |fexp| fexp.state })
+  end
+end
+