ruote 0.9.19 → 0.9.20

data/test/functional/eft_8_log.rb

@@ -0,0 +1,50 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Thu Sep 13 17:46:20 JST 2007
+#
+
+require 'fileutils'
+
+require File.dirname(__FILE__) + '/base'
+
+
+class EftLogTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_exp
+
+    File.open('logs/ruote.log', 'w') { |f| f.write('') }
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+        log 'log:0'
+        log do
+          'log:1'
+        end
+        log :message => 'log:2'
+        log :message => 'log:3', :level => 'info'
+      end
+    end
+
+    log_level_to_debug # required for the sake of the test
+
+    assert_trace(pdef, '')
+
+    return if defined?(ActiveRecord)
+      # log format altered by ActiveRecord... Have to fix that one day
+
+    assert_equal 1, OpenWFE.grep("DEBUG .*log:0", "logs/ruote.log").size
+    assert_equal 1, OpenWFE.grep('log:0', 'logs/ruote.log').size
+
+    assert_equal 1, OpenWFE.grep('log:1', 'logs/ruote.log').size
+    assert_equal 4, OpenWFE.grep('log:.$', 'logs/ruote.log').size
+
+    assert_equal 1, OpenWFE.grep("INFO .*log:3", "logs/ruote.log").size
+    assert_equal 1, OpenWFE.grep('log:3', 'logs/ruote.log').size
+  end
+end
+

data/test/functional/eft_9_set.rb

@@ -0,0 +1,132 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Tue Feb  3 16:40:16 JST 2009
+#
+
+require File.dirname(__FILE__) + '/base'
+
+
+class EftSetTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_set_variables
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+
+        set :v => 'v0', :value => 'a'
+        set :var => 'v1', :value => 'b'
+        set :variable => 'v2', :value => 'c'
+
+        set :v => 'v3', :val => 'd'
+        set :var => 'v4', :v => 'e' # doesn't work, hence no 'e'
+
+        echo '${v0} ${v1} ${v2} ${v3} ${v4}'
+      end
+    end
+
+    assert_trace(pdef, 'a b c d')
+  end
+
+  def test_set_var_not_string
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+
+        set :v => 'v0', :value => [ 1, 2 ]
+
+        echo '${v0}'
+      end
+    end
+
+    assert_trace(pdef, ruby18 ? '12' : '[1, 2]')
+  end
+
+  def test_set_fields
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+
+        set :f => 'f0', :val => 'a'
+        set :fld => 'f1', :val => 'b'
+        set :field => 'f2', :val => 'c'
+
+        echo '${f:f0} ${f:f1} ${f:f2}'
+      end
+    end
+
+    assert_trace(pdef, 'a b c')
+  end
+
+  def test_set_field_not_string
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+
+        set :f => 'f0', :value => [ 1, 2 ]
+
+        echo '${f:f0}'
+      end
+    end
+
+    assert_trace(pdef, ruby18 ? '12' : '[1, 2]')
+  end
+
+  def test_set_escaped
+
+    @engine.register_participant :peek do |workitem|
+      @tracer << workitem.fields['f0']
+      @tracer << workitem.fields['f1']
+    end
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+        set :f => 'f0', :value => '.${v0}', :escape => 'true'
+        set :f => 'f1', :value => '.${v1}', :escape => true
+        peek
+      end
+    end
+
+    assert_trace(pdef, '.${v0}.${v1}')
+  end
+
+  def test_set_nested
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+
+        set :f => 'f0' do
+          'a'
+        end
+
+        echo '${f:f0}'
+      end
+    end
+
+    assert_trace(pdef, 'a')
+  end
+
+  def test_set_fval_varval
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+
+        set :f => 'f0', :value => 'a'
+        set :v => 'v0', :value => '0'
+        set :f => 'f1', :variable_value => 'v0'
+        set :v => 'v1', :field_value => 'f0'
+        set :f => 'f2', :var_value => 'v0'
+        set :v => 'v2', :f_value => 'f0'
+
+        echo '${f:f0} ${v0} ${f:f1} ${v1} ${f:f2} ${v2}'
+      end
+    end
+
+    assert_trace(pdef, 'a 0 0 a 0 a')
+  end
+end
+

data/test/functional/engine_helper.rb

