ruote 0.9.20 → 2.1.1

data/test/unit/ut_17_storage.rb

@@ -0,0 +1,122 @@
+
+#
+# testing ruote
+#
+# Mon Dec 14 15:03:13 JST 2009
+#
+
+require 'yajl' rescue require 'json'
+require 'patron' rescue nil
+
+require File.join(File.dirname(__FILE__), %w[ .. test_helper.rb ])
+require File.join(File.dirname(__FILE__), %w[ .. functional storage_helper.rb ])
+
+
+class UtStorage < Test::Unit::TestCase
+
+  def setup
+    @s = determine_storage({})
+    @s.add_test_type('dogfood') if @s.respond_to?(:add_test_type)
+    @s.put(
+      '_id' => 'toto',
+      'type' => 'dogfood',
+      'message' => 'testing')
+  end
+  def teardown
+    @s.get_many('dogfood').each { |d| @s.delete(d) }
+  end
+
+  def test_get_configuration
+
+    assert_not_nil @s.get_configuration('engine')
+  end
+
+  def test_get
+
+    h = @s.get('dogfood', 'toto')
+
+    assert_not_nil h['_rev']
+
+    h = @s.get('dogfood', 'nada')
+
+    assert_nil h
+  end
+
+  def test_put
+
+    @s.put('_id' => 'nada', 'type' => 'dogfood', 'message' => 'testing again')
+
+    h = @s.get('dogfood', 'nada')
+
+    assert_not_nil h['_rev']
+  end
+
+  def test_put_fail
+
+    r = @s.put('_id' => 'toto', 'type' => 'dogfood', 'message' => 'more')
+
+    assert_equal 'toto', r['_id']
+    assert_not_nil r['_rev']
+  end
+
+  def test_put_update_rev
+
+    doc = { '_id' => 'ouinouin', 'type' => 'dogfood', 'message' => 'more' }
+
+    r = @s.put(doc, :update_rev => true)
+
+    assert_not_nil doc['_rev']
+  end
+
+  def test_delete_fail
+
+    assert_raise(ArgumentError) do
+      @s.delete('_id' => 'toto')
+    end
+  end
+
+  def test_delete
+
+    doc = @s.get('dogfood', 'toto')
+
+    r = @s.delete(doc)
+
+    assert_nil r
+  end
+
+  def test_delete_missing
+
+    r = @s.delete('_id' => 'x', '_rev' => '12-13231123132', 'type' => 'dogfood')
+
+    assert_equal true, r
+  end
+
+  def test_keys_should_be_string
+
+    require 'yajl' rescue require 'json'
+    Rufus::Json.detect_backend
+
+    doc = { '_id' => 'h0', 'type' => 'dogfood', :m0 => :z, :m1 => [ :a, :b ] }
+
+    @s.put(doc)
+
+    doc = @s.get('dogfood', 'h0')
+
+    assert_equal 'z', doc['m0']
+    assert_equal %w[ a b ], doc['m1']
+  end
+
+  # Updating a gone document must result in a 'true' reply.
+  #
+  def test_put_missing
+
+    h = @s.get('dogfood', 'toto')
+
+    assert_nil @s.delete(h)
+
+    h['colour'] = 'blue'
+
+    assert_equal true, @s.put(h)
+  end
+end
+

data/test/unit/ut_1_fei.rb

@@ -0,0 +1,20 @@
+
+#
+# testing ruote
+#
+# Fri May 15 10:08:51 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/fei'
+
+
+class UtFeiTest < Test::Unit::TestCase
+
+  def test_initial
+
+    assert true
+  end
+end
+

data/test/unit/ut_2_wfidgen.rb

@@ -0,0 +1,21 @@
+
+#
+# testing ruote
+#
+# Tue May 19 17:58:51 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/id/wfid_generator'
+require 'ruote/id/mnemo_wfid_generator'
+
+
+class UtWfidGenTest < Test::Unit::TestCase
+
+  def test_zero
+
+    assert true
+  end
+end
+

data/test/unit/ut_3_wait_logger.rb

