ruote 2.1.9 → 2.1.10

data/test/functional/ft_5_on_error.rb

@@ -30,6 +30,54 @@ class FtOnErrorTest < Test::Unit::TestCase
     assert_equal 1, logger.log.select { |e| e['action'] == 'fail' }.size
   end
 
+  def test_on_error_unknown_participant_name
+
+    pdef = Ruote.process_definition :name => 'test' do
+      participant :mark_started
+      sequence :on_error => :mark_failed do
+        participant :bogus
+      end
+      participant :mark_finished
+    end
+
+    @marks = []
+
+    @engine.register_participant 'mark\_.+' do |workitem|
+      @marks << workitem.participant_name
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    assert_equal %w[ mark_started mark_failed mark_finished ], @marks
+  end
+
+  def test_on_error_unknown_participant_name_2
+
+    pdef = Ruote.process_definition :name => 'test' do
+      participant :mark_started
+      participant :bogus, :on_error => :mark_failed
+      participant :mark_finished
+    end
+
+    @marks = []
+
+    @engine.register_participant 'mark\_.+' do |workitem|
+      @marks << workitem.participant_name
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    assert_equal %w[ mark_started mark_failed mark_finished ], @marks
+  end
+
   def test_on_error_neutralization
 
     pdef = Ruote.process_definition do
@@ -96,6 +144,26 @@ class FtOnErrorTest < Test::Unit::TestCase
     assert_nil @engine.process(wfid)
   end
 
+  def test_on_error_undo__pass
+
+    @engine.register_participant :nemo do |wi|
+      wi.fields['fail_count'] = 1
+      raise 'nemo'
+    end
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'in'
+        nemo :on_error => 'undo'
+        echo '${f:error}|${f:fail_count}'
+      end
+    end
+
+    wfid = assert_trace(%w[ in |1 ], pdef)
+
+    assert_nil @engine.process(wfid)
+  end
+
   def test_missing_handler_triggers_regular_error
 
     pdef = Ruote.process_definition :on_error => 'failpath' do
@@ -151,5 +219,40 @@ class FtOnErrorTest < Test::Unit::TestCase
     assert_equal 1, a_count
     assert_equal 1, e_count
   end
+
+  def test_participant_on_error
+
+    pdef = Ruote.process_definition do
+      troublemaker :on_error => 'handle_error'
+      define 'handle_error' do
+        troublespotter
+      end
+    end
+
+    workitem = nil
+
+    @engine.register_participant :troublemaker do |wi|
+      wi.fields['seen'] = true
+      raise 'Beijing, we have a problem !'
+    end
+    @engine.register_participant :troublespotter do |wi|
+      workitem = wi
+      @tracer << 'err...'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    #er = @engine.process(wfid).errors.first
+    #puts er.message
+    #puts er.trace
+
+    assert_equal 'err...', @tracer.to_s
+    assert_equal 4, workitem.error.size
+    assert_equal 'RuntimeError', workitem.error[2]
+    assert_equal true, workitem.fields['seen']
+  end
 end
 

data/test/functional/ft_9_subprocesses.rb

@@ -82,8 +82,9 @@ class FtSubprocessesTest < Test::Unit::TestCase
 
     wait_for(:alpha)
     wait_for(:alpha)
-    wait_for(1)
+    wait_for(3)
 
+    assert_equal 2, wfids.size
     assert_equal 2, wfids.sort.uniq.size
   end
 

data/test/functional/storage_helper.rb

@@ -66,7 +66,11 @@ else uses the in-memory Ruote::Engine (fastest, but no persistence at all)
     lib, path = pers
     $:.unshift(File.join(path, 'lib'))
 
-    load File.join(path, %w[ test integration_connection.rb ])
+    begin
+      load File.join(path, %w[ test functional_connection.rb ])
+    rescue LoadError => le
+      load File.join(path, %w[ test integration_connection.rb ])
+    end
 
     new_storage(opts)
 

