ruote 2.3.0.1 → 2.3.0.2

data/test/functional/ft_82_await_attribute.rb

@@ -0,0 +1,84 @@
+
+#
+# testing ruote
+#
+# Wed Dec  5 21:38:21 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtAwaitAttributeTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_left_tag
+
+    pdef = Ruote.define do
+      concurrence do
+        sequence do
+          echo 'b', :await => 'left_tag:x'
+        end
+        sequence :tag => 'x' do
+          wait '1s'
+          echo 'a'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal('terminated', r['action'])
+    assert_equal(%w[ a b ], @tracer.to_a)
+
+    assert_equal 0, @dashboard.storage.get_trackers['trackers'].size
+  end
+
+  def test_left_tag__implicit_in
+
+    pdef = Ruote.define do
+      concurrence do
+        sequence do
+          echo 'c', :await => 'tag:x'
+        end
+        sequence do
+          echo 'a'
+          wait 0.350
+          echo 'b', :tag => 'x'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal('terminated', r['action'])
+    assert_equal(%w[ a b c ], @tracer.to_a)
+
+    assert_equal 0, @dashboard.storage.get_trackers['trackers'].size
+  end
+
+  def test_default_to_left_tag
+
+    pdef = Ruote.define do
+      concurrence do
+        sequence do
+          echo 'b', :await => 'x'
+        end
+        sequence :tag => 'x' do
+          wait '.350'
+          echo 'a'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal('terminated', r['action'])
+    assert_equal(%w[ a b ], @tracer.to_a)
+
+    assert_equal 0, @dashboard.storage.get_trackers['trackers'].size
+  end
+end
+

data/test/functional/ft_83_trackers.rb

@@ -0,0 +1,79 @@
+
+#
+# testing ruote
+#
+# Tue Dec 18 07:35:02 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtTrackersTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_get_trackers
+
+    pdef =
+      Ruote.define do
+        await :left_tag => 'nada0' do
+          echo 'nada0'
+        end
+      end
+
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for('apply')
+
+    exp = @dashboard.ps(wfid).expressions.last
+
+    assert_equal Hash, @dashboard.get_trackers.class
+    assert_equal [ Ruote.sid(exp.fei) ], @dashboard.get_trackers.keys
+  end
+
+  def test_remove_fei_sid_tracker
+
+    pdef =
+      Ruote.define do
+        concurrence do
+          await :left_tag => 'nada0' do
+            echo 'nada0'
+          end
+          await :left_tag => 'nada1' do
+            echo 'nada1'
+          end
+          await :left_tag => 'nada2' do
+            echo 'nada2'
+          end
+        end
+      end
+
+    wfid = @dashboard.launch(pdef)
+    (1 + 3).times { @dashboard.wait_for('apply') }
+
+    assert_equal 3, @dashboard.storage.get_trackers['trackers'].size
+    assert_equal 3, @dashboard.get_trackers.size
+
+    ps = @dashboard.ps(wfid)
+    fei = ps.leaves[0].fei
+    hfei = ps.leaves[1].fei.h
+    sfei = ps.leaves[2].fei.sid
+
+    @dashboard.remove_tracker(fei)
+    @dashboard.remove_tracker(hfei)
+    @dashboard.remove_tracker(sfei)
+
+    assert_equal 0, @dashboard.storage.get_trackers['trackers'].size
+    assert_equal 0, @dashboard.get_trackers.size
+  end
+
+  def test_remove_string_id_tracker
+
+    @dashboard.add_tracker(nil, 'apply', 'xyz', {}, {})
+
+    assert_equal 1, @dashboard.get_trackers.size
+
+    @dashboard.remove_tracker('xyz')
+
+    assert_equal 0, @dashboard.get_trackers.size
+  end
+end
+

data/test/functional/storage.rb

@@ -218,19 +218,18 @@ class FtStorage < Test::Unit::TestCase
   def test_put_sequence
 
     revs = []
-    put_ats = []
     doc = { '_id' => 'putseq', 'type' => 'errors' }
 
     77.times do |i|
 
-      @s.put(doc)
+      r = @s.put(doc)
       doc = @s.get('errors', 'putseq')
 
       revs << doc['_rev']
-      put_ats << doc['put_at']
 
+      assert_nil r
+      assert_not_nil doc['put_at']
       assert_equal i + 1, revs.uniq.size
-      assert_equal i + 1, put_ats.uniq.size
     end
   end
 

data/test/unit/ut_12_wait_logger.rb

@@ -78,7 +78,7 @@ class UtWaitLoggerTest < Test::Unit::TestCase
     assert %w[ terminated error_intercepted ].include?(r['action'])
   end
 
