ruote-maestrodev 2.2.1

data/test/unit/ut_23_svc_tracker.rb

@@ -0,0 +1,48 @@
+
+#
+# testing ruote
+#
+# Mon Apr 25 12:24:57 JST 2011
+#
+# in Singapore
+#
+
+require File.join(File.dirname(__FILE__), %w[ .. test_helper.rb ])
+
+require 'ostruct'
+require 'ruote'
+require 'ruote/svc/tracker'
+
+
+class UtSvcTrackerTest < Test::Unit::TestCase
+
+  class FakeStorage
+    def initialize
+      @count = -1
+    end
+    def put(doc)
+      @count = @count + 1
+      return true if @count == 0
+      nil
+    end
+    def get_trackers
+      { 'trackers' => {} }
+    end
+  end
+
+  # Fighting issue found by Pedro Texeira :
+  #
+  # http://groups.google.com/group/openwferu-users/browse_thread/thread/cf2546d0b1cebfe8
+  #
+  def test_add_tracker_fail_and_retry
+
+    con = OpenStruct.new(:storage => FakeStorage.new)
+
+    pl = Ruote::Tracker.new(con)
+
+    pl.add_tracker('some-wfid', 'reply', 'some-id', {}, {})
+
+    assert true
+  end
+end
+

data/test/unit/ut_24_radial_reader.rb

