ruote 2.1.11 → 2.2.0

data/test/functional/storage_helper.rb

@@ -13,10 +13,10 @@ def locate_storage_impl (arg)
 
   pers = arg[2..-1]
 
-  path = File.expand_path(
-    File.join(File.dirname(__FILE__), %w[ .. .. .. ], "ruote-#{pers}"))
+  path = Dir[File.expand_path(
+    File.join(File.dirname(__FILE__), %w[ .. .. .. ], "ruote-#{pers}*"))].first
 
-  (File.exist?(path) && File.directory?(path)) ? [ pers, path ] : nil
+  File.directory?(path) ? [ pers, path ] : nil
 end
 
 #
@@ -37,7 +37,7 @@ else uses the in-memory Ruote::Engine (fastest, but no persistence at all)
     exit 0
   end
 
-  ps = ARGV.select { |a| a.match(/^--/) }
+  ps = ARGV.select { |a| a.match(/^--[a-z]/) }
   ps.delete('--split')
 
   persistent = opts.delete(:persistent)
@@ -56,10 +56,7 @@ else uses the in-memory Ruote::Engine (fastest, but no persistence at all)
   elsif not ps.empty?
 
     pers = nil
-    ps.each do |a|
-      pers = locate_storage_impl(a)
-      break if pers
-    end
+    ps.find { |a| pers = locate_storage_impl(a) }
 
     raise "no persistence found (#{ps.inspect})" unless pers
 
@@ -67,14 +64,19 @@ else uses the in-memory Ruote::Engine (fastest, but no persistence at all)
     $:.unshift(File.join(path, 'lib'))
 
     begin
-      load File.join(path, %w[ test functional_connection.rb ])
+      load 'test/functional_connection.rb'
     rescue LoadError => le
       begin
-        load File.join(path, %w[ test integration_connection.rb ])
+        load File.join(path, %w[ test functional_connection.rb ])
       rescue LoadError => lee
-        p le
-        p lee
-        raise lee
+        begin
+          load File.join(path, %w[ test integration_connection.rb ])
+        rescue LoadError => leee
+          p le
+          p lee
+          p leee
+          raise leee
+        end
       end
     end
 

data/test/functional/test.rb

@@ -9,11 +9,9 @@ def l (t)
 
   if ARGV.include?('--split')
 
-    _v = ARGV.include?('-v') ? ' -v' : ' '
-
     puts
     puts "=== #{t} :"
-    puts `ruby#{_v} #{t} #{ARGV.join(' ')}`
+    puts `ruby -I. #{t} #{ARGV.join(' ')}`
 
     es = $?.exitstatus
     es = es.nil? ? 66 : es.to_s.to_i

data/test/test_helper.rb

@@ -19,11 +19,3 @@ def require_json
   end
 end
 
-def require_patron
-  begin
-    require 'patron'
-  rescue LoadError => le
-    # stick with net/http
-  end
-end
-

data/test/unit/storage.rb

@@ -8,10 +8,13 @@
 require File.join(File.dirname(__FILE__), %w[ .. test_helper.rb ])
 
 require_json
-#require_patron
 
 require File.join(File.dirname(__FILE__), %w[ .. functional storage_helper.rb ])
 
+require 'ruote/fei'
+require 'ruote/participant'
+
+
 #
 # note : using the 'errors' type, but this test is about generic storage, not
 #        about errors per se.
@@ -25,16 +28,25 @@ class UtStorage < Test::Unit::TestCase
 
     #@s.add_type('errors')
 
+    @s.purge_type!('errors')
+    @s.purge_type!('expressions')
+    @s.purge_type!('msgs')
+    @s.purge_type!('workitems')
+
     @s.put(
       '_id' => 'toto',
       'type' => 'errors',
       'message' => 'testing')
   end
+
   def teardown
 
-    @s.get_many('errors').each do |d|
-      @s.delete(d)
-    end
+    @s.purge_type!('errors')
+    @s.purge_type!('expressions')
+    @s.purge_type!('msgs')
+    @s.purge_type!('workitems')
+
+    @s.shutdown
   end
 
   def test_get_configuration