data/test/functional/test.rb

@@ -15,7 +15,10 @@ def l (t)
     puts "=== #{t} :"
     puts `ruby#{_v} #{t} #{ARGV.join(' ')}`
 
-    exit $?.exitstatus if $?.exitstatus != 0
+    es = $?.exitstatus
+    es = es.nil? ? 66 : es.to_s.to_i
+
+    exit(es) if es != 0
   else
     load(t)
   end

data/test/functional/vertical.rb

@@ -0,0 +1,46 @@
+
+#require 'open3'
+
+TEST = ARGV[0]
+
+STORAGES = %w[ fs dm couch redis beanstalk ].unshift(nil)
+
+unless TEST
+  puts %{
+
+USAGE :
+
+  ruby test/functional/vertical.rb path/to/test.rb
+
+will run the given test with against all the storage implementations.
+
+#{STORAGES}
+
+  }
+  exit 0
+end
+
+STORAGES.each do |storage|
+
+  dashdash = `ruby -v`.match(/^ruby 1\.9\./) ? '' : '--'
+  storage = storage.nil? ? '' : "--#{storage}"
+
+  command = "ruby #{TEST} #{dashdash} #{storage}"
+  puts('-' * 80)
+  puts("#{command}")
+
+  #Open3.popen3("#{command} 2>&1") do |_, stdout, _|
+  #  loop do
+  #    s = stdout.read(7)
+  #    break unless s
+  #    $stdout.print(s)
+  #    $stdout.flush
+  #  end
+  #end
+    # popen3 is nice, but it doesn't set $?
+
+  puts `#{command} 2>&1`
+
+  puts("\nFAILED\n\n") if $?.exitstatus.to_i != 0
+end
+

data/test/unit/storage.rb

@@ -24,6 +24,7 @@ class UtStorage < Test::Unit::TestCase
       'message' => 'testing')
   end
   def teardown
+
     @s.get_many('dogfood').each { |d| @s.delete(d) }
   end
 
@@ -92,6 +93,19 @@ class UtStorage < Test::Unit::TestCase
     assert_nil r
   end
 
+  def test_put_update_rev_twice
+
+    doc = { '_id' => 'ouinouin', 'type' => 'dogfood', 'message' => 'more' }
+
+    r = @s.put(doc, :update_rev => true)
+    assert_nil r
+
+    doc = { '_id' => 'ouinouin', 'type' => 'dogfood', 'message' => 'more' }
+
+    r = @s.put(doc, :update_rev => true)
+    assert_not_nil r
+  end
+
   def test_delete_fail
 
     assert_raise(ArgumentError) do
@@ -153,7 +167,7 @@ class UtStorage < Test::Unit::TestCase
     @s.put('_id' => 'nada', 'type' => 'dogfood', 'message' => 'testing')
     @s.put('_id' => 'estereo', 'type' => 'dogfood', 'message' => 'testing')
 
-    assert_equal %w[ estereo nada ouinouin toto ], @s.ids('dogfood')
+    assert_equal %w[ estereo nada ouinouin toto ], @s.ids('dogfood').sort
   end
 
   def test_get_many
@@ -165,6 +179,8 @@ class UtStorage < Test::Unit::TestCase
     assert_equal 31, @s.get_many('dogfood').size
     assert_equal 10, @s.get_many('dogfood', nil, :limit => 10).size
     assert_equal 1, @s.get_many('dogfood', /!7$/).size
+    assert_equal 30, @s.get_many('dogfood', /^xx!/).size
+    assert_equal 30, @s.get_many('dogfood', /x/).size
   end
 end
 

data/test/unit/storages.rb

@@ -1,17 +1,37 @@
 
-puts "\n\n\n== in memory"
+dashdash = `ruby -v`.match(/^ruby 1\.9\./) ? '' : '--'
+
+puts("\n\n== in memory")
 puts
 puts `ruby test/unit/storage.rb`
