ruote-maestrodev 2.2.1

data/test/unit/ut_15_util.rb

@@ -0,0 +1,57 @@
+
+#
+# testing ruote
+#
+# Sat Sep 19 13:27:18 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/util/misc'
+
+
+class UtMiscTest < Test::Unit::TestCase
+
+  def test_narrow_to_number
+
+    assert_equal nil, Ruote.narrow_to_number(nil)
+    assert_equal nil, Ruote.narrow_to_number('a')
+    assert_equal nil, Ruote.narrow_to_number(Object.new)
+
+    assert_equal 0, Ruote.narrow_to_number(0)
+    assert_equal 1, Ruote.narrow_to_number(1)
+
+    assert_equal 0.0, Ruote.narrow_to_number(0.0)
+    assert_equal 1.0, Ruote.narrow_to_number(1.0)
+
+    assert_equal 0, Ruote.narrow_to_number('0')
+    assert_equal 1, Ruote.narrow_to_number('1')
+
+    assert_equal 0.0, Ruote.narrow_to_number('0.0')
+    assert_equal 1.0, Ruote.narrow_to_number('1.0')
+  end
+
+  def test_regex_or_s
+
+    assert_equal /bravo/, Ruote.regex_or_s('/bravo/')
+    assert_equal 'nada', Ruote.regex_or_s('nada')
+    assert_equal nil, Ruote.regex_or_s(nil)
+  end
+
+  class Klass
+    def initialize(s)
+      @s = s
+    end
+  end
+
+  def test_fulldup
+
+    a = Klass.new('hello')
+    b = Ruote.fulldup(a)
+
+    assert_equal Klass, b.class
+    assert_not_equal a.object_id, b.object_id
+    assert_equal 'hello', b.instance_variable_get(:@s)
+  end
+end
+

data/test/unit/ut_16_reader.rb