@@ -214,12 +226,7 @@ class UtStorage < Test::Unit::TestCase
 
   def test_get_many_options
 
-    30.times do |i|
-      @s.put(
-        '_id' => sprintf("yy!%0.2d", i),
-        'type' => 'errors',
-        'msg' => "whatever #{i}")
-    end
+    load_30_errors
 
     # limit
 
@@ -255,5 +262,142 @@ class UtStorage < Test::Unit::TestCase
         'errors', nil, :skip => 0, :limit => 3, :descending => true
       ).collect { |d| d['_id'] })
   end
+
+  def test_dump
+
+    load_30_errors
+
+    assert @s.dump('errors').length > 0
+  end
+
+  def test_ids_and_errors
+
+    load_30_errors
+
+    assert_equal 31, @s.ids('errors').length
+  end
+
+  def test_ids_are_sorted
+
+    load_30_errors
+
+    assert_equal @s.ids('errors').sort, @s.ids('errors')
+  end
+
+  def test_reserve
+
+    taoe = Thread.abort_on_exception
+    Thread.abort_on_exception = true
+
+    reserved = []
+    threads = []
+
+    threads << Thread.new do
+      i = 0
+      loop do
+        @s.put_msg('launch', 'tree' => i)
+        i = i + 1
+      end
+    end
+
+    2.times do
+
+      threads << Thread.new do
+        loop do
+          msgs = @s.get_msgs
+          msgs[0, 100].each do |msg|
+            next if msg['tree'].nil?
+            next unless @s.reserve(msg)
+            if reserved.include?(msg['tree'])
+              puts "=" * 80
+              p [ :dbl, :r, msg['_rev'], :t, msg['tree'] ]
+            end
+            reserved << msg['tree']
+            sleep(rand * 0.01)
+          end
+        end
+      end
+    end
+
+    sleep 7
+
+    threads.each { |t| t.terminate }
+
+    Thread.abort_on_exception = taoe
+
+    assert_equal false, reserved.empty?
+    assert_equal reserved.size, reserved.uniq.size
+  end
+
+  def test_by_field
+
+    return unless @s.respond_to?(:by_field)
+
+    load_workitems
+
+    assert_equal 3, @s.by_field('workitems', 'place', 'kyouto').size
+    assert_equal 1, @s.by_field('workitems', 'place', 'sendai').size
+    assert_equal Hash, @s.by_field('workitems', 'place', 'sendai').first.class
+  end
+
+  def test_by_participant
+
+    return unless @s.respond_to?(:by_participant)
+
+    load_workitems
+
+    assert_equal 2, @s.by_participant('workitems', 'fujiwara', {}).size
+    assert_equal 1, @s.by_participant('workitems', 'shingen', {}).size
+    assert_equal Hash, @s.by_participant('workitems', 'shingen', {}).first.class
+  end
+
+  def test_query_workitems
+
+    return unless @s.respond_to?(:query_workitems)
+
+    load_workitems
+
+    assert_equal 3, @s.query_workitems('place' => 'kyouto').size
+    assert_equal 1, @s.query_workitems('place' => 'kyouto', 'at' => 'kamo').size
+
+    assert_equal(
+      Ruote::Workitem, @s.query_workitems('place' => 'kyouto').first.class)
+  end
+
+  protected
+
+  def load_30_errors
+
+    30.times do |i|
+      @s.put(
+        '_id' => sprintf("yy!%0.2d", i),
+        'type' => 'errors',
+        'msg' => "whatever #{i}")
+    end
+  end
+
+  def put_workitem(wfid, participant_name, fields)
+
+    @s.put(
+      'type' => 'workitems',
+      '_id' => "wi!0_0!12ff!#{wfid}",
+      'participant_name' => participant_name,
+      'wfid' => wfid,
+      'fields' => fields)
+  end
+
+  def load_workitems
+
+    put_workitem(
+      '20110218-nadanada', 'fujiwara', 'place' => 'kyouto')
+    put_workitem(
+      '20110218-nedenada', 'fujiwara', 'place' => 'kyouto', 'at' => 'kamo')
+    put_workitem(
+      '20110218-nadanodo', 'taira', 'place' => 'kyouto')
+    put_workitem(
+      '20110218-nodonada', 'date', 'place' => 'sendai')
+    put_workitem(
+      '20110218-nadanudu', 'shingen', 'place' => 'nagoya')
+  end
 end
 

