ruote 0.9.19 → 0.9.20

data/test/extras/test.rb

@@ -0,0 +1,16 @@
+
+#
+# testing Ruote
+#
+# since Mon Oct  9 22:19:44 JST 2006
+#
+
+dirpath = File.dirname(__FILE__)
+
+tests = Dir.new(dirpath).entries.select { |e| e.match(/^et\_.*\.rb$/) }.sort
+
+tests.each { |e| load "#{dirpath}/#{e}" }
+
+#tests.each { |e| puts `ruby #{dirpath}/#{e}` }
+  # making sure that each test is runnable standalone
+

data/test/functional/base.rb

@@ -0,0 +1,198 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Sat Sep 20 23:40:10 JST 2008
+#
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+require File.dirname(__FILE__) + '/engine_helper.rb'
+
+require 'openwfe/engine'
+
+
+module FunctionalBase
+
+  def setup
+
+    @tracer = Tracer.new
+
+    ac = {}
+
+    class << ac
+      alias :old_put :[]=
+      def []= (k, v)
+        raise("!!!!! #{k.class}\n#{k.inspect}") \
+          if k.class != String and k.class != Symbol
+        old_put(k, v)
+      end
+    end
+      #
+      # useful for tracking misuses of the application context
+
+    ac['__tracer'] = @tracer
+    ac[:ruby_eval_allowed] = true
+    ac[:definition_in_launchitem_allowed] = true
+
+    @engine = determine_engine_class(ac).new(ac)
+
+    @terminated_processes = []
+    @engine.get_expression_pool.add_observer(:terminate) do |c, fe, wi|
+      @terminated_processes << fe.fei.wfid
+      #p [ :terminated, @terminated_processes ]
+    end
+  end
+
+  def teardown
+
+    $OWFE_LOG.level = Logger::INFO
+    @engine.stop
+  end
+
+  #
+  # returns true when running on a Ruby 1.8.x like interpreter
+  #
+  def ruby18
+
+    RUBY_VERSION.match(/^1\.8\./)
+  end
+
+  #
+  # launch_thing is a process definition or a launch item
+  #
+  def assert_trace (launch_thing, expected_trace, opts={})
+
+    fei = @engine.launch(launch_thing, opts[:launch_opts] || {})
+
+    wait(fei, opts)
+
+    yield(@engine) if block_given?
+
+    assert_engine_clean(fei, opts)
+
+    assert_equal(expected_trace, @tracer.to_s) if expected_trace
+
+    purge_engine unless opts[:no_purge]
+
+    fei
+  end
+
+  protected
+
+  def log_level_to_debug
+
+    $OWFE_LOG.level = Logger::DEBUG
+  end
+
+  def wait (fei, opts={})
+
+    #opts[:wait] ?
+    #  @engine.wait_for(fei) :
+    #  sleep(opts[:after] || 0.350)
+
+    Thread.pass
+    return if @terminated_processes.include?(fei.wfid)
+    @engine.wait_for(fei)
+  end
+
+  def assert_engine_clean (fei=nil, opts={})
+
+    assert_no_errors(fei, opts)
+    assert_no_remaining_expressions(fei, opts)
+  end
+
+  def assert_no_errors (fei, opts)
+
+    return if opts[:ignore_errors]
+
+    ps = if fei
+      @engine.process_status(fei.wfid)
+    else
+      @engine.process_statuses.values.first
+    end
+
+    return unless ps
+    return if ps.errors.size == 0
+
+    # TODO : implement 'banner' function
+
+    puts '-' * 80
+    puts 'caught process error(s)'
+    puts
+    ps.errors.values.each do |e|
+      puts "  ** error : #{e.error_class} \"#{e.stacktrace}\""
+    end
+    puts '-' * 80
+
+    puts_trace_so_far
+
+    flunk 'caught process error(s)'
+  end
+
+  def assert_no_remaining_expressions (fei, opts)
+
+    return if opts[:ignore_errors]
+
+    expcount = @engine.get_expression_storage.size
+    return if expcount == 1
+
+    50.times { Thread.pass }
+    expcount = @engine.get_expression_storage.size
+    return if expcount == 1
+
+    puts '-' * 80
+    puts 'too many expressions left in storage'
+    puts
+    puts "this test's wfid : #{fei.wfid}"
+    puts
+    puts 'left :'
+    puts
+    puts @engine.get_expression_storage.to_s
+    puts
+    puts '-' * 80
+
+    puts_trace_so_far
+
+    flunk 'too many expressions left in storage'
+  end
+
+  def purge_engine
+
+    @engine.application_context.values.each do |s|
+      s.purge if s.respond_to?(:purge)
+    end
+    FileUtils.rm_rf('work')
+  end
+
+  def puts_trace_so_far
+
+    #puts '. ' * 40
+    puts 'trace so far'
+    puts '---8<---'
+    puts @tracer.to_s
+    puts '--->8---'
+    puts '. ' * 40
+  end
+end
+
+class Tracer
+  def initialize
+    super
+    @trace = ''
+  end
+  def to_s
+    @trace.to_s.strip
+  end
+  def << s
+    @trace << s
+  end
+  def clear
+    @trace = ''
+  end
+  def puts s
+    @trace << "#{s}\n"
+  end
+end
+