-  def test_or_error
+  def test_or_error_when_error
 
     @engine.register :alpha, Ruote::NullParticipant
 
@@ -91,8 +91,6 @@ class UtWaitLoggerTest < Test::Unit::TestCase
       error 'oh crap'
     end
 
-    #@engine.noisy = true
-
     i0 = @engine.launch(d0)
     i1 = @engine.launch(d1)
 
@@ -102,6 +100,46 @@ class UtWaitLoggerTest < Test::Unit::TestCase
     assert_equal 'error_intercepted', r['action']
   end
 
+  def test_or_error_when_alpha
+
+    @engine.register :alpha, Ruote::NullParticipant
+
+    d0 = Ruote.define do
+      alpha
+    end
+
+    i0 = @engine.launch(d0)
+
+    r = @engine.wait_for(:alpha, :or_error)
+
+    assert_equal 'dispatch', r['action']
+    assert_equal 'alpha', r['participant_name']
+  end
+
+  # this test will *sometimes* fail with WaitLogger#check_waiting
+  # in revision 92adc70950087637ec76fa394f9bb149fd8a61f4 and earlier
+  # due to an elusive race condition that is not possible to replicate
+  # in this test.
+  # with the current code (as of this writing) it will never fail
+  def test_or_error_when_alpha_multiple_interests
+
+    @engine.register :alpha,  Ruote::NoOpParticipant
+    @engine.register :bravo, Ruote::NullParticipant
+
+    d0 = Ruote.define do
+      alpha
+      bravo
+    end
+
+    i0 = @engine.launch(d0)
+
+    r0 = @engine.wait_for(:alpha, :or_error)
+    r1 = @engine.wait_for(:bravo)
+
+    assert_equal 'dispatch', r1['action']
+    assert_equal 'bravo', r1['participant_name']
+  end
+
   def test_wait_for_hash
 
     #@engine.noisy = true

data/test/unit/ut_15_util.rb

@@ -53,5 +53,35 @@ class UtMiscTest < Test::Unit::TestCase
     assert_not_equal a.object_id, b.object_id
     assert_equal 'hello', b.instance_variable_get(:@s)
   end
+
+  def test_camelize
+
+    assert_equal(
+      'alphaBravoCharly', Ruote.camelize('alpha_bravo_charly'))
+    assert_equal(
+      'AlphaBravoCharly', Ruote.camelize('alpha_bravo_charly', true))
+  end
+
+  def test_decamelize
+
+    assert_equal(
+      'alpha_bravo_charly', Ruote.decamelize('alphaBravoCharly'))
+    assert_equal(
+      'alpha_bravo_charly', Ruote.decamelize('AlphaBravoCharly'))
+  end
+
+  def test_insp
+
+    assert_equal(
+      '{a: [a, b], c: 3, d: true}',
+      Ruote.insp({ 'a' => %w[ a b ], 'c' => 3, 'd' => true }))
+  end
+
+  def test_pps
+
+    assert_equal(
+      "{\"a\"=>[\"a\", \"b\"], \"c\"=>3, \"d\"=>true}\n",
+      Ruote.pps({ 'a' => %w[ a b ], 'c' => 3, 'd' => true }))
+  end
 end
 

data/test/unit/ut_17_merge.rb

@@ -7,149 +7,150 @@
 
 require File.expand_path('../../test_helper', __FILE__)
 
-module Ruote; end
+require 'ruote/fei'
+require 'ruote/merge'
+require 'ruote/extract'
 require 'ruote/exp/flow_expression'
-require 'ruote/exp/merge'
+require 'ruote/exp/fe_concurrence'
 
 
 class MergeTest < Test::Unit::TestCase
 
-  class Merger < Ruote::Exp::FlowExpression
-    include Ruote::Exp::MergeMixin
+  class Merger < Ruote::Exp::ConcurrenceExpression
     def initialize
     end
     def tree
       [ 'nada', {}, [] ]
     end
+    public :merge_workitems
   end
 
-  def new_workitem(fields)
+  def new_workitem(expid, fields)
 
