ruote 2.2.0 → 2.3.0

data/test/unit/ut_19_part_template.rb

@@ -5,7 +5,7 @@
 # Thu Mar  4 10:24:30 JST 2010
 #
 
-require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.expand_path('../../test_helper', __FILE__)
 
 require_json
 require 'ruote/context'

data/test/unit/ut_1_fei.rb

@@ -5,8 +5,9 @@
 # Fri May 15 10:08:51 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.expand_path('../../test_helper', __FILE__)
 
+require 'ostruct'
 require 'ruote'
 
 
@@ -159,7 +160,15 @@ class UtFeiTest < Test::Unit::TestCase
 
     ids = n.times.collect { Ruote.generate_subid(h) }
 
-    assert_equal n, ids.uniq.size, "subid generation seems weak"
+    assert_equal n, ids.uniq.size, '/!\ subid generation seems weak'
+  end
+
+  def test_extract_wfid
+
+    assert_equal 'i', Ruote.extract_wfid('i')
+    assert_equal 'i', Ruote.extract_wfid({ 'wfid' => 'i' })
+    assert_equal 'i', Ruote.extract_wfid({ 'fei' => { 'wfid' => 'i' } })
+    assert_equal 'i', Ruote.extract_wfid(OpenStruct.new('wfid' => 'i'))
   end
 end
 

data/test/unit/ut_20_composite_storage.rb

@@ -5,7 +5,7 @@
 # Sun Mar 14 21:25:52 JST 2010
 #
 
-require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.expand_path('../../test_helper', __FILE__)
 
 require 'ruote'
 require 'ruote/storage/composite_storage'
@@ -44,5 +44,31 @@ class UtCompositeStorageTest < Test::Unit::TestCase
     assert_nil r
     assert_equal 0, @default.h['msgs'].size
   end
+
+  class TracingStorage
+    attr_reader :trace
+    def initialize
+      @trace = []
+    end
+    def method_missing(m, *args)
+      @trace << [ m, *args ]
+    end
+  end
+
+  def test_special_methods
+
+    default = TracingStorage.new
+
+    cs = Ruote::CompositeStorage.new(default, {})
+
+    cs.delete_schedule('x') # schedule id
+    cs.reserve('type' => 'schedules', '_id' => 'nada')
+
+    assert_equal([
+      [ :delete_schedule, 'x' ],
+      [ :reserve, { 'type' => 'schedules', '_id' => 'nada' } ]
+    ],
+    default.trace)
+  end
 end
 

data/test/unit/{ut_21_participant_list.rb → ut_21_svc_participant_list.rb}

@@ -5,15 +5,14 @@
 # Wed Jan 26 09:21:06 JST 2011
 #
 
-require File.join(File.dirname(__FILE__), %w[ .. test_helper.rb ])
-#require File.join(File.dirname(__FILE__), %w[ .. functional storage_helper.rb ])
+require File.expand_path('../../test_helper', __FILE__)
 
 require 'ostruct'
 require 'ruote'
 require 'ruote/svc/participant_list'
 
 
-class UtEngineTest < Test::Unit::TestCase
+class UtSvcParticipantListTest < Test::Unit::TestCase
 
   class FakeStorage
     def initialize

data/test/unit/ut_22_filter.rb

@@ -5,7 +5,7 @@
 # Sun Jan 30 21:08:14 JST 2011
 #
 
-require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.expand_path('../../test_helper', __FILE__)
 
 require_json
 require 'rufus/json'
@@ -31,9 +31,12 @@ class UtFilterTest < Test::Unit::TestCase
   #
   # transformations
 
-  def assert_filter(result, filter, hash)
+  def assert_filter(result, filter, hash, double_tilde=nil)
 
-    assert_equal(result, Ruote.filter(Rufus::Json.dup(filter), hash))
+    assert_equal(
+      result,
+      Ruote.filter(
+        Rufus::Json.dup(filter), hash, :double_tilde => double_tilde))
   end
 
   def test_remove
