ruote-maestrodev 2.2.1

data/test/functional/eft_28_once.rb

@@ -0,0 +1,135 @@
+
+#
+# testing ruote
+#
+# Mon Oct 26 17:49:55 JST 2009
+#
+# in the train from Friboug to Zurich-Flughafen
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftOnceTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_once
+
+    pdef = Ruote.process_definition do
+      echo 'in'
+      concurrence do
+        once '${v:ok}', :freq => '1s' do
+          echo 'done.'
+        end
+        sequence do
+          wait '1s'
+          echo 'over'
+          set 'v:ok' => true
+        end
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ in over done. ], pdef
+
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_once_blocking
+
+    pdef = Ruote.process_definition do
+      echo 'in'
+      concurrence do
+        sequence do
+          once '${v:ok}', :freq => '1s'
+          echo 'done.'
+        end
+        sequence do
+          wait '1s'
+          echo 'over'
+          set 'v:ok' => true
+        end
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ in over done. ], pdef
+
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_cancel
+
+    pdef = Ruote.process_definition do
+      once '${v:ok}', :freq => '10d'
+      echo 'done.'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(2)
+
+    assert_equal 1, @engine.storage.get_many('schedules').size
+
+    @engine.cancel_process(wfid)
+
+    wait_for(4)
+
+    assert_nil @engine.process(wfid)
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_cancel_once_child_is_active
+
+    pdef = Ruote.process_definition do
+      as_soon_as 'true', :freq => '10d' do
+        alpha
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    @engine.cancel(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_equal 0, @engine.storage_participant.size
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_once_cron
+
+    pdef = Ruote.process_definition do
+      echo 'in'
+      concurrence do
+        _when '${v:ok}', :freq => '* * * * * *' do # every second
+          echo 'done.'
+        end
+        sequence do
+          wait '1s'
+          echo 'over'
+          set 'v:ok' => true
+        end
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ in over done. ], pdef
+
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+end
+

data/test/functional/eft_29_cron.rb

@@ -0,0 +1,64 @@
+
+#
+# testing ruote
+#
+# Tue Oct 27 16:13:41 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftCronTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_cron
+
+    pdef = Ruote.process_definition do
+      cron '* * * * * *' do
+        echo 'ok'
+      end
+    end
+
+    #noisy
+
+    t = Time.now
+    wfid = @engine.launch(pdef)
+
+    wait_for(7)
+
+    d = Time.now - t
+
+    @engine.cancel_process(wfid)
+
+    wait_for(5)
+
+    assert_match /^ok\nok/, @tracer.to_s
+    assert_nil @engine.process(wfid)
+    assert_equal 0, @engine.storage.get_many('schedules').size
+    #assert d < 5.0, "#{d} < 5.0 :("
+  end
+
+  def test_every
+
+    pdef = Ruote.process_definition do
+      every '1s' do
+        echo 'ok'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(7)
+
+    @engine.cancel_process(wfid)
+
+    wait_for(5)
+
+    assert_match /^ok\nok/, @tracer.to_s
+    assert_nil @engine.process(wfid)
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+end
+

data/test/functional/eft_2_sequence.rb

@@ -0,0 +1,58 @@
+
+#
+# testing ruote
+#
+# Sat Jan 24 22:40:35 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftSequenceTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_empty_sequence
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+      end
+    end
+
+    #noisy
+
+    assert_trace('', pdef)
+  end
+
+  def test_a_b_sequence
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        echo 'a'
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace("a\nb", pdef)
+  end
+
+  def test_alice_bob_sequence
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        participant :ref => 'alice'
+        participant :ref => 'bob'
+      end
+    end
+
+    @engine.register_participant '.+' do |workitem|
+      @tracer << workitem.participant_name + "\n"
+    end
+
+    #noisy
+
+    assert_trace("alice\nbob", pdef)
+  end
+end
+

data/test/functional/eft_30_ref.rb

