ruote 2.2.0 → 2.3.0

data/test/functional/ft_21_forget.rb

@@ -5,7 +5,7 @@
 # Mon Jul 27 09:17:51 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 require 'ruote/participant'
 
@@ -22,13 +22,13 @@ class FtForgetTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha do
-      @tracer << "alpha\n"
+    @dashboard.register_participant :alpha do
+      tracer << "alpha\n"
     end
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(wfid)
     wait_for(wfid)
@@ -43,7 +43,7 @@ class FtForgetTest < Test::Unit::TestCase
 
   def test_forgotten_tree
 
-    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+    sp = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
     pdef = Ruote.process_definition do
       sequence do
@@ -51,11 +51,11 @@ class FtForgetTest < Test::Unit::TestCase
       end
     end
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(wfid)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_not_nil ps
     assert_equal 0, ps.errors.size
@@ -63,10 +63,6 @@ class FtForgetTest < Test::Unit::TestCase
 
     fei = ps.expressions.first.fei
     assert_equal fei, ps.root_expression_for(fei).fei
-
-    #puts "not sure..."
-    #p ps.original_tree
-    #p ps.current_tree
   end
 
   def test_forget_true_string
@@ -79,16 +75,15 @@ class FtForgetTest < Test::Unit::TestCase
       charly
     end
 
-    @engine.register_participant '.+' do |wi|
-      @tracer << wi.participant_name + "\n"
+    @dashboard.register_participant '.+' do |wi|
+      tracer << wi.participant_name + "\n"
     end
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(wfid)
     wait_for(wfid)
 
-    #assert_equal "alpha\nbravo\ncharly", @tracer.to_s
     assert_equal %w[ alpha bravo charly ], @tracer.to_a.sort
   end
 
@@ -102,20 +97,20 @@ class FtForgetTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant 'alpha', Ruote::NullParticipant
+    @dashboard.register_participant 'alpha', Ruote::NullParticipant
       # this participant never replies
 
-    @engine.register_participant 'bravo', Ruote::NoOpParticipant
+    @dashboard.register_participant 'bravo', Ruote::NoOpParticipant
       # this one simply replies
 
-    #@engine.noisy = true
+    #@dashboard.noisy = true
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
-    @engine.wait_for(:bravo)
-    @engine.wait_for(:bravo)
+    @dashboard.wait_for(:bravo)
+    @dashboard.wait_for(:bravo)
 
-    assert_not_nil @engine.process(wfid)
+    assert_not_nil @dashboard.process(wfid)
   end
 
   # As reported by Nando Sola
@@ -135,19 +130,19 @@ class FtForgetTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register do
+    @dashboard.register do
       catchall Ruote::NoOpParticipant
     end
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
-    @engine.wait_for(wfid)
+    @dashboard.wait_for(wfid)
 
     assert_equal(
       [],
-      @engine.history.all.select { |e| e['action'] == 'error_intercepted' })
+      @dashboard.history.all.select { |e| e['action'] == 'error_intercepted' })
   end
 end
 

data/test/functional/ft_22_process_definitions.rb

@@ -7,7 +7,7 @@
 
 require 'socket' # just for SocketError
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class FtProcessDefinitionTest < Test::Unit::TestCase
@@ -32,16 +32,16 @@ class FtProcessDefinitionTest < Test::Unit::TestCase
   def test_remote_definitions_not_allowed
 
     assert_raise ArgumentError do
-      @engine.launch('http://defs.example.com/def0.rb')
+      @dashboard.launch('http://defs.example.com/def0.rb')
     end
   end
 
   def test_remote_definitions_allowed
 
-    @engine.context['remote_definition_allowed'] = true
+    @dashboard.context['remote_definition_allowed'] = true
 
     e = assert_raise SocketError, OpenURI::HTTPError, ArgumentError do
-      @engine.launch('http://defs.example.com/def0.rb')
+      @dashboard.launch('http://defs.example.com/def0.rb')
     end
 
     assert_not_equal 'remote process definitions are not allowed', e.message
@@ -51,8 +51,8 @@ class FtProcessDefinitionTest < Test::Unit::TestCase
 
     prev = Rufus::Json.backend
 
-    #require 'json' # json 1.4.3 being buggy...
-    require 'json/pure'
+    require 'json' # warning, json 1.4.3 is buggy...
+    #require 'json/pure'
     Rufus::Json.backend = :json
 
     #pdef = Ruote.process_definition :name => 'test' do
@@ -69,6 +69,8 @@ class FtProcessDefinitionTest < Test::Unit::TestCase
 
     Rufus::Json.backend = prev
       # back to initial state
+  rescue => e
+    p e
   end
 
   def test_local_definition

data/test/functional/ft_23_load_defs.rb

