ruote 2.2.0 → 2.3.0

data/test/unit/ut_12_wait_logger.rb

@@ -0,0 +1,123 @@
+
+#
+# testing ruote
+#
+# Thu Dec 10 14:08:30 JST 2009
+#
+
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'ruote'
+
+
+class UtWaitLoggerTest < Test::Unit::TestCase
+
+  def setup
+    @engine = Ruote::Engine.new(Ruote::Worker.new(Ruote::HashStorage.new))
+    @engine.register :alpha, Ruote::StorageParticipant
+  end
+  def teardown
+    @engine.shutdown
+  end
+
+  def test_wait_for_participant
+
+    #@engine.noisy = true
+
+    pdef = Ruote.process_definition :name => 'test' do
+      alpha
+    end
+
+    @engine.launch(pdef)
+    msg = @engine.wait_for(:alpha)
+
+    assert_equal 1, @engine.storage_participant.size
+
+    assert_not_nil msg
+    assert_not_nil msg['workitem']
+    assert_equal 'dispatch', msg['action']
+  end
+
+  def test_wait_for_action
+
+    #@engine.noisy = true
+
+    pdef = Ruote.process_definition :name => 'test' do
+      alpha
+    end
+
+    @engine.launch(pdef)
+
+    msg = @engine.wait_for('apply')
+
+    assert_equal 'apply', msg['action']
+
+    msg = @engine.wait_for('dispatch')
+
+    assert_equal 'dispatch', msg['action']
+  end
+
+  def test_wait_for_muliple_things
+
+    d0 = Ruote.define do
+      7.times { noop }
+    end
+    d1 = Ruote.define do
+      7.times { noop }
+      error 'oh crap'
+    end
+
+    #@engine.noisy = true
+
+    i0 = @engine.launch(d0)
+    i1 = @engine.launch(d1)
+
+    r = @engine.wait_for(i0, i1)
+
+    assert [ i0, i1 ].include?(r['wfid'])
+    assert %w[ terminated error_intercepted ].include?(r['action'])
+  end
+
+  def test_or_error
+
+    @engine.register :alpha, Ruote::NullParticipant
+
+    d0 = Ruote.define do
+      35.times { noop }
+      alpha
+    end
+    d1 = Ruote.define do
+      3.times { noop }
+      error 'oh crap'
+    end
+
+    #@engine.noisy = true
+
+    i0 = @engine.launch(d0)
+    i1 = @engine.launch(d1)
+
+    r = @engine.wait_for(:alpha, :or_error)
+
+    assert_equal i1, r['wfid']
+    assert_equal 'error_intercepted', r['action']
+  end
+
+  def test_wait_for_hash
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(Ruote.define do
+      sequence do
+        cursor do
+          wait '1d'
+        end
+      end
+    end)
+
+    r = @engine.wait_for('action' => 'apply', 'exp_name' => 'wait')
+
+    assert_equal 'apply', r['action']
+    assert_equal 'wait', r['tree'][0]
+  end
+end
+

data/test/unit/ut_14_is_uri.rb

@@ -5,7 +5,7 @@
 # Tue Sep  1 13:39:43 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.expand_path('../../test_helper', __FILE__)
 
 require 'ruote/util/misc'
 

data/test/unit/ut_15_util.rb

@@ -5,7 +5,7 @@
 # Sat Sep 19 13:27:18 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.expand_path('../../test_helper', __FILE__)
 
 require 'ruote/util/misc'
 

data/test/unit/ut_16_reader.rb

@@ -5,8 +5,9 @@
 # Tue Oct 20 10:48:11 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.expand_path('../../test_helper', __FILE__)
 
+require_json
 require 'ruote/reader'
 
 
@@ -21,13 +22,13 @@ class PdefReaderTest < Test::Unit::TestCase
     end
   }
 
-
   TREE1 = Ruote::Reader.read(%{
     Ruote.define :name => 'nada' do
-      sequence do
-        alpha
-        participant 'bravo', :timeout => '2d', :on_board => true
-      end
+      alpha
+      participant 'bravo', :timeout => '2d', :on_board => true
+      participant 'charly', :on_board => false, :whatever => nil
+      doug :a => 'false', :b => 'true', :c => 'nil', :d => 4.5
+      dec 'v:x'
     end
   })
 
@@ -65,10 +66,11 @@ class PdefReaderTest < Test::Unit::TestCase
       %{
 <?xml version="1.0" encoding="UTF-8"?>
 <define name="nada">
-  <sequence>
-    <alpha/>
-    <participant timeout="2d" on-board="true" ref="bravo"/>
-  </sequence>
+  <alpha/>
+  <participant on-board="true" ref="bravo" timeout="2d"/>
+  <participant on-board="false" ref="charly" whatever="nil"/>
+  <doug a="false" b="true" c="nil" d="4.5"/>
+  <dec ref="v:x"/>
 </define>
       }.strip,
       Ruote::Reader.to_xml(TREE1, :indent => 2).strip)