+puts("\nFAILED") if $?.exitstatus.to_i != 0
+
+puts("\n\n== fs")
+puts
+puts `ruby test/unit/storage.rb #{dashdash} --fs`
+puts("\nFAILED") if $?.exitstatus.to_i != 0
+
+puts("\n\n== route-couch")
+puts
+#puts `ruby -r patron -r yajl test/unit/storage.rb #{dashdash} --couch`
+puts `ruby test/unit/storage.rb #{dashdash} --couch`
+puts("\nFAILED") if $?.exitstatus.to_i != 0
 
-puts "\n\n\n== fs_storage"
+puts("\n\n== route-dm")
 puts
-puts `ruby test/unit/storage.rb --fs`
+#puts `ruby -r yajl test/unit/storage.rb #{dashdash} --dm`
+puts `ruby test/unit/storage.rb #{dashdash} --dm`
+puts("\nFAILED") if $?.exitstatus.to_i != 0
 
-puts "\n\n\n== couch_storage"
+puts("\n\n== route-redis")
 puts
-puts `ruby -r patron -r yajl test/unit/storage.rb --couch`
+#puts `ruby -r yajl test/unit/storage.rb #{dashdash} --redis`
+puts `ruby test/unit/storage.rb #{dashdash} --redis`
+puts("\nFAILED") if $?.exitstatus.to_i != 0
 
-puts "\n\n\n== dm_storage"
+puts("\n\n== route-beanstalk")
 puts
-puts `ruby -r yajl test/unit/storage.rb --dm`
+#puts `ruby -r yajl test/unit/storage.rb #{dashdash} --beanstalk`
+puts `ruby test/unit/storage.rb #{dashdash} --beanstalk`
+puts("\nFAILED") if $?.exitstatus.to_i != 0
 

data/test/unit/ut_11_lookup.rb

@@ -47,5 +47,41 @@ class LookupTest < Test::Unit::TestCase
 
     assert_equal({"customer.name"=>"bravo"}, h)
   end
+
+  def test_hash_unset
+
+    h = { 'customer' => { 'name' => 'alpha', 'rank' => '1st' } }
+    r = Ruote.unset(h, 'customer.rank')
+
+    assert_equal('1st', r)
+    assert_equal({ 'customer' => { 'name' => 'alpha' } }, h)
+  end
+
+  def test_array_unset
+
+    h = { 'customers' => %w[ alpha bravo charly ] }
+    r = Ruote.unset(h, 'customers.1')
+
+    assert_equal('bravo', r)
+    assert_equal({ 'customers' => %w[ alpha charly ] }, h)
+  end
+
+  def test_array_unset_fail
+
+    h = { 'customers' => %w[ alpha bravo charly ] }
+    r = Ruote.unset(h, 'customers.x')
+
+    assert_equal(nil, r)
+    assert_equal({ 'customers' => %w[ alpha bravo charly ] }, h)
+  end
+
+  def test_unset_fail
+
+    h = { 'customer' => { 'name' => 'alpha', 'rank' => '1st' } }
+    r = Ruote.unset(h, 'customer.rank.0')
+
+    assert_equal(nil, r)
+    assert_equal({ 'customer' => { 'name' => 'alpha', 'rank' => '1st' } }, h)
+  end
 end
 

data/test/unit/ut_16_parser.rb

@@ -75,6 +75,26 @@ class PdefParserTest < Test::Unit::TestCase
       Ruote::Parser.to_xml(TREE1, :indent => 2).strip)
   end
 
+  def test_if_to_xml
+
+    tree = Ruote.process_definition do
+      _if 'nada' do
+        participant 'nemo'
+      end
+    end
+
+    assert_equal(
+      %{
+<?xml version="1.0" encoding="UTF-8"?>
+<define>
+  <if test="nada">
+    <participant ref="nemo"/>
+  </if>
+</define>
+      }.strip,
+      Ruote::Parser.to_xml(tree, :indent => 2).strip)
+  end
+
   def test_to_ruby
 
     #puts Ruote::Parser.to_ruby(TREE1)