data/test/functional/db_ft_0_ar_participants.rb

@@ -0,0 +1,136 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Fri Mar  6 15:13:40 JST 2009
+#
+
+require File.dirname(__FILE__) + '/base'
+
+require 'test/ar_test_connection'
+require 'openwfe/extras/participants/ar_participants'
+
+
+class DbFtArParticipantsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_sequence
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+        alpha
+        bravo
+      end
+    end
+
+    @engine.register_participant 'alpha', OpenWFE::Extras::ArParticipant
+    @engine.register_participant 'bravo', OpenWFE::Extras::ArParticipant
+
+    li = OpenWFE::LaunchItem.new(pdef)
+    li.brand = 'maserati'
+
+    clear_workitems
+
+    @engine.launch(li)
+
+    sleep 0.350
+
+    wis = OpenWFE::Extras::ArWorkitem.find(:all)
+
+    assert_equal 1, wis.size
+
+    wi = wis.first
+
+    assert_equal '0.0.0', wi.expid
+    assert_equal 'alpha', wi.participant_name
+
+    wi.delete
+    @engine.reply(wi.as_owfe_workitem)
+
+    sleep 0.350
+
+    wis = OpenWFE::Extras::ArWorkitem.find(:all)
+
+    assert_equal 1, wis.size
+
+    wi = wis.first
+
+    assert_equal '0.0.1', wi.expid
+    assert_equal 'bravo', wi.participant_name
+
+    wi.delete
+    @engine.reply(wi.as_owfe_workitem)
+
+    sleep 0.350
+
+    assert_engine_clean
+    purge_engine
+  end
+
+  def test_flatten_keywords_0
+
+    assert_flattened(
+      '|a:b|c:d|',
+      { 'a' => 'b', 'c' => 'd' })
+    assert_flattened(
+      '|a:b|c:d|e:|f|g|h|',
+      { 'a' => 'b', 'c' => 'd', 'e' => %w{ f g h } })
+    assert_flattened(
+      '|a:b|c:|d:e|f:g|h:|i|j|',
+      { 'a' => 'b', 'c' => { 'd' => 'e', 'f' => 'g', 'h' => %w{ i j } } })
+    assert_flattened(
+      '|a:b,c|d:e, f|',
+      { 'a' => 'b,c', 'd' => 'e, f' })
+    assert_flattened(
+      '|a:bc|d:e f|',
+      { 'a' => 'b|c', 'd' => 'e| f' })
+  end
+
+  def test_search_workitems
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      participant '${f:target}'
+    end
+
+    @engine.register_participant 'alpha', OpenWFE::Extras::ArParticipant
+    @engine.register_participant 'bravo', OpenWFE::Extras::ArParticipant
+
+    launch(pdef, 'target' => 'alpha')
+    launch(pdef, 'target' => 'bravo')
+
+    sleep 0.350
+
+    assert_equal(
+      1,
+      OpenWFE::Extras::ArWorkitem.search('participant:alpha', nil).size)
+    assert_equal(
+      2,
+      OpenWFE::Extras::ArWorkitem.search('target:', nil).size)
+    assert_equal(
+      1,
+      OpenWFE::Extras::ArWorkitem.search(':bravo', nil).size)
+
+    OpenWFE::Extras::ArWorkitem.destroy_all
+    purge_engine
+  end
+
+  def launch (pdef, fields)
+    li = OpenWFE::LaunchItem.new(pdef)
+    li.fields = li.fields.merge(fields)
+    @engine.launch(li)
+  end
+
+  protected
+
+  def clear_workitems
+    OpenWFE::Extras::ArWorkitem.delete_all
+  end
+
+  def assert_flattened (target, h)
+
+    assert_equal(target, OpenWFE::Extras::ArWorkitem.flatten_keywords(h, nil))
+  end
+end
+