@@ -5,7 +5,7 @@
 # Wed Aug  5 08:35:38 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class FtLoadDefsTest < Test::Unit::TestCase
@@ -29,8 +29,32 @@ end
     File.open(fn, 'w') { |f| f.write(pdef) }
 
     assert_equal(
-      ["define", {"name"=>"test"}, [["sequence", {}, [["echo", {"a"=>nil}, []], ["echo", {"b"=>nil}, []]]]]],
-      @engine.load_definition(fn))
+      [ 'define', { 'name' => 'test' }, [
+        ['sequence', {}, [
+          ['echo', { 'a' => nil }, [] ],
+          ['echo', { 'b' => nil}, [] ] ] ] ] ],
+      @dashboard.load_definition(fn))
+  end
+
+  def test_load_definition_with_absolute_path
+
+    pdef = %{
+Ruote.process_definition do
+  echo 'a'
+end
+    }
+
+    path = File.join('work', 'tmp')
+    fn = File.join(path, 'pdef.rb')
+
+    FileUtils.mkdir_p(path)
+    File.open(fn, 'w') { |f| f.write(pdef) }
+
+    fn = File.expand_path(fn)
+
+    assert_equal(
+      [ 'define', {}, [ [ 'echo', { 'a' => nil }, [] ] ] ],
+      @dashboard.load_definition(fn))
   end
 
   def test_load_illegal_definition
@@ -47,8 +71,8 @@ end
     FileUtils.mkdir_p(path)
     File.open(fn, 'w') { |f| f.write(pdef) }
 
-    assert_raise ArgumentError do
-      @engine.load_definition(fn)
+    assert_raise Ruote::Reader::Error do
+      @dashboard.load_definition(fn)
     end
   end
 end

data/test/functional/ft_24_block_participant.rb

@@ -5,7 +5,7 @@
 # Tue Aug 11 13:56:28 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class FtBlockParticipantTest < Test::Unit::TestCase
@@ -23,19 +23,23 @@ class FtBlockParticipantTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha do
-      @tracer << "a\n"
+    @dashboard.register_participant :alpha do
+      tracer << "a\n"
     end
-    @engine.register_participant :bravo do |workitem|
-      @tracer << "b:f0:#{workitem.fields['f0']}\n"
+    @dashboard.register_participant :bravo do |workitem|
+      tracer << "b:f0:#{workitem.fields['f0']}\n"
     end
-    @engine.register_participant :charly do |workitem, fexp|
-      @tracer << "c:f0:#{workitem.fields['f0']}:#{fexp.lookup_variable('v0')}\n"
+    @dashboard.register_participant :charly do |workitem, fexp|
+      tracer << "c:f0:#{workitem.fields['f0']}:#{fexp.lookup_variable('v0')}\n"
     end
 
-    #noisy
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
 
-    assert_trace "a\nb:f0:f0val\nc:f0:f0val:v0val", pdef
+    assert_equal 'terminated', r['action']
+    assert_equal "a\nb:f0:f0val\nc:f0:f0val:v0val", @tracer.to_s
   end
 
   TEST_BLOCK = Ruote.process_definition do
@@ -50,7 +54,7 @@ class FtBlockParticipantTest < Test::Unit::TestCase
     return if Ruote::WIN or Ruote::JAVA
       # defective 'json' lib on windows render this test useless
 
-    @engine.register_participant :alpha do |workitem|
+    @dashboard.register_participant :alpha do |workitem|
       'seen'
     end
 
@@ -64,7 +68,7 @@ class FtBlockParticipantTest < Test::Unit::TestCase
     return if Ruote::WIN
       # defective 'json' lib on windows renders this test useless
 
-    @engine.register_participant :alpha do |workitem|
+    @dashboard.register_participant :alpha do |workitem|
       Time.now
     end
 
@@ -76,9 +80,9 @@ class FtBlockParticipantTest < Test::Unit::TestCase
       /\b#{Time.now.year}\b/
     end
 
-    wfid = @engine.launch(TEST_BLOCK)
+    wfid = @dashboard.launch(TEST_BLOCK)
 
-    @engine.wait_for(wfid)
+    @dashboard.wait_for(wfid)
 
     assert_match match, @tracer.to_s
   end
@@ -87,21 +91,22 @@ class FtBlockParticipantTest < Test::Unit::TestCase
 
     fn = "test/bad.#{Time.now.to_f}.txt"
 