@@ -96,5 +116,28 @@ end
 
     assert_equal TREE1.to_json, Ruote::Parser.to_json(TREE1)
   end
+
+  DEF1 = %{
+Ruote.process_definition do
+  sequence do
+    alpha
+    set :field => 'f', :value => 'v'
+    bravo
+  end
+end
+  }
+
+  def test_from_ruby_file
+
+    fn = File.expand_path(File.join(File.dirname(__FILE__), '_ut_16_def1.rb'))
+
+    File.open(fn, 'wb') { |f| f.write(DEF1) }
+
+    assert_equal(
+      ["define", {}, [["sequence", {}, [["alpha", {}, []], ["set", {"field"=>"f", "value"=>"v"}, []], ["bravo", {}, []]]]]],
+      Ruote::Parser.parse(fn))
+
+    FileUtils.rm(fn)
+  end
 end
 

data/test/unit/ut_1_fei.rb

@@ -7,7 +7,7 @@
 
 require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
 
-require 'ruote/fei'
+require 'ruote'
 
 
 class UtFeiTest < Test::Unit::TestCase
@@ -86,6 +86,33 @@ class UtFeiTest < Test::Unit::TestCase
     assert_equal(
       '0_0_1!!20100224-fake',
       Ruote::FlowExpressionId.from_id('wi!store!0_0_1!!20100224-fake').to_storage_id)
+
+    assert_equal(
+      '0_0_1!!20100224-fake',
+      Ruote::FlowExpressionId.from_id('eng!0_0_1!!20100224-fake').to_storage_id)
+    assert_equal(
+      'eng',
+      Ruote::FlowExpressionId.from_id('eng!0_0_1!!20100224-fake').engine_id)
+  end
+
+  def test_extract_h
+
+    assert_equal(
+      { 'engine_id' => 'engine',
+        'expid' => '0_0_1',
+        'sub_wfid' => '',
+        'wfid' => '20100224-fake' },
+      Ruote::FlowExpressionId.extract_h('0_0_1!!20100224-fake'))
+  end
+
+  def test_extract
+    assert_equal(
+      Ruote::FlowExpressionId.new(
+        { 'engine_id' => 'engine',
+          'expid' => '0_0_1',
+          'sub_wfid' => '',
+          'wfid' => '20100224-fake' }),
+      Ruote::FlowExpressionId.extract('0_0_1!!20100224-fake'))
   end
 end
 

data/test/unit/ut_7_workitem.rb

@@ -44,5 +44,28 @@ class UtWorkitemTest < Test::Unit::TestCase
     w0.set_field('customer.address', [ 'Cornwall Square 10b', 'Singapore-La' ])
     assert_equal 'Cornwall Square 10b', w0.lookup('customer.address.0')
   end
+
+  #def test_indifferent_access
+  #  w0 = Ruote::Workitem.new(
+  #    'fields' => { 'customer' => 'john' })
+  #  assert_equal 'john', w0.fields['customer']
+  #  assert_equal 'john', w0.fields[:customer]
+  #end
+
+  def test_sid
+
+    f0 = { 'expid' => '0', 'wfid' => '20101224-baba', 'engine_id' => 'engine' }
+    w0 = Ruote::Workitem.new('fei' => f0, 'fields' => { 'a' => 'A' })
+
+    assert_equal '0!!20101224-baba', w0.sid
+  end
+
+  def test_wfid
+
+    f0 = { 'expid' => '0', 'wfid' => '20101224-baba', 'engine_id' => 'engine' }
+    w0 = Ruote::Workitem.new('fei' => f0, 'fields' => { 'a' => 'A' })
+
+    assert_equal '20101224-baba', w0.wfid
+  end
 end