ruote 0.9.18 → 0.9.19

data/test/ft_54b_listen.rb

@@ -11,56 +11,56 @@ require 'openwfe/participants/participants'
 
 
 class FlowTest54b < Test::Unit::TestCase
-    include FlowTestBase
+  include FlowTestBase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
 
-    #
-    # Test 0
-    #
+  #
+  # Test 0
+  #
 
-    class Test0 < OpenWFE::ProcessDefinition
-        sequence do
-            listen :to => "^channel_.$", :upon => :reply
-            _print "ok"
-        end
+  class Test0 < OpenWFE::ProcessDefinition
+    sequence do
+      listen :to => "^channel_.$", :upon => :reply
+      _print "ok"
     end
+  end
 
-    def test_0
+  def test_0
 
-        #log_level_to_debug
+    #log_level_to_debug
 
-        launch Test0
+    launch Test0
 
-        sleep 0.350
+    sleep 0.350
 
-        assert_equal @tracer.to_s, ""
+    assert_equal @tracer.to_s, ""
 
-        wi = OpenWFE::InFlowWorkItem.new
-        wi.participant_name = "channel_z"
+    wi = OpenWFE::InFlowWorkItem.new
+    wi.participant_name = "channel_z"
 
-        r = @engine.reply wi
-        assert r
+    r = @engine.reply wi
+    assert r
 
-        sleep 0.350
+    sleep 0.350
 
-        #
-        # "post test", checking that engine replies 'false' when
-        # nobody consumed the message
+    #
+    # "post test", checking that engine replies 'false' when
+    # nobody consumed the message
 
-        assert_equal @tracer.to_s, "ok"
+    assert_equal @tracer.to_s, "ok"
 
-        wi = OpenWFE::InFlowWorkItem.new
-        wi.participant_name = "channel_unknown"
+    wi = OpenWFE::InFlowWorkItem.new
+    wi.participant_name = "channel_unknown"
 
-        r = @engine.reply wi
-        assert (not r)
-    end
+    r = @engine.reply wi
+    assert (not r)
+  end
 
 end
 

data/test/ft_54c_listen.rb

@@ -11,89 +11,89 @@ require 'openwfe/participants/participants'
 
 
 class FlowTest54c < Test::Unit::TestCase
-    include FlowTestBase
+  include FlowTestBase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
 
-    #
-    # Test 0
-    #
+  #
+  # Test 0
+  #
 
-    class Test0 < OpenWFE::ProcessDefinition
-        concurrence do
+  class Test0 < OpenWFE::ProcessDefinition
+    concurrence do
 
-            listen :to => "^channel_.$", :once => false do
-                _print "apply"
-            end
+      listen :to => "^channel_.$", :once => false do
+        _print "apply"
+      end
 
-            sequence do
-                _sleep "300"
-                participant :ref => "channel_z"
-                channel_z
-            end
-        end
+      sequence do
+        _sleep "300"
+        participant :ref => "channel_z"
+        channel_z
+      end
     end
+  end
 
-    def test_0
+  def test_0
 
-        @engine.register_participant :channel_z do
-            @tracer << "z\n"
-        end
-
-        #log_level_to_debug
-
-        outputs = [
-            %w{ z apply z apply }.join("\n"),
-            %w{ z z apply apply }.join("\n")
-        ]
-
-        dotest Test0, outputs, 0.850, true
+    @engine.register_participant :channel_z do
+      @tracer << "z\n"
     end
 
-    #
-    # Test 1
-    #
-
-    class Test1 < OpenWFE::ProcessDefinition
-        concurrence do
-            listen :to => "channel9", :once => false do
-                listen9
-            end
-            sequence do
-                _sleep "300"
-                channel9
-            end
-        end
+    #log_level_to_debug
+
+    outputs = [
+      %w{ z apply z apply }.join("\n"),
+      %w{ z z apply apply }.join("\n")
+    ]
+
+    dotest Test0, outputs, 0.850, true
+  end
+
+  #
+  # Test 1
+  #
+
+  class Test1 < OpenWFE::ProcessDefinition
+    concurrence do
+      listen :to => "channel9", :once => false do
+        listen9
+      end
+      sequence do
+        _sleep "300"
+        channel9
+      end
     end
+  end
 
-    def test_1
+  def test_1
 
-        #log_level_to_debug
+    #log_level_to_debug
 
-        @engine.register_participant "channel9", OpenWFE::NullParticipant
-        @engine.register_participant "listen9", OpenWFE::NullParticipant
+    @engine.register_participant "channel9", OpenWFE::NullParticipant
+    @engine.register_participant "listen9", OpenWFE::NullParticipant
 