@@ -428,16 +431,57 @@ class UtFilterTest < Test::Unit::TestCase
       { 'x' => %w[ a b c ] })
   end
 
+  def test_take
+
+    assert_filter(
+      { 'x' => 'a', 'z' => 'b' },
+      [ { 'field' => 'x', 'take' => 'true' } ],
+      { 'x' => 'a', 'y' => 'a' },
+      { 'z' => 'b' }) # ~~
+  end
+
+  def test_discard
+
+    assert_filter(
+      { 'y' => 'a', 'z' => 'b' },
+      [ { 'field' => 'x', 'discard' => 'true' } ],
+      { 'x' => 'a', 'y' => 'a' },
+      { 'z' => 'b' }) # ~~
+  end
+
+  def test_discard_multiple
+
+    assert_filter(
+      { 'z' => 'a', '1' => 'b' },
+      [ { 'field' => 'x|y', 'discard' => 'true' } ],
+      { 'x' => 'a', 'y' => 'a', 'z' => 'a' },
+      { '1' => 'b' }) # ~~
+  end
+
   #
   # validations
 
   def assert_valid(filter, hash)
 
-    Ruote.filter(Rufus::Json.dup(filter), hash)
-    assert true
+    begin
+      Ruote.filter(Rufus::Json.dup(filter), hash)
+      assert true
+    rescue Ruote::ValidationError => ve
+      puts
+      puts
+      p ve
+      p ve.deviations
+      puts
+      puts 'hash:'
+      p hash
+      puts 'filter:'
+      filter.each { |l| p l }
+      puts
+      assert false
+    end
   end
 
-  def assert_not_valid(filter, hash, deviations=1)
+  def assert_not_valid(filter, hash, opts={ :deviations => 1 })
 
     error = nil
 
@@ -446,14 +490,46 @@ class UtFilterTest < Test::Unit::TestCase
     rescue => error
     end
 
+    p error.deviations if opts[:verbose]
+
     assert_not_nil(
       error, "ValidationError was not raised")
     assert_equal(
-      deviations, error.deviations.size, "deviation count doesn't match")
+      opts[:deviations], error.deviations.size, "deviation count doesn't match")
 
     @deviations = error.deviations
   end
 
+  def test_presence
+
+    assert_valid(
+      [ { 'field' => 'x' } ], { 'x' => 'deux' })
+    assert_not_valid(
+      [ { 'field' => 'x' } ], { 'y' => 'trois' })
+
+    assert_valid(
+      [ { 'field' => '/x|y/' } ], { 'x' => 'deux' })
+    assert_not_valid(
+      [ { 'field' => '/x|y/' } ], { 'z' => 'quatre' })
+  end
+
+  def test_this_or_that_field
+
+    assert_valid(
+      [ { 'field' => 'x|y', 'type' => 'string' } ], { 'x' => 'deux' })
+    assert_valid(
+      [ { 'field' => 'x|y', 'type' => 'string' } ], { 'y' => 'trois' })
+
+
+    assert_valid(
+      [ { 'field' => 'x|y'} ], { 'x' => 'deux' })
+
+    assert_not_valid(
+      [ { 'field' => 'x|y', 'type' => 'string' } ], { 'z' => 'quatre' })
+    assert_not_valid(
+      [ { 'field' => 'x|y' } ], { 'z' => 'quatre' })
+  end
+
   def test_type
 
     assert_valid(
@@ -507,6 +583,9 @@ class UtFilterTest < Test::Unit::TestCase
       [ { 'field' => 'x', 'type' => 'null' } ], { 'x' => false })
     assert_not_valid(
       [ { 'field' => 'x', 'type' => 'null' } ], { 'x' => 1 })
+
+    assert_not_valid(
+      [ { 'field' => 'x', 'type' => 'string' } ], {})
   end
 
   def test_type_deep
