ruote-maestrodev 2.2.1

data/test/functional/eft_32_lose.rb

@@ -0,0 +1,93 @@
+
+#
+# testing ruote
+#
+# Thu Nov 25 10:05:28 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftLoseTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_lose_alone
+
+    pdef = Ruote.process_definition do
+      lose
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(2)
+      # wait until the process reaches the 'lose' expression
+
+    sleep 0.500
+
+    ps = @engine.process(wfid)
+
+    assert_equal 0, ps.errors.size
+    assert_equal 2, ps.expressions.size
+
+    # the process is just stuck at the 'lose' expression
+  end
+
+  def test_losing_child
+
+    pdef = Ruote.process_definition do
+      lose do
+        alpha
+      end
+      charly
+    end
+
+    @engine.register_participant '.+' do |wi|
+      @tracer << wi.participant_name
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(7)
+      # wait until 'alpha' replies to its parent 'lose'
+
+    sleep 0.500
+
+    assert_equal 'alpha', @tracer.to_s
+  end
+
+  def test_cancelling_lose
+
+    pdef = Ruote.process_definition do
+      lose do
+        alpha
+      end
+    end
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(6)
+      # wait until 'alpha' replies to its parent 'lose'
+
+    sleep 0.500
+
+    assert_equal 1, @engine.storage_participant.size
+
+    @engine.cancel_process(wfid)
+
+    sleep 0.500
+
+    assert_equal 0, @engine.storage_participant.size
+    assert_nil @engine.process(wfid)
+  end
+end
+

data/test/functional/eft_33_let.rb

@@ -0,0 +1,31 @@
+
+#
+# testing ruote
+#
+# Fri Dec 24 15:35:17 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftLetTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_let
+
+    pdef = Ruote.process_definition do
+      set 'v:var' => 'val'
+      echo "out:${v:var}"
+      let do
+        set 'v:var' => 'val1'
+        echo "in:${v:var}"
+      end
+      echo "out:${v:var}"
+    end
+
+    #noisy
+
+    assert_trace %w[ out:val in:val1 out:val ], pdef
+  end
+end
+

data/test/functional/eft_34_given.rb

@@ -0,0 +1,123 @@
+
+#
+# testing ruote
+#
+# Sat Dec 25 12:21:00 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftGivenTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_given_that
+
+    pdef = Ruote.process_definition do
+      given do
+        that "${state} == ready" do
+          echo "a"
+        end
+        that "${location} == nichoume" do
+          echo "b"
+        end
+        # anything that follows is "else"
+        echo "c"
+        echo "d"
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ c d ], pdef, :clear
+    assert_trace %w[ a ], { 'state' => 'ready' }, pdef, :clear
+    assert_trace %w[ b ], { 'location' => 'nichoume' }, pdef, :clear
+    assert_trace %w[ a ], { 'state' => 'ready', 'location' => 'nichoume' }, pdef, :clear
+  end
+
+  def test_given_x_of
+
+    pdef = Ruote.process_definition do
+      given "${status}" do
+        of "ready" do
+          echo "a"
+        end
+        of "dead" do
+          echo "b"
+        end
+        echo "c"
+        echo "d"
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ c d ], pdef, :clear
+    assert_trace %w[ a ], { 'status' => 'ready' }, pdef, :clear
+    assert_trace %w[ b ], { 'status' => 'dead' }, pdef, :clear
+  end
+
+  def test_given_x_of_and_that
+
+    pdef = Ruote.process_definition do
+      given "${status}" do
+        that "${location} == higashiyama" do
+          echo "a"
+        end
+        of "ready" do
+          echo "b"
+        end
+        of "dead" do
+          echo "c"
+        end
+        echo "d"
+      end
+    end
+
+    assert_trace %w[ d ], {}, pdef, :clear
+    assert_trace %w[ b ], { 'status' => 'ready' }, pdef, :clear
+    assert_trace %w[ a ], { 'status' => 'dead', 'location' => 'higashiyama' }, pdef, :clear
+  end
+
+  def test_attributes
+
+    pdef = Ruote.process_definition do
+      given :t => "${status}" do
+        that :t => "${location} == higashiyama" do
+          echo "a"
+        end
+        of :t => "ready" do
+          echo "b"
+        end
+        of "dead" do
+          echo "c"
+        end
+        echo "d"
+      end
+    end
+
+    assert_trace %w[ d ], {}, pdef, :clear
+    assert_trace %w[ b ], { 'status' => 'ready' }, pdef, :clear
+    assert_trace %w[ a ], { 'status' => 'dead', 'location' => 'higashiyama' }, pdef, :clear
+  end
+
+  def test_match
+
+    pdef = Ruote.define do
+      given "${status}" do
+        of "/^a/" do
+          echo 'a'
+        end
+        of /^b/ do
+          echo 'b'
+        end
+        echo 'z'
+      end
+    end
+
+    assert_trace %w[ z ], {}, pdef, :clear
+    assert_trace %w[ a ], { 'status' => 'alpha' }, pdef, :clear
+    assert_trace %w[ b ], { 'status' => 'bravo' }, pdef, :clear
+  end
+end
+