-        fei = launch Test1
+    fei = launch Test1
 
-        sleep 0.700
+    sleep 0.700
 
-        #puts @engine.get_expression_storage
-        assert_equal 8, @engine.get_expression_storage.size
+    #puts @engine.get_expression_storage
+    assert_equal 8, @engine.get_expression_storage.size
 
-        #puts @engine.get_expression_storage
+    #puts @engine.get_expression_storage
 
-        @engine.cancel_process fei
+    @engine.cancel_process fei
 
-        sleep 0.700
+    sleep 0.700
 
-        #puts @engine.get_expression_storage
-        assert_equal 1, @engine.get_expression_storage.size
-    end
+    #puts @engine.get_expression_storage
+    assert_equal 1, @engine.get_expression_storage.size
+  end
 
 end
 

data/test/ft_55_ptimeout.rb

@@ -11,49 +11,48 @@ require 'openwfe/def'
 
 
 class FlowTest55 < Test::Unit::TestCase
-    include FlowTestBase
-    include PendingJobsMixin
+  include FlowTestBase
+  include PendingJobsMixin
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
 
-    #
-    # Test 0
-    #
+  #
+  # Test 0
+  #
 
-    class Test0 < OpenWFE::ProcessDefinition
-        concurrence :count => 1 do
-            sequence do
-                participant :ref => "channel_z", :timeout => "1s"
-                _print "cancelled?"
-            end
-            _print "concurrence done"
-        end
+  class Test0 < OpenWFE::ProcessDefinition
+    concurrence :count => 1 do
+      sequence do
+        participant :ref => "channel_z", :timeout => "1s"
+        _print "cancelled?"
+      end
+      _print "concurrence done"
     end
+  end
 
-    def test_0
+  def test_0
 
-        #scheduler = @engine.get_scheduler
-        #class << scheduler
-        #    attr_reader :pending_jobs
-        #end
+    #scheduler = @engine.get_scheduler
+    #log_level_to_debug
 
-        #log_level_to_debug
+    @engine.register_participant :channel_z, OpenWFE::NullParticipant
 
-        @engine.register_participant :channel_z, OpenWFE::NullParticipant
+    #p scheduler.at_job_count
+    assert_no_jobs_left
 
-        #require 'pp'; pp(scheduler.pending_jobs)
-        assert_no_jobs_left
+    dotest Test0, "concurrence done"
 
-        dotest Test0, "concurrence done"
+    sleep 0.350 # give some time for the timeout unschedule
 
-        #require 'pp'; pp(scheduler.pending_jobs)
-        assert_no_jobs_left
-    end
+    #p scheduler.at_job_count
+    #p scheduler.instance_variable_get(:@non_cron_jobs)
+    assert_no_jobs_left
+  end
 
 end
 

data/test/ft_56_timeout.rb

@@ -11,49 +11,49 @@ require 'openwfe/def'
 
 
 class FlowTest56 < Test::Unit::TestCase
-    include FlowTestBase
-    include PendingJobsMixin
+  include FlowTestBase
+  include PendingJobsMixin
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
 
-    #
-    # Test 0
-    #
+  #
+  # Test 0
+  #
 
-    class Test0 < OpenWFE::ProcessDefinition
+  class Test0 < OpenWFE::ProcessDefinition
+    sequence do
+      _timeout :after => "1s" do
         sequence do
-            _timeout :after => "1s" do
-                sequence do
-                    _print "ok"
-                    _sleep "2s"
-                    _print "not ok"
-                end
-            end
-            _print "done"
+          _print "ok"
+          _sleep "2s"
+          _print "not ok"
         end
+      end
+      _print "done"
     end
+  end
 
-    def test_0
+  def test_0
 
-        assert_no_jobs_left
+    assert_no_jobs_left
 
-        dotest Test0, "ok\ndone"
+    dotest Test0, "ok\ndone"
 
-        sleep 0.350 # skip one scheduler beat
+    sleep 0.350 # skip one scheduler beat
 
-        #s = @engine.get_scheduler
-        #class << s
-        #    attr_reader :pending_jobs
-        #end
-        #p s.pending_jobs.collect { |j| [ j.job_id, j.class.name ] }
+    #s = @engine.get_scheduler
+    #class << s
+    #  attr_reader :pending_jobs
+    #end
+    #p s.pending_jobs.collect { |j| [ j.job_id, j.class.name ] }
 
-        assert_no_jobs_left
-    end
+    assert_no_jobs_left
+  end
 
 end
 

data/test/ft_57_a.rb