@@ -598,7 +677,7 @@ class UtFilterTest < Test::Unit::TestCase
     assert_not_valid(
       [ { 'field' => '/./', 'type' => 'string' } ],
       { 'x' => 1, 'z' => 1 },
-      2)
+      :deviations => 2)
   end
 
   def test_match
@@ -635,6 +714,26 @@ class UtFilterTest < Test::Unit::TestCase
       { 'x' => 2.0 })
   end
 
+  def test_is
+
+    assert_valid(
+      [ { 'field' => 'x', 'is' => true } ],
+      { 'x' => true })
+    assert_valid(
+      [ { 'field' => 'x', 'is' => (1..3).to_a } ],
+      { 'x' => [ 1, 2, 3 ] })
+
+    assert_not_valid(
+      [ { 'field' => 'x', 'is' => false } ],
+      { 'x' => true })
+    assert_not_valid(
+      [ { 'field' => 'x', 'is' => true } ],
+      { 'x' => 1 })
+    assert_not_valid(
+      [ { 'field' => 'x', 'is' => (1..3).to_a } ],
+      { 'x' => [ 3, 2, 1 ] })
+  end
+
   def test_size
 
     assert_valid(
@@ -706,6 +805,9 @@ class UtFilterTest < Test::Unit::TestCase
     assert_valid(
       [ { 'field' => 'x', 'empty' => true } ],
       { 'x' => '' })
+    assert_valid(
+      [ { 'field' => 'x', 'empty' => false } ],
+      { 'x' => [ 1 ] })
 
     assert_not_valid(
       [ { 'field' => 'x', 'empty' => true } ],
@@ -716,6 +818,23 @@ class UtFilterTest < Test::Unit::TestCase
     assert_not_valid(
       [ { 'field' => 'x', 'empty' => true } ],
       { 'x' => { 'a' =>  'b' } })
+    assert_not_valid(
+      [ { 'field' => 'x', 'empty' => false } ],
+      { 'x' => {} })
+  end
+
+  def test_string_and_empty
+
+    assert_valid(
+      [ { 'field' => 'x', 'empty' => true, 'type' => 'string' } ],
+      { 'x' => '' })
+    assert_valid(
+      [ { 'field' => 'x', 'empty' => false, 'type' => 'string' } ],
+      { 'x' => 'yyy' })
+
+    assert_not_valid(
+      [ { 'field' => 'x', 'empty' => true, 'type' => 'string' } ],
+      { 'x' => {} })
   end
 
   def test_in
@@ -726,6 +845,9 @@ class UtFilterTest < Test::Unit::TestCase
     assert_valid(
       [ { 'field' => 'x', 'in' => "alpha, bravo" } ],
       { 'x' => 'alpha' })
+    assert_valid(
+      [ { 'field' => 'x', 'in' => [ true ] } ],
+      { 'x' => true })
 
     assert_not_valid(
       [ { 'field' => 'x', 'in' => %w[ alpha bravo ] } ],
@@ -733,6 +855,9 @@ class UtFilterTest < Test::Unit::TestCase
     assert_not_valid(
       [ { 'field' => 'x', 'in' => "alpha, bravo" } ],
       { 'x' => 'charly' })
+    assert_not_valid(
+      [ { 'field' => 'x', 'in' => [ false ] } ],
+      { 'x' => true })
   end
 
   def test_has__keys
@@ -787,6 +912,31 @@ class UtFilterTest < Test::Unit::TestCase
       { 'x' => %w[ a b c ] })
   end
 
+  def test_includes
+
+    assert_valid(
+      [ { 'field' => 'x', 'includes' => 'a' } ],
+      { 'x' => %w[ a b c ] })
+
+    assert_not_valid(
+      [ { 'field' => 'x', 'includes' => 'z' } ],
+      { 'x' => %w[ a b c ] })
+    assert_not_valid(
+      [ { 'field' => 'x', 'includes' => 'z' } ],
+      { 'x' => 'abcz' })
+  end
+
+  def test_includes__value
+
+    assert_valid(
+      [ { 'field' => 'x', 'includes' => 1 } ],
+      { 'x' => { 'a' => 1 } })
+
+    assert_not_valid(
+      [ { 'field' => 'x', 'includes' => '1' } ],
+      { 'x' => { 'a' => 1 } })
+  end
+
   def test_valid
 
     # 'valid' can be used in conjunction with the dollar notation
@@ -833,7 +983,7 @@ class UtFilterTest < Test::Unit::TestCase
         'x' => %w[ a b c ],
         'y' => true
       },
-      2)
+      :deviations => 2)
 
     assert_equal [
       [ { "has" => 1, "field" => "x", "t" => "array"}, "x", [ "a", "b", "c" ] ],
@@ -853,7 +1003,22 @@ class UtFilterTest < Test::Unit::TestCase
       :no_raise => true)
 
     assert_equal(
-      [ [ { "has" => "a", "field" => "x", "t" => "hash"}, "x", [ "a", "b", "c" ] ] ], r)
+      [ [ { "has" => "a", "field" => "x", "t" => "hash"}, "x", [ "a", "b", "c" ] ] ],
+      r)
+  end
+
+  # Data passes through the filter untouched.
+  #
+  def test_no_raise_empty_result
+
+    r = Ruote.filter(
+      [ { 'field' => 'x', 't' => 'array', 'has' => 'a' } ],
+      { 'x' => %w[ a b c ] },
+      :no_raise => true)
+
+    assert_equal(
+      { 'x' => %w[ a b c ] },
+      r)
   end
 
   #
