ruote-maestrodev 2.2.1

data/test/functional/ft_21_forget.rb

@@ -0,0 +1,153 @@
+
+#
+# testing ruote
+#
+# Mon Jul 27 09:17:51 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtForgetTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_basic
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha :forget => true
+        alpha
+      end
+    end
+
+    @engine.register_participant :alpha do
+      @tracer << "alpha\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+    wait_for(wfid)
+
+    assert_equal %w[ alpha alpha ].join("\n"), @tracer.to_s
+
+    #logger.log.each { |e| p e }
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'ceased' }.size
+    assert_equal 1, logger.log.select { |e| e['action'] == 'terminated' }.size
+  end
+
+  def test_forgotten_tree
+
+    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha :forget => true
+      end
+    end
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_not_nil ps
+    assert_equal 0, ps.errors.size
+    assert_equal 1, ps.expressions.size
+
+    fei = ps.expressions.first.fei
+    assert_equal fei, ps.root_expression_for(fei).fei
+
+    #puts "not sure..."
+    #p ps.original_tree
+    #p ps.current_tree
+  end
+
+  def test_forget_true_string
+
+    pdef = Ruote.process_definition do
+      concurrence :count => 1 do
+        alpha :forget => 'true'
+        bravo
+      end
+      charly
+    end
+
+    @engine.register_participant '.+' do |wi|
+      @tracer << wi.participant_name + "\n"
+    end
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+    wait_for(wfid)
+
+    #assert_equal "alpha\nbravo\ncharly", @tracer.to_s
+    assert_equal %w[ alpha bravo charly ], @tracer.to_a.sort
+  end
+
+  def test_forget_and_cursor
+
+    pdef = Ruote.define do
+      cursor do
+        alpha :forget => true
+        bravo
+        rewind
+      end
+    end
+
+    @engine.register_participant 'alpha', Ruote::NullParticipant
+      # this participant never replies
+
+    @engine.register_participant 'bravo', Ruote::NoOpParticipant
+      # this one simply replies
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:bravo)
+    @engine.wait_for(:bravo)
+
+    assert_not_nil @engine.process(wfid)
+  end
+
+  # As reported by Nando Sola
+  #
+  # http://groups.google.com/group/openwferu-users/browse_thread/thread/50308e9dce8359e6
+  #
+  def test_forget_on_forget
+
+    pdef = Ruote.define do
+      concurrence do
+        listen :to => 'bravo', :upon =>'reply', :wfid => true do
+          sequence :forget => true do
+            alpha
+          end
+        end
+        bravo
+      end
+    end
+
+    @engine.register do
+      catchall Ruote::NoOpParticipant
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [],
+      @engine.history.all.select { |e| e['action'] == 'error_intercepted' })
+  end
+end
+

data/test/functional/ft_22_process_definitions.rb

@@ -0,0 +1,90 @@
+
+#
+# testing ruote
+#
+# Fri Jul 31 10:21:51 JST 2009
+#
+
+require 'socket' # just for SocketError
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtProcessDefinitionTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_sequence
+
+    pdef = %{
+<process-definition name="test">
+  <sequence>
+    <echo>a</echo>
+    <echo>b</echo>
+  </sequence>
+</process-definition>
+    }
+
+    #noisy
+
+    assert_trace(%w[ a b ], pdef)
+  end
+
+  def test_remote_definitions_not_allowed
+
+    assert_raise ArgumentError do
+      @engine.launch('http://defs.example.com/def0.rb')
+    end
+  end
+
+  def test_remote_definitions_allowed
+
+    @engine.context['remote_definition_allowed'] = true
+
+    e = assert_raise SocketError, OpenURI::HTTPError, ArgumentError do
+      @engine.launch('http://defs.example.com/def0.rb')
+    end
+
+    assert_not_equal 'remote process definitions are not allowed', e.message
+  end
+
+  def test_json_definition
+
+    prev = Rufus::Json.backend
+
+    require 'json' # warning, json 1.4.3 is buggy...
+    #require 'json/pure'
+    Rufus::Json.backend = :json
+
+    #pdef = Ruote.process_definition :name => 'test' do
+    #  sequence do
+    #    echo 'a'
+    #    echo 'b'
+    #  end
+    #end
+    #p pdef.to_json
+
+    assert_trace(
+      %w[ a b ],
+      "[\"define\",{\"name\":\"test\"},[[\"sequence\",{},[[\"echo\",{\"a\":null},[]],[\"echo\",{\"b\":null},[]]]]]]")
+
+    Rufus::Json.backend = prev
+      # back to initial state
+  rescue => e
+    p e
+  end
+
+  def test_local_definition
+
+    path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'pdef.xml'))
+
+    assert_trace(%w[ a b ], path)
+  end
+
+  def test_local_unexpanded_definition
+
+    path = File.join(File.dirname(__FILE__), '..', 'pdef.xml')
+
+    assert_trace(%w[ a b ], path)
+  end
+end
+