@@ -11,135 +11,138 @@ require 'openwfe/def'
 
 
 class FlowTest57 < Test::Unit::TestCase
-    include FlowTestBase
-
-    #def setup
-    #end
-
-    #def teardown
-    #end
-
-
-    #
-    # Test 0
-    #
-
-    class Test0 < OpenWFE::ProcessDefinition
-        sequence do
-            _set :field => "list" do
-                _a """
-                    <array>
-                        <string>a</string>
-                        <string>b</string>
-                        <string>c</string>
-                        <null/>
-                        <true/>
-                    </array>
-                """
-            end
-            _print "${r:wi.list.join('|')}"
-            _print "-"
-            _set :field => "list" do
-                _attribute """
---- 
+  include FlowTestBase
+
+  #def setup
+  #end
+
+  #def teardown
+  #end
+
+
+  #
+  # Test 0
+  #
+
+  class Test0 < OpenWFE::ProcessDefinition
+    sequence do
+      _set :field => "list" do
+        _a """
+          <array>
+            <string>a</string>
+            <string>b</string>
+            <string>c</string>
+            <null/>
+            <true/>
+          </array>
+        """
+      end
+      _print "${r:wi.list.join('|')}"
+      _print "-"
+      _set :field => "list" do
+        _attribute """
+---
 - a
 - b
 - 3
-                """
-            end
-            _print "${r:wi.list.join('|')}"
-        end
+        """
+      end
+      _print "${r:wi.list.join('|')}"
     end
+  end
 
-    def test_0
+  def test_0
 
-        dotest(
-            Test0, 
-            """
+    dotest(
+      Test0,
+      """
 a|b|c||true
 -
 a|b|3
-            """.strip)
-    end
+      """.strip)
+  end
 
-    def test_1
+  def test_1
 
-        dotest(
-            """
+    dotest(
+      """
 <process-definition name='57_b' revision='1'>
-    <sequence>
-        <set field='list'>
-            <a>
---- 
+  <sequence>
+    <set field='list'>
+      <a>
+---
 - c
 - d
 - e
-            </a>
-        </set>
-        <print>${r:wi.list.join('|')}</print>
-    </sequence>
+      </a>
+    </set>
+    <print>${r:wi.list.join('|')}</print>
+  </sequence>
 </process-definition>
-            """,
-            "c|d|e")
-    end
+      """,
+      "c|d|e")
+  end
 
-    def test_2
+  def test_2
 
-        dotest(
-            """
+    dotest(
+      """
 <process-definition name='57_c' revision='2'>
-    <sequence>
-        <set field='list'>
-            <a>
-            <array>
-                <string>a</string>
-                <number>2</number>
-                <string>c</string>
-                <false/>
-            </array>
-            </a>
-        </set>
-        <print>${r:wi.list.join('|').strip}</print>
-    </sequence>
+  <sequence>
+    <set field='list'>
+      <a>
+      <array>
+        <string>a</string>
+        <number>2</number>
+        <string>c</string>
+        <false/>
+      </array>
+      </a>
+    </set>
+    <print>${r:wi.list.join('|').strip}</print>
+  </sequence>
 </process-definition>
-            """,
-            "a|2|c|false")
+      """,
+      "a|2|c|false")
+  end
+
+  #
+  # Test 3
+  #
+
+  class Test3 < OpenWFE::ProcessDefinition
+    sequence do
+      _set :field => "other" do
+        reval { "77" }
+      end
+      _print "${f:other}"
     end
+  end
 
-    #
-    # Test 3
-    #
-
-    class Test3 < OpenWFE::ProcessDefinition
-        sequence do
-            _set :field => "other" do
-                reval { "77" }
-            end
-            _print "${f:other}"
-        end
-    end
+  def test_3
 
-    def test_3
+    dotest Test3, "77"
+  end
 
-        dotest Test3, "77"
-    end
+  #
+  # Test 4
+  #
 
-    #
-    # Test 4
-    #
-
-    class Test4 < OpenWFE::ProcessDefinition
-        sequence do
-            set :field => "other" do
-                a '[1,2,3,false,"toto"]'
-            end
-            _print "${f:other}"
-        end
+  class Test4 < OpenWFE::ProcessDefinition
+    sequence do
+      set :v => "v0", :val => "ToTo"
+      set :field => "other" do
+        a '[1,2,3,false,"toto","${v0}"]'
+      end
+      _print "${f:other}"
     end
+  end
 
-    def test_4
+  def test_4
 
-        dotest Test4, "123falsetoto"
-    end
+    require 'json'
+
+    dotest Test4, "123falsetotoToTo"
+  end
 end