ruote-maestrodev 2.2.1

data/test/functional/ft_30_smtp_participant.rb

@@ -0,0 +1,122 @@
+
+#
+# testing ruote
+#
+# Tue Sep 15 09:04:36 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/smtp_participant'
+
+
+class NftSmtpParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  unless Ruote::JAVA
+
+    require 'mailtrap' # sudo gem install mailtrap
+
+    class Trap < ::Mailtrap
+      def puts(s)
+        # silent night...
+      end
+    end
+  end
+
+#  def test_smtp
+#
+#    return if Ruote::JAVA
+#
+#    pdef = Ruote.process_definition :name => 'test' do
+#      sequence do
+#        set 'f:item' => 'cat food'
+#        alpha
+#      end
+#    end
+#
+#    trapfile = Ruote::WIN ? 'ruote_mailtrap.txt' : '/tmp/ruote_mailtrap.txt'
+#    FileUtils.rm_f(trapfile)
+#
+#    t = Thread.new do
+#      Trap.new('127.0.0.1', 2525, true, trapfile)
+#    end
+#    sleep 0.040
+#      # give it some time to start listening
+#
+#    @engine.register_participant(
+#      :alpha,
+#      Ruote::SmtpParticipant.new(
+#        :server => '127.0.0.1',
+#        :port => 2525,
+#        :to => 'toto@cloudwhatever.ch',
+#        :from => 'john@outoftheblue.ch',
+#        :notification => true,
+#        :template => %{
+#  Hello, do you want ${f:item} ?
+#        }))
+#
+#    #noisy
+#
+#    wfid = @engine.launch(pdef)
+#
+#    #sleep 0.450
+#    wait_for(wfid)
+#
+#    assert_match(/cat food/, File.read(trapfile))
+#    assert_nil @engine.process(wfid)
+#
+#    t.kill
+#  end
+
+  def test_smtp_non_instance_participant
+
+    return if Ruote::JAVA
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set 'f:item' => 'cat food'
+        alpha
+      end
+    end
+
+    trapfile = "ruote_mailtrap_#{$$}_#{Time.now.to_f}.txt"
+
+    trapfile = Ruote::WIN ? trapfile : "/tmp/#{trapfile}"
+    FileUtils.rm_f(trapfile)
+
+    t = Thread.new do
+      Trap.new('127.0.0.1', 2525, true, trapfile)
+    end
+    sleep 0.040
+      # give it some time to start listening
+
+    @engine.register_participant(
+      :alpha,
+      Ruote::SmtpParticipant,
+      :server => '127.0.0.1',
+      :port => 2525,
+      :to => 'toto@cloudwhatever.ch',
+      :from => 'john@outoftheblue.ch',
+      :notification => true,
+      :template => %{
+  Hello, do you want ${f:item} ?
+      })
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    #sleep 0.450
+    wait_for(wfid)
+
+    trapped = File.read(trapfile)
+    FileUtils.rm_f(trapfile)
+
+    assert_match /want cat food/, trapped
+    assert_nil @engine.process(wfid)
+
+    t.kill
+  end
+end
+

data/test/functional/ft_31_part_blocking.rb

@@ -0,0 +1,72 @@
+
+#
+# testing ruote
+#
+# Fri Sep 25 16:15:57 JST 2009
+#
+# By David Goldhirsch
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+class FtPartBlockingTest < Test::Unit::TestCase
+ include FunctionalBase
+
+ def test_equal_time_favors_first
+   run_engine
+   assert_equal 'first', @tracer.to_s
+ end
+
+ def test_second_is_faster
+   #noisy
+   run_engine :first_time => 0.5
+   assert_equal 'second', @tracer.to_s
+ end
+
+ def test_first_is_faster
+   run_engine  :second_time => 0.5
+   assert_equal 'first', @tracer.to_s
+ end
+
+ protected
+
+ def run_engine(options={})
+
+   @engine.context.stash[:first_time] = options[:first_time] || 0.0
+   @engine.context.stash[:second_time] = options[:second_time] || 0.0
+
+   if @engine.context.stash[:first_time] == @engine.context.stash[:second_time]
+     @engine.context.stash[:second_time] = @engine.context.stash[:first_time] + 0.1
+   end
+
+   pdef = Ruote.process_definition :name => 'simple' do
+     sequence do
+       concurrence do # spec says this is equivalent to :count => 1
+         participant :ref => 'first'
+         participant :ref => 'second'
+       end
+       participant :ref => 'trace'
+     end
+   end
+
+   @engine.register_participant :first do |wi|
+     sleep stash[:first_time]
+     wi.fields['result'] = 'first'
+   end
+
+   @engine.register_participant :second do |wi|
+     sleep stash[:second_time]
+     wi.fields['result'] = 'second'
+   end
+
+   @engine.register_participant :trace do |wi|
+     @tracer << "#{wi.fields['result']}"
+   end
+
+   wfid = @engine.launch(pdef)
+   @engine.wait_for(wfid)
+
+   wfid
+ end
+end
+