@@ -0,0 +1,41 @@
+
+#
+# testing ruote
+#
+# Thu Dec 10 14:08:30 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/parser/ruby_dsl'
+require 'ruote/engine'
+require 'ruote/worker'
+require 'ruote/storage/hash_storage'
+require 'ruote/part/hash_participant'
+
+
+class UtWaitLoggerTest < Test::Unit::TestCase
+
+  def test_wait_for_participant
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        #wait '1'
+        alpha
+      end
+    end
+
+    engine = Ruote::Engine.new(Ruote::Worker.new(Ruote::HashStorage.new))
+
+    alpha = engine.register_participant :alpha, Ruote::HashParticipant.new
+
+    engine.launch(pdef)
+    msg = engine.wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+
+    assert_not_nil msg
+    assert_not_nil msg['workitem']
+  end
+end
+

data/test/unit/ut_4_expmap.rb

@@ -0,0 +1,20 @@
+
+#
+# testing ruote
+#
+# Wed May 20 11:21:39 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/exp/expression_map'
+
+
+class UtExpMapTest < Test::Unit::TestCase
+
+  def test_zero
+
+    assert true
+  end
+end
+

data/test/unit/ut_5_tree.rb

@@ -0,0 +1,54 @@
+
+#
+# testing ruote
+#
+# Thu May 21 15:29:48 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/engine/process_status'
+
+
+class TreeTest < Test::Unit::TestCase
+
+  def test_decompose_tree
+
+    assert_equal(
+      {"0"=>["define", {"name"=>"nada"}],
+       "0_0"=>["sequence", {}],
+       "0_0_0"=>["alpha", {}],
+       "0_0_1"=>["bravo", {}]},
+      Ruote.decompose_tree(
+        ["define", {"name"=>"nada"}, [
+          ["sequence", {}, [["alpha", {}, []], ["bravo", {}, []]]]
+        ]]))
+  end
+
+  def test_decompose_sub_tree
+
+    assert_equal(
+      {"0_1"=>["define", {"name"=>"nada"}],
+       "0_1_0"=>["sequence", {}],
+       "0_1_0_0"=>["alpha", {}],
+       "0_1_0_1"=>["bravo", {}]},
+      Ruote.decompose_tree(
+        ["define", {"name"=>"nada"}, [
+          ["sequence", {}, [["alpha", {}, []], ["bravo", {}, []]]]
+        ]], '0_1'))
+  end
+
+  def test_recompose_tree
+
+    assert_equal(
+      ["define", {"name"=>"nada"}, [
+        ["sequence", {}, [["alpha", {}, []], ["bravo", {}, []]]]
+      ]],
+      Ruote.recompose_tree(
+        {"0"=>["define", {"name"=>"nada"}],
+         "0_0"=>["sequence", {}],
+         "0_0_0"=>["alpha", {}],
+         "0_0_1"=>["bravo", {}]}))
+  end
+end
+

data/test/unit/ut_6_condition.rb