@@ -0,0 +1,225 @@
+
+#
+# testing ruote
+#
+# Tue Oct 20 10:48:11 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require_json
+require 'ruote/reader'
+
+
+class PdefReaderTest < Test::Unit::TestCase
+
+  DEF0 = %{
+    Ruote.define :name => 'nada' do
+      sequence do
+        alpha
+        bravo
+      end
+    end
+  }
+
+  TREE1 = Ruote::Reader.read(%{
+    Ruote.define :name => 'nada' do
+      sequence do
+        alpha
+        participant 'bravo', :timeout => '2d', :on_board => true
+      end
+    end
+  })
+
+  def test_from_string
+
+    tree = Ruote::Reader.read(DEF0)
+
+    assert_equal(
+      ["define", {"name"=>"nada"}, [
+        ["sequence", {}, [["alpha", {}, []], ["bravo", {}, []]]]
+      ]],
+      tree)
+  end
+
+  def test_from_file
+
+    fn = File.join(File.dirname(__FILE__), '_ut_16_def.rb')
+
+    File.open(fn, 'w') { |f| f.write(DEF0) }
+
+    tree = Ruote::Reader.read(fn)
+
+    assert_equal(
+      ["define", {"name"=>"nada"}, [
+        ["sequence", {}, [["alpha", {}, []], ["bravo", {}, []]]]
+      ]],
+      tree)
+
+    FileUtils.rm_f(fn) # sooner or later, it will get erased
+  end
+
+  def test_to_xml
+
+    assert_equal(
+      %{
+<?xml version="1.0" encoding="UTF-8"?>
+<define name="nada">
+  <sequence>
+    <alpha/>
+    <participant timeout="2d" on-board="true" ref="bravo"/>
+  </sequence>
+</define>
+      }.strip,
+      Ruote::Reader.to_xml(TREE1, :indent => 2).strip)
+  end
+
+  def test_if_to_xml
+
+    tree = Ruote.process_definition do
+      _if 'nada' do
+        participant 'nemo'
+      end
+    end
+
+    assert_equal(
+      %{
+<?xml version="1.0" encoding="UTF-8"?>
+<define>
+  <if test="nada">
+    <participant ref="nemo"/>
+  </if>
+</define>
+      }.strip,
+      Ruote::Reader.to_xml(tree, :indent => 2).strip)
+  end
+
+  def test_to_ruby
+
+    assert_equal(
+      %{
+Ruote.process_definition :name => "nada" do
+  sequence do
+    alpha
+    participant "bravo", :timeout => "2d", :on_board => true
+  end
+end
+      }.strip,
+      Ruote::Reader.to_ruby(TREE1).strip)
+  end
+
+  def test_to_json
+
+    require 'json'
+
+    assert_equal TREE1.to_json, Ruote::Reader.to_json(TREE1)
+  end
+
+  def test_to_radial
+
+    assert_equal(
+      %{
+define name: "nada"
+  sequence
+    alpha
+    participant "bravo", timeout: "2d", on_board: true
+      }.strip,
+      Ruote::Reader.to_radial(TREE1).strip)
+  end
+
+  DEF1 = %{
+Ruote.process_definition do
+  sequence do
+    alpha
+    set :field => 'f', :value => 'v'
+    bravo
+  end
+end
+  }
+
+  def test_from_ruby_file
+
+    fn = File.expand_path(File.join(File.dirname(__FILE__), '_ut_16_def1.rb'))
+
+    File.open(fn, 'wb') { |f| f.write(DEF1) }
+
+    assert_equal(
+      ["define", {}, [["sequence", {}, [["alpha", {}, []], ["set", {"field"=>"f", "value"=>"v"}, []], ["bravo", {}, []]]]]],
+      Ruote::Reader.read(fn))
+
+    FileUtils.rm(fn)
+  end
+
+  # Make sure that ruby method names like 'freeze' or 'clone' can be used
+  # in process definitions.
+  #
+  def test_ruby_blank_slate
+
+    t = Ruote::Reader.read(%{
+      Ruote.define do
+        freeze
+        clone
+        untrust
+      end
+    })
+
+    assert_equal(
+      [ 'define', {}, [
+        [ 'freeze', {}, [] ], [ 'clone', {}, [] ], [ 'untrust', {}, [] ]
+      ] ],
+      t)
+  end
+
+  def test_radial
+
+    tree = Ruote::Reader.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_parse_error__ruby
+
+    err = nil
+
+    begin
+      Ruote::Reader.read(%{
+        Ruote.process_definition # missing "do"
+          alpha
+        end
+      })
+    rescue => err
+    end
+
+    assert_equal Ruote::Reader::Error, err.class
+    assert_equal Racc::ParseError, err.cause.class
+  end
+
+  def test_parse_error__radial
+
+    err = nil
+
+    begin
+      Ruote::Reader.read(%{
+        process_definition ${f:y}
+          alpha
+      })
+    rescue => err
+    end
+
+    assert_equal Ruote::Reader::Error, err.class
+    assert_equal Parslet::UnconsumedInput, err.cause.class
+  end
+end
+

data/test/unit/ut_18_engine.rb