data/test/functional/ft_23_load_defs.rb

@@ -0,0 +1,79 @@
+
+#
+# testing ruote
+#
+# Wed Aug  5 08:35:38 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtLoadDefsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_load_definition
+
+    pdef = %{
+Ruote.process_definition :name => 'test' do
+  sequence do
+    echo 'a'
+    echo 'b'
+  end
+end
+    }
+
+    path = File.join('work', 'tmp')
+    fn = File.join(path, 'pdef.rb')
+
+    FileUtils.mkdir_p(path)
+    File.open(fn, 'w') { |f| f.write(pdef) }
+
+    assert_equal(
+      [ 'define', { 'name' => 'test' }, [
+        ['sequence', {}, [
+          ['echo', { 'a' => nil }, [] ],
+          ['echo', { 'b' => nil}, [] ] ] ] ] ],
+      @engine.load_definition(fn))
+  end
+
+  def test_load_definition_with_absolute_path
+
+    pdef = %{
+Ruote.process_definition do
+  echo 'a'
+end
+    }
+
+    path = File.join('work', 'tmp')
+    fn = File.join(path, 'pdef.rb')
+
+    FileUtils.mkdir_p(path)
+    File.open(fn, 'w') { |f| f.write(pdef) }
+
+    fn = File.expand_path(fn)
+
+    assert_equal(
+      [ 'define', {}, [ [ 'echo', { 'a' => nil }, [] ] ] ],
+      @engine.load_definition(fn))
+  end
+
+  def test_load_illegal_definition
+
+    pdef = %{
+Ruote.process_definition :name => 'test' do
+  exit
+end
+    }
+
+    path = File.join('work', 'tmp')
+    fn = File.join(path, 'pdef.rb')
+
+    FileUtils.mkdir_p(path)
+    File.open(fn, 'w') { |f| f.write(pdef) }
+
+    assert_raise Ruote::Reader::Error do
+      @engine.load_definition(fn)
+    end
+  end
+end
+

data/test/functional/ft_24_block_participant.rb