data/test/unit/{ut_0_ruby_parser.rb → ut_0_ruby_reader.rb}

@@ -7,11 +7,10 @@
 
 require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
 
-require 'ruote/parser'
-#require 'ruote/parser/ruby_dsl'
+require 'ruote/reader'
 
 
-class UtRubyParserTest < Test::Unit::TestCase
+class UtRubyReaderTest < Test::Unit::TestCase
 
   #def test_whatever
   #  tree = Ruote.define do
@@ -125,33 +124,84 @@ class UtRubyParserTest < Test::Unit::TestCase
       Ruote.to_tree { sequence { alpha; bravo } })
   end
 
-  def test_raise
+  def test_treechecker
 
     #assert_raise Nada do
-      Ruote::Parser.parse %{ Ruote.define { alpha } }
+      Ruote::Reader.read %{ Ruote.define { alpha } }
     #end
 
     assert_raise ArgumentError do
-      Ruote::Parser.parse %{ Ruote.define { abort } }
+      Ruote::Reader.read %{ Ruote.define { abort } }
     end
     assert_raise ArgumentError do
-      Ruote::Parser.parse %{ Ruote.define { exit } }
+      Ruote::Reader.read %{ Ruote.define { exit } }
     end
     assert_raise ArgumentError do
-      Ruote::Parser.parse %{ Ruote.define { exit! } }
+      Ruote::Reader.read %{ Ruote.define { exit! } }
     end
 
     assert_raise ArgumentError do
-      Ruote::Parser.parse %{ Ruote.define { x = Kernel } }
+      Ruote::Reader.read %{ Ruote.define { x = Kernel } }
     end
 
     assert_raise ArgumentError do
-      Ruote::Parser.parse %{ Ruote.define { module Nada; end } }
+      Ruote::Reader.read %{ Ruote.define { module Nada; end } }
     end
 
     assert_raise ArgumentError do
-      Ruote::Parser.parse %{ Ruote.define { File.read('stuff') } }
+      Ruote::Reader.read %{ Ruote.define { File.read('stuff') } }
     end
+
+    assert_raise ArgumentError do
+      Ruote::Reader.read %{ Ruote.define { at_exit { } } }
+    end
+
+    assert_raise ArgumentError do
+      Ruote::Reader.read %{ Ruote.define { def nada; end } }
+    end
+  end
+
+  def test_attribute_text_regexp
+
+    tree = Ruote.define do
+      given "${target}" do
+        of "/^employee-/" do
+        end
+        of /^customer-/ do
+        end
+      end
+    end
+
+    assert_equal(
+      ["define", {}, [
+        ["given", {"${target}"=>nil}, [
+          ["of", {"/^employee-/"=>nil}, []],
+          ["of", {"/^customer-/"=>nil}, []]]]]],
+      tree)
+  end
+
+  def test_attribute_value_regexp
+
+    tree = Ruote.define do
+      subprocess 'alpha', :match => /^nada$/
+    end
+
+    assert_equal(
+      ["define", {}, [["subprocess", {"alpha"=>nil, "match"=>"/^nada$/"}, []]]],
+      tree)
+  end
+
+  def test_attribute_value_regexp_deep
+
+    tree = Ruote.define do
+      alpha :filter => { :in => [ { :field => /^private_/ } ] }
+    end
+
+    assert_equal(
+      [ "define", {}, [
+        [ "alpha", { "filter" => { "in" => [ { "field" => '/^private_/' } ] } }, [] ]
+      ] ],
+      tree)
   end
 end
 

data/test/unit/ut_11_lookup.rb

@@ -18,6 +18,13 @@ class LookupTest < Test::Unit::TestCase
     assert_equal('B', Ruote.lookup({ 'h' => %w[ A B C ] }, 'h.1'))
   end
 
