oflow 0.6.0 → 0.8.0

data/test/actorwrap_test.rb

@@ -1,11 +1,7 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../lib")
-].each { |path| $: << path unless $:.include?(path) }
-
-require 'test/unit'
+require 'helper'
 require 'oflow'
 require 'oflow/test'
 
@@ -24,7 +20,7 @@ class Nonsense < ::OFlow::Actor
 
 end # Nonsense
 
-class ActorWrapTest < ::Test::Unit::TestCase
+class ActorWrapTest < ::MiniTest::Test
 
   def test_actorwrap
     wrap = ::OFlow::Test::ActorWrap.new('wrapper', Nonsense)

data/test/all_tests.rb

@@ -1,12 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../lib")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(__FILE__)
 
-
-require 'test/unit'
+require 'helper'
 
 require 'box_test'
 require 'task_test'
@@ -14,11 +11,10 @@ require 'tracker_test'
 require 'actorwrap_test'
 
 require 'flow_basic_test'
-require 'flow_rescue_test'
 require 'flow_log_test'
 require 'flow_cfg_error_test'
 require 'flow_rescue_test'
-require 'flow_nest_test'
+require 'flow_linked_test'
 require 'flow_tracker_test'
 
 # Actor tests

data/test/box_test.rb

@@ -1,15 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
-# required. That can be set in the RUBYOPT environment variable.
-# export RUBYOPT=-w
+$: << File.dirname(__FILE__)
 
-$VERBOSE = true
-
-$: << File.join(File.dirname(__FILE__), "../lib")
-
-require 'test/unit'
+require 'helper'
 require 'oflow'
 
 class Access
@@ -20,7 +14,7 @@ class Access
   end
 end # Access
 
-class BoxTest < ::Test::Unit::TestCase
+class BoxTest < ::MiniTest::Test
 
   def test_box_new
     data = { a: [1, 'first'], b: true }
@@ -121,7 +115,7 @@ class BoxTest < ::Test::Unit::TestCase
     assert_equal(nil, b2.get('f:0'), 'get f:0')
     assert_equal('new', b2.get('f:1'), 'get f:1')
 
-    assert_raise(::OFlow::FrozenError) { box.set('d:x:1', 'three') }
+    assert_raises(::OFlow::FrozenError) { box.set('d:x:1', 'three') }
   end
 
 end # BoxTest

data/test/flow_basic_test.rb

@@ -1,11 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../lib")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(__FILE__) unless $:.include? File.dirname(__FILE__)
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 
 require 'collector'
@@ -28,12 +26,13 @@ class Stutter < ::OFlow::Actor
 
 end # Stutter
 