@@ -0,0 +1,138 @@
+
+#
+# testing ruote
+#
+# Sun Jun 14 17:30:43 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/exp/expression_map'
+require 'ruote/util/treechecker'
+
+
+class ConditionTest < Test::Unit::TestCase
+
+  class Conditional
+
+    def treechecker
+      return @tc if @tc
+      @tc = Ruote::TreeChecker.new
+      @tc.context = {}
+      @tc
+    end
+  end
+
+  class FakeExpression < Conditional
+
+    def initialize (h)
+      @h = h
+    end
+    def attribute (k)
+      @h[k]
+    end
+  end
+
+  def assert_not_skip (result, h)
+
+    fe = FakeExpression.new(h)
+
+    sif = fe.attribute(:if)
+    sunless = fe.attribute(:unless)
+
+    assert_equal result, Ruote::Exp::Condition.apply?(sif, sunless)
+  end
+
+  def assert_b (b, conditional)
+
+    assert_equal(
+      b,
+      Ruote::Exp::Condition.true?(conditional),
+      ">#{conditional}< was expected to be #{b}")
+  end
+
+  def test_if
+
+    assert_not_skip false, :if => 'true == false'
+    assert_not_skip false, :if => "'true' == 'false'"
+    assert_not_skip false, :if => '"true" == "false"'
+
+    assert_not_skip true, :if => 'a == a'
+    assert_not_skip true, :if => '"a" == "a"'
+  end
+
+  def test_unless
+
+    assert_not_skip true, :unless => 'true == false'
+    assert_not_skip false, :unless => 'false == false'
+  end
+
+  def test_set
+
+    assert_not_skip true, :if => 'true set'
+    assert_not_skip true, :if => "'true' set"
+    assert_not_skip true, :if => '"true" set'
+
+    assert_not_skip true, :if => 'true is set'
+    assert_not_skip true, :if => '"true" is set'
+    assert_not_skip true, :if => "'true' is set"
+    assert_not_skip false, :if => 'true is not set'
+  end
+
+  def test_illegal_code
+
+    assert_not_skip true, :if => 'exit'
+  end
+
+  def test_true
+
+    assert_b true, 'true == true'
+    assert_b true, 'alpha == alpha'
+
+    assert_b true, 'true is set'
+    assert_b true, 'false is set'
+
+    assert_b false, 'true is not set'
+    assert_b false, 'is set'
+    assert_b false, ' is set'
+  end
+
+  def test_bang_equal
+
+    assert_b false, 'true != true'
+    assert_b true, 'true != false'
+  end
+
+  def test_match
+
+    assert_b false, 'alpha =~ bravo'
+    assert_b true, 'alpha =~ al'
+  end
+
+  def test_number_comparision
+
+    assert_b true, 'b > a'
+    assert_b false, 'a > b'
+    assert_b true, '100 > 10'
+    assert_b true, '100 > 90'
+    assert_b true, '100.0 > 90'
+  end
+
+  def test_emptiness
+
+    assert_b true, ' == '
+    assert_b false, " == ''"
+    assert_b false, ' == ""'
+  end
+
+  def test_strip
+
+    assert_not_skip true, :if => 'a == a '
+    assert_not_skip true, :if => ' a == a '
+    assert_not_skip true, :if => ' a == a'
+    assert_not_skip true, :if => 'a ==  a'
+    assert_not_skip true, :if => 'a  == a'
+    assert_not_skip true, :if => 'a==a'
+  end
+end
+

data/test/unit/ut_7_workitem.rb

@@ -0,0 +1,21 @@
+
+#
+# testing ruote
+#
+# Mon Jun 15 16:43:06 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/fei'
+require 'ruote/workitem'
+
+
+class UtWorkitemTest < Test::Unit::TestCase
+
+  def test_zero
+
+    assert true
+  end
+end
+

data/test/unit/ut_8_tree_to_dot.rb

@@ -0,0 +1,72 @@
+
+#
+# testing ruote
+#
+# Wed Jul 15 09:27:20 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/parser/ruby_dsl'
+require 'ruote/tree_dot'
+
+
+class TreeDotTest < Test::Unit::TestCase
+
+  def test_sequence
+
+    tree = Ruote.define :name => 'test' do
+      sequence do
+        alpha
+        bravo
+      end
+    end
+
+    #puts Ruote.tree_to_dot(tree)
+
+    assert_equal(
+      %{
+digraph "ruote process definition" {
+  "0" [ label = "define {'name'=>'test'}" ];
+  "0_0" [ label = "sequence {}" ];
+  "0_0_0" [ label = "alpha {}" ];
+  "0_0_1" [ label = "bravo {}" ];
+  "0_0" -> "0_0_0";
+  "0_0_1" -> "0_0";
+  "0_0_0" -> "0_0_1";
+  "0" -> "0_0";
+  "0_0" -> "0";
+}
+      }.strip,
+      Ruote.tree_to_dot(tree).strip)
+  end
+
+  def test_concurrence
+
+    tree = Ruote.define :name => 'test' do
+      concurrence do
+        alpha
+        bravo
+      end
+    end
+
+    #puts Ruote.tree_to_dot(tree)
+
+    assert_equal(
+      %{
+digraph "ruote process definition" {
+  "0" [ label = "define {'name'=>'test'}" ];
+  "0_0" [ label = "concurrence {}" ];
+  "0_0_0" [ label = "alpha {}" ];
+  "0_0_1" [ label = "bravo {}" ];
+  "0_0" -> "0_0_0";
+  "0_0_0" -> "0_0";
+  "0_0" -> "0_0_1";
+  "0_0_1" -> "0_0";
+  "0" -> "0_0";
+  "0_0" -> "0";
+}
+      }.strip,
+      Ruote.tree_to_dot(tree).strip)
+  end
+end