oflow 0.6.0 → 0.8.0

data/lib/oflow/test/actorwrap.rb

@@ -35,7 +35,7 @@ module OFlow
       end
 
       def links()
-        lnk = Link.new(@name, nil)
+        lnk = Link.new(@name, nil, nil)
         lnk.instance_variable_set(:@target, self)
         { nil => lnk }
       end

data/lib/oflow/version.rb

@@ -1,5 +1,5 @@
 
 module OFlow
   # Current version of the module. 
-  VERSION = '0.6.0'
+  VERSION = '0.8.0'
 end

data/test/actors/balancer_test.rb

@@ -1,12 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../../lib"),
-  File.join(File.dirname(__FILE__), "..")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(File.dirname(__FILE__)) unless $:.include? File.dirname(File.dirname(__FILE__))
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 require 'oflow/test'
 
@@ -33,12 +30,13 @@ class Busy < ::OFlow::Actor
 
 end # Busy
 
-class BalancerTest < ::Test::Unit::TestCase
+class BalancerTest < ::MiniTest::Test
 
   def test_balancer_fair
+    env = ::OFlow::Env.new('')
     balancer = nil
     collector = nil
-    ::OFlow::Env.flow('fair') { |f|
+    env.flow('fair') { |f|
       f.task('balance', ::OFlow::Actors::Balancer) { |t|
         balancer = t
         t.link(:one, :one, nil)
@@ -58,21 +56,25 @@ class BalancerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     9.times { |i| balancer.receive(nil, ::OFlow::Box.new(i)) }
-    ::OFlow::Env.flush()
+    env.flush()
     counts = {}
     collector.collection.each { |a| counts[a[0]] = counts.fetch(a[0], 0) + 1 }
 
     assert_equal(counts[:one], counts[:two], 'all counts should be the same')
     assert_equal(counts[:two], counts[:three], 'all counts should be the same')
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_balancer_less_busy
+    env = ::OFlow::Env.new('')
     balancer = nil
     collector = nil
-    ::OFlow::Env.flow('less-busy') { |f|
+    env.flow('less-busy') { |f|
       f.task('balance', ::OFlow::Actors::Balancer) { |t|
         balancer = t
         t.link(:one, :one, nil)
@@ -92,8 +94,11 @@ class BalancerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     40.times { |i| balancer.receive(nil, ::OFlow::Box.new(i)); sleep(0.005) }
-    ::OFlow::Env.flush()
+    env.flush()
     counts = {}
     collector.collection.each { |a| counts[a[0]] = counts.fetch(a[0], 0) + 1 }
     #puts "*** #{counts}"
@@ -101,7 +106,7 @@ class BalancerTest < ::Test::Unit::TestCase
     assert(counts[:one] > counts[:two], 'one is faster and should have processed more than two')
     assert(counts[:two] > counts[:three], 'two is faster and should have processed more than three')
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
 end # BalancerTest

data/test/actors/httpserver_test.rb

@@ -1,13 +1,10 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../../lib"),
-  File.join(File.dirname(__FILE__), "..")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(File.dirname(__FILE__)) unless $:.include? File.dirname(File.dirname(__FILE__))
 
+require 'helper'
 require 'net/http'
-require 'test/unit'
 require 'oflow'
 require 'oflow/test'
 
@@ -25,17 +22,21 @@ class Reply < ::OFlow::Actor
 
 end # Reply
 
-class HttpServerTest < ::Test::Unit::TestCase
+class HttpServerTest < ::MiniTest::Test
 
   def test_httpserver
-    ::OFlow::Env.flow('http-server', port: 6060) { |f|
-      f.task('server', ::OFlow::Actors::HttpServer) { |t|
+    env = ::OFlow::Env.new('')
+    env.flow('http-server') { |f|
+      f.task('server', ::OFlow::Actors::HttpServer, port: 6060) { |t|
         t.link(nil, :reply, nil)
       }
       f.task(:reply, Reply) { |t|
         t.link(nil, :server, :reply)
       }
     }
+    env.prepare()
+    env.start()
+
     # GET
     uri = URI('http://localhost:6060/test?a=1&b=two')
     reply = Net::HTTP.get(uri)
@@ -50,8 +51,8 @@ class HttpServerTest < ::Test::Unit::TestCase
     assert_equal(%|{:id=>2, :method=>\"POST\", :protocol=>\"HTTP/1.1\", :path=>\"/test\", :args=>nil, \"Accept-Encoding\"=>\"gzip;q=1.0,deflate;q=0.6,identity;q=0.3\", \"Accept\"=>\"*/*\", \"User-Agent\"=>\"Ruby\", \"Host\"=>\"localhost:6060\", \"Content-Type\"=>\"application/x-www-form-urlencoded\", \"Content-Length\"=>9, :body=>\"a=1&b=two\"}|,
                  reply, 'expected reply from POST')
 
-    ::OFlow::Env.flush()
-    ::OFlow::Env.clear()
+    env.flush()
+    env.clear()
   end
 
 end # HttpServerTest

data/test/actors/log_test.rb

@@ -1,16 +1,13 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../../lib"),
-  File.join(File.dirname(__FILE__), "..")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(File.dirname(__FILE__)) unless $:.include? File.dirname(File.dirname(__FILE__))
 
-require 'test/unit'
+require 'helper'
 require 'stringio'
 require 'oflow'
 
-class LogTest < ::Test::Unit::TestCase
+class LogTest < ::MiniTest::Test
 
   def test_log
     stream = StringIO.new()

data/test/actors/merger_test.rb

@@ -1,12 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../../lib"),
-  File.join(File.dirname(__FILE__), "..")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(File.dirname(__FILE__)) unless $:.include? File.dirname(File.dirname(__FILE__))
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 require 'oflow/test'
 
@@ -39,12 +36,13 @@ class Multiplier < ::OFlow::Actor
 
 end # Multiplier
 
-class MergerTest < ::Test::Unit::TestCase
+class MergerTest < ::MiniTest::Test
 
   def test_merger_any
+    env = ::OFlow::Env.new('')
     start = nil
     collector = nil
-    ::OFlow::Env.flow('merge') { |f|
+    env.flow('merge') { |f|
       f.task(:split, Splitter) { |t|
         start = t
         t.link(:left, :one, nil)
@@ -63,21 +61,25 @@ class MergerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     start.receive(nil, ::OFlow::Box.new(1))
-    ::OFlow::Env.flush()
+    env.flush()
 
     result = collector.collection[0]
     assert_equal(2, result.size, 'should be 2 values in the box')
     assert(result.include?(2), 'box should include 2')
     assert(result.include?(3), 'box should include 3')
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_merger_tracker
+    env = ::OFlow::Env.new('')
     start = nil
     collector = nil
-    ::OFlow::Env.flow('merge') { |f|
+    env.flow('merge') { |f|
       f.task(:split, Splitter) { |t|
         start = t
         t.link(:left, :one, nil)
@@ -96,11 +98,14 @@ class MergerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     tracker = ::OFlow::Tracker.create('start')
     start.receive(nil, ::OFlow::Box.new(1, tracker))
     tracker2 = ::OFlow::Tracker.create('start2')
     start.receive(nil, ::OFlow::Box.new(10, tracker2))
-    ::OFlow::Env.flush()
+    env.flush()
 
     box = collector.collection[0]
     result = box.contents
@@ -109,19 +114,19 @@ class MergerTest < ::Test::Unit::TestCase
     assert(result.include?(3), 'box should include 3')
     
     t = box.tracker()
-    assert_not_nil(t, 'should have a tracker')
+    refute_nil(t, 'should have a tracker')
     assert_equal(t.id, tracker.id, 'tracker id should be carried through')
     track = t.track
     
     assert_equal('start', track[0].location)
-    assert_equal(':merge:split', track[1].location)
+    assert_equal('merge:split', track[1].location)
     split = track[2].map { |a| a.map { |stamp| stamp.location } }
 
     assert_equal(2, split.size, 'should be 2 values in the split')
-    assert(split.include?([':merge:one']), 'split should include [merge:one]')
-    assert(split.include?([':merge:two']), 'split should include [merge:two]')
-    assert_equal(':merge:merge', track[3].location)
-    assert_equal(':merge:collector', track[4].location)
+    assert(split.include?(['merge:one']), 'split should include [merge:one]')
+    assert(split.include?(['merge:two']), 'split should include [merge:two]')
+    assert_equal('merge:merge', track[3].location)
+    assert_equal('merge:collector', track[4].location)
 
     box = collector.collection[1]
     result = box.contents
@@ -129,7 +134,7 @@ class MergerTest < ::Test::Unit::TestCase
     assert(result.include?(20), 'box should include 20')
     assert(result.include?(30), 'box should include 30')
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
 end # MergerTest

data/test/actors/persister_test.rb

@@ -1,18 +1,16 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../../lib"),
-  File.join(File.dirname(__FILE__), "..")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(File.dirname(__FILE__)) unless $:.include? File.dirname(File.dirname(__FILE__))
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 require 'oflow/test'
 
-class PersisterTest < ::Test::Unit::TestCase
+class PersisterTest < ::MiniTest::Test
 
   def test_persister_config
+    root_dir = File.dirname(File.dirname(__FILE__))
     t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Persister, state: ::OFlow::Task::BLOCKED,
                                      dir: 'db/something',
                                      key_path: 'key',
@@ -22,7 +20,7 @@ class PersisterTest < ::Test::Unit::TestCase
                                      with_seq_num: true,
                                      historic: true,
                                      seq_path: 'seq')
-    assert_equal('db/something', t.actor.dir, 'dir set from options')
+    assert_equal(File.join(root_dir, 'db/something'), t.actor.dir, 'dir set from options')
     assert_equal('key', t.actor.key_path, 'key_path set from options')
     assert_equal('seq', t.actor.seq_path, 'seq_path set from options')
     assert_equal('data', t.actor.data_path, 'data_path set from options')
@@ -32,7 +30,7 @@ class PersisterTest < ::Test::Unit::TestCase
     `rm -r #{t.actor.dir}`
 
     t = ::OFlow::Test::ActorWrap.new('persist', ::OFlow::Actors::Persister, state: ::OFlow::Task::BLOCKED)
-    assert_equal('db/test/persist', t.actor.dir, 'dir set from options')
+    assert_equal(File.join(root_dir, 'db/test/persist'), t.actor.dir, 'dir set from options')
     assert_equal('key', t.actor.key_path, 'key_path set from options')
     assert_equal('seq', t.actor.seq_path, 'seq_path set from options')
     assert_equal(true, t.actor.caching?, 'cache set from options')

data/test/actors/timer_test.rb

@@ -1,24 +1,22 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../../lib"),
-  File.join(File.dirname(__FILE__), "..")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(File.dirname(__FILE__)) unless $:.include? File.dirname(File.dirname(__FILE__))
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 require 'oflow/test'
 
 require 'collector'
 
-class TimerTest < ::Test::Unit::TestCase
+class TimerTest < ::MiniTest::Test
 
   def test_timer_period_repeat
+    env = ::OFlow::Env.new('')
     period = 0.1
     timer = nil
     collector = nil
-    ::OFlow::Env.flow('one-time') { |f|
+    env.flow('one-time') { |f|
       f.task('once', ::OFlow::Actors::Timer, repeat: 4, period: period) { |t|
         timer = t
         t.link(:ping, :collector, :tick)
@@ -27,7 +25,10 @@ class TimerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
-    ::OFlow::Env.flush()
+    env.prepare()
+    env.start()
+
+    env.flush()
     prev = nil
     ticks = collector.collection.map do |t|
       tf = t[2].to_f
@@ -49,7 +50,7 @@ class TimerTest < ::Test::Unit::TestCase
       assert(-limit < dif && dif < limit, "Verify timer fires are within 10% of expected. (dif: #{dif}, limit: #{limit})")
     end
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_timer_options_start
@@ -65,7 +66,7 @@ class TimerTest < ::Test::Unit::TestCase
     assert_equal(Time, t.actor.start.class, 'is the start time a Time?')
     assert(0.1 > (Time.now() + 2 - t.actor.start), 'is the start time now + 2?')
 
-    assert_raise(::OFlow::ConfigError) do
+    assert_raises(::OFlow::ConfigError) do
       ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, start: 'now')
     end
   end
@@ -82,22 +83,25 @@ class TimerTest < ::Test::Unit::TestCase
     assert_equal(Time, t.actor.stop.class, 'is the stop time a Time?')
     assert(0.1 > (Time.now() + 2 - t.actor.stop), 'is the stop time now + 2?')
 
-    assert_raise(::OFlow::ConfigError) do
+    assert_raises(::OFlow::ConfigError) do
       ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, stop: 'now')
     end
   end
 
   def test_timer_options_period
-    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: nil, state: ::OFlow::Task::BLOCKED)
-    assert_equal(nil, t.actor.period, 'is the period nil?')
-
+    assert_raises(::OFlow::ConfigError) do
+      ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: nil, state: ::OFlow::Task::BLOCKED)
+    end
     t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: 2, state: ::OFlow::Task::BLOCKED)
     assert_equal(2, t.actor.period, 'is the period 2?')
 
     t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: 2.0, state: ::OFlow::Task::BLOCKED)
     assert_equal(2.0, t.actor.period, 'is the period 2.0?')
 
-    assert_raise(::OFlow::ConfigError) do
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: "2.5", state: ::OFlow::Task::BLOCKED)
+    assert_equal(2.5, t.actor.period, 'is the period 2.5?')
+
+    assert_raises(::OFlow::ConfigError) do
       ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: 'now')
     end
   end
@@ -109,7 +113,7 @@ class TimerTest < ::Test::Unit::TestCase
     t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, repeat: 2, state: ::OFlow::Task::BLOCKED)
     assert_equal(2, t.actor.repeat, 'is the repeat 2?')
 
-    assert_raise(::OFlow::ConfigError) do
+    assert_raises(::OFlow::ConfigError) do
       ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, repeat: 2.0)
     end
   end
@@ -124,7 +128,7 @@ class TimerTest < ::Test::Unit::TestCase
     t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, with_tracker: true, state: ::OFlow::Task::BLOCKED)
     assert_equal(true, t.actor.with_tracker, 'is the with_tracker true?')
 
-    assert_raise(::OFlow::ConfigError) do
+    assert_raises(::OFlow::ConfigError) do
       ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, with_tracker: 'now')
     end
 
@@ -144,10 +148,11 @@ class TimerTest < ::Test::Unit::TestCase
   end
 
   def test_timer_perform_period
+    env = ::OFlow::Env.new('')
     period = 0.1
     timer = nil
     collector = nil
-    ::OFlow::Env.flow('one-time') { |f|
+    env.flow('one-time') { |f|
       f.task('once', ::OFlow::Actors::Timer, repeat: 2, period: 2) { |t|
         timer = t
         t.link(:ping, :collector, :tick)
@@ -156,8 +161,11 @@ class TimerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     timer.receive(:period, ::OFlow::Box.new(period))
-    ::OFlow::Env.flush()
+    env.flush()
     prev = nil
     ticks = collector.collection.map do |t|
       tf = t[2].to_f
@@ -179,14 +187,15 @@ class TimerTest < ::Test::Unit::TestCase
       assert(-limit < dif && dif < limit, "Verify timer fires are within 10% of expected. (dif: #{dif}, limit: #{limit})")
     end
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_timer_perform_repeat
+    env = ::OFlow::Env.new('')
     repeat = 2
     timer = nil
     collector = nil
-    ::OFlow::Env.flow('one-time') { |f|
+    env.flow('one-time') { |f|
       f.task('once', ::OFlow::Actors::Timer, repeat: 4, period: 0.1) { |t|
         timer = t
         t.link(:ping, :collector, :tick)
@@ -195,18 +204,22 @@ class TimerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     timer.receive(:repeat, ::OFlow::Box.new(repeat))
-    ::OFlow::Env.flush()
+    env.flush()
     assert_equal(2, collector.collection.size)
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_timer_perform_start
+    env = ::OFlow::Env.new('')
     now = Time.now()
     timer = nil
     collector = nil
-    ::OFlow::Env.flow('one-time') { |f|
+    env.flow('one-time') { |f|
       f.task('once', ::OFlow::Actors::Timer, repeat: 1, period: 0.1, start: 2) { |t|
         timer = t
         t.link(:ping, :collector, :tick)
@@ -215,18 +228,22 @@ class TimerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     timer.receive(:start, ::OFlow::Box.new(nil))
-    ::OFlow::Env.flush()
+    env.flush()
     first_fire = collector.collection[0][2] - now
     assert(0.01 > first_fire, "first fire was at #{first_fire}, expected less than 0.01 msecs?")
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_timer_perform_stop
+    env = ::OFlow::Env.new('')
     timer = nil
     collector = nil
-    ::OFlow::Env.flow('one-time') { |f|
+    env.flow('one-time') { |f|
       f.task('once', ::OFlow::Actors::Timer, repeat: 10, period: 0.1, stop: 2) { |t|
         timer = t
         t.link(:ping, :collector, :tick)
@@ -235,17 +252,21 @@ class TimerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     timer.receive(:stop, ::OFlow::Box.new(0.25))
-    ::OFlow::Env.flush()
+    env.flush()
     assert_equal(3, collector.collection.size)
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_timer_perform_label
+    env = ::OFlow::Env.new('')
     timer = nil
     collector = nil
-    ::OFlow::Env.flow('one-time') { |f|
+    env.flow('one-time') { |f|
       f.task('once', ::OFlow::Actors::Timer, repeat: 2, period: 0.1, label: 'first') { |t|
         timer = t
         t.link(:ping, :collector, :tick)
@@ -254,17 +275,21 @@ class TimerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     timer.receive(:label, ::OFlow::Box.new('second'))
-    ::OFlow::Env.flush()
+    env.flush()
     assert_equal(['first', 'second'], collector.collection.map { |x| x[0] })
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_timer_perform_tracker
+    env = ::OFlow::Env.new('')
     timer = nil
     collector = nil
-    ::OFlow::Env.flow('one-time') { |f|
+    env.flow('one-time') { |f|
       f.task('once', ::OFlow::Actors::Timer, repeat: 2, period: 0.1, with_tracker: false) { |t|
         timer = t
         t.link(:ping, :collector, :tick)
@@ -273,11 +298,14 @@ class TimerTest < ::Test::Unit::TestCase
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     timer.receive(:with_tracker, ::OFlow::Box.new(true))
-    ::OFlow::Env.flush()
+    env.flush()
     assert_equal([false, true], collector.collection.map { |x| !x.tracker.nil? })
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
 end # TimerTest