data/test/functional/ft_33_participant_subprocess_priority.rb

@@ -0,0 +1,32 @@
+
+#
+# testing ruote
+#
+# Wed Oct 21 05:35:29 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtParticipantSubprocessPriorityTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_priority
+
+    pdef = Ruote.process_definition do
+      sub0
+      define 'sub0' do
+        echo 'sub0'
+      end
+    end
+
+    @engine.register_participant '.+' do
+      @tracer << 'participant'
+    end
+
+    #noisy
+
+    assert_trace 'sub0', pdef
+  end
+end
+

data/test/functional/ft_34_cursor_rewind.rb

@@ -0,0 +1,101 @@
+
+#
+# testing ruote
+#
+# Fri Nov 13 10:30:32 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+#
+# testing forced rewinding
+#
+class FtCursorRewindTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_cursor_forced_back
+
+    pdef = Ruote.process_definition do
+      cursor do
+        alpha
+        bravo
+        charly
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    bravo = @engine.register_participant :bravo, Ruote::StorageParticipant
+    charly = @engine.register_participant :charly, Ruote::StorageParticipant
+
+    #noisy
+
+    #
+    # reaching initial situation...
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    alpha.proceed(alpha.first)
+    wait_for(:bravo)
+
+    #
+    # rewinding...
+
+    wi = bravo.first
+    wi.fields['__command__'] = [ 'back', 2 ]
+
+    @engine.reply(wi)
+
+    #
+    # workitem is back to alpha
+
+    wait_for(:alpha)
+  end
+
+  def test_cursor_forced_jump
+
+    pdef = Ruote.process_definition do
+      cursor do
+        alpha
+        bravo
+        charly
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    @engine.register_participant :bravo, Ruote::StorageParticipant
+    sto = @engine.register_participant :charly, Ruote::StorageParticipant
+
+    #noisy
+
+    #
+    # reaching initial situation...
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    sto.proceed(sto.first)
+    wait_for(:bravo)
+
+    #
+    # rewinding...
+
+    wi = sto.first
+
+    exp = @engine.process(wfid).expressions.find { |e| e.name == 'cursor' }
+    wi.h['fei'] = exp.h.fei
+    wi.fields['__command__'] = [ 'jump', 'alpha' ]
+      #
+      # passing the "jump alpha" command to the cursor directly
+
+    @engine.reply(wi)
+
+    #
+    # workitem is back to alpha
+
+    wait_for(:alpha)
+  end
+end
+

data/test/functional/ft_35_add_service.rb

@@ -0,0 +1,56 @@
+
+#
+# testing ruote
+#
+# Thu Dec 24 18:05:39 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtAddServiceTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyService
+
+    attr_reader :context, :options
+
+    def initialize(context, options={})
+
+      @context = context
+      @options = options
+    end
+  end
+
+  def test_as_path_class
+
+    @engine.add_service('toto', 'ruote', 'FtAddServiceTest::MyService')
+
+    assert_equal MyService, @engine.context.toto.class
+  end
+
+  def test_as_instance
+
+    @engine.add_service('toto', MyService.new(nil))
+
+    assert_equal MyService, @engine.context.toto.class
+  end
+
+  def test_as_path_class_options
+
+    @engine.add_service(
+      'toto', 'ruote', 'FtAddServiceTest::MyService', 'colour' => 'blue')
+
+    assert_equal MyService, @engine.context.toto.class
+    assert_equal 'blue', @engine.context.toto.options['colour']
+  end
+
+  def test_add_service_returns_service
+
+    toto = @engine.add_service(
+      'toto', 'ruote', 'FtAddServiceTest::MyService', 'colour' => 'blue')
+
+    assert_equal MyService, toto.class
+  end
+end
+

