ruote-maestrodev 2.2.1

data/test/functional/ft_50_engine_config.rb

@@ -0,0 +1,22 @@
+
+#
+# testing ruote
+#
+# Mon Dec  6 10:40:29 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtEngineConfigTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_engine_config
+
+    @engine.configure('a', 'b')
+
+    assert_equal 'b', @engine.configuration('a')
+    assert_equal 'b', @engine.storage.get_configuration('engine')['a']
+  end
+end
+

data/test/functional/ft_51_misc.rb

@@ -0,0 +1,67 @@
+
+#
+# testing ruote
+#
+# Thu Dec  9 16:39:54 JST 2010
+#
+
+require 'stringio'
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtMiscTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_noisy
+
+    result = String.new
+    out = StringIO.new(result, 'w+')
+
+    prev = $stdout
+    $stdout = out
+
+    @engine.noisy = true
+
+    wfid = @engine.launch(Ruote.define do
+      echo 'nada'
+    end)
+
+    @engine.wait_for(wfid)
+
+    out.close
+    $stdout = prev
+
+    assert_not_nil result
+  end
+
+  class NoCancel
+    def consume(workitem)
+      # do nothing
+    end
+    # no cancel method implementation
+  end
+
+  def test_participant_missing_cancel_method
+
+    pdef = Ruote.define do
+      participant 'no_cancel'
+    end
+
+    @engine.register 'no_cancel', NoCancel
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:no_cancel)
+
+    @engine.cancel(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_match(
+      /undefined method `cancel' for/,
+      @engine.ps(wfid).errors.first.message)
+  end
+end
+

data/test/functional/ft_52_case.rb

@@ -0,0 +1,134 @@
+
+#
+# testing ruote
+#
+# Fri Dec 24 14:53:30 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+#
+# Tests about replacement for case x when 'y' and switch(x) constructs.
+#
+class FtCaseTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  # The alternatives are bound at the process level
+  #
+  def test_open_lambda
+
+    pdef = Ruote.define do
+
+      define 'a' do
+        set 'f:result' => 'a'
+      end
+      define 'b' do
+        set 'f:result' => 'b'
+      end
+
+      subprocess '${the_case}'
+    end
+
+    wfid = @engine.launch(pdef, 'the_case' => 'a')
+    r = @engine.wait_for(wfid)
+    assert_equal 'a', r['workitem']['fields']['result']
+
+    wfid = @engine.launch(pdef, 'the_case' => 'b')
+    r = @engine.wait_for(wfid)
+    assert_equal 'b', r['workitem']['fields']['result']
+  end
+
+  # The alternatives are bound inside of the case subprocess (definition)
+  #
+  def test_nested_lambda
+
+    pdef = Ruote.define do
+
+      define 'case' do
+        define 'a' do
+          set 'f:result' => 'a'
+        end
+        define 'b' do
+          set 'f:result' => 'b'
+        end
+        subprocess '${the_case}'
+      end
+
+      subprocess 'case'
+    end
+
+    wfid = @engine.launch(pdef, 'the_case' => 'a')
+    r = @engine.wait_for(wfid)
+    assert_equal 'a', r['workitem']['fields']['result']
+
+    wfid = @engine.launch(pdef, 'the_case' => 'b')
+    r = @engine.wait_for(wfid)
+    assert_equal 'b', r['workitem']['fields']['result']
+  end
+
+  # /!\
+  #
+  # Works as well, but the cases are bound in the global/process scope
+  #
+  def test_local_lambda
+
+    pdef = Ruote.define do
+
+      sequence do
+        define 'a' do
+          set 'f:result' => 'a'
+        end
+        define 'b' do
+          set 'f:result' => 'b'
+        end
+        subprocess '${the_case}'
+      end
+
+      subprocess 'a' # /!\
+    end
+
+    wfid = @engine.launch(pdef, 'the_case' => 'a')
+    r = @engine.wait_for(wfid)
+    assert_equal 'a', r['workitem']['fields']['result']
+
+    wfid = @engine.launch(pdef, 'the_case' => 'b')
+    r = @engine.wait_for(wfid)
+    assert_equal 'a', r['workitem']['fields']['result']
+  end
+
+  # Works as well, but the cases are bound in the global/process scope
+  #
+  def test_let_lambda
+
+    pdef = Ruote.define do
+
+      define 'a' do
+        echo 'global_a'
+      end
+
+      let do
+        define 'a' do
+          echo 'a'
+        end
+        define 'b' do
+          echo 'b'
+        end
+        subprocess '${the_case}'
+      end
+
+      subprocess 'a'
+    end
+
+    wfid = @engine.launch(pdef, 'the_case' => 'a')
+    @engine.wait_for(wfid)
+    assert_equal %w[ a global_a ], @tracer.to_a
+
+    @tracer.clear
+
+    wfid = @engine.launch(pdef, 'the_case' => 'b')
+    @engine.wait_for(wfid)
+    assert_equal %w[ b global_a ], @tracer.to_a
+  end
+end
+

data/test/functional/ft_53_engine_on_terminate.rb

@@ -0,0 +1,95 @@
+
+#
+# testing ruote
+#
+# Thu Jan  6 21:49:01 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+#require 'ruote/participant'
+
+
+class FtEngineOnTerminateTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_no_on_terminate
+
+    assert_nil @engine.on_terminate
+  end
+
+  def test_on_terminate
+
+    @engine.on_terminate = 'supervisor'
+
+    assert_equal(
+      [ 'define', {}, [ [ 'supervisor', {}, [] ] ] ],
+      @engine.on_terminate)
+  end
+
+  def test_on_terminate_tree
+
+    @engine.on_terminate = Ruote.define do
+      echo '${__terminate__.wfid} terminated'
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(Ruote.define do
+      echo 'main'
+    end)
+
+    @engine.wait_for(wfid)
+    sleep 1
+
+    assert_equal [ 'main', "#{wfid} terminated" ], @tracer.to_a
+  end
+
+  # on_terminate processes are not triggered for on_error processes.
+  #
+  def test_no_on_terminate_when_on_error
+
+    @engine.on_error = Ruote.define do
+      echo 'on_error'
+    end
+    @engine.on_terminate = Ruote.define do
+      echo 'on_terminate'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define do
+      echo 'main'
+      error 'in main'
+    end)
+
+    @engine.wait_for(wfid)
+    sleep 1
+
+    assert_equal [ 'main', 'on_error' ], @tracer.to_a
+  end
+
+  # on_error processes are triggered for on_terminate processes as well.
+  #
+  def test_on_error_when_on_terminate
+
+    @engine.on_error = Ruote.define do
+      echo 'on_error'
+    end
+    @engine.on_terminate = Ruote.define do
+      error 'in on_terminate'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define do
+      echo 'main'
+    end)
+
+    @engine.wait_for(wfid)
+    sleep 1
+
+    assert_equal [ 'main', 'on_error' ], @tracer.to_a
+  end
+end
+

data/test/functional/ft_54_patterns.rb

@@ -0,0 +1,104 @@
+
+#
+# testing ruote
+#
+# Fri Jan  7 15:13:28 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+#require 'ruote/participant'
+
+
+class FtPatternsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+
+  # A task is only enabled when the process instance (of which it is part) is
+  # in a specific state (typically a parallel branch). The state is assumed to
+  # be a specific execution point (also known as a milestone) in the process
+  # model. When this execution point is reached the nominated task can be
+  # enabled. If the process instance has progressed beyond this state, then the
+  # task cannot be enabled now or at any future time (i.e. the deadline has
+  # expired). Note that the execution does not influence the state itself, i.e.
+  # unlike normal control-flow dependencies it is a test rather than a trigger.
+
+  #MILESTONE = Ruote.define do
+  #
+  #  concurrence :count => 1 do
+  #
+  #    sequence do
+  #      participant 'a'
+  #      participant 'b', :tag => 'milestone'
+  #      participant 'c'
+  #    end
+  #
+  #    listen :to => 'milestone', :upon => 'entering', :wfid => true do
+  #      concurrence :count => 1 do
+  #        listen :to => 'milestone', :upon => 'leaving', :wfid => true
+  #        participant 'd'
+  #      end
+  #    end
+  #  end
+  #end
+    # this works, but, if the participant d implementation is 'fast', the
+    # milestone could be left before the inner listen is reached.
+    # This listen could thus listen for an event that already occurred and
+    # thus be locked...
+    #
+    # the revised version makes sure the milestone is listened to (bot#
+    # entering and leaving) before participant b is reached.
+
+  MILESTONE = Ruote.define do
+
+    concurrence do
+
+      sequence do
+        participant 'a'
+        participant 'b', :tag => 'milestone'
+        participant 'c'
+      end
+
+      concurrence :count => 1 do
+        sequence do
+          listen :to => 'milestone', :upon => 'entering', :wfid => true
+          participant 'd'
+        end
+        listen :to => 'milestone', :upon => 'leaving', :wfid => true
+      end
+    end
+  end
+
+  def test_18_milestone
+
+    @engine.register do
+      catchall Ruote::StorageParticipant
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(MILESTONE)
+
+    @engine.wait_for(:a)
+
+    assert_equal({}, @engine.ps(wfid).tags)
+
+    @engine.storage_participant.proceed(@engine.storage_participant.first)
+
+    @engine.wait_for(:d)
+
+    assert_equal %w[ milestone ], @engine.ps(wfid).tags.collect { |t| t.first }
+    assert_equal %w[ b d ], @engine.ps(wfid).position.collect { |pos| pos[1] }
+
+    wi = @engine.storage_participant.by_participant('b').first
+    @engine.storage_participant.proceed(wi)
+
+    @engine.wait_for(:c)
+
+    sleep 0.7 # give some time for the task d to get removed
+
+    assert_equal({}, @engine.ps(wfid).tags)
+    assert_equal %w[ c ], @engine.ps(wfid).position.collect { |pos| pos[1] }
+  end
+end
+

data/test/functional/ft_55_engine_participant.rb

@@ -0,0 +1,303 @@
+
+#
+# testing ruote
+#
+# Wed Jan 20 22:35:20 JST 2010
+#
+# between Denpasar and Singapore
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require_json
+Rufus::Json.detect_backend
+require 'ruote'
+require 'ruote/storage/fs_storage'
+require 'ruote/participant'
+
+
+class FtEngineParticipantTest < Test::Unit::TestCase
+  #include FunctionalBase
+
+  def setup
+
+    @dir0 = "work_0_#{$$}_#{self.object_id}_#{Time.now.to_f}"
+    @dir1 = "work_1_#{$$}_#{self.object_id}_#{Time.now.to_f}"
+
+    @engine0 =
+      Ruote::Engine.new(
+        Ruote::Worker.new(
+          Ruote::FsStorage.new(
+            @dir0,
+            'engine_id' => 'engine0',
+            's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])))
+    @engine1 =
+      Ruote::Engine.new(
+        Ruote::Worker.new(
+          Ruote::FsStorage.new(
+            @dir1,
+            'engine_id' => 'engine1',
+            's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])))
+
+    @tracer0 = Tracer.new
+    @engine0.add_service('tracer', @tracer0)
+
+    @tracer1 = Tracer.new
+    @engine1.add_service('tracer', @tracer1)
+
+    @engine0.register_participant(
+      'engine1',
+      Ruote::EngineParticipant,
+      'storage_class' => Ruote::FsStorage,
+      'storage_path' => 'ruote/storage/fs_storage',
+      'storage_args' => @dir1)
+    @engine1.register_participant(
+      'engine0',
+      Ruote::EngineParticipant,
+      'storage_class' => Ruote::FsStorage,
+      'storage_path' => 'ruote/storage/fs_storage',
+      'storage_args' => @dir0)
+  end
+
+  def teardown
+
+    @engine0.shutdown
+    @engine1.shutdown
+
+  ensure
+    FileUtils.rm_rf(@dir0)
+    FileUtils.rm_rf(@dir1)
+  end
+
+  def noisy
+
+    @engine0.context.logger.noisy = true
+    @engine1.context.logger.noisy = true
+    @engine1.context.logger.color = '32' # green
+  end
+
+  def test_as_participant
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        participant :ref => 'engine1', :pdef => 'subp'
+        echo 'c'
+      end
+      define 'subp' do
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+    @engine0.wait_for(wfid)
+
+    assert_equal "a\nc", @tracer0.to_s
+    assert_equal "b", @tracer1.to_s
+  end
+
+  def test_as_subprocess
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        subprocess 'subp', :engine => 'engine1'
+        echo 'c'
+      end
+      define 'subp' do
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+    @engine0.wait_for(wfid)
+
+    assert_equal "a\nc", @tracer0.to_s
+    assert_equal "b", @tracer1.to_s
+  end
+
+  def test_as_subprocess_2
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        subp :engine => 'engine1'
+        echo 'c'
+      end
+      define 'subp' do
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+    @engine0.wait_for(wfid)
+
+    assert_equal "a\nc", @tracer0.to_s
+    assert_equal "b", @tracer1.to_s
+  end
+
+  def test_cancel_process
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        subp :engine => 'engine1'
+        echo 'c'
+      end
+      define 'subp' do
+        alpha
+      end
+    end
+
+    #noisy
+
+    alpha = @engine1.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine0.launch(pdef)
+
+    @engine1.wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+    assert_not_nil alpha.first.fei.subid
+
+    @engine0.cancel_process(wfid)
+    @engine0.wait_for(wfid)
+
+    #@engine0.wait_for(1) # since dispatch_cancel is asynchronous now
+    sleep 0.777 # but well sometimes the dispatch is too fast
+
+    assert_equal 0, alpha.size
+
+    assert_equal 'a', @tracer0.to_s
+    assert_equal '', @tracer1.to_s
+  end
+
+  def test_with_variables
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:v0' => 'b'
+        echo 'a'
+        subp :engine => 'engine1'
+        echo 'c'
+      end
+      define 'subp' do
+        echo '${r:engine_id}:${v:v0}'
+      end
+    end
+
+    @engine1.context['ruby_eval_allowed'] = true
+      # just for ${r:engine_id}
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+    @engine0.wait_for(wfid)
+
+    assert_equal "a\nc", @tracer0.to_s
+    assert_equal "engine1:b", @tracer1.to_s
+
+    assert_nil @engine0.process(wfid)
+  end
+
+  def test_with_uri
+
+    path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'pdef.xml'))
+
+    pdef = Ruote.process_definition do
+      participant :ref => 'engine1', :pdef => path
+    end
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+    @engine0.wait_for(wfid)
+
+    assert_equal "", @tracer0.to_s
+    assert_equal "a\nb", @tracer1.to_s
+
+    assert_nil @engine0.process(wfid)
+  end
+
+  def test_forget
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        participant :ref => 'engine1', :pdef => 'subp', :forget => true
+        echo 'c'
+      end
+      define 'subp' do
+        bravo
+      end
+    end
+
+    bravo = @engine1.register_participant :bravo, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+    @engine0.wait_for(wfid) # terminated
+
+    assert_equal [], @engine0.processes
+
+    @engine1.wait_for(:bravo)
+
+    bravo.proceed(bravo.first)
+
+    @engine1.wait_for(wfid) # ceased
+
+    assert_equal [], @engine0.processes
+    assert_equal [], @engine1.processes
+  end
+
+  def test_replay_gone_engine_participant
+
+    @engine1.unregister_participant('engine0')
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        participant :ref => 'engine1', :pdef => 'subp'
+        echo 'c'
+      end
+      define 'subp' do
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+    @engine1.wait_for(wfid) # error
+
+    errs = @engine1.process(wfid).errors
+
+    assert_equal 1, errs.size
+
+    # fix error cause
+
+    @engine1.register_participant(
+      'engine0',
+      Ruote::EngineParticipant,
+      'storage_class' => Ruote::FsStorage,
+      'storage_path' => 'ruote/storage/fs_storage',
+      'storage_args' => @dir0)
+
+    # replay
+
+    @engine1.replay_at_error(errs.first)
+
+    @engine0.wait_for(wfid)
+
+    assert_equal "a\nc", @tracer0.to_s
+    assert_equal "b", @tracer1.to_s
+  end
+end
+