-    { 'fields' => fields }
+    {
+      'fei' => {
+        'engine' => 'e', 'wfid' => '12', 'subid' => '34', 'expid' => expid
+      },
+      'fields' => fields
+    }
   end
 
   def new_workitems
 
     [
-      new_workitem('a' => 0, 'b' => -1),
-      new_workitem('a' => 1)
+      new_workitem('0_0', 'a' => 0, 'b' => -1),
+      new_workitem('0_1', 'a' => 1)
     ]
   end
 
   def test_override
 
     assert_equal(
-      { 'fields' => { 'a' => 1 } },
-      Merger.new.merge_workitems(new_workitems, 'override'))
+      { 'a' => 1 },
+      Merger.new.merge_workitems(new_workitems, 'override')['fields'])
     assert_equal(
-      { 'fields' => { 'a' => 0, 'b' => -1 } },
-      Merger.new.merge_workitems(new_workitems.reverse, 'override'))
+      { 'a' => 0, 'b' => -1 },
+      Merger.new.merge_workitems(new_workitems.reverse, 'override')['fields'])
   end
 
   def test_mix
 
     assert_equal(
-      { 'fields' => { 'a' => 1, 'b' => -1 } },
-      Merger.new.merge_workitems(new_workitems, 'mix'))
+      { 'a' => 1, 'b' => -1 },
+      Merger.new.merge_workitems(new_workitems, 'mix')['fields'])
     assert_equal(
-      { 'fields' => { 'a' => 0, 'b' => -1 } },
-      Merger.new.merge_workitems(new_workitems.reverse, 'mix'))
+      { 'a' => 0, 'b' => -1 },
+      Merger.new.merge_workitems(new_workitems.reverse, 'mix')['fields'])
   end
 
   def test_isolate
 
     assert_equal(
-      { 'fields' => {
-        '0' => { 'a' => 0, 'b' => -1 },
-        '1' => { 'a' => 1 }
-      } },
-      Merger.new.merge_workitems(new_workitems, 'isolate'))
+      { '0' => { 'a' => 0, 'b' => -1 }, '1' => { 'a' => 1 } },
+      Merger.new.merge_workitems(new_workitems, 'isolate')['fields'])
     assert_equal(
-      { 'fields' => {
-        '0' => { 'a' => 1 },
-        '1' => { 'a' => 0, 'b' => -1 }
-      } },
-      Merger.new.merge_workitems(new_workitems.reverse, 'isolate'))
+      { '1' => { 'a' => 1 }, '0' => { 'a' => 0, 'b' => -1 } },
+      Merger.new.merge_workitems(new_workitems.reverse, 'isolate')['fields'])
   end
 
   def test_stack
 
     assert_equal(
-      { 'fields' => {
-          'stack' => [ { 'a' => 0, 'b' => -1 }, { 'a' => 1 } ],
-          'stack_attributes' => {}
-      } },
-      Merger.new.merge_workitems(new_workitems, 'stack'))
+      { 'stack' => [ { 'a' => 0, 'b' => -1 }, { 'a' => 1 } ] },
+      Merger.new.merge_workitems(new_workitems, 'stack')['fields'])
     assert_equal(
-      { 'fields' => {
-          'stack' => [ { 'a' => 1 }, { 'a' => 0, 'b' => -1 } ],
-          'stack_attributes' => {}
-      } },
-      Merger.new.merge_workitems(new_workitems.reverse, 'stack'))
+      { 'stack' => [ { 'a' => 1 }, { 'a' => 0, 'b' => -1 } ] },
+      Merger.new.merge_workitems(new_workitems.reverse, 'stack')['fields'])
   end
 
   def test_unknown
 
     assert_equal(
-      { 'fields' => { 'a' => 0, 'b' => -1 } },
-      Merger.new.merge_workitems(new_workitems, '???'))
+      { 'a' => 0, 'b' => -1 },
+      Merger.new.merge_workitems(new_workitems, '???')['fields'])
     assert_equal(
-      { 'fields' => { 'a' => 1 } },
-      Merger.new.merge_workitems(new_workitems.reverse, '???'))
+      { 'a' => 1 },
+      Merger.new.merge_workitems(new_workitems.reverse, '???')['fields'])
   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' })
+      new_workitem(
+        '0_0', 'a' => 0, 'b' => [ 'x', 'y' ], 'c' => { 'aa' => 'bb' }),
+      new_workitem(
+        '0_1', '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'))
+      },
+      Merger.new.merge_workitems(workitems, 'union')['fields'])
   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' })
+      new_workitem(
+        '0_0', 'a' => 0, 'b' => [ 'x', 'y' ], 'c' => { 'aa' => 'bb' }),
+      new_workitem(
+        '0_1', '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'))
+      },
+      Merger.new.merge_workitems(workitems, 'concat')['fields'])
   end
 
   def test_deep
 
     workitems = [
       new_workitem(
+        '0_0',
         'a' => 0,
         'b' => [ 'x', 'y' ],
         'c' => { 'aa' => 'bb', 'cc' => { 'a' => 'b' } }),
       new_workitem(
+        '0_1',
         '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'))
+      },
+      Merger.new.merge_workitems(workitems, 'deep')['fields'])
   end
 end