data/test/functional/ft_36_storage_history.rb

@@ -0,0 +1,150 @@
+
+#
+# testing ruote
+#
+# Tue Jan  5 17:51:10 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+#require 'ruote/log/fs_history'
+require 'ruote/part/no_op_participant'
+
+
+class FtStorageHistoryTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_by_wfid
+
+    pdef = Ruote.process_definition do
+      alpha
+      echo 'done.'
+    end
+
+    history = @engine.add_service(
+      'history', 'ruote/log/storage_history', 'Ruote::StorageHistory')
+
+    @engine.register_participant :alpha, Ruote::NoOpParticipant
+
+    #noisy
+
+    wfid0 = assert_trace('done.', pdef)
+    wfid1 = assert_trace("done.\ndone.", pdef)
+
+    sleep 0.100
+
+    assert_equal 21, @engine.storage.get_many('history').size
+
+    h = @engine.context.history.by_process(wfid0)
+    #h.each { |r| p r }
+    assert_equal 9, h.size
+
+    # testing record.to_h
+
+    h = @engine.context.history.by_process(wfid1)
+    #h.each { |r| p r }
+    assert_equal 9, h.size
+
+    history.clear!
+
+    assert_equal 0, @engine.storage.get_many('history').size
+  end
+
+  def test_by_date
+
+    @engine.add_service(
+      'history', 'ruote/log/storage_history', 'Ruote::StorageHistory')
+
+    6.times do |i|
+      @engine.storage.put(
+        '_id' => "!2010-01-06!11414#{i}!0!!20100106-bichisosupo",
+        'type' => 'history')
+    end
+    7.times do |i|
+      @engine.storage.put(
+        '_id' => "!2010-01-07!11414#{i}!0!!20100107-bichitehoni",
+        'type' => 'history')
+    end
+
+    assert_equal 6, @engine.context.history.by_date('2010-01-06').size
+    assert_equal 7, @engine.context.history.by_date('2010-01-07').size
+  end
+
+  def test_range
+
+    @engine.add_service(
+      'history', 'ruote/log/storage_history', 'Ruote::StorageHistory')
+
+    7.times do |i|
+      i = i + 1
+      @engine.storage.put(
+        '_id' => "!2010-01-0#{i}!114147!0!!2010010#{i}-bichisosupo",
+        'type' => 'history')
+    end
+
+    assert_equal(
+      [ Time.parse('2010-01-01 00:00:00 UTC'),
+        Time.parse('2010-01-08 00:00:00 UTC') ],
+      @engine.context.history.range)
+  end
+
+  def test_engine_dot_history
+
+    @engine.add_service(
+      'history', 'ruote/log/storage_history', 'Ruote::StorageHistory')
+
+    assert_equal Ruote::StorageHistory, @engine.history.class
+  end
+
+  def test_wfids
+
+    @engine.add_service(
+      'history', 'ruote/log/storage_history', 'Ruote::StorageHistory')
+
+    @engine.register_participant 'alpha', Ruote::NullParticipant
+
+    3.times do
+      @engine.launch(Ruote.define { alpha })
+      @engine.wait_for(:alpha)
+    end
+
+    assert_equal 3, @engine.history.wfids.size
+  end
+
+  # Cf
+  #   https://github.com/jmettraux/ruote/issues/29
+  #   http://ruote-irclogs.s3.amazonaws.com/log_2011-06-06.html
+  #
+  def test_concurrence_replies
+
+    @engine.add_service(
+      'history', 'ruote/log/storage_history', 'Ruote::StorageHistory')
+
+    pdef = Ruote.define do
+      concurrence :count => 1 do
+        alpha
+        bravo
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::NullParticipant
+    @engine.register_participant :bravo, Ruote::NoOpParticipant
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    repliers = []
+
+    @engine.context.history.by_wfid(wfid).each do |record|
+      if record['action'] == 'reply'
+        wi = record['workitem']
+        repliers << [ wi['fei']['expid'], wi['participant_name'] ]
+      end
+    end
+
+    assert_equal [ %w[ 0_0_1 bravo ], %w[ 0_0 bravo ] ], repliers[0, 2]
+  end
+end
+