@@ -0,0 +1,47 @@
+
+#
+# testing ruote
+#
+# Sun Jan  3 12:04:07 JST 2010
+#
+# Matt Nichols (http://github.com/mattnichols)
+#
+
+require File.join(File.dirname(__FILE__), %w[ .. test_helper.rb ])
+require File.join(File.dirname(__FILE__), %w[ .. functional storage_helper.rb ])
+
+require 'ruote'
+
+
+class UtEngineTest < Test::Unit::TestCase
+
+  def test_initialize_with_worker
+
+    storage = determine_storage(
+      's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])
+    worker = Ruote::Worker.new(storage)
+    engine = Ruote::Engine.new(worker, false)
+  end
+
+  def test_initialize_with_worker_and_without_logger
+
+    storage = determine_storage({})
+    worker = Ruote::Worker.new(storage)
+    engine = Ruote::Engine.new(worker, false)
+  end
+
+  def test_initialize_with_storage
+
+    storage = determine_storage(
+      's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])
+
+    engine = Ruote::Engine.new(storage)
+  end
+
+  def test_initialize_storage_without_logger
+
+    storage = determine_storage({})
+    engine = Ruote::Engine.new(storage)
+  end
+end
+

data/test/unit/ut_19_part_template.rb

@@ -0,0 +1,86 @@
+
+#
+# testing ruote
+#
+# Thu Mar  4 10:24:30 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require_json
+require 'ruote/context'
+require 'ruote/part/template'
+require 'ruote/storage/hash_storage'
+
+
+class UtPartTemplateTest < Test::Unit::TestCase
+
+  class MyParticipant
+    include ::Ruote::TemplateMixin
+
+    def initialize
+
+      @context = ::Ruote::Context.new(::Ruote::HashStorage.new)
+    end
+  end
+
+  DEFAULT = %{
+workitem for gonzalo
+
+{
+  "wfid": "20100304-bidehachina",
+  "expid": "0_0_1"
+}
+
+ - 'car'  ==>  "BMW"
+ - 'model'  ==>  "BMW 328 Mille Miglia"
+  }.strip
+
+  def setup
+
+    @workitem = {
+      'fei'=> { 'wfid' => '20100304-bidehachina', 'expid' => '0_0_1' },
+      'participant_name' => 'gonzalo',
+      'fields' => {
+        'car' => 'BMW',
+        'model' => 'BMW 328 Mille Miglia'
+      }
+    }
+  end
+
+  def test_default_template
+
+    assert_equal(
+      DEFAULT,
+      MyParticipant.new.render_default_template(@workitem))
+
+    assert_equal(
+      DEFAULT,
+      MyParticipant.new.render_template(nil, nil, @workitem))
+  end
+
+  def test_file_template
+
+    fn = "#{__FILE__}.template"
+
+    File.open(fn, 'wb') { |f| f.write('the model is ${f:model}') }
+
+    assert_equal(
+      'the model is BMW 328 Mille Miglia',
+      MyParticipant.new.render_template(fn, nil, @workitem))
+
+    FileUtils.rm_f(fn)
+  end
+
+  def test_string_template
+
+    template = %{
+My car is a ${f:car}
+    }.strip
+
+    assert_equal(
+      'My car is a BMW',
+      MyParticipant.new.render_template(template, nil, @workitem))
+  end
+end
+

data/test/unit/ut_1_fei.rb

@@ -0,0 +1,165 @@
+
+#
+# testing ruote
+#
+# Fri May 15 10:08:51 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote'
+
+
+class UtFeiTest < Test::Unit::TestCase
+
+  def test_misc
+
+    fei = Ruote::FlowExpressionId.new(
+      'expid' => '0_0',
+      'wfid' => '20101224-bababa',
+      'subid' => '5dbf4ce1553453baa17c2213d239e5fa',
+      'engine_id' => 'engine')
+
+    assert_equal(
+      '0_0!5dbf4ce1553453baa17c2213d239e5fa!20101224-bababa',
+      fei.to_storage_id)
+
+    assert_equal(
+      0,
+      fei.child_id)
+
+    assert_equal(
+      { 'expid' => '0_0',
+        'wfid' => '20101224-bababa',
+        'subid' => '5dbf4ce1553453baa17c2213d239e5fa',
+        'engine_id' => 'engine' },
+      fei.to_h)
+  end
+
+  def test_direct_child
+
+    f0 = {
+      'expid' => '0', 'wfid' => '20101224-bababa', 'engine_id' => 'engine' }
+    f1 = {
+      'expid' => '0_0', 'wfid' => '20101224-bababa', 'engine_id' => 'engine' }
+    f2 = {
+      'expid' => '0_0_0', 'wfid' => '20101224-bababa', 'engine_id' => 'engine' }
+    f3 = {
+      'expid' => '0_0', 'wfid' => '20101224-bakayaro', 'engine_id' => 'engine' }
+
+    assert_equal false, Ruote::FlowExpressionId.direct_child?(f0, f0)
+    assert_equal true, Ruote::FlowExpressionId.direct_child?(f0, f1)
+    assert_equal false, Ruote::FlowExpressionId.direct_child?(f0, f2)
+    assert_equal false, Ruote::FlowExpressionId.direct_child?(f0, f3)
+  end
+
+  def test_is_a_fei
+
+    assert_equal(
+      true,
+      Ruote::FlowExpressionId.is_a_fei?(
+        'expid' => '0', 'wfid' => '20101224-bababa', 'engine_id' => 'engine'))
+    assert_equal(
+      false,
+      Ruote::FlowExpressionId.is_a_fei?(
+        'nada' => '0', 'wfid' => '20101224-bababa', 'engine_id' => 'engine'))
+  end
+
+  def test_equality
+
+    f0 = Ruote::FlowExpressionId.new(
+      'expid' => '0_0', 'wfid' => '20101224-bababa', 'engine_id' => 'engine')
+    f1 = Ruote::FlowExpressionId.new(
+      'expid' => '0_0', 'wfid' => '20101224-bababa', 'engine_id' => 'engine')
+    f2 = Ruote::FlowExpressionId.new(
+      'expid' => '0_1', 'wfid' => '20101224-bababa', 'engine_id' => 'engine')
+
+    assert f0 == f1
+    assert f0 != f2
+
+    assert_equal f0.hash, f1.hash
+    assert_not_equal f0.hash, f2.hash
+  end
+
+  def test_from_id
+
+    assert_equal(
+      '0_0_1!!20100224-fake',
+      Ruote::FlowExpressionId.from_id('0_0_1!!20100224-fake').to_storage_id)
+    assert_equal(
+      '0_0_1!!20100224-fake',
+      Ruote::FlowExpressionId.from_id('wi!0_0_1!!20100224-fake').to_storage_id)
+    assert_equal(
+      '0_0_1!!20100224-fake',
+      Ruote::FlowExpressionId.from_id('wi!store!0_0_1!!20100224-fake').to_storage_id)
+
+    assert_equal(
+      '0_0_1!!20100224-fake',
+      Ruote::FlowExpressionId.from_id('eng!0_0_1!!20100224-fake').to_storage_id)
+    assert_equal(
+      'eng',
+      Ruote::FlowExpressionId.from_id('eng!0_0_1!!20100224-fake').engine_id)
+  end
+
+  def test_extract_h
+
+    assert_equal(
+      { 'engine_id' => 'engine',
+        'expid' => '0_0_1',
+        'subid' => '5dbf4ce1553453baa17c2213d239e5fa',
+        'wfid' => '20100224-fake' },
+      Ruote::FlowExpressionId.extract_h(
+        '0_0_1!5dbf4ce1553453baa17c2213d239e5fa!20100224-fake'))
+  end
+
+  def test_extract
+
+    assert_equal(
+      Ruote::FlowExpressionId.new(
+        'engine_id' => 'engine',
+        'expid' => '0_0_1',
+        'subid' => '5dbf4ce1553453baa17c2213d239e5fa',
+        'wfid' => '20100224-fake'),
+      Ruote::FlowExpressionId.extract(
+        '0_0_1!5dbf4ce1553453baa17c2213d239e5fa!20100224-fake'))
+  end
+
+  def test_subid_backward_compatibility__subid
+
+    fei = Ruote::FlowExpressionId.new(
+      'engine_id' => 'engine',
+      'expid' => '0_0_1',
+      'subid' => 'd7ca677379e2a1f4933402b9196cf2a1',
+      'wfid' => '20100224-fake')
+
+    assert_equal 'd7ca677379e2a1f4933402b9196cf2a1', fei.sub_wfid
+    assert_equal 'd7ca677379e2a1f4933402b9196cf2a1', fei.subid
+    assert_equal 'd7ca677379e2a1f4933402b9196cf2a1', fei.h['subid']
+    assert_nil fei.h['sub_wfid']
+  end
+
+  def test_subid_backward_compatibility__sub_wfid
+
+    fei = Ruote::FlowExpressionId.new(
+      'engine_id' => 'engine',
+      'expid' => '0_0_1',
+      'sub_wfid' => 'd7ca677379e2a1f4933402b9196cf2a1',
+      'wfid' => '20100224-fake')
+
+    assert_equal 'd7ca677379e2a1f4933402b9196cf2a1', fei.sub_wfid
+    assert_equal 'd7ca677379e2a1f4933402b9196cf2a1', fei.subid
+    assert_equal 'd7ca677379e2a1f4933402b9196cf2a1', fei.h['subid']
+    assert_nil fei.h['sub_wfid']
+  end
+
+  def test_generate_subid
+
+    n = 21_000
+    h = '0_0'
+
+    ids = n.times.collect { Ruote.generate_subid(h) }
+
+    assert_equal n, ids.uniq.size, "subid generation seems weak"
+  end
+end
+