ruote 0.9.20 → 2.1.1

data/test/functional/ft_20_storage_participant.rb

@@ -0,0 +1,46 @@
+
+#
+# testing ruote
+#
+# Thu Dec  3 22:39:03 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/storage_participant'
+
+
+class FtStorageParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_participant
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      alpha
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 1, @engine.storage.get_many('workitems').size
+
+    alpha = Ruote::StorageParticipant.new
+    alpha.context = @engine.context
+
+    wi = alpha.first
+
+    assert_equal Ruote::Workitem, wi.class
+
+    alpha.reply(wi)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+  end
+end
+

data/test/functional/ft_21_forget.rb

@@ -0,0 +1,42 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Mon Jul 27 09:17:51 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+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
+end
+

data/test/functional/ft_22_process_definitions.rb

@@ -0,0 +1,80 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# 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(pdef, %w[ a b ])
+  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'
+    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(
+      "[\"define\",{\"name\":\"test\"},[[\"sequence\",{},[[\"echo\",{\"a\":null},[]],[\"echo\",{\"b\":null},[]]]]]]",
+      %w[ a b ])
+
+    Rufus::Json.backend = prev
+      # back to initial state
+  end
+
+  def test_local_definition
+
+    path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'pdef.xml'))
+
+    assert_trace(path, %w[ a b ])
+  end
+end
+

data/test/functional/ft_23_load_defs.rb

@@ -0,0 +1,55 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# 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_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 ArgumentError do
+      @engine.load_definition(fn)
+    end
+  end
+end
+

data/test/functional/ft_24_block_participants.rb

@@ -0,0 +1,59 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# 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 pdef, "a\nb:f0:f0val\nc:f0:f0val:v0val"
+  end
+
+  def test_block_result
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo '${f:__result__}'
+      end
+    end
+
+    @engine.register_participant :alpha do |workitem|
+      'seen'
+    end
+
+    #noisy
+
+    assert_trace pdef, 'seen'
+  end
+end
+

data/test/functional/ft_25_receiver.rb

@@ -0,0 +1,87 @@
+
+#
+# testing ruote
+#
+# Wed Aug 12 23:24:16 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtReceiverTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def setup
+
+    super
+
+    @pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        alpha
+        echo '.'
+      end
+    end
+
+    @alpha = @engine.register_participant 'alpha', MyParticipant.new
+  end
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+
+    attr_accessor :wi
+
+    def consume (workitem)
+
+      @wi = workitem
+
+      # no reply to the engine
+    end
+  end
+
+  class MyReceiver < Ruote::Receiver
+  end
+
+  def test_my_receiver
+
+    receiver = MyReceiver.new(@engine.storage)
+
+    #noisy
+
+    wfid = @engine.launch(@pdef)
+
+    wait_for(:alpha)
+    while @alpha.wi.nil? do
+      Thread.pass
+    end
+
+    assert_equal 3, @engine.process(wfid).expressions.size
+
+    receiver.receive(@alpha.wi)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    rcv = logger.log.select { |e| e['action'] == 'receive' }.first
+    assert_equal 'FtReceiverTest::MyReceiver', rcv['receiver']
+  end
+
+  def test_engine_receive
+
+    wfid = @engine.launch(@pdef)
+
+    wait_for(:alpha)
+
+    @engine.receive(@alpha.wi)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    rcv = logger.log.select { |e| e['action'] == 'receive' }.first
+    assert_equal 'Ruote::Engine', rcv['receiver']
+  end
+end
+

data/test/functional/ft_26_participant_timeout.rb

@@ -0,0 +1,49 @@
+
+#
+# testing ruote
+#
+# Sun Aug 16 14:25:35 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/hash_participant'
+
+
+class FtParticipantTimeoutTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_participant_defined_timeout
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        bravo
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    bravo = @engine.register_participant :bravo, Ruote::HashParticipant.new
+
+    class << alpha
+      def timeout
+        '1s'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(10)
+
+    assert_equal 0, alpha.size
+    assert_equal 1, bravo.size
+
+    #logger.log.each { |l| p l }
+    assert_equal 1, logger.log.select { |e| e['flavour'] == 'timeout' }.size
+    assert_equal 0, @engine.storage.get_many('schedules').size
+
+    assert_not_nil bravo.first.fields['__timed_out__']
+  end
+end
+

data/test/functional/ft_27_var_indirection.rb

@@ -0,0 +1,93 @@
+
+#
+# testing ruote
+#
+# Sun Aug 23 16:59:07 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtVarIndirectionTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_participant_indirection
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:v' => 'alpha'
+        #participant '${v:v}'
+        v
+      end
+    end
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << "alpha\n"
+    end
+
+    #noisy
+
+    assert_trace pdef, 'alpha'
+  end
+
+  def test_subprocess_indirection
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:v' => 'sub0'
+        #subprocess '${v:v}'
+        v
+      end
+      define 'sub0' do
+        echo 'a'
+      end
+    end
+
+    #noisy
+
+    assert_trace pdef, 'a'
+  end
+
+  def test_subprocess_indirection_uri
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:v' => File.join(File.dirname(__FILE__), '..', 'pdef.xml')
+        #subprocess '${v:v}'
+        v
+      end
+    end
+
+    #noisy
+
+    assert_trace pdef, %w[ a b ]
+  end
+
+  def test_subprocess_uri_set_as_engine_variable
+
+    pdef = Ruote.process_definition do
+      v
+    end
+
+    #noisy
+
+    @engine.variables['v'] = File.join(File.dirname(__FILE__), '..', 'pdef.xml')
+
+    assert_trace pdef, %w[ a b ]
+  end
+
+  def test_subprocess_uri_set_as_engine_variable__absolute
+
+    pdef = Ruote.process_definition do
+      v
+    end
+
+    #noisy
+
+    @engine.variables['v'] = File.expand_path(
+      File.join(File.dirname(__FILE__), '..', 'pdef.xml'))
+
+    assert_trace pdef, %w[ a b ]
+  end
+end
+