@@ -0,0 +1,122 @@
+
+#
+# testing Ruote
+#
+# since Mon Oct  9 22:19:44 JST 2006
+#
+
+#
+# Returns the class of the engine to use, based on the ARGV
+#
+def determine_engine_class (application_context)
+
+  if ARGV.include?('--help')
+    puts %{
+
+ARGUMENTS for functional tests :
+
+  --fs  : used OpenWFE::FsPersistedEngine (fast)
+     -y : makes 'fs' store expressions as YAML (slow)
+
+  --tc  : used OpenWFE::TcPersistedEngine (fast) (rufu/edo if possible)
+  --tt  : used OpenWFE::TtPersistedEngine (fast) (rufus/tokyo Tyrant)
+  --TC  : used OpenWFE::TcPersistedEngine (fast) (rufus/tokyo)
+
+  --fp  : uses OpenWFE::FilePersistedEngine (slow and deprecated)
+  --cfp : uses OpenWFE::CachedFilePersistedEngine (fast and deprecated)
+
+  --db  : uses OpenWFE::Extras::DbPersistedEngine
+  --ar  : uses OpenWFE::Extras::ArPersistedEngine (ActiveRecord)
+  --dm  : uses OpenWFE::Extras::DmPersistedEngine (DataMapper)
+
+  -C    : disable caching (used for thorough persistence testing)
+
+else uses the in-memory OpenWFE::Engine (fastest, but no persistence at all)
+
+    }
+    exit 0
+  end
+
+  require 'openwfe/engine'
+
+  application_context[:persist_as_yaml] = true if ARGV.include?('-y')
+  application_context[:no_expstorage_cache] = true if ARGV.include?('-C')
+
+  klass = if $ruote_engine_class
+
+    $ruote_engine_class
+
+  else
+
+    if ARGV.include?('--fp') # very slow
+
+      require 'openwfe/engine/file_persisted_engine'
+      OpenWFE::FilePersistedEngine
+
+    elsif ARGV.include?('--cfp') # fast but not 100% robust
+
+      require 'openwfe/engine/file_persisted_engine'
+      OpenWFE::CachedFilePersistedEngine
+
+    elsif ARGV.include?('--tc') # fast and robust
+
+      application_context[:use_rufus_tokyo] = true
+        # forces to use FFI based bindings (2 times slower)
+
+      require 'openwfe/engine/tc_engine'
+      OpenWFE::TcPersistedEngine
+
+    elsif ARGV.include?('--TC') # fast and robust, fastest
+
+      require 'openwfe/engine/tc_engine'
+      OpenWFE::TcPersistedEngine
+
+    elsif ARGV.include?('--tt') # not slow, robust, remote
+
+      require 'openwfe/engine/tt_engine'
+      OpenWFE::TtPersistedEngine
+
+    elsif ARGV.include?('--fs') # fast and robust
+
+      require 'openwfe/engine/fs_engine'
+      OpenWFE::FsPersistedEngine
+
+    elsif ARGV.include?('--db')
+
+      require File.dirname(__FILE__) + '/../ar_test_connection'
+      require 'openwfe/extras/engine/db_persisted_engine'
+      OpenWFE::Extras::DbPersistedEngine
+
+    elsif ARGV.include?('--ar')
+
+      require File.dirname(__FILE__) + '/../ar_test_connection'
+      require 'openwfe/extras/engine/ar_engine'
+      OpenWFE::Extras::ArPersistedEngine
+
+    elsif ARGV.include?('--dm')
+
+      require File.dirname(__FILE__) + '/../dm_test_connection'
+      require 'openwfe/extras/engine/dm_engine'
+      OpenWFE::Extras::DmPersistedEngine
+
+    else # in-memory, use only for testing !
+
+      OpenWFE::Engine
+    end
+  end
+
+  unless $advertised
+
+    yaml = application_context[:persist_as_yaml] ? ' (yaml)' : ''
+    cache = application_context[:no_expstorage_cache] ? ' (no cache)' : ''
+
+    puts
+    puts "  using engine of class #{klass}#{yaml}#{cache}"
+    puts
+
+    $advertised = true
+  end
+
+  klass
+end
+

data/test/functional/ft_0_vars_at_launch.rb

@@ -0,0 +1,27 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Sat Sep 20 23:40:10 JST 2008
+#
+
+require File.dirname(__FILE__) + '/base'
+
+
+class FtVarsAtLaunchTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class Test0 < OpenWFE::ProcessDefinition
+    echo '${var0}'
+  end
+
+  def test_vars_at_launch
+    assert_trace(
+      Test0,
+      'val0',
+      :launch_opts => { :variables => { 'var0' => 'val0' } })
+  end
+end
+

data/test/functional/ft_1_process_status.rb

@@ -0,0 +1,46 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Since Sat Jul  7 22:44:00 JST 2007 (tanabata)
+#
+
+require File.dirname(__FILE__) + '/base'
+
+require 'openwfe/participants/store_participants'
+
+
+class FtProcessStatusTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_process_status
+
+    #log_level_to_debug
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      store_a
+    end
+
+    sa = @engine.register_participant('store_a', OpenWFE::HashParticipant)
+
+    fei = @engine.launch(pdef)
+
+    sa.join # resumes as soon as a workitem reaches the participant
+
+    ps = @engine.process_statuses
+
+    #p ps[fei.wfid].all_expressions.collect { |fexp| fexp.fei.to_s }
+
+    assert_equal 1, ps.size
+
+    assert_equal 1, ps[fei.wfid].expressions.size
+    assert_equal 3, ps[fei.wfid].all_expressions.size
+    assert_equal 1, ps[fei.wfid].applied_workitems.size
+    assert_equal 0, ps[fei.wfid].errors.size
+
+    purge_engine
+  end
+end
+