data/test/functional/eft_35_filter.rb

@@ -0,0 +1,375 @@
+
+#
+# testing ruote
+#
+# Mon Jan 31 14:45:09 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftFilterTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def assert_terminates(pdef, fields, result=nil)
+
+    wfid = @engine.launch(pdef, fields)
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal(result, r['workitem']['fields']) if result
+  end
+
+  def assert_does_not_validate(pdef, fields={})
+
+    wfid = @engine.launch(pdef, fields)
+    r = @engine.wait_for(wfid)
+
+    err = @engine.errors.first
+
+    assert_equal 'error_intercepted', r['action']
+    assert_match /ValidationError/, err.message
+    assert_equal Array, err.deviations.class
+  end
+
+  #
+  # the tests
+
+  def test_filter_single_rule_validation
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string'
+    end
+
+    assert_terminates(pdef, 'x' => 'nada')
+  end
+
+  def test_filter_single_rule__drop_if
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :if => true
+    end
+
+    assert_terminates(pdef, 'x' => 'nada')
+  end
+
+  def test_filter_single_rule_validation_failure
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string'
+    end
+
+    assert_does_not_validate(pdef, 'x' => 2)
+  end
+
+  def test_filter_single_rule_transformation
+
+    pdef = Ruote.process_definition do
+      filter 'x', :or => 'crimea'
+    end
+
+    assert_terminates(pdef, {}, { 'x' => 'crimea' })
+  end
+
+  def test_filter_single_rule_in
+
+    pdef = Ruote.process_definition do
+      filter 'colour', :in => %w[ red green blue ]
+    end
+
+    assert_terminates(pdef, 'colour' => 'green')
+  end
+
+  PDEF1 = Ruote.process_definition do
+    filter :in => [
+      { :field => 'x', :type => 'string' },
+      { :field => 'y', :type => 'number' }
+    ]
+  end
+
+  def test_filter_multiple_rules_validation
+
+    assert_terminates(PDEF1, 'x' => 's', 'y' => 2)
+  end
+
+  def test_filter_multiple_rules_validation_failure
+
+    assert_does_not_validate(PDEF1, 'x' => 's', 'y' => 's')
+  end
+
+  def test_filter_multiple_rules_transformation
+
+    pdef = Ruote.process_definition do
+      filter :in => [
+        { :field => 'x', :or => 'alpha' },
+        { :field => 'y', :or => 'bravo' }
+      ]
+    end
+
+    assert_terminates(pdef, {}, { 'x' => 'alpha', 'y' => 'bravo' })
+  end
+
+  def test_filter_in_variable
+
+    pdef = Ruote.process_definition do
+      set 'v:toto' => [
+        { :field => 'a', :set => 'A' },
+        { :field => 'b', :or => 'B' },
+      ]
+      filter 'v:toto'
+    end
+
+    assert_terminates(pdef, {}, { 'a' => 'A', 'b' => 'B' })
+  end
+
+  def test_in_filter_in_variable
+
+    # compatibility with the :filter attribute
+
+    pdef = Ruote.process_definition do
+      set 'v:toto' => { :in => [
+        { :field => 'a', :set => 'A' },
+        { :field => 'b', :or => 'B' },
+      ] }
+      filter 'v:toto'
+    end
+
+    assert_terminates(pdef, {}, { 'a' => 'A', 'b' => 'B' })
+  end
+
+  def test_filter_in_field
+
+    pdef = Ruote.process_definition do
+      set 'f:toto' => [
+        { :field => 'a', :set => 'A' },
+        { :field => 'b', :or => 'B' },
+      ]
+      filter 'f:toto'
+      unset 'f:toto'
+    end
+
+    assert_terminates(pdef, {}, { 'a' => 'A', 'b' => 'B' })
+  end
+
+  def test_in_filter_in_field
+
+    pdef = Ruote.process_definition do
+      set 'f:toto' => { :in => [
+        { :field => 'a', :set => 'A' },
+        { :field => 'b', :or => 'B' },
+      ] }
+      filter 'f:toto'
+      unset 'f:toto'
+    end
+
+    assert_terminates(pdef, {}, { 'a' => 'A', 'b' => 'B' })
+  end
+
+  def test_tilde
+
+    # the ~ points to the hash as it was right before the filtering began
+
+    pdef = Ruote.process_definition do
+      filter :in => [
+        { :field => 'x', :set => 'X' },
+        { :field => 'x', :copy_from => '~.x' },
+      ]
+    end
+
+    assert_terminates(pdef, { 'x' => 1 }, { 'x' => 1 })
+  end
+
+  def test_double_tilde
+
+    # the ~~ points to the workitem fields as they are in the parent expression
+
+    pdef = Ruote.process_definition do
+      filter 'x', :set => 'X'
+      filter 'x', :copy_from => '~~.x'
+    end
+
+    assert_terminates(pdef, { 'x' => 1 }, { 'x' => 1 })
+  end
+
+  def test_record
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :record => true
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { '__validation_errors__' => [
+          [ { 'type' => 'string', 'field' => 'x' }, 'x', 1 ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_record__complex
+
+    pdef = Ruote.process_definition do
+      filter :in => [
+        { :field => 'x', :type => 'string', :record => true },
+        { :field => 'y', :type => 'number' }
+      ]
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { '__validation_errors__' => [
+          [ { 'type' => 'string', 'field' => 'x' }, 'x', 1 ],
+          [ { 'type' => 'number', 'field' => 'y' }, 'y', nil ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_record_in_designated_field
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :record => 'verrors'
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { 'verrors' => [
+          [ { 'type' => 'string', 'field' => 'x' }, 'x', 1 ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_record_accumulates
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :record => true
+      filter 'y', :type => 'number', :record => true
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { '__validation_errors__' => [
+          [ { 'type' => 'string', 'field' => 'x' }, 'x', 1 ],
+          [ { 'type' => 'number', 'field' => 'y' }, 'y', nil ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_record_flushes_and_accumulates
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :record => true
+      filter 'y', :type => 'number', :record => true, :flush => true
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { '__validation_errors__' => [
+          [ { 'type' => 'number', 'field' => 'y' }, 'y', nil ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_filter_and_block
+
+    pdef = Ruote.process_definition do
+      filter do
+        field 'x', :type => 'string'
+        field 'y', :type => 'number'
+      end
+    end
+
+    #@engine.noisy = true
+
+    assert_terminates(pdef, 'x' => 's', 'y' => 2)
+    assert_does_not_validate(pdef, 'x' => 's', 'y' => 's')
+  end
+
+  def test_filter_and_block__radial
+
+    pdef = %{
+      define
+        filter
+          f x, type: 'string'
+          f y, type: 'number'
+    }
+
+    #@engine.noisy = true
+
+    assert_terminates(pdef, 'x' => 's', 'y' => 2)
+    assert_does_not_validate(pdef, 'x' => 's', 'y' => 's')
+  end
+
+  def test_filter_and_block__field_name_is_expname
+
+    pdef = %{
+      define
+        filter
+          x type: 'string'
+          y type: 'number'
+    }
+
+    #@engine.noisy = true
+
+    assert_terminates(pdef, 'x' => 's', 'y' => 2)
+    assert_does_not_validate(pdef, 'x' => 's', 'y' => 's')
+  end
+
+  def test_filter_and_block__collision_with_if
+
+    pdef = %{
+      define
+        filter if: true
+          x type: 'string'
+          y type: 'number'
+    }
+
+    #@engine.noisy = true
+
+    assert_terminates(pdef, 'x' => 's', 'y' => 2)
+    assert_does_not_validate(pdef, 'x' => 's', 'y' => 's')
+  end
+
+  def test_filter_block_and_or
+
+    pdef = Ruote.process_definition do
+      filter do
+        field 'x', :type => 'string'
+        _or
+        field 'x', :type => 'number'
+      end
+    end
+
+    #@engine.noisy = true
+
+    assert_terminates(pdef, 'x' => 's')
+    assert_terminates(pdef, 'x' => 5)
+    assert_does_not_validate(pdef, 'x' => true)
+  end
+
+  def test_filter_block_and_or__radial
+
+    pdef = %{
+      define
+        filter
+          x type: 'string'
+          or
+          x type: 'number'
+    }
+
+    #@engine.noisy = true
+
+    assert_terminates(pdef, 'x' => 's')
+    assert_terminates(pdef, 'x' => 5)
+    assert_does_not_validate(pdef, 'x' => true)
+  end
+end
+