-class FlowBasicTest < ::Test::Unit::TestCase
+class FlowBasicTest < ::MiniTest::Test
 
   def test_flow_basic
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
-    ::OFlow::Env.flow('basic', :opt1 => 1) { |f|
+    env.flow('basic') { |f|
       # collects results
       f.task(:collector, Collector) { |t|
         collector = t.actor
@@ -51,43 +50,46 @@ class FlowBasicTest < ::Test::Unit::TestCase
       }
       f.task(:ignore, ::OFlow::Actors::Ignore)
     }
+    env.prepare()
+    env.start()
+
     # see if the flow was constructed correctly
-    assert_equal(%|OFlow::Env {
+    assert_equal(%| (OFlow::Env) {
   basic (OFlow::Flow) {
     collector (Collector) {
     }
     trigger (Stutter) {
-      collector => collector:trigger
-      once => dub:twice
+      collector => :collector:trigger
+      once => :dub:twice
     }
     dub (Stutter) {
-      collector => collector:dub
-      twice => dub:once
-      once => ignore:
+      collector => :collector:dub
+      twice => :dub:once
+      once => :ignore:
     }
     ignore (OFlow::Actors::Ignore) {
     }
   }
-}|, ::OFlow::Env.describe())
+}|, env.describe())
 
     # run it and check the output
     trigger.receive(:once, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
-    assert_equal([[':basic:trigger', :once, 7],
-                  [':basic:dub', :twice, 7],
-                  [':basic:dub', :once, 7, 'with_link'],
+    env.flush()
+    assert_equal([['basic:trigger', :once, 7],
+                  ['basic:dub', :twice, 7],
+                  ['basic:dub', :once, 7, 'with_link'],
                  ], collector.collection)
 
     # run again and make sure all tasks use links
     collector.collection = []
     trigger.receive(:once, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
-    assert_equal([[':basic:trigger', :once, 7, 'with_link'],
-                  [':basic:dub', :twice, 7, 'with_link'],
-                  [':basic:dub', :once, 7, 'with_link'],
+    env.flush()
+    assert_equal([['basic:trigger', :once, 7, 'with_link'],
+                  ['basic:dub', :twice, 7, 'with_link'],
+                  ['basic:dub', :once, 7, 'with_link'],
                  ], collector.collection)
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
 end # FlowBasicTest

data/test/flow_cfg_error_test.rb

@@ -1,11 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../lib")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(__FILE__) unless $:.include? File.dirname(__FILE__)
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 
 require 'collector'
@@ -49,11 +47,12 @@ class Miss < ::OFlow::Actor
 
 end # Miss
 
-class FlowCfgErrTest < ::Test::Unit::TestCase
+class FlowCfgErrTest < ::MiniTest::Test
 
   def test_flow_link_unresolved
     begin
-      ::OFlow::Env.flow('unresolved', :opt1 => 1) { |f|
+      env = ::OFlow::Env.new('')
+      env.flow('unresolved') { |f|
         f.task(:one, Dummy) { |t|
           t.link(:two, :two, nil)
         }
@@ -61,17 +60,20 @@ class FlowCfgErrTest < ::Test::Unit::TestCase
           t.link(:second, :two, nil)
         }
       }
+      env.prepare()
+      env.start()
       assert(false, "expected a ValidateError")
     rescue ::OFlow::ValidateError => ve
-      assert_equal([":unresolved:one: Failed to find task 'two'.",
-                    ":unresolved:three: Failed to find task 'two'."], ve.problems.map { |p| p.to_s })
+      assert_equal(["unresolved:one: Failed to find task 'two'.",
+                    "unresolved:three: Failed to find task 'two'."], ve.problems.map { |p| p.to_s })
     end
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def test_flow_link_missing
+    env = ::OFlow::Env.new('')
     begin
-      ::OFlow::Env.flow('miss-me') { |f|
+      env.flow('miss-me') { |f|
         f.task(:sort, Miss) { |t|
           t.link(:fixnum, :fix, nil)
         }
@@ -80,12 +82,14 @@ class FlowCfgErrTest < ::Test::Unit::TestCase
           t.link(:wrong, :sort, :complex)
         }
       }
+      env.prepare()
+      env.start()
       assert(false, "expected a ValidateError")
     rescue ::OFlow::ValidateError => ve
-      assert_equal([":miss-me:sort: Missing link for 'float'.",
-                    ":miss-me:fix: 'complex' not allowed on ':miss-me:sort'."], ve.problems.map { |p| p.to_s })
+      assert_equal(["miss-me:sort: Missing link for 'float'.",
+                    "miss-me:fix: 'complex' not allowed on 'miss-me:sort'."], ve.problems.map { |p| p.to_s })
     end
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   # TBD missing links for output spec

data/test/flow_linked_test.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__) unless $:.include? File.dirname(__FILE__)
+
+require 'helper'
+require 'oflow'
+
+require 'collector'
+
+class Hop < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    task.warn("#{op} #{box.contents}")
+    task.ship(op, box)
+  end
+
+end # Hop
+
+class FlowLinkedTest < ::MiniTest::Test
+
+  def test_flow_linked
+    env = ::OFlow::Env.new('')
+    env.log = ::OFlow::Task.new(env, :log, Collector)
+    trigger = nil
+
+    env.flow(:prime) { |f|
+      # starts off the process
+      trigger = f.task(:trigger, Hop) { |t|
+        t.link(nil, :one, nil, :linked)
+      }
+      f.task(:in, Hop) { |t|
+          t.link(nil, :done, nil)
+      }
+      f.task(:done, ::OFlow::Actors::Ignore)
+    }
+    env.flow(:linked) { |f|
+      f.task(:one, Hop) { |t|
+        t.link(nil, :two, nil)
+      }
+      f.task(:two, Hop) { |t|
+        t.link(nil, :in, :bye, :prime)
+      }
+    }
+    env.prepare()
+    env.start()
+
+    # see if the flow was constructed correctly
+    assert_equal(%| (OFlow::Env) {
+  prime (OFlow::Flow) {
+    trigger (Hop) {
+       => linked:one:
+    }
+    in (Hop) {
+       => :done:
+    }
+    done (OFlow::Actors::Ignore) {
+    }
+  }
+  linked (OFlow::Flow) {
+    one (Hop) {
+       => :two:
+    }
+    two (Hop) {
+       => prime:in:bye
+    }
+  }
+}|, env.describe())
+
+    # run it and check the output
+    trigger.receive(:go, ::OFlow::Box.new(7))
+    env.flush()
+    assert_equal([['go 7', 'prime:trigger'],
+                  [' 7', 'linked:one'],
+                  [' 7', 'linked:two'],
+                  ['bye 7', 'prime:in']
+                 ], env.log.actor.collection)
+
+    env.clear()
+  end
+
+  def test_flow_linked_label
+    env = ::OFlow::Env.new('')
+    env.log = ::OFlow::Task.new(env, :log, Collector)
+    trigger = nil
+
+    env.flow(:prime) { |f|
+      # starts off the process
+      trigger = f.task(:trigger, Hop) { |t|
+        t.link(:go, :one, :hip, :linked)
+      }
+      f.task(:in, Hop) { |t|
+          t.link(:bye, :done, nil)
+      }
+      f.task(:done, ::OFlow::Actors::Ignore)
+    }
+    env.flow(:linked) { |f|
+      f.task(:one, Hop) { |t|
+        t.link(:hip, :two, :hop)
+      }
+      f.task(:two, Hop) { |t|
+        t.link(:hop, :in, :bye, :prime)
+      }
+    }
+    env.prepare()
+    env.start()
+
+    # see if the flow was constructed correctly
+    assert_equal(%| (OFlow::Env) {
+  prime (OFlow::Flow) {
+    trigger (Hop) {
+      go => linked:one:hip
+    }
+    in (Hop) {
+      bye => :done:
+    }
+    done (OFlow::Actors::Ignore) {
+    }
+  }
+  linked (OFlow::Flow) {
+    one (Hop) {
+      hip => :two:hop
+    }
+    two (Hop) {
+      hop => prime:in:bye
+    }
+  }
+}|, env.describe())
+
+    # run it and check the output
+    trigger.receive(:go, ::OFlow::Box.new(7))
+    env.flush()
+    assert_equal([['go 7', 'prime:trigger'],
+                  ['hip 7', 'linked:one'],
+                  ['hop 7', 'linked:two'],
+                  ['bye 7', 'prime:in']
+                 ], env.log.actor.collection)
+
+    env.clear()
+  end
+
+end # FlowLinkedTest

data/test/flow_log_test.rb

@@ -1,11 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../lib")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(__FILE__) unless $:.include? File.dirname(__FILE__)
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 
 require 'collector'
@@ -23,89 +21,105 @@ class Noise < ::OFlow::Actor
 
 end # Noise
 
-class FlowLogTest < ::Test::Unit::TestCase
+class FlowLogTest < ::MiniTest::Test
 
   # Make sure the log works and relays to a log task if it exists.
   def test_flow_log_relay
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
     ::OFlow::Env.log_level = Logger::WARN
-    ::OFlow::Env.flow('log_relay') { |f|
+    env.flow('log_relay') { |f|
       trigger = f.task('noise', Noise)
       f.task(:log, Collector) { |t|
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     trigger.receive(:speak, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
+    env.flush()
 
-    assert_equal(collector.collection.size, 1)
-    assert_equal(collector.collection[0][0], 'op: speak, box: 7')
-    assert_equal(collector.collection[0][1], ':log_relay:noise')
+    assert_equal(1, collector.collection.size)
+    assert_equal('op: speak, box: 7', collector.collection[0][0])
+    assert_equal('log_relay:noise', collector.collection[0][1])
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   # Make sure the log in the flow var is used.
   def test_flow_log_var
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
     ::OFlow::Env.log_level = Logger::WARN
-    ::OFlow::Env.flow('log_var') { |f|
+    env.flow('log_var') { |f|
       trigger = f.task('noise', Noise)
       f.log = f.task(:collector, Collector) { |t|
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     trigger.receive(:speak, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
+    env.flush()
 
-    assert_equal(collector.collection.size, 1)
-    assert_equal(collector.collection[0][0], 'op: speak, box: 7')
-    assert_equal(collector.collection[0][1], ':log_var:noise')
+    assert_equal(1, collector.collection.size)
+    assert_equal('op: speak, box: 7', collector.collection[0][0])
+    assert_equal('log_var:noise', collector.collection[0][1])
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   # Make sure the log in the Env var is used.
   def test_flow_log_env
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
     ::OFlow::Env.log_level = Logger::WARN
-    ::OFlow::Env.flow('log_env') { |f|
+    env.flow('log_env') { |f|
       trigger = f.task('noise', Noise)
-      ::OFlow::Env.log = f.task(:collector, Collector) { |t|
+      env.log = f.task(:collector, Collector) { |t|
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     trigger.receive(:speak, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
+    env.flush()
 
-    assert_equal(collector.collection.size, 1)
-    assert_equal(collector.collection[0][0], 'op: speak, box: 7')
-    assert_equal(collector.collection[0][1], ':log_env:noise')
+    assert_equal(1, collector.collection.size)
+    assert_equal('op: speak, box: 7', collector.collection[0][0])
+    assert_equal('log_env:noise', collector.collection[0][1])
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
-  def test_flow_log_info
+  def test_flow_log_debug
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
     ::OFlow::Env.log_level = Logger::WARN
-    ::OFlow::Env.flow('log_info') { |f|
+    env.flow('log_info') { |f|
       f.log = f.task(:collector, Collector) { |t|
         collector = t.actor
       }
       # Set after log to avoid race condition with the creation of the collector
       # and the assignment to f.log. The race is whether a log message is
       # displayed on the output.
-      ::OFlow::Env.log_level = Logger::INFO
+    ::OFlow::Env.log_level = Logger::DEBUG
       trigger = f.task('noise', Noise) { |t|
         t.link(nil, :collector, nil)
       }
     }
+    env.prepare()
+    env.start()
+
     trigger.receive(:speak, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
+    env.flush()
 
     entries = collector.collection.map { |entry| entry[0] }
     assert_equal(["Creating actor Noise with options {:state=>1}.",
@@ -115,7 +129,7 @@ class FlowLogTest < ::Test::Unit::TestCase
                   "shipping Box{[7]} to collector:",
                   7], entries)
 
-    ::OFlow::Env.clear()
+    env.clear()
     ::OFlow::Env.log_level = Logger::WARN
   end