data/test/functional/ft_2_file_listener.rb

@@ -0,0 +1,45 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Since Mon Oct  9 22:19:44 JST 2006
+#
+
+require File.dirname(__FILE__) + '/base'
+
+require 'openwfe/listeners/listeners'
+require 'openwfe/participants/participants'
+
+
+class FtFileListenerTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_file_listener
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence do
+        participant :fp
+        echo 'done.'
+      end
+    end
+
+    FileUtils.mkdir('work/in') unless File.exist?('work/in')
+
+    fp = @engine.register_participant(:fp, OpenWFE::FileParticipant)
+    @engine.register_listener(OpenWFE::FileListener, :freq => '300')
+
+    fei = @engine.launch(pdef)
+    sleep 0.350
+
+    assert_equal '', @tracer.to_s
+
+    Dir['work/out/*.yaml'].each { |f| FileUtils.mv(f, 'work/in/') }
+
+    sleep 0.700
+
+    assert_equal 'done.', @tracer.to_s
+  end
+end
+

data/test/functional/ft_3_on_cancel.rb

@@ -0,0 +1,171 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Since Mon Oct  9 22:19:44 JST 2006
+#
+
+require File.dirname(__FILE__) + '/base'
+
+
+class FtOnCancelTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_on_cancel_participant
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence :on_cancel => 'decommission' do
+        alpha
+      end
+    end
+
+    @engine.register_participant(:alpha, OpenWFE::NullParticipant)
+      # receives workitems, discards them, doesn't reply to the engine
+
+    @engine.register_participant(:decommission) do |workitem|
+      @tracer << "#{workitem.fei.wfid} decom\n"
+    end
+
+    fei = @engine.launch(pdef)
+
+    sleep 0.350
+
+    assert_equal '', @tracer.to_s
+
+    ps = @engine.process_status(fei)
+
+    assert_equal 1, ps.expressions.size
+    assert_equal 'alpha', ps.expressions.first.fei.expname
+
+    @engine.cancel_process(fei)
+
+    sleep 0.350
+
+    assert_equal "#{fei.wfid}.0 decom", @tracer.to_s
+
+    assert_nil @engine.process_status(fei)
+  end
+
+  def test_on_cancel_subprocess
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence :on_cancel => 'decommission' do
+        alpha
+      end
+      process_definition :name => 'decommission' do
+        sequence do
+          echo 'decommission...'
+          echo 'decommissioned.'
+        end
+      end
+    end
+
+    @engine.register_participant(:alpha, OpenWFE::NullParticipant)
+      # receives workitems, discards them, doesn't reply to the engine
+
+    fei = @engine.launch(pdef)
+
+    sleep 0.350
+
+    assert_equal '', @tracer.to_s
+
+    @engine.cancel_process(fei)
+
+    sleep 0.350
+
+    assert_equal "decommission...\ndecommissioned.", @tracer.to_s
+
+    assert_nil @engine.process_status(fei)
+  end
+
+  def test_on_cancel_via_cancel_process_expression
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence :on_cancel => 'decommission' do
+        echo 'a'
+        cancel_process
+        echo 'b'
+      end
+      process_definition :name => 'decommission' do
+        sequence do
+          echo 'y'
+          echo 'z'
+        end
+      end
+    end
+
+    fei = @engine.launch(pdef)
+
+    sleep 0.350
+
+    assert_equal "a\ny\nz", @tracer.to_s
+
+    assert_nil @engine.process_status(fei)
+  end
+
+  def test_on_cancel_and_variables
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence :on_cancel => 'decommission' do
+        echo 'a'
+        set :var => 'v0', :val => 'z'
+        cancel_process
+        echo 'b'
+      end
+      process_definition :name => 'decommission' do
+        sequence do
+          echo '${v0}'
+        end
+      end
+    end
+
+    fei = @engine.launch(pdef)
+
+    sleep 0.350
+
+    assert_equal "a\nz", @tracer.to_s
+
+    assert_nil @engine.process_status(fei)
+  end
+
+  def test_on_cancel_and_undo
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence :on_cancel => 'decom', :tag => 'seq' do
+        echo 'a'
+        undo 'seq'
+        echo 'b'
+      end
+      process_definition :name => 'decom' do
+        echo 'd'
+      end
+    end
+
+    assert_trace pdef, "a\nd"
+  end
+
+  def test_on_cancel_and_redo
+
+    pdef = OpenWFE.process_definition :name => 'test' do
+      sequence :on_cancel => 'decom', :tag => 'seq' do
+        echo 'a'
+        _redo 'seq'
+        echo 'b'
+      end
+      process_definition :name => 'decom' do
+        echo 'd'
+      end
+    end
+
+    fei = @engine.launch(pdef)
+
+    sleep 0.350
+
+    assert_equal %w{ a d a b }.join("\n"), @tracer.to_s
+
+    assert_nil @engine.process_status(fei)
+  end
+end
+