@@ -0,0 +1,155 @@
+
+#
+# testing ruote
+#
+# Tue Jul 20 12:47:36 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftRefTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class AlphaParticipant
+    include Ruote::LocalParticipant
+
+    def consume(workitem)
+      @context.tracer << workitem.fei.expid
+      @context.tracer << "\n"
+      reply(workitem)
+    end
+  end
+
+  def test_participant
+
+    pdef = Ruote.process_definition do
+      ref :ref => 'alpha'
+      ref 'alpha'
+      echo 'done.'
+    end
+
+    @engine.register_participant :alpha, AlphaParticipant
+
+    #noisy
+
+    assert_trace %w[ 0_0 0_1 done. ], pdef
+  end
+
+  def test_subprocess
+
+    pdef = Ruote.process_definition do
+
+      define 'alpha' do
+        echo 'alpha'
+      end
+
+      sequence do
+        ref :ref => 'alpha'
+        ref 'alpha'
+        echo 'done.'
+      end
+    end
+
+    assert_trace %w[ alpha alpha done. ], pdef
+  end
+
+  def test_missing_participant_ref
+
+    pdef = Ruote.process_definition do
+      ref 'alpha'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    # correct problem and replay at error
+
+    @engine.register_participant 'alpha', AlphaParticipant
+
+    @engine.replay_at_error(ps.errors.first)
+
+    @engine.wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+    assert_equal '0_0', @tracer.to_s
+  end
+
+  def test_missing_subprocess_ref
+
+    pdef = Ruote.process_definition do
+      ref 'alpha'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    # correct problem and replay at error
+
+    @engine.variables['alpha'] = Ruote.process_definition do
+      echo 'alpha'
+    end
+
+    @engine.replay_at_error(ps.errors.first)
+
+    @engine.wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+    assert_equal 'alpha', @tracer.to_s
+  end
+
+  # Making sure that the ref expression forces the triggered subprocess to
+  # consider its timeout.
+  #
+  def test_ref_and_subprocess_timeout
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    pdef = Ruote.process_definition do
+      define 'sub0' do
+        alpha
+      end
+      ref 'sub0', :timeout => '2d'
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(:alpha)
+
+    scheds = @engine.schedules
+
+    assert_equal 1, scheds.size
+    assert_equal '0_1', scheds.first['target'].expid
+  end
+
+  def test_missing_ref_and_undo
+
+    pdef = Ruote.process_definition do
+      ref 'nemo', :on_error => 'undo'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+  end
+end
+

data/test/functional/eft_31_registerp.rb

@@ -0,0 +1,130 @@
+
+#
+# testing ruote
+#
+# Wed Oct 13 21:22:41 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftRegisterpTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_register_forbidden
+
+    pdef = Ruote.define do
+      registerp 'alpha', :class => 'C', :opt0 => 'val0'
+    end
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    err = @engine.errors.first
+
+    assert_equal(
+      "#<ArgumentError: 'registerp_allowed' is set to false, " +
+      "cannot [un]register participants from process definitions>",
+      err.message)
+  end
+
+  def test_register_from_attributes
+
+    #@engine.noisy = true
+
+    @engine.context['registerp_allowed'] = true
+
+    pdef = Ruote.define do
+      registerp 'alpha', :class => 'C', :opt0 => 'val_a'
+      registerp /bravo/, :class => 'C', :opt0 => 'val_b'
+      registerp :regex => /charly/, :class => 'C', :opt0 => 'val_c'
+      registerp :regex => 'delta', :class => 'C', :opt0 => 'val_d'
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [
+        [ '^alpha$', [ 'C', { 'opt0' => 'val_a' } ] ],
+        [ 'bravo', [ 'C', { 'opt0' => 'val_b' } ] ],
+        [ 'charly', [ 'C', { 'opt0' => 'val_c' } ] ],
+        [ 'delta', [ 'C', { 'opt0' => 'val_d' } ] ]
+      ],
+      @engine.participant_list.collect { |e| e.to_a })
+  end
+
+  def test_register_from_workitem
+
+    #@engine.noisy = true
+
+    @engine.context['registerp_allowed'] = true
+
+    pdef = Ruote.define do
+      registerp :participants => 'participants'
+      registerp :participant => 'participant'
+    end
+
+    wfid = @engine.launch(pdef,
+      'participants' => [
+        [ 'alpha', 'C', { 'opt0' => 'val_a' } ],
+        [ '/bravo/', 'C', { 'opt0' => 'val_b' } ]
+      ],
+      'participant' => [ '/charly/', 'C', { 'opt0' => 'val_c' } ])
+
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [
+        [ '^alpha$', [ 'C', { 'opt0' => 'val_a' } ] ],
+        [ 'bravo', [ 'C', { 'opt0' => 'val_b' } ] ],
+        [ 'charly', [ 'C', { 'opt0' => 'val_c' } ] ]
+      ],
+      @engine.participant_list.collect { |e| e.to_a })
+  end
+
+  def test_register_with_position
+
+    #@engine.noisy = true
+
+    @engine.context['registerp_allowed'] = true
+
+    pdef = Ruote.define do
+      registerp 'alpha', :class => 'C', :opt0 => 'val_a'
+      registerp /bravo/, :class => 'C', :opt0 => 'val_b', :position => 0
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [
+        [ 'bravo', [ 'C', { 'opt0' => 'val_b', 'position' => 0 } ] ],
+        [ '^alpha$', [ 'C', { 'opt0' => 'val_a' } ] ]
+      ],
+      @engine.participant_list.collect { |e| e.to_a })
+  end
+
+  def test_unregister
+
+    #@engine.noisy = true
+
+    @engine.context['registerp_allowed'] = true
+
+    pdef = Ruote.define do
+      registerp 'alpha', :class => 'C', :opt0 => 'val_a'
+      unregisterp 'alpha'
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [],
+      @engine.participant_list.collect { |e| e.to_a })
+  end
+end
+