data/test/functional/eft_0_process_definition.rb

@@ -0,0 +1,34 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Sat Jan 24 22:40:35 JST 2009
+#
+
+require File.dirname(__FILE__) + '/base'
+
+
+class EftProcessDefinitionTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class Test0 < OpenWFE::ProcessDefinition
+  end
+  def test_empty_procdef_0
+    assert_trace(Test0, '')
+  end
+
+  def test_empty_procdef_1
+    assert_trace(OpenWFE.process_definition(:name => 'test_1') { }, '')
+  end
+
+  def test_empty_procdef_xml
+    assert_trace(%{
+<process-definition name="test">
+</process-definition>
+      },
+      '')
+  end
+end
+

data/test/functional/eft_10_unset.rb

@@ -0,0 +1,60 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Tue Feb  3 16:40:16 JST 2009
+#
+
+require File.dirname(__FILE__) + '/base'
+
+
+class EftUnsetTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_unset_variables
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+
+        set :v => 'v0', :val => 'a'
+        set :v => 'v1', :val => 'b'
+        set :v => 'v2', :val => 'c'
+
+        echo '${v0}${v1}${v2}'
+
+        unset :v => 'v0'
+        unset :var => 'v1'
+        unset :variable => 'v2'
+
+        echo '..${v0}${v1}${v2}'
+      end
+    end
+
+    assert_trace(pdef, "abc\n..")
+  end
+
+  def test_unset_fields
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+
+        set :f => 'f0', :val => 'a'
+        set :f => 'f1', :val => 'b'
+        set :f => 'f2', :val => 'c'
+
+        echo '${f:f0}${f:f1}${f:f2}'
+
+        unset :f => 'f0'
+        unset :fld => 'f1'
+        unset :field => 'f2'
+
+        echo '..${f:f0}${f:f1}${f:f2}'
+      end
+    end
+
+    assert_trace(pdef, "abc\n..")
+  end
+end
+

data/test/functional/eft_11_sleep.rb

@@ -0,0 +1,95 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Tue Feb 24 14:39:54 JST 2009
+#
+
+require File.dirname(__FILE__) + '/base'
+
+
+class EftSleepTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_sleep_for
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      concurrence do
+        sequence do
+          _sleep :for => '1s'
+          echo 'a'
+        end
+        echo 'b'
+      end
+    end
+
+    assert_trace(pdef, "b\na")
+  end
+
+  def test_sleep_for_implicit
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      concurrence do
+        sequence do
+          _sleep '1s'
+          echo 'a'
+        end
+        echo 'b'
+      end
+    end
+
+    assert_trace(pdef, "b\na")
+  end
+
+  def test_sleep_until
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      concurrence do
+        sequence do
+          _sleep :until => "#{Time.now + 1}"
+          echo 'a'
+        end
+        echo 'b'
+      end
+    end
+
+    assert_trace(pdef, "b\na")
+  end
+
+  def test_sleep_scheduler_job
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      _sleep '1h'
+    end
+
+    fei = @engine.launch(pdef)
+
+    sleep 0.350
+
+    jobs = @engine.get_scheduler.find_jobs(OpenWFE::WaitExpression.name)
+
+    assert_equal 1, jobs.size
+
+    purge_engine
+  end
+
+  def test_sleep_scheduler_job_tags
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      _sleep '1h', :scheduler_tags => 'a, b'
+    end
+
+    fei = @engine.launch(pdef)
+
+    sleep 0.350
+
+    assert_equal 1, @engine.get_scheduler.find_jobs('a').size
+    assert_equal 1, @engine.get_scheduler.find_jobs('b').size
+
+    purge_engine
+  end
+
+end
+