ruote 2.3.0.1 → 2.3.0.2

data/test/functional/ft_79_attach.rb

@@ -0,0 +1,138 @@
+
+#
+# testing ruote
+#
+# Wed Oct  3 09:22:39 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtAttachTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_attach
+
+    @dashboard.register '.+', Ruote::StorageParticipant
+
+    pdef = Ruote.define do
+      set 'v:message' => 'hello world'
+      bravo
+    end
+
+    wfid = @dashboard.launch(pdef, 'message' => 'hello planet')
+    r = @dashboard.wait_for('dispatched')
+
+    adef = Ruote.define do
+      echo '${v:message}'
+      echo '${f:message}'
+    end
+
+    fei = @dashboard.attach(r['fei'], adef)
+    r = @dashboard.wait_for('ceased')
+
+    ps = @dashboard.ps(wfid)
+
+    assert_equal '0_1_0', fei.expid
+    assert_equal wfid, fei.wfid
+
+    assert_equal "hello world\nhello planet", @tracer.to_s
+
+    assert_equal 0, ps.errors.size
+    assert_equal 2, ps.expressions.size
+    assert_equal 1, ps.stored_workitems.size
+  end
+
+  def test_attach_fields_option
+
+    @dashboard.register '.+', Ruote::StorageParticipant
+
+    pdef = Ruote.define do
+      set 'v:message' => 'hello world'
+      bravo
+    end
+
+    wfid = @dashboard.launch(pdef, 'message' => 'hello planet')
+    r = @dashboard.wait_for('dispatched')
+
+    adef = Ruote.define do
+      echo '${v:message}'
+      echo '${f:message}'
+    end
+
+    fei = @dashboard.attach(r['fei'], adef, :fields => { 'message' => 'nada' })
+    r = @dashboard.wait_for('ceased')
+    #ps = @dashboard.ps(wfid)
+
+    assert_equal "hello world\nnada", @tracer.to_s
+  end
+
+  # Well, let's not test those 3 lines of code.
+  #
+  #def test_attach_merge_fields_option
+  #end
+
+  def test_attach_with_fe
+
+    @dashboard.register '.+', Ruote::StorageParticipant
+
+    pdef = Ruote.define do
+      set 'v:message' => 'hello world'
+      bravo
+    end
+
+    wfid = @dashboard.launch(pdef, 'message' => 'hello planet')
+    r = @dashboard.wait_for('dispatched')
+
+    adef = Ruote.define do
+      echo '${v:message}'
+      echo '${f:message}'
+    end
+
+    fe = @dashboard.ps(wfid).expressions.last
+    fei = @dashboard.attach(fe.h, adef)
+    r = @dashboard.wait_for('ceased')
+
+    ps = @dashboard.ps(wfid)
+
+    assert_equal '0_1_0', fei.expid
+    assert_equal wfid, fei.wfid
+
+    assert_equal "hello world\nhello planet", @tracer.to_s
+
+    assert_equal 0, ps.errors.size
+    assert_equal 2, ps.expressions.size
+    assert_equal 1, ps.stored_workitems.size
+  end
+
+  def test_attach_with_error
+
+    @dashboard.register '.+', Ruote::NullParticipant
+
+    pdef = Ruote.define do
+      nancy
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for('dispatched')
+
+    adef = Ruote.define do
+      error 'failing in style'
+    end
+
+    fei = @dashboard.attach(r['fei'], adef)
+    r = @dashboard.wait_for('error_intercepted')
+
+    ps = @dashboard.ps(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    @dashboard.cancel(fei)
+    r = @dashboard.wait_for('ceased')
+
+    ps = @dashboard.ps(wfid)
+
+    assert_equal 0, ps.errors.size
+  end
+end
+

data/test/functional/ft_7_tags.rb

@@ -361,5 +361,32 @@ class FtTagsTest < Test::Unit::TestCase
 
     assert_equal %w[ in_handler handler_out left_tag ], @tracer.to_a
   end
+
+  # Those empty tags tests were fixed during the Fukuoka RubyKaigi 01
+  # (2012/12/01).
+  #
+  def test_empty_tag
+
+    pdef = Ruote.define do
+      noop :tag => ''
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+  end
+
+  def test_empty_untrimmed_tag
+
+    pdef = Ruote.define do
+      noop :tag => ' '
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+  end
 end
 

data/test/functional/ft_80_pause_on_apply.rb

@@ -0,0 +1,64 @@
+
+#
+# testing ruote
+#
+# Sat Oct 13 06:09:12 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtPauseOnApplyTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_pause_apply_then_resume
+
+    @dashboard.register do
+      alpha Ruote::StorageParticipant
+      bravo Ruote::NoOpParticipant
+    end
+
+    pdef = Ruote.define do
+      echo 'a'
+      alpha
+      echo 'b'
+      bravo :pos => [ 1, 1 ]
+      bravo :pos => [ 2, 1 ]
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(:alpha)
+
+    tid = @dashboard.add_tracker(
+      wfid,
+      'pre_apply',
+      nil,
+      { 'tree.1.pos' => [ [ 1, 1 ] ] },
+      { '_auto_remove' => true, '_alter' => 'merge', 'state' => 'paused' })
+
+    assert_equal String, tid.class
+
+    wi = @dashboard.storage_participant.first
+    @dashboard.storage_participant.proceed(wi)
+
+    @dashboard.wait_for('apply')      # echo 'b'
+    r = @dashboard.wait_for('apply')  # bravo :pos => [ 1, 1 ]
+
+    assert_equal nil, r['state']
+
+    ps = @dashboard.ps(wfid)
+    bravo = ps.expressions.last
+
+    assert_equal 'paused', bravo.state
+    assert_not_nil bravo.h.paused_apply
+
+    @dashboard.resume(bravo)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+
+    assert_equal 0, @dashboard.storage.get_trackers['trackers'].size
+  end
+end
+

data/test/functional/ft_81_mutation.rb

@@ -0,0 +1,417 @@
+
+#
+# testing ruote
+#
+# Tue Oct 30 06:52:44 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtComputeMutationTest < Test::Unit::TestCase
+
+  #
+  # use a transient engine to test the mutation computation
+
+  def setup
+
+    @dash = Ruote::Dashboard.new(Ruote::Worker.new(Ruote::HashStorage.new))
+    @dash.noisy = ENV['NOISY'] == 'true'
+
+    @dash.register do
+      sam Ruote::StorageParticipant
+      nick Ruote::NoOpParticipant
+    end
+  end
+
+  def teardown
+
+    @dash.shutdown
+  end
+
+  def pprint(t0, t1, mutation)
+
+    puts
+    puts '>' + '-' * 79
+    p t0
+    p t1
+    puts mutation
+    puts '<' + '-' * 79
+  end
+
+  def print_header
+
+    return unless ENV['NOISY'] == 'true'
+
+    puts "\n" + "'" * `stty size`.strip.split(' ').last.to_i
+    puts caller[1]
+    puts
+  end
+
+  #
+  # the tests themselves
+
+  #
+  # sequence testing
+
+  def launch_nick_nick_sam_sequence
+
+    print_header
+
+    @pdef = Ruote.define do
+      nick
+      nick
+      sam
+    end
+
+    @wfid = @dash.launch(@pdef)
+    3.times { @dash.wait_for('dispatched') }
+  end
+
+  def test_sequence_same_tree
+
+    launch_nick_nick_sam_sequence
+
+    pdef1 = Ruote.define do
+      nick
+      nick
+      sam
+    end
+
+    mutation = @dash.compute_mutation(@wfid, pdef1)
+    a = mutation.to_a
+
+    #pprint(@pdef, pdef1, mutation)
+    assert_equal(0, a.size)
+  end
+
+  def test_sequence_change_post_child
+
+    launch_nick_nick_sam_sequence
+
+    pdef1 = Ruote.define do
+      nick
+      nick
+      sam
+      nick
+    end
+
+    mutation = @dash.compute_mutation(@wfid, pdef1)
+    a = mutation.to_a
+
+    #pprint(@pdef, pdef1, mutation)
+    assert_equal(1, a.size)
+    assert_equal(0, Ruote.extract_child_id(a.first['fei']))
+    assert_equal(:update, a.first['action'])
+    assert_equal(pdef1, a.first['tree'])
+  end
+
+  def test_sequence_change_pre_child
+
+    launch_nick_nick_sam_sequence
+
+    pdef1 = Ruote.define do
+      nick
+      sam
+      sam
+    end
+
+    mutation = @dash.compute_mutation(@wfid, pdef1)
+    a = mutation.to_a
+
+    #pprint(@pdef, pdef1, mutation)
+    assert_equal(1, a.size)
+    assert_equal(0, Ruote.extract_child_id(a.first['fei']))
+    assert_equal(:re_apply, a.first['action'])
+    assert_equal(pdef1, a.first['tree'])
+  end
+
+  def test_deeper_sequence
+
+    print_header
+
+    pdef0 = Ruote.define do
+      nick
+      sequence do
+        nick
+        sam
+      end
+      nick
+    end
+
+    wfid = @dash.launch(pdef0)
+    3.times { @dash.wait_for('dispatched') }
+
+    ps = @dash.ps(wfid)
+
+    pdef1 = Ruote.define do
+      nick
+      sequence do
+        nick
+        hector
+      end
+      nick
+    end
+
+    mutation = @dash.compute_mutation(wfid, pdef1)
+    a = mutation.to_a
+
+    #pprint(pdef0, pdef1, mutation)
+    assert_equal(3, a.size)
+
+    assert_equal('0', a[0]['fei'].expid)
+    assert_equal(:update, a[0]['action'])
+    assert_equal('define', a[0]['tree'].first)
+
+    assert_equal('0_1', a[1]['fei'].expid)
+    assert_equal(:update, a[1]['action'])
+    assert_equal('sequence', a[1]['tree'].first)
+
+    assert_equal('0_1_1', a[2]['fei'].expid)
+    assert_equal(:re_apply, a[2]['action'])
+    assert_equal('hector', a[2]['tree'].first)
+  end
+
+  def test_mutation_apply
+
+    print_header
+
+    pdef0 = Ruote.define do
+      sequence do
+        nick
+        error "nada"
+        sam
+      end
+    end
+
+    wfid = @dash.launch(pdef0)
+    @dash.wait_for('error_intercepted')
+
+    pdef1 = Ruote.define do
+      sequence do
+        nick
+        nick
+      end
+    end
+
+    mutation = @dash.compute_mutation(wfid, pdef1)
+    #puts mutation
+
+    mutation.apply
+
+    @dash.wait_for('terminated')
+
+    # the last sam is gone... He didn't get invoked...
+  end
+
+  def test_mutation_apply_force_update
+
+    print_header
+
+    pdef0 = Ruote.define do
+      sequence do
+        nick
+        error "nada"
+        sam
+      end
+    end
+
+    wfid = @dash.launch(pdef0)
+    @dash.wait_for('error_intercepted')
+
+    pdef1 = Ruote.define do
+      sequence do
+        nick
+        nick
+      end
+    end
+
+    mutation = @dash.compute_mutation(wfid, pdef1)
+
+    mutation.apply(:force_update)
+
+    ps = @dash.ps(wfid)
+
+    assert_equal(
+      [ [ 'define', {}, [
+          [ 'sequence', {}, [ ['nick', {}, [] ], ['nick', {}, [] ] ] ] ] ],
+        [  'sequence', {}, [ ['nick', {}, [] ], [ 'nick', {}, [] ] ] ],
+        [  'nick', {}, [] ] ],
+      ps.expressions.collect { |e| e.tree })
+  end
+
+  #
+  # concurrence testing
+
+  def launch_sam_sam_concurrence
+
+    print_header
+
+    @pdef = Ruote.define do
+      concurrence do
+        sam
+        sam
+      end
+    end
+
+    @wfid = @dash.launch(@pdef)
+    2.times { @dash.wait_for('dispatched') }
+  end
+
+  def test_concurrence_add_branch
+
+    launch_sam_sam_concurrence
+
+    pdef1 = Ruote.define do
+      concurrence do
+        sam
+        sam
+        nick
+      end
+    end
+
+    mutation = @dash.compute_mutation(@wfid, pdef1)
+    a = mutation.to_a
+
+    #pprint(@pdef, pdef1, mutation)
+    assert_equal(2, a.size)
+
+    assert_equal('0', a[0]['fei'].expid)
+    assert_equal(:update, a[0]['action'])
+    assert_equal(pdef1, a[0]['tree'])
+
+    assert_equal('0_0', a[1]['fei'].expid)
+    assert_equal(:re_apply, a[1]['action'])
+    assert_equal(pdef1[2][0], a[1]['tree'])
+  end
+
+  def test_concurrence
+
+    launch_sam_sam_concurrence
+
+    pdef1 = Ruote.define do
+      concurrence do
+        sam
+        nick
+      end
+    end
+
+    mutation = @dash.compute_mutation(@wfid, pdef1)
+    a = mutation.to_a
+
+    #pprint(@pdef, pdef1, mutation)
+    assert_equal(3, a.size)
+
+    assert_equal('0', a[0]['fei'].expid)
+    assert_equal(:update, a[0]['action'])
+    assert_equal('define', a[0]['tree'][0])
+
+    assert_equal('0_0', a[1]['fei'].expid)
+    assert_equal(:update, a[1]['action'])
+    assert_equal('concurrence', a[1]['tree'][0])
+
+    assert_equal('0_0_1', a[2]['fei'].expid)
+    assert_equal(:re_apply, a[2]['action'])
+    assert_equal('nick', a[2]['tree'][0])
+  end
+
+  def launch_sam_nick_concurrence
+
+    print_header
+
+    @pdef = Ruote.define do
+      concurrence do
+        sam
+        nick
+      end
+    end
+
+    @wfid = @dash.launch(@pdef)
+    2.times { @dash.wait_for('dispatched') }
+  end
+
+  def test_concurrence_change_child_that_already_replied
+
+    launch_sam_nick_concurrence
+
+    pdef1 = Ruote.define do
+      concurrence do
+        sam
+        sam
+      end
+    end
+
+    mutation = @dash.compute_mutation(@wfid, pdef1)
+    a = mutation.to_a
+
+    #pprint(@pdef, pdef1, mutation)
+    assert_equal(2, a.size)
+
+    assert_equal('0', a[0]['fei'].expid)
+    assert_equal(:update, a[0]['action'])
+    assert_equal('define', a[0]['tree'][0])
+
+    assert_equal('0_0', a[1]['fei'].expid)
+    assert_equal(:re_apply, a[1]['action'])
+    assert_equal('concurrence', a[1]['tree'][0])
+  end
+
+  def launch_deep_concurrence
+
+    print_header
+
+    @pdef = Ruote.define do
+      concurrence do
+        sam
+        sequence do
+          nick
+          sam
+        end
+      end
+    end
+
+    @wfid = @dash.launch(@pdef)
+    2.times { @dash.wait_for('dispatched') }
+  end
+
+  def test_deep_inside_of_concurrence
+
+    launch_deep_concurrence
+
+    pdef1 = Ruote.define do
+      concurrence do
+        sam
+        sequence do
+          nick
+          sam
+          sam
+        end
+      end
+    end
+
+    mutation = @dash.compute_mutation(@wfid, pdef1)
+    a = mutation.to_a
+
+    #pprint(@pdef, pdef1, mutation)
+    assert_equal(3, a.size)
+
+    assert_equal('0', a[0]['fei'].expid)
+    assert_equal(:update, a[0]['action'])
+    assert_equal('define', a[0]['tree'].first)
+
+    assert_equal('0_0', a[1]['fei'].expid)
+    assert_equal(:update, a[1]['action'])
+    assert_equal('concurrence', a[1]['tree'].first)
+
+    assert_equal('0_0_1', a[2]['fei'].expid)
+    assert_equal(:update, a[2]['action'])
+
+    assert_equal(
+      [ 'sequence', {}, [
+        [ 'nick', {}, [] ],
+        [ 'sam', {}, [] ],
+        [ 'sam', {}, [] ] ] ],
+      a[2]['tree'])
+  end
+end
+