ruote-maestrodev 2.2.1

data/test/functional/ft_40_wait_logger.rb

@@ -0,0 +1,62 @@
+
+#
+# testing ruote
+#
+# Tue Apr 20 12:32:44 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/storage_participant'
+
+
+class FtWaitLoggerTest < Test::Unit::TestCase
+
+  def teardown
+
+    @engine.shutdown
+    @engine.context.storage.purge!
+  end
+
+  def test_wait_logger
+
+    @engine = Ruote::Engine.new(Ruote::Worker.new(determine_storage({})))
+
+    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    pdef = Ruote.process_definition { alpha }
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(:alpha)
+    assert_equal 'dispatch', r['action']
+
+    sp.proceed(sp.first)
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+  end
+
+  def test_wait_logger_seen
+
+    @engine = Ruote::Engine.new(Ruote::Worker.new(determine_storage({})))
+
+    #@engine.noisy = true
+
+    pdef = Ruote.process_definition { }
+
+    wfid = @engine.launch(pdef)
+
+    sleep 0.500
+    sleep 2.000 if @engine.storage.class.name.match(/Couch/)
+
+    assert_equal 2, @engine.context.logger.instance_variable_get(:@seen).size
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal 0, @engine.context.logger.instance_variable_get(:@seen).size
+  end
+end
+

data/test/functional/ft_41_participants.rb

@@ -0,0 +1,91 @@
+
+#
+# testing ruote
+#
+# Mon Jun 14 12:02:53 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtParticipantsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      workitem.fields['seen'] = true
+      reply_to_engine(workitem)
+    end
+  end
+
+  class MyMessageParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+      @opts = opts
+    end
+    def consume(workitem)
+      workitem.fields['message'] = @opts['message']
+      reply_to_engine(workitem)
+    end
+  end
+
+  def test_participant_without_initialize
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.process_definition do
+      alpha
+    end)
+
+    r = wait_for(wfid)
+
+    assert_equal true, r['workitem']['fields']['seen']
+  end
+
+  def test_participant_with_initialize
+
+    @engine.register_participant :bravo, MyMessageParticipant, 'message' => 'hi'
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.process_definition do
+      bravo
+    end)
+
+    r = wait_for(wfid)
+
+    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_42_storage_copy.rb

@@ -0,0 +1,71 @@
+
+#
+# testing ruote
+#
+# Tue Jun 15 09:07:58 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/storage_participant'
+
+
+class FtStorageCopyTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_copy_to_hash_storage
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.process_definition do
+      sequence do
+        alpha :timeout => '2d'
+      end
+    end)
+
+    wait_for(:alpha)
+
+    sleep 0.100 # making sure msgs have all been processed
+
+    target = Ruote::HashStorage.new
+    source = @engine.context.storage
+
+    #count = source.copy_to(target, :verbose => true)
+    count = source.copy_to(target)
+
+    assert_equal 8, count
+    assert_equal source.ids('expressions'), target.ids('expressions')
+  end
+
+  def test_copy_from_hash_storage
+
+    engine = Ruote::Engine.new(Ruote::Worker.new(Ruote::HashStorage.new()))
+
+    engine.register_participant '.+', Ruote::StorageParticipant
+
+    #engine.context.logger.noisy = true
+
+    wfid = engine.launch(Ruote.process_definition do
+      sequence do
+        alpha :timeout => '2d'
+      end
+    end)
+
+    engine.wait_for(:alpha)
+
+    sleep 0.100 # making sure msgs have all been processed
+
+    source = engine.context.storage
+    target = @engine.context.storage
+
+    #count = source.copy_to(target, :verbose => true)
+    count = source.copy_to(target)
+
+    assert_equal 8, count
+    assert_equal source.ids('expressions'), target.ids('expressions')
+    assert_not_nil @engine.process(wfid)
+  end
+end
+

data/test/functional/ft_43_participant_on_reply.rb

@@ -0,0 +1,87 @@
+
+#
+# testing ruote
+#
+# Thu Apr 22 14:41:38 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtParticipantOnReplyTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+    end
+    def consume(workitem)
+      reply(workitem)
+    end
+    def on_reply(workitem)
+      workitem.fields['message'] = 'hello'
+    end
+  end
+
+  def test_participant_on_reply
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo '${f:message}'
+      end
+    end
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    assert_trace('hello', pdef)
+  end
+
+  class AwkwardParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+    end
+    def consume(workitem)
+      reply(workitem)
+    end
+    def on_reply(workitem)
+      return if workitem.fields['pass']
+      raise "something went wrong"
+    end
+  end
+
+  def test_participant_on_reply_error
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'over.'
+      end
+    end
+
+    @engine.register_participant :alpha, AwkwardParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    err = ps.errors.first
+    err.fields['pass'] = true
+    @engine.replay_at_error(err)
+
+    wait_for(wfid)
+
+    assert_equal 'over.', @tracer.to_s
+  end
+end
+

data/test/functional/ft_44_var_participant.rb

@@ -0,0 +1,35 @@
+
+#
+# testing ruote
+#
+# Wed Jul 14 09:43:58 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtVarParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_var_participant
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:alpha' => [ 'Ruote::StorageParticipant', {} ]
+        alpha
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    assert_equal 1, @engine.storage_participant.size
+    assert_equal 'alpha', @engine.storage_participant.first.participant_name
+  end
+end
+

data/test/functional/ft_45_participant_accept.rb

@@ -0,0 +1,64 @@
+
+#
+# testing ruote
+#
+# Wed Jul 21 13:37:59 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtParticipantAcceptTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+
+    def initialize(opts)
+      @opts = opts
+    end
+
+    def accept?(workitem)
+      workitem.participant_name.match(@opts['filter'] || '.?')
+    end
+
+    def consume(workitem)
+      @context.tracer << 'filtered:'
+      @context.tracer << workitem.participant_name
+      @context.tracer << "\n"
+      reply(workitem)
+    end
+  end
+
+  class MyOtherParticipant
+    include Ruote::LocalParticipant
+
+    def consume(workitem)
+      @context.tracer << workitem.participant_name
+      @context.tracer << "\n"
+      reply(workitem)
+    end
+  end
+
+  def test_participant_on_reply
+
+    pdef = Ruote.process_definition do
+      sequence do
+        absolute
+        aberrant
+        aloof
+        nada
+      end
+    end
+
+    @engine.register_participant 'a.+', MyParticipant, 'filter' => '^ab'
+    @engine.register_participant '.+', MyOtherParticipant
+
+    #noisy
+
+    assert_trace %w[ filtered:absolute filtered:aberrant aloof nada ], pdef
+  end
+end
+

data/test/functional/ft_46_launch_single.rb

@@ -0,0 +1,83 @@
+
+#
+# testing ruote
+#
+# Sat Sep 25 23:24:16 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtLaunchSingleTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_no_name_singles_are_rejected
+
+    assert_raise ArgumentError do
+      @engine.launch_single(Ruote.process_definition do
+        wait '2y'
+        echo 'over.'
+      end)
+    end
+  end
+
+  def test_launch_single
+
+    pdef = Ruote.process_definition 'unique_process' do
+      wait '2y'
+      echo 'over.'
+    end
+
+    #noisy
+
+    wfid = @engine.launch_single(pdef)
+
+    assert_equal(
+      wfid,
+      @engine.storage.get('variables', 'singles')['h']['unique_process'].first)
+
+    @engine.wait_for(2)
+
+    assert_not_nil @engine.process(wfid)
+
+    wfid1 = @engine.launch_single(pdef)
+
+    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
+