@@ -99,10 +101,11 @@ class PdefReaderTest < Test::Unit::TestCase
     assert_equal(
       %{
 Ruote.process_definition :name => "nada" do
-  sequence do
-    alpha
-    participant "bravo", :timeout => "2d", :on_board => true
-  end
+  alpha
+  participant "bravo", :on_board => true, :timeout => "2d"
+  participant "charly", :on_board => false, :whatever => nil
+  doug :a => "false", :b => "true", :c => "nil", :d => 4.5
+  dec "v:x"
 end
       }.strip,
       Ruote::Reader.to_ruby(TREE1).strip)
@@ -115,6 +118,51 @@ end
     assert_equal TREE1.to_json, Ruote::Reader.to_json(TREE1)
   end
 
+  def test_to_radial
+
+    assert_equal(
+      %{
+define name: nada
+  alpha
+  participant bravo, on_board: true, timeout: 2d
+  participant charly, on_board: false, whatever: nil
+  doug a: "false", b: "true", c: "nil", d: 4.5
+  dec "v:x"
+      }.strip,
+      Ruote::Reader.to_radial(TREE1).strip)
+  end
+
+  def test_to_radial_back_and_forth
+
+    rad = Ruote::Reader.to_radial(TREE1)
+
+    assert_equal TREE1, Ruote::Reader.read(rad)
+  end
+
+  def test_to_radial_2
+
+    tree = Ruote.define do
+      participant 'bob', 'message' => "hello my\ndear world"
+      participant 'charly', 'message' => 'oh my'
+    end
+
+    rad = Ruote::Reader.to_radial(tree)
+
+    assert_equal tree, Ruote::Reader.read(rad)
+  end
+
+  def test_to_expid_radial
+
+    assert_equal(
+      %{  0  define name: nada
+0_0    alpha
+0_1    participant bravo, on_board: true, timeout: 2d
+0_2    participant charly, on_board: false, whatever: nil
+0_3    doug a: "false", b: "true", c: "nil", d: 4.5
+0_4    dec "v:x"},
+      Ruote::Reader.to_expid_radial(TREE1))
+  end
+
   DEF1 = %{
 Ruote.process_definition do
   sequence do
@@ -157,5 +205,79 @@ end
       ] ],
       t)
   end
+
+  def test_radial
+
+    tree = Ruote::Reader.read(%{
+      define name: 'nada'
+        sequence
+          alpha
+          participant bravo, timeout: 2d, on-board: true
+    })
+
+    assert_equal(
+      [ 'define', { 'name' => 'nada' }, [
+        [ 'sequence', {}, [
+          [ 'alpha', {}, [] ],
+          [ 'participant', { 'bravo' => nil, 'timeout' => '2d', 'on_board' => true }, [] ]
+        ] ]
+      ] ],
+      tree)
+  end
+
+  def test_parse_error__ruby
+
+    err = nil
+
+    begin
+      Ruote::Reader.read(%{
+        Ruote.process_definition # missing "do"
+          alpha
+        end
+      })
+    rescue => err
+    end
+
+    assert_equal Ruote::Reader::Error, err.class
+    assert_equal Racc::ParseError, err.cause.class
+  end
+
+  def test_parse_error__radial
+
+    err = nil
+
+    begin
+      Ruote::Reader.read(%{
+        process_definition [f:y]
+          alpha
+      })
+    rescue => err
+    end
+
+    assert_equal Ruote::Reader::Error, err.class
+    assert_equal Parslet::UnconsumedInput, err.cause.class
+  end
+
+  def test_ruby_attributes
+
+    pdef = Ruote.define do
+      sequence :on_error => [
+        { /unknown participant/ => 'alpha' },
+        { nil => 'bravo' }
+      ] do
+        nada
+      end
+    end
+
+    assert_equal(
+      [ 'define', {}, [
+        [ 'sequence', { 'on_error' => [
+          { '/unknown participant/' => 'alpha' }, { nil => 'bravo' }
+          ] }, [
+          [ 'nada', {}, [] ]
+        ] ]
+      ] ],
+      pdef)
+  end
 end
 

data/test/unit/ut_17_merge.rb