@@ -899,5 +1064,61 @@ class UtFilterTest < Test::Unit::TestCase
         ]
       }))
   end
+
+  def test_top_level_or
+
+    filter = [
+      { 'field' => 'x', 'type' => 'string' },
+      { 'field' => 'y', 'type' => 'number' },
+      'or',
+      { 'field' => 'z', 'type' => 'bool' }
+    ]
+
+    assert_valid(filter, { 'x' => 'whatever', 'y' => 1 })
+    assert_valid(filter, { 'z' => true })
+    assert_valid(filter, { 'x' => -9, 'z' => false })
+    assert_valid(filter, { 'x' => 'ah', 'y' => 2 })
+
+    assert_not_valid(filter, { 'x' => 'whatever', 'y' => 'notanumber' })
+    assert_not_valid(filter, { 'z' => 'notabool' })
+    assert_not_valid(filter, { 'x' => 'x', 'z' => 'nada' })
+
+    filter = [
+      [ { 'field' => 'x', 'type' => 'string' },
+        { 'field' => 'y', 'type' => 'number' } ],
+      [ { 'field' => 'z', 'type' => 'bool' } ]
+    ]
+
+    assert_valid(filter, { 'x' => 'whatever', 'y' => 1 })
+    assert_valid(filter, { 'z' => true })
+    assert_valid(filter, { 'x' => -9, 'z' => false })
+    assert_valid(filter, { 'x' => 'ah', 'y' => 2 })
+  end
+
+  def test_top_level_or_and_pipe_field
+
+    filter = [
+      { 'field' => 'x|params.x', 'type' => 'string' },
+      'or',
+      { 'field' => 'y|params.y', 'type' => 'bool' }
+    ]
+
+    assert_valid(filter, { 'x' => 'out' })
+    assert_valid(filter, { 'params' => { 'x' => 'in' } })
+    assert_valid(filter, { 'y' => true })
+    assert_valid(filter, { 'params' => { 'y' => false } })
+
+    assert_not_valid(filter, { 'y' => 'out' })
+    assert_not_valid(filter, { 'params' => { 'y' => 'in' } })
+    assert_not_valid(filter, {})
+  end
+
+  def test_misc_neutralization
+
+    assert_valid(
+      [ { :field => 'x', :type => :string } ], { 'x' => 'deux' })
+    assert_valid(
+      [ { :field => 'x', 'smatch' => /de/ } ], { 'x' => 'deux' })
+  end
 end
 

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.expand_path('../../test_helper', __FILE__)
+
+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
+