@@ -0,0 +1,332 @@
+# encoding: UTF-8
+
+#
+# testing ruote
+#
+# Sat Apr 30 13:22:49 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/reader/radial'
+
+
+class RadialReaderTest < Test::Unit::TestCase
+
+  #
+  # tests focusing on attribute parsing (line parsing)
+
+  class ReadError < RuntimeError
+    def initialize(s, e)
+      @string = s
+      @error = e
+    end
+    def to_s
+      s = "error while parsing >#{@string}< : #{@error.to_s}"
+      s << "\n\n#{@error.error_tree}" if @error.respond_to?(:error_tree)
+      s
+    end
+    def backtrace
+      @error.backtrace
+    end
+  end
+
+  def self.assert_read(target_tree, s)
+    @@i ||= 0
+    self.instance_eval do
+      define_method("test_#{@@i}") do
+        begin
+          assert_equal(target_tree, Ruote::RadialReader.read(s))
+        rescue => e
+          raise ReadError.new(s, e)
+        end
+      end
+    end
+    @@i = @@i + 1
+  end
+
+  # the tests themselves
+
+  assert_read(
+    [ 'define', {}, [] ],
+    'define')
+  assert_read(
+    [ 'define', {}, [] ],
+    'define # whatever')
+  assert_read(
+    [ 'concurrent_iterator', {}, [] ],
+    'concurrent-iterator')
+  assert_read(
+    [ 'define', { 'alpha' => nil }, [] ],
+    'define "alpha"')
+  assert_read(
+    [ 'define', { 'bravo' => nil }, [] ],
+    'define "bravo" # whatever')
+  assert_read(
+    [ 'define', { 'name' => 'charly' }, [] ],
+    'define name: "charly"')
+  assert_read(
+    [ 'define', { 'name' => 'delta' }, [] ],
+    'define name: "delta" # whatever')
+  assert_read(
+    [ 'define', { 'name' => 'echo' }, [] ],
+    'define "name": "echo" # whatever')
+  assert_read(
+    [ 'define', { 'a' => 'AA', 'b' => 'BB' }, [] ],
+    'define a: AA, b: BB # whatever')
+  #assert_read(
+  #  [ 'define', { 'a' => 'A A', 'b' => 'B B' }, [] ],
+  #  'define a: A A, b: B B')
+  #assert_read(
+  #  [ 'define', { 'a' => 'A A', 'b' => 2.0 }, [] ],
+  #  'define a: A A, b: 2.0')
+  assert_read(
+    [ 'define', { 'work_flow' => 'foxtrot' }, [] ],
+    'define work-flow: foxtrot')
+  assert_read(
+    [ 'define', { 'work_flow' => 'gamma' }, [] ],
+    'define "work-flow": gamma')
+  assert_read(
+    [ 'define', { 'work_flow' => 'hotel' }, [] ],
+    'define "work-flow": "hotel"')
+  assert_read(
+    [ 'define', { 'india' => nil, 'mount' => 'batten' }, [] ],
+    'define "india", mount: batten # whatever')
+  assert_read(
+    [ 'romeo', { 'timeout' => '2d'}, [] ],
+    'romeo timeout: 2d # whatever')
+
+  assert_read(
+    [ 'sierra', {}, [] ],
+    'sierra # whatever')
+  assert_read(
+    [ 'tango', {}, [] ],
+    'tango ')
+
+  # JSON arrays and objects
+
+  assert_read(
+    [ 'echo', { 'lima' => nil, 'a' => [ 1, 2, 3 ] }, [] ],
+    'echo "lima", a: [ 1, 2, 3 ] # whatever')
+  assert_read(
+    [ 'echo', { 'name' => 'mike', 'a' => { 'b' => 'c' } }, [] ],
+    "echo name: 'mike', a: { b => c }")
+  assert_read(
+    [ 'echo', { 'name' => 'november', 'a' => { 'b' => 'c', 'd' => 'e' } }, [] ],
+    "echo name: 'november', a: { b => c, 'd' => \"e\" }")
+  assert_read(
+    [ 'echo', { 'oscar' => nil, 'a' => nil }, [] ],
+    'echo "oscar", a: null')
+
+  # Ruby misc
+
+  assert_read(
+    [ 'define', { 'name' => 'juliet' }, [] ],
+    "define name: 'juliet'")
+  assert_read(
+    [ 'define', { 'name' => 'kilo', 'a' => 'b' }, [] ],
+    "define name: 'kilo', a: b")
+  assert_read(
+    [ 'echo', { 'papa' => nil, 'a' => nil }, [] ],
+    'echo "papa", a: nil # whatever')
+  #assert_read(
+  #  [ 'echo', { 'quebec' => nil, 'b' => [ 'A', 'B' ] }, [] ],
+  #  'echo "quebec", b: %w[ A B ] # whatever')
+
+  #
+  # weird expression [names]
+
+  assert_read(
+    [ 'server_array.toto.first', {}, [] ],
+    'server_array.toto.first')
+  assert_read(
+    [ 'server_array.${v:/sa_name}.first', {}, [] ],
+    'server_array.${v:/sa_name}.first')
+  assert_read(
+    [ 'server_array.${v:/sa_name}.first', { 'nada' => nil, 'ok' => true }, [] ],
+    'server_array.${v:/sa_name}.first nada, ok:true')
+
+  #
+  # more complete tests
+
+  def test_error_reporting
+
+    e = nil
+
+    begin
+      Ruote::RadialReader.read(%{
+        "nada"
+      })
+    rescue => e
+    end
+
+    assert_equal Parslet::UnconsumedInput, e.class
+    assert_not_nil e.error_tree
+
+    #puts e.error_tree
+  end
+
+  def test_error_on_empty_string
+
+    assert_raise ArgumentError do
+      Ruote::RadialReader.read(%{
+      })
+    end
+  end
+
+  def test_sequence
+
+    tree = Ruote::RadialReader.read(%{
+      process_definition "nada"
+        sequence
+          alpha
+          bravo
+    })
+
+    assert_equal(
+      [ 'process_definition', { 'nada' => nil }, [
+        [ 'sequence', {}, [ [ 'alpha', {}, []], [ 'bravo', {}, [] ] ] ]
+      ]],
+      tree)
+  end
+
+  def test_echo
+
+    tree = Ruote::RadialReader.read(%{
+define name: "nada"
+  echo "la vida loca"
+    })
+
+    assert_equal(
+      [ 'define', { 'name' => 'nada' }, [
+        [ 'echo', { 'la vida loca' => nil }, [] ] ] ],
+      tree)
+  end
+
+  def test_concurrent_iterator
+
+    tree = Ruote::RadialReader.read(%{
+process_definition name: "nada"
+  concurrent_iterator on_field: "toti", to_field: "toto"
+    })
+
+    assert_equal(
+      [ 'process_definition', { 'name' => 'nada' }, [
+        [ 'concurrent_iterator', { 'on_field' => 'toti', 'to_field' => 'toto' }, [] ] ] ],
+      tree)
+  end
+
+  def test_multiline_strings
+
+    tree = Ruote::RadialReader.read(%{
+      process_definition "zama"
+        echo "
+          nada
+        ", ol: korrect
+        echo '
+          #nada
+        '
+        # just a comment
+        echo "
+          'hola'
+        "
+    })
+
+    assert_equal(
+      [ 'process_definition', { 'zama' => nil }, [
+        [ 'echo', { "\n          nada\n        " => nil, 'ol' => 'korrect' }, [] ],
+        [ 'echo', { "\n          #nada\n        " => nil }, [] ],
+        [ 'echo', { "\n          'hola'\n        " => nil }, [] ]
+      ]],
+      tree)
+  end
+
+  def test_unicode
+
+    tree = Ruote::RadialReader.read(%{
+      process_definition "nada"
+        echo "très bon"
+    })
+
+    assert_equal(
+      [ 'process_definition', { 'nada' => nil }, [
+        [ 'echo', { 'très bon' => nil }, [] ]
+      ]],
+      tree)
+  end
+
+  def test_2d
+
+    tree = Ruote::RadialReader.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_back
+
+    tree = Ruote::RadialReader.read(%{
+      process-definition nada
+        concurrence
+          sequence
+            alpha
+            bravo
+          charly
+        delta
+    })
+
+    assert_equal(
+      [ 'process_definition', { 'nada' => nil }, [
+        [ 'concurrence', {}, [
+          [ 'sequence', {}, [
+            [ 'alpha', {}, [] ],
+            [ 'bravo', {}, [] ]
+          ] ],
+          [ 'charly', {}, [] ]
+        ] ],
+        [ 'delta', {}, [] ]
+      ] ],
+      tree)
+  end
+
+  def test_regexes
+
+    tree = Ruote::RadialReader.read(%{
+      process_definition "nada"
+        participant nada, fix: /nada/
+    })
+
+    assert_equal(
+      [ 'process_definition', { 'nada' => nil }, [
+        [ 'participant', { 'nada' => nil, 'fix' => '/nada/' }, [] ]
+      ]],
+      tree)
+  end
+
+  def test_array
+
+    pdef = %{
+      filter in: [ { field: f, type: bool, empty: false } ]
+    }
+
+    assert_equal(
+      [
+        'filter',
+        { 'in' => [ { 'empty' => false, 'type' => 'bool', 'field' => 'f' } ] },
+        []
+      ],
+      Ruote::RadialReader.read(pdef))
+  end
+end
+

data/test/unit/ut_25_merge.rb

@@ -0,0 +1,113 @@
+
+#
+# testing ruote
+#
+# Fri May 13 14:12:52 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+module Ruote; end
+require 'ruote/exp/merge'
+
+
+class MergeTest < Test::Unit::TestCase
+
+  class Merger
+    include Ruote::Exp::MergeMixin
+
+    def expand_atts
+      nil
+    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' => nil
+      } },
+      Merger.new.merge_workitems(new_workitems, 'stack'))
+    assert_equal(
+      { 'fields' => {
+          'stack' => [ { 'a' => 1 }, { 'a' => 0, 'b' => -1 } ],
+          'stack_attributes' => nil
+      } },
+      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' ], 'c' => { 'aa' => 'bb' }),
+      new_workitem('a' => 1, 'b' => [ 'y' ], 'c' => { 'cc' => 'dd' })
+    ]
+
+    assert_equal(
+      { 'fields' => {
+        'a' => 1, 'b' => [ 'x', 'y' ], 'c' => { 'aa' => 'bb', 'cc' => 'dd' }
+      } },
+      Merger.new.merge_workitems(workitems, 'union'))
+  end
+end
+