@@ -0,0 +1,235 @@
+
+#
+# testing ruote
+#
+# Tue Aug 11 13:56:28 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtBlockParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_workitems_dispatching_message
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set :var => 'v0', :val => 'v0val'
+        set :field => 'f0', :val => 'f0val'
+        alpha
+        bravo
+        charly
+      end
+    end
+
+    @engine.register_participant :alpha do
+      @tracer << "a\n"
+    end
+    @engine.register_participant :bravo do |workitem|
+      @tracer << "b:f0:#{workitem.fields['f0']}\n"
+    end
+    @engine.register_participant :charly do |workitem, fexp|
+      @tracer << "c:f0:#{workitem.fields['f0']}:#{fexp.lookup_variable('v0')}\n"
+    end
+
+    #noisy
+
+    assert_trace "a\nb:f0:f0val\nc:f0:f0val:v0val", pdef
+  end
+
+  TEST_BLOCK = Ruote.process_definition do
+    sequence do
+      alpha
+      echo '${f:__result__}'
+    end
+  end
+
+  def test_block_result
+
+    return if Ruote::WIN or Ruote::JAVA
+      # defective 'json' lib on windows render this test useless
+
+    @engine.register_participant :alpha do |workitem|
+      'seen'
+    end
+
+    #noisy
+
+    assert_trace 'seen', TEST_BLOCK
+  end
+
+  def test_non_jsonfiable_result
+
+    return if Ruote::WIN
+      # defective 'json' lib on windows renders this test useless
+
+    @engine.register_participant :alpha do |workitem|
+      Time.now
+    end
+
+    #noisy
+
+    match = if defined?(DataMapper) && DataMapper::VERSION < '1.0.0'
+      /^$/
+    else
+      /\b#{Time.now.year}\b/
+    end
+
+    wfid = @engine.launch(TEST_BLOCK)
+
+    @engine.wait_for(wfid)
+
+    assert_match match, @tracer.to_s
+  end
+
+  def test_raise_security_error_before_evaluating_rogue_code
+
+    fn = "test/bad.#{Time.now.to_f}.txt"
+
+    @engine.participant_list = [
+      #[ 'alpha', [ 'Ruote::BlockParticipant', { 'block' => 'exit(3)' } ] ]
+      [ 'alpha', [ 'Ruote::BlockParticipant', { 'block' => "proc { File.open(\"#{fn}\", \"wb\") { |f| f.puts(\"bad\") } }" } ] ]
+    ]
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define { alpha })
+
+    @engine.wait_for(wfid)
+
+    assert_equal false, File.exist?(fn), 'security check not enforced'
+
+    assert_equal 1, @engine.errors(wfid).size
+    assert_match /SecurityError/, @engine.errors(wfid).first.message
+
+    FileUtils.rm(fn) rescue nil
+  end
+
+  def test_raise_security_error_upon_registering_rogue_block_participant
+
+    assert_raise Rufus::SecurityError do
+
+      @engine.register 'rogue' do |workitem|
+        workitem.content = File.read('test/nada.txt')
+      end
+    end
+  end
+
+  def test_on_cancel_registration
+
+    @engine.register 'nemo',
+      :on_workitem => lambda { |wi|
+        p wi
+      },
+      :on_cancel => lambda { |fei, flavour|
+        p fei, flavour
+      }
+
+    assert_equal(
+      { 'on_cancel' => "proc { |fei, flavour|\n        p fei, flavour\n      }",
+        'on_workitem' => "proc { |wi|\n        p wi\n      }" },
+      @engine.participant_list.first.options)
+  end
+
+  def test_on_cancel
+
+    @engine.register 'sleeper',
+      :on_workitem => lambda { |workitem|
+        context.tracer << "consumed\n"
+        sleep 60 # preventing the implicit reply_to_engine(workitem)
+      },
+      :on_cancel => lambda { |fei, flavour|
+        context.tracer << "cancelled\n"
+      }
+
+    pdef = Ruote.define do
+      sleeper
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:sleeper)
+    sleep 0.350
+
+    assert_equal 'consumed', @tracer.to_s
+
+    @engine.cancel(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_equal "consumed\ncancelled", @tracer.to_s
+  end
+
+  def test_on_reply
+
+    @engine.register 'consumer',
+      :on_workitem => lambda { |workitem|
+        context.tracer << "consumed\n"
+      },
+      :on_reply => lambda { |workitem|
+        context.tracer << "replied\n"
+      }
+
+    pdef = Ruote.define do
+      consumer
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal "consumed\nreplied", @tracer.to_s
+  end
+
+  def test_accept
+
+    @engine.register 'consumer',
+      :on_workitem => lambda { |workitem|
+        raise 'fail miserably'
+      },
+      :accept? => lambda { |workitem|
+        false
+      }
+
+    pdef = Ruote.define do
+      consumer
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_match /unknown participant/, @engine.ps(wfid).errors.first.message
+  end
+
+  def test_do_not_thread
+
+    @engine.register 'consumer',
+      :on_workitem => lambda { |workitem|
+        context.tracer << "in\n"
+      },
+      :do_not_thread => lambda { |workitem|
+        context.tracer << "dnt\n"
+        false
+      }
+
+    pdef = Ruote.define do
+      consumer
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(:consumer)
+
+    sleep 0.350
+
+    assert_equal "dnt\nin", @tracer.to_s
+  end
+end
+