@@ -0,0 +1,155 @@
+
+#
+# testing ruote
+#
+# Fri May 13 14:12:52 JST 2011
+#
+
+require File.expand_path('../../test_helper', __FILE__)
+
+module Ruote; end
+require 'ruote/exp/flow_expression'
+require 'ruote/exp/merge'
+
+
+class MergeTest < Test::Unit::TestCase
+
+  class Merger < Ruote::Exp::FlowExpression
+    include Ruote::Exp::MergeMixin
+    def initialize
+    end
+    def tree
+      [ 'nada', {}, [] ]
+    end
+  end
+
+  def new_workitem(fields)
+
+    { 'fields' => fields }
+  end
+
+  def new_workitems
+
+    [
+      new_workitem('a' => 0, 'b' => -1),
+      new_workitem('a' => 1)
+    ]
+  end
+
+  def test_override
+
+    assert_equal(
+      { 'fields' => { 'a' => 1 } },
+      Merger.new.merge_workitems(new_workitems, 'override'))
+    assert_equal(
+      { 'fields' => { 'a' => 0, 'b' => -1 } },
+      Merger.new.merge_workitems(new_workitems.reverse, 'override'))
+  end
+
+  def test_mix
+
+    assert_equal(
+      { 'fields' => { 'a' => 1, 'b' => -1 } },
+      Merger.new.merge_workitems(new_workitems, 'mix'))
+    assert_equal(
+      { 'fields' => { 'a' => 0, 'b' => -1 } },
+      Merger.new.merge_workitems(new_workitems.reverse, 'mix'))
+  end
+
+  def test_isolate
+
+    assert_equal(
+      { 'fields' => {
+        '0' => { 'a' => 0, 'b' => -1 },
+        '1' => { 'a' => 1 }
+      } },
+      Merger.new.merge_workitems(new_workitems, 'isolate'))
+    assert_equal(
+      { 'fields' => {
+        '0' => { 'a' => 1 },
+        '1' => { 'a' => 0, 'b' => -1 }
+      } },
+      Merger.new.merge_workitems(new_workitems.reverse, 'isolate'))
+  end
+
+  def test_stack
+
+    assert_equal(
+      { 'fields' => {
+          'stack' => [ { 'a' => 0, 'b' => -1 }, { 'a' => 1 } ],
+          'stack_attributes' => {}
+      } },
+      Merger.new.merge_workitems(new_workitems, 'stack'))
+    assert_equal(
+      { 'fields' => {
+          'stack' => [ { 'a' => 1 }, { 'a' => 0, 'b' => -1 } ],
+          'stack_attributes' => {}
+      } },
+      Merger.new.merge_workitems(new_workitems.reverse, 'stack'))
+  end
+
+  def test_unknown
+
+    assert_equal(
+      { 'fields' => { 'a' => 0, 'b' => -1 } },
+      Merger.new.merge_workitems(new_workitems, '???'))
+    assert_equal(
+      { 'fields' => { 'a' => 1 } },
+      Merger.new.merge_workitems(new_workitems.reverse, '???'))
+  end
+
+  def test_union
+
+    workitems = [
+      new_workitem('a' => 0, 'b' => [ 'x', 'y' ], 'c' => { 'aa' => 'bb' }),
+      new_workitem('a' => 1, 'b' => [ 'y', 'z' ], 'c' => { 'cc' => 'dd' })
+    ]
+
+    assert_equal(
+      { 'fields' => {
+        'a' => 1,
+        'b' => [ 'x', 'y', 'z' ],
+        'c' => { 'aa' => 'bb', 'cc' => 'dd' }
+      } },
+      Merger.new.merge_workitems(workitems, 'union'))
+  end
+
+  def test_concat
+
+    workitems = [
+      new_workitem('a' => 0, 'b' => [ 'x', 'y' ], 'c' => { 'aa' => 'bb' }),
+      new_workitem('a' => 1, 'b' => [ 'y', 'z' ], 'c' => { 'cc' => 'dd' })
+    ]
+
+    assert_equal(
+      { 'fields' => {
+        'a' => 1,
+        'b' => [ 'x', 'y', 'y', 'z' ],
+        'c' => { 'aa' => 'bb', 'cc' => 'dd' }
+      } },
+      Merger.new.merge_workitems(workitems, 'concat'))
+  end
+
+  def test_deep
+
+    workitems = [
+      new_workitem(
+        'a' => 0,
+        'b' => [ 'x', 'y' ],
+        'c' => { 'aa' => 'bb', 'cc' => { 'a' => 'b' } }),
+      new_workitem(
+        'a' => 1,
+        'b' => [ 'y', 'z' ],
+        'c' => { 'dd' => 'ee', 'cc' => { 'c' => 'd' } })
+    ]
+
+    assert_equal(
+      { 'fields' => {
+        'a' => 1,
+        'b' => [ 'x', 'y', 'y', 'z' ],
+        'c' => { 'aa' => 'bb', 'cc' => { 'a' => 'b', 'c' => 'd' }, 'dd' => 'ee' }
+      } },
+      Merger.new.merge_workitems(workitems, 'deep'))
+  end
+end
+