ruote-maestrodev 2.2.1

data/test/bm/t.rb

@@ -0,0 +1,35 @@
+
+$:.unshift('lib')
+
+require 'ruote/engine'
+
+pdef = Ruote.process_definition do
+  sequence do
+    #625.times do
+    #500.times do
+    5000.times do
+      echo 'a'
+    end
+  end
+end
+
+engine = Ruote::Engine.new
+t = Time.now
+fei = engine.launch(pdef)
+engine.wait_for(fei.wfid)
+puts "#{Time.now - t}s"
+
+#require 'eventmachine'
+#EM.run {
+#  engine = Ruote::Engine.new
+#  t = Time.now
+#  fei = engine.launch(pdef)
+#  #engine.wait_for(fei.wfid)
+#  #puts "#{Time.now - t}s"
+#  #EM.stop
+#  engine.wqueue.observe(:processes) do |eclass, emsg, args|
+#    puts "#{Time.now - t}s"
+#    EM.stop
+#  end
+#}
+

data/test/functional/base.rb

@@ -0,0 +1,247 @@
+
+#
+# testing ruote
+#
+# Sat Sep 20 23:40:10 JST 2008
+#
+
+require 'fileutils'
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.join(File.dirname(__FILE__), 'storage_helper.rb')
+
+require 'ruote'
+
+
+trap 'USR2' do
+
+  require 'irb'
+  require 'irb/completion'
+
+  IRB.setup(nil)
+  ws = IRB::WorkSpace.new(binding)
+  irb = IRB::Irb.new(ws)
+  IRB::conf[:MAIN_CONTEXT] = irb.context
+  irb.eval_input
+end
+
+trap 'INT' do
+  #
+  # why do I have to do that ?
+  #
+  puts
+  puts '-' * 80
+  caller.each { |l| p l }
+  puts '-' * 80
+  exit 1
+end if RUBY_VERSION.match(/^1.9./)
+
+puts "pid #{$$}"
+
+
+module FunctionalBase
+
+  def setup
+
+    p self.class if ARGV.include?('-T') or ARGV.include?('-N')
+
+    #require 'ruote/util/look'
+    #Ruote::Look.dump_lsof
+    #Ruote::Look.dump_lsof_count
+      #
+      # uncomment this when "too many open files"
+
+    @engine =
+      Ruote::Engine.new(
+        Ruote::Worker.new(
+          determine_storage(
+            's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])))
+
+    $_test = self
+    $_engine = @engine
+      #
+      # handy when hijacking (https://github.com/ileitch/hijack)
+      # or flinging USR2 at the test process
+
+    @tracer = Tracer.new
+
+    tracer = @tracer
+    @engine.context.instance_eval { @tracer = tracer }
+
+    @engine.add_service('tracer', @tracer)
+    @engine.add_service('stash', {})
+
+    noisy if ARGV.include?('-N')
+
+    #noisy # uncommented, it makes all the tests noisy
+  end
+
+  def teardown
+
+    @engine.shutdown
+    @engine.context.storage.purge!
+    @engine.context.storage.close if @engine.context.storage.respond_to?(:close)
+  end
+
+  def stash
+
+    @engine.context.stash
+  end
+
+  def assert_log_count(count, &block)
+
+    c = @engine.context.logger.log.select(&block).size
+
+    #logger.to_stdout if ( ! @engine.context[:noisy]) && c != count
+
+    assert_equal count, c
+  end
+
+  #   assert_trace(*expected_traces, pdef)
+  #   assert_trace(*expected_traces, fields, pdef)
+  #
+  def assert_trace(*args)
+
+    if args.last == :clear
+      args.pop
+      @tracer.clear
+    end
+
+    pdef = args.pop
+    fields = args.last.is_a?(Hash) ? args.pop : {}
+    expected_traces = args.collect { |et| et.is_a?(Array) ? et.join("\n") : et }
+
+    wfid = @engine.launch(pdef, fields)
+
+    r = wait_for(wfid)
+
+    assert_engine_clean(wfid)
+
+    trace = r['workitem']['fields']['_trace']
+    trace = trace ? trace.join('') : @tracer.to_s
+
+    if expected_traces.length > 0
+      ok, nok = expected_traces.partition { |et| trace == et }
+      assert_equal(nok.first, trace) if ok.empty?
+    end
+
+    assert(true)
+      # so that the assertion count matches
+
+    wfid
+  end
+
+  def logger
+
+    @engine.context.logger
+  end
+
+  protected
+
+  def noisy(on=true)
+
+    puts "\nnoisy " + caller[0] if on
+    @engine.context.logger.noisy = true
+  end
+
+  def wait_for(*wfid_or_part)
+
+    @engine.wait_for(*wfid_or_part)
+  end
+
+  def assert_engine_clean(wfid)
+
+    assert_no_errors(wfid)
+    assert_no_remaining_expressions(wfid)
+  end
+
+  def assert_no_errors(wfid)
+
+    errors = @engine.storage.get_many('errors', /#{wfid}$/)
+
+    return if errors.size == 0
+
+    puts
+    puts '-' * 80
+    puts 'remaining process error(s)'
+    puts
+    errors.each do |e|
+      puts "  ** #{e['message']}"
+      puts e['trace']
+    end
+    puts '-' * 80
+
+    puts_trace_so_far
+
+    flunk 'remaining process error(s)'
+  end
+
+  def assert_no_remaining_expressions(wfid)
+
+    expcount = @engine.storage.get_many('expressions').size
+    return if expcount == 0
+
+    tf, _, tn = caller[2].split(':')
+
+    puts
+    puts '-' * 80
+    puts 'too many expressions left in storage'
+    puts
+    puts "this test : #{tf}"
+    puts "            #{tn}"
+    puts
+    puts "this test's wfid : #{wfid}"
+    puts
+    puts 'left :'
+    puts
+    puts @engine.context.storage.dump('expressions')
+    puts
+    puts '-' * 80
+
+    puts_trace_so_far
+
+    flunk 'too many expressions left in storage'
+  end
+
+  def puts_trace_so_far
+
+    #puts '. ' * 40
+    puts 'trace so far'
+    puts '---8<---'
+    puts @tracer.to_s
+    puts '--->8---'
+    puts
+  end
+end
+
+# Re-opening workitem for a shortcut to a '_trace' field
+#
+class Ruote::Workitem
+  def trace
+    @h['fields']['_trace'] ||= []
+  end
+end
+
+class Tracer
+  attr_reader :s
+  def initialize
+    super
+    @s = ''
+  end
+  def to_s
+    @s.to_s.strip
+  end
+  def to_a
+    to_s.split("\n")
+  end
+  def << s
+    @s << s
+  end
+  def clear
+    @s = ''
+  end
+  def puts(s)
+    @s << "#{s}\n"
+  end
+end
+

data/test/functional/concurrent_base.rb

@@ -0,0 +1,98 @@
+
+#
+# Testing ruote
+#
+# Fri Dec  4 17:15:10 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base.rb')
+
+
+class Ruote::Worker
+
+  public :process
+end
+
+class Ruote::Engine
+
+  def peek_msg
+    @msgs = @context.storage.get_msgs if ( ! @msgs) || @msgs.size < 1
+    @msgs.shift
+  end
+
+  def do_process(msg)
+    @context.worker.process(msg)
+  end
+
+  def step(count)
+    return if count == 0
+    loop do
+      m = next_msg
+      next unless m
+      do_process(m)
+      break
+    end
+    step(count - 1)
+  end
+
+  def next_msg
+    loop do
+      if m = peek_msg
+        return m
+      end
+    end
+  end
+
+  def gather_msgs
+    (1..77).to_a.inject({}) { |h, i|
+      #(i % 10).times { Thread.pass }
+      sleep 0.001
+      sleep 0.025 # couch :-(
+      m = peek_msg
+      h[m['_id']] = m if m
+      h
+    }.values.sort { |a, b|
+      a['put_at'] <=> b['put_at']
+    }
+  end
+end
+
+
+module ConcurrentBase
+
+  def setup
+
+    @storage = determine_storage(
+      's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])
+
+    @engine0 = Ruote::Engine.new(Ruote::Worker.new(@storage), false)
+    @engine1 = Ruote::Engine.new(Ruote::Worker.new(@storage), false)
+      #
+      # the 2 engines are set with run=false
+
+    @tracer0 = Tracer.new
+    @tracer1 = Tracer.new
+
+    @engine0.context.add_service('s_tracer', @tracer0, nil)
+    @engine1.context.add_service('s_tracer', @tracer1, nil)
+
+    @engine1.context.logger.color = '32' # green
+  end
+
+  def teardown
+
+    @storage.purge!
+
+    @engine0.shutdown
+    @engine1.shutdown
+  end
+
+  protected
+
+  def noisy
+
+    @engine0.context.logger.noisy = true
+    @engine1.context.logger.noisy = true
+  end
+end
+

data/test/functional/crunner.rb

@@ -0,0 +1,31 @@
+
+pers = ARGV.find { |a| a.match(/^--/) } || ''
+tnumber = ARGV.find { |a| a.match(/^\d+/) } || 2
+
+i = 0
+
+puts `ruby -v`
+
+loop do
+
+  t = Dir["test/functional/ct_#{tnumber}_*.rb"].first
+
+  raise "didn't find test..." unless t
+
+  s = `ruby #{t} #{pers}`
+
+  if $? != 0
+    puts
+    puts s
+  else
+    if (i % 5) == 0
+      print i.to_s
+    else
+      print '.'
+    end
+    STDOUT.flush
+  end
+
+  i = i + 1
+end
+

data/test/functional/ct_0_concurrence.rb

@@ -0,0 +1,65 @@
+
+#
+# testing ruote
+#
+# Wed Jul  8 15:30:55 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'concurrent_base')
+
+#require 'ruote/part/hash_participant'
+
+
+class CtConcurrenceTest < Test::Unit::TestCase
+  include ConcurrentBase
+
+  # A collision between two workers replying to the same concurrence expression.
+  #
+  # Worker 0 replies for echo 'a' while worker 1 replies for echo 'b'.
+  #
+  def test_collision
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        echo 'a'
+        echo 'b'
+      end
+    end
+
+    noisy if ARGV.include?('-N')
+
+    wfid = @engine0.launch(pdef)
+
+    replies = []
+
+    while replies.size < 2
+
+      msg = @engine0.next_msg
+
+      if msg['action'] == 'reply'
+        replies << msg
+      else
+        @engine0.do_process(msg)
+      end
+    end
+
+    replies.sort! { |a, b| a['put_at'] <=> b['put_at'] }
+
+    #replies.each { |r| p r }
+
+    t0 = Thread.new { @engine1.do_process(replies[0]) }
+    t1 = Thread.new { @engine0.do_process(replies[1]) }
+    t0.join
+    t1.join
+
+    msgs = @engine0.gather_msgs
+
+    assert_equal 1, msgs.size, 'exactly 1 message was expected'
+
+    msg = msgs.first
+
+    assert_equal 'reply', msg['action']
+    assert_equal '0', msg['fei']['expid']
+  end
+end
+