-    @engine.participant_list = [
+    @dashboard.participant_list = [
       #[ 'alpha', [ 'Ruote::BlockParticipant', { 'block' => 'exit(3)' } ] ]
       [ 'alpha', [ 'Ruote::BlockParticipant', { 'block' => "proc { File.open(\"#{fn}\", \"wb\") { |f| f.puts(\"bad\") } }" } ] ]
     ]
 
-    #noisy
+    #@dashboard.noisy = true
 
-    wfid = @engine.launch(Ruote.define { alpha })
+    wfid = @dashboard.launch(Ruote.define { alpha })
 
-    @engine.wait_for(wfid)
+    @dashboard.wait_for(wfid)
+    sleep 0.300
 
     assert_equal false, File.exist?(fn), 'security check not enforced'
 
-    assert_equal 1, @engine.errors(wfid).size
-    assert_match /SecurityError/, @engine.errors(wfid).first.message
+    assert_equal 1, @dashboard.errors(wfid).size
+    assert_match /SecurityError/, @dashboard.errors(wfid).first.message
 
     FileUtils.rm(fn) rescue nil
   end
@@ -110,10 +115,184 @@ class FtBlockParticipantTest < Test::Unit::TestCase
 
     assert_raise Rufus::SecurityError do
 
-      @engine.register 'rogue' do |workitem|
+      @dashboard.register 'rogue' do |workitem|
         workitem.content = File.read('test/nada.txt')
       end
     end
   end
+
+  # cf https://github.com/jmettraux/ruote/issues/30
+  #
+  def test_begin_rescue_end
+
+    @dashboard.register 'rogue' do |workitem|
+      begin
+      rescue => e
+      end
+    end
+
+    assert true
+  end
+
+  def test_on_cancel_registration
+
+    @dashboard.register 'nemo',
+      :on_workitem => lambda { |wi|
+        p wi
+      },
+      :on_cancel => lambda { |fei, flavour|
+        p fei, flavour
+      }
+
+    assert_equal(
+      { 'on_cancel' => "proc { |fei, flavour|\n        p fei, flavour\n      }",
+        'on_workitem' => "proc { |wi|\n        p wi\n      }" },
+      @dashboard.participant_list.first.options)
+  end
+
+  def test_on_cancel
+
+    @dashboard.register 'sleeper',
+      :on_workitem => lambda { |workitem|
+        context.tracer << "consumed\n"
+        sleep 60 # preventing the implicit reply_to_engine(workitem)
+      },
+      :on_cancel => lambda { |fei, flavour|
+        context.tracer << "cancelled\n"
+      }
+
+    pdef = Ruote.define do
+      sleeper
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:sleeper)
+    sleep 0.350
+
+    assert_equal 'consumed', @tracer.to_s
+
+    @dashboard.cancel(wfid)
+
+    @dashboard.wait_for(wfid)
+
+    assert_equal "consumed\ncancelled", @tracer.to_s
+  end
+
+  def test_on_reply
+
+    @dashboard.register 'consumer',
+      :on_workitem => lambda { |workitem|
+        context.tracer << "consumed\n"
+      },
+      :on_reply => lambda { |workitem|
+        context.tracer << "replied\n"
+      }
+
+    pdef = Ruote.define do
+      consumer
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
+
+    assert_equal "consumed\nreplied", @tracer.to_s
+  end
+
+  def test_accept
+
+    @dashboard.register 'consumer',
+      :on_workitem => lambda { |workitem|
+        raise 'fail miserably'
+      },
+      :accept? => lambda { |workitem|
+        false
+      }
+
+    pdef = Ruote.define do
+      consumer
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
+
+    assert_match /unknown participant/, @dashboard.ps(wfid).errors.first.message
+  end
+
+  def test_do_not_thread
+
+    @dashboard.register 'consumer',
+      :on_workitem => lambda { |workitem|
+        context.tracer << "in\n"
+      },
+      :do_not_thread => lambda { |workitem|
+        context.tracer << "dnt\n"
+        false
+      }
+
+    pdef = Ruote.define do
+      consumer
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(:consumer)
+
+    sleep 0.350
+
+    assert_equal "dnt\nin", @tracer.to_s
+  end
+
+  def test_block_with_methods
+
+    @dashboard.register 'consumer' do
+      on_workitem do
+        context.tracer << "on_workitem\n"
+      end
+      on_cancel do
+        context.tracer << "on_cancel\n"
+      end
+    end
+
+    assert_equal(
+      %w[ on_cancel on_workitem ],
+      @dashboard.participant_list[0].options.keys.sort)
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(Ruote.define do
+      consumer
+    end)
+    @dashboard.wait_for(wfid)
+
+    assert_equal 'on_workitem', @tracer.to_s
+  end
+
+  def test_block_with_methods_2
+
+    @dashboard.register do
+
+      consumer do
+
+        on_workitem do
+          context.tracer << "on_workitem\n"
+        end
+        on_cancel do
+          context.tracer << "on_cancel\n"
+        end
+      end
+    end
+
+    assert_equal(
+      %w[ on_cancel on_workitem ],
+      @dashboard.participant_list[0].options.keys.sort)
+  end
 end