+  def test_lookup_dot
+
+    h = { 'a' => 'b' }
+
+    assert_equal h, Ruote.lookup(h, '.')
+  end
+
   def test_container_lookup
 
     assert_equal(

data/test/unit/ut_13_serializer.rb

@@ -14,7 +14,7 @@ class UtSerializerTest < Test::Unit::TestCase
 
   class Vehicle
     attr_accessor :type
-    def initialize (t)
+    def initialize(t)
       @type = t
     end
   end

data/test/unit/ut_15_util.rb

@@ -30,5 +30,28 @@ class UtMiscTest < Test::Unit::TestCase
     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_parser.rb → ut_16_reader.rb}

@@ -7,10 +7,10 @@
 
 require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
 
-require 'ruote/parser'
+require 'ruote/reader'
 
 
-class PdefParserTest < Test::Unit::TestCase
+class PdefReaderTest < Test::Unit::TestCase
 
   DEF0 = %{
     Ruote.define :name => 'nada' do
@@ -22,7 +22,7 @@ class PdefParserTest < Test::Unit::TestCase
   }
 
 
-  TREE1 = Ruote::Parser.parse(%{
+  TREE1 = Ruote::Reader.read(%{
     Ruote.define :name => 'nada' do
       sequence do
         alpha
@@ -33,7 +33,7 @@ class PdefParserTest < Test::Unit::TestCase
 
   def test_from_string
 
-    tree = Ruote::Parser.parse(DEF0)
+    tree = Ruote::Reader.read(DEF0)
 
     assert_equal(
       ["define", {"name"=>"nada"}, [
@@ -48,7 +48,7 @@ class PdefParserTest < Test::Unit::TestCase
 
     File.open(fn, 'w') { |f| f.write(DEF0) }
 
-    tree = Ruote::Parser.parse(fn)
+    tree = Ruote::Reader.read(fn)
 
     assert_equal(
       ["define", {"name"=>"nada"}, [
@@ -61,7 +61,6 @@ class PdefParserTest < Test::Unit::TestCase
 
   def test_to_xml
 
-    #puts Ruote::Parser.to_xml(TREE1, :indent => 2)
     assert_equal(
       %{
 <?xml version="1.0" encoding="UTF-8"?>
@@ -72,7 +71,7 @@ class PdefParserTest < Test::Unit::TestCase
   </sequence>
 </define>
       }.strip,
-      Ruote::Parser.to_xml(TREE1, :indent => 2).strip)
+      Ruote::Reader.to_xml(TREE1, :indent => 2).strip)
   end
 
   def test_if_to_xml
@@ -92,12 +91,11 @@ class PdefParserTest < Test::Unit::TestCase
   </if>
 </define>
       }.strip,
-      Ruote::Parser.to_xml(tree, :indent => 2).strip)
+      Ruote::Reader.to_xml(tree, :indent => 2).strip)
   end
 
   def test_to_ruby
 
-    #puts Ruote::Parser.to_ruby(TREE1)
     assert_equal(
       %{
 Ruote.process_definition :name => "nada" do
@@ -107,14 +105,14 @@ Ruote.process_definition :name => "nada" do
   end
 end
       }.strip,
-      Ruote::Parser.to_ruby(TREE1).strip)
+      Ruote::Reader.to_ruby(TREE1).strip)
   end
 
   def test_to_json
 
     require 'json'
 
-    assert_equal TREE1.to_json, Ruote::Parser.to_json(TREE1)
+    assert_equal TREE1.to_json, Ruote::Reader.to_json(TREE1)
   end
 
   DEF1 = %{
@@ -135,7 +133,7 @@ end
 
     assert_equal(
       ["define", {}, [["sequence", {}, [["alpha", {}, []], ["set", {"field"=>"f", "value"=>"v"}, []], ["bravo", {}, []]]]]],
-      Ruote::Parser.parse(fn))
+      Ruote::Reader.read(fn))
 
     FileUtils.rm(fn)
   end
@@ -145,7 +143,7 @@ end
   #
   def test_ruby_blank_slate
 
-    t = Ruote::Parser.parse(%{
+    t = Ruote::Reader.read(%{
       Ruote.define do
         freeze
         clone