tap 0.7.9 → 0.8.0

data/lib/tap/version.rb

@@ -1,3 +1,4 @@
 module Tap
-  VERSION="0.7.9" 
+  VERSION="0.8.0" 
+  HOMEPAGE="http://tap.rubyforge.org"
 end

data/lib/tap/workflow.rb

@@ -1,5 +1,7 @@
 module Tap
   
+  # == UNDER CONSTRUCTION
+  #
   # App can build workflows directly, using methods like sequence, merge, and
   # multithread, but these workflows are hard to abstract and resuse.  Workflow
   # is a specialized type of Task allows the encapsulation and reuse of workflow 

data/test/app/lib/app_test_task.rb

@@ -1,2 +1,3 @@
+require 'tap'
 class AppTestTask < Tap::Task
 end

data/test/app_test.rb

@@ -5,11 +5,85 @@ require 'logger'
 
 class AppTest < Test::Unit::TestCase
 	include Tap
+	include TapTestMethods
+	
   acts_as_tap_test
 	
-	def setup
-		super
-		app.queue.clear
+	def stub_gemspec(name, version)
+	  spec = Gem::Specification.new
+    spec.name = name
+    spec.version = version
+    spec.loaded_from = "/path/to/gems"
+    spec
+	end
+	
+	def test_app_documentation
+    task = Tap::Task.new {|task, input| input += 1 }
+    assert_equal Tap::App.instance, task.app
+    task.enq 1,2,3
+  
+    task.app.run      
+  
+    assert_equal [2,3,4], task.results.collect {|audit| audit._current}
+	end
+	
+	#
+	# App instance test
+	#
+	
+	def test_instance_returns_current_instance
+	  a = Tap::App.new
+	  Tap::App.instance = a
+	  assert_equal a, Tap::App.instance
+	end
+	
+	def test_instance_initializes_new_App_if_not_set
+	  Tap::App.instance = nil
+	  assert Tap::App.instance.kind_of?(Tap::App)
+	end
+	
+	#
+	# App parse_yaml test
+	#
+	
+	def test_parse_yaml_documentation
+    str = {'key' => 'value'}.to_yaml
+    assert_equal "--- \nkey: value\n", str
+    assert_equal({'key' => 'value'}, Tap::App.parse_yaml(str))
+    assert_equal "str", Tap::App.parse_yaml("str")
+	end
+	
+	def test_parse_yaml_parses_correctly_formatted_strings
+    assert_equal({'key' => 'value'}, Tap::App.parse_yaml("---\nkey: value"))
+	end
+	
+	def test_parse_yaml_returns_strings_not_matching_yaml_format
+    assert_equal("str", Tap::App.parse_yaml("str"))
+	end
+	
+	#
+	# App read_erb_yml test
+	#
+	
+	def test_read_erb_yaml_templates_file_using_erb_then_loads_as_yaml
+	  file = tempfile
+	  File.open(file, "w") do |f|
+	    f << %Q{
+<% value = "value" %>
+<%= "k" + "ey" %>: <%= value %>}
+	  end
+	  
+	  assert_equal({'key' => 'value'}, Tap::App.read_erb_yaml(file))
+	end
+	
+	def test_read_erb_yaml_returns_nil_if_filepath_does_not_exist_or_is_a_dir
+	  file = File.dirname(__FILE__) + "/app/no_existant_file.txt"
+	  dir = File.dirname(__FILE__) + "/app"
+	  
+    assert !File.exists?(file)
+    assert File.directory?(dir)
+    assert_nil Tap::App.read_erb_yaml(file)
+    assert_nil Tap::App.read_erb_yaml(dir)
 	end
 	
 	# 
@@ -40,8 +114,7 @@ class AppTest < Test::Unit::TestCase
       :logger => {
         :device => STDOUT,
         :level => 1, # corresponds to 'INFO'
-        :datetime_format => '%H:%M:%S'},
-      :load_paths => []
+        :datetime_format => '%H:%M:%S'}
     }
     assert_equal expected, app.config
     
@@ -51,18 +124,16 @@ class AppTest < Test::Unit::TestCase
     app[:abs, true] = '/absolute/path'
     strio = StringIO.new('')
     app.logger = Logger.new(strio)
-    app.load_paths << "path"
-    
+
     expected = {
       :root => Dir.pwd,
       :directories => {:lib => 'alt/lib'},
-      :absolute_paths => {:abs => '/absolute/path'},
+      :absolute_paths => {:abs => File.expand_path('/absolute/path')},
       :options => {:trace => true},
       :logger => {
         :device => strio,
         :level => 0, 
-        :datetime_format => nil},
-      :load_paths => ["path"]
+        :datetime_format => nil}
     }
     
     assert_equal 0, app.logger.level
@@ -73,22 +144,49 @@ class AppTest < Test::Unit::TestCase
   #
   # reconfigure test
   #
+  
+  def test_reconfigure_documentation
+    app = Tap::App.new :root => "/root", :directories => {:dir => 'path/to/dir'}
+    app.reconfigure(
+      :root => "./new/root",
+      :logger => {:level => Logger::DEBUG})
+  
+    assert_equal File.expand_path("./new/root"), app.root  
+    assert_equal File.expand_path("./new/root/path/to/dir"), app[:dir]          
+    assert_equal Logger::DEBUG, app.logger.level   
+  end
 	
-  def test_reconfigure_may_overrride_root_directories_options_and_logging
+  def test_reconfigure_root_sets_app_root
     app = App.new
     
     assert_equal Dir.pwd, app.root
     app.reconfigure :root => './alt/root'
-    assert_equal './alt/root', app.root
-    
+    assert_equal File.expand_path('./alt/root'), app.root
+  end
+  
+  def test_reconfigure_directories_sets_directories
+    app = App.new
     assert_equal({}, app.directories)
     app.reconfigure :directories => {:lib => 'alt/lib'}
     assert_equal({:lib => 'alt/lib'}, app.directories)
-    
+  end
+  
+  def test_reconfigure_absolute_paths_sets_absolute_paths
+    app = App.new
+    assert_equal({}, app.absolute_paths)
+    app.reconfigure :absolute_paths => {:log => '/path/to/log'}
+    assert_equal({:log => File.expand_path('/path/to/log')}, app.absolute_paths)
+  end
+  
+  def test_reconfigure_options_sets_options
+    app = App.new
     assert_equal({}, app.options.marshal_dump)
     app.reconfigure :options => {:trace => true}
     assert_equal({:trace => true}, app.options.marshal_dump)
-    
+  end
+  
+  def test_reconfigure_logger_sets_logger
+    app = App.new
     assert_equal STDOUT, app.logger.logdev.dev
     strio = StringIO.new('')
     app.reconfigure :logger => {:device => strio, :level => Logger::WARN}
@@ -96,6 +194,64 @@ class AppTest < Test::Unit::TestCase
     assert_equal Logger::WARN, app.logger.level
   end
   
+  def test_reconfigure_map_sets_map
+    app = App.new
+    assert_equal({}, app.map)
+    app.reconfigure :map => {'some/task_name' => Tap::Task}
+    assert_equal({'some/task_name' => Tap::Task}, app.map)
+  end
+  
+  def test_reconfigure_sends_unhandled_options_to_block_if_given
+    app = App.new
+    was_in_block = false
+    app.reconfigure(:unknown => 'value') do |key, value|
+      assert_equal(:unknown, key)
+      assert_equal('value', value)
+      was_in_block = true
+    end
+    assert was_in_block
+  end
+  
+  def test_reconfigure_raises_error_for_unhandled_options
+    app = App.new
+    assert_raise(ArgumentError) { app.reconfigure(:unknown => 'value') }
+  end
+  
+  class AppHandlesConfig < App
+    attr_accessor :handled_configs
+    def handle_configuation(key, value)
+      (self.handled_configs ||= []).concat [key, value]
+      true
+    end
+  end
+  
+  def test_reconfigure_sends_unhandled_options_to_handle_configuation_if_defined
+    app = AppHandlesConfig.new
+    was_in_block = false
+    app.reconfigure(:unknown => 'value') do |key, value|
+      was_in_block = true
+    end
+    assert_equal [:unknown, 'value'], app.handled_configs
+    assert !was_in_block
+  end
+  
+  class AppDoesNotHandleConfig < AppHandlesConfig
+    def handle_configuation(key, value)
+      (self.handled_configs ||= []).concat [key, value]
+      false
+    end
+  end
+  
+  def test_reconfigure_goes_to_block_if_handle_configuration_returns_false
+    app = AppDoesNotHandleConfig.new
+    was_in_block = false
+    app.reconfigure(:unknown => 'value') do |key, value|
+      was_in_block = true
+    end
+    assert_equal [:unknown, 'value'], app.handled_configs
+    assert was_in_block
+  end
+
 	#
 	# set logger tests
 	#
@@ -121,33 +277,35 @@ class AppTest < Test::Unit::TestCase
   class TaskSubClass < Task
   end
   
-  def test_task_returns_task_if_a_task_is_provided
-    task = Task.new
-    assert_equal task, app.task(task)
-    
-    subtask = TaskSubClass.new
-    assert_equal subtask, app.task(subtask)
+  class AnotherTask < Task
   end
   
-  def test_task_reconfigures_task_with_config
-    task = Task.new
-    config = {"key" => "value"}
-    
-    assert_equal({}, task.config)
-    assert_equal task, app.task(task, config)
-    assert_equal(config.symbolize_keys, task.config)
+  def test_task_documentation
+    app.map = {"mapped-task" => "AppTest::AnotherTask"}
+  
+    t = app.task('mapped-task-1.0', :key => 'value')
+    assert_equal AnotherTask, t.class      
+    assert_equal "mapped-task-1.0", t.name 
+    assert_equal 'value', t.config[:key]
   end
   
-  def test_task_looks_up_and_instantiates_task_if_task_is_a_string
+  def test_task_looks_up_and_instantiates_task
     assert_equal TaskSubClass, app.task("AppTest::TaskSubClass").class
   end
   
-  def test_task_translates_strings_to_class_name_using_map_if_possible
+  def test_task_instantiates_a_new_task_for_each_call
+    t1 = app.task("AppTest::TaskSubClass")
+    t2 = app.task("AppTest::TaskSubClass")
+    
+    assert_not_equal t1.object_id, t2.object_id
+  end
+  
+  def test_task_translates_task_name_to_class_name_using_map_if_possible
     app.map["mapped_name"] = "AppTest::TaskSubClass"
     assert_equal TaskSubClass, app.task("mapped_name").class
   end
   
-  def test_task_translates_strings_to_class_name_using_camelize_by_default
+  def test_task_translates_task_name_to_class_name_using_camelize_by_default
     assert_equal TaskSubClass, app.task("app_test/task_sub_class").class
   end
   
@@ -157,7 +315,7 @@ class AppTest < Test::Unit::TestCase
     assert_equal "app_test/task_sub_class-1.1", t.name
   end
   
-  def test_task_can_find_task_classes_along_Dependencies_load_paths
+  def test_task_looks_up_task_classes_along_Dependencies_load_paths
     begin
       Dependencies.load_paths << app['lib']
       assert_equal AppTestTask, app.task("AppTestTask").class
@@ -166,14 +324,60 @@ class AppTest < Test::Unit::TestCase
     end
   end
   
-  def test_task_raises_error_if_class_cannot_be_found
-    assert_raise(RuntimeError) { app.task("NonExistant") }
+  def test_task_raises_lookup_error_if_class_cannot_be_found
+    assert_raise(App::LookupError) { app.task("NonExistant") }
+  end
+  
+  #
+  # task_class_name test
+  #
+  
+  def test_task_class_name_documentation
+    t = Task.new
+    app.map = {"mapped-task" => "AnotherTask"}
+    assert_equal "Tap::Task", app.task_class_name(t)              
+    assert_equal "AnotherTask", app.task_class_name('mapped-task-1.0')   
+  end
+  
+  def test_task_class_name_returns_task_class_name
+    task = Task.new
+    assert_equal "Tap::Task", app.task_class_name(task)
+    
+    subtask = TaskSubClass.new
+    assert_equal "AppTest::TaskSubClass", app.task_class_name(subtask)
+    
+    non_task = Object.new
+    non_task.extend Tap::Task::Base
+    assert_equal "Object", app.task_class_name(non_task)
+  end
+
+  def test_task_class_name_returns_deversioned_camelized_name
+    assert_equal "AppTest::TaskSubClass", app.task_class_name("app_test/task_sub_class-1.1")
+  end
+  
+  def test_task_class_name_resolves_names_using_map
+    app.map = {"mapped-task" => "AnotherTask"}
+    assert_equal "AnotherTask", app.task_class_name("mapped-task-1.1")
   end
   
   #
 	# config_templates tests
 	#
   
+  def test_config_templates_documentation
+    simple = tempfile
+    File.open(simple, "w") {|f| f <<  "key: value"}
+    assert_equal([{"key" => "value"}], app.config_templates(simple))
+  
+    array_with_erb = tempfile
+    File.open(array_with_erb, "w") do |f| 
+      f << %Q{ 
+- key: <%= 1 %>
+- key: <%= 1 + 1 %>}
+    end
+    assert_equal([{"key" => 1}, {"key" => 2}], app.config_templates(array_with_erb))
+  end
+  
 	def test_config_templates_retrieves_templates_for_the_specified_task_config_file
 	  filepath = app.filepath('config', "version.yml")
 	  assert File.exists?(filepath)
@@ -212,19 +416,19 @@ class AppTest < Test::Unit::TestCase
   # execute test
   #
   
-  def test_execute_executes_task_with_inputs
-    t = Task.new(&add_one)
-    t.enq(1,2,3)
-    
-		app.execute(t)
-		assert_inputs(t => [1,2,3])
-		assert_outputs(t => [2,3,4])
-		assert_equal [1,2,3], runlist
-		assert_audits(t.results, 
-			0 => [[nil,1], [t,2]],
-			1 => [[nil,2], [t,3]],
-			2 => [[nil,3], [t,4]])
-  end
+  # def test_execute_executes_task_with_inputs
+  #   t = Task.new(&add_one)
+  #   t.enq(1,2,3)
+  #   
+  #     app.execute(t)
+  #     assert_inputs(t => [1,2,3])
+  #     assert_outputs(t => [2,3,4])
+  #     assert_equal [1,2,3], runlist
+  #     assert_audits(t.results, 
+  #       0 => [[nil,1], [t,2]],
+  #       1 => [[nil,2], [t,3]],
+  #       2 => [[nil,3], [t,4]])
+  # end
   
 	#
 	# run tests
@@ -409,6 +613,7 @@ class AppTest < Test::Unit::TestCase
 		end
 	end
 	
+  # inconsistent test ruby, windows
 	def test_multithreaded_tasks_execute_in_order
 	  extended_test do
 			max_threads = 0
@@ -459,7 +664,11 @@ class AppTest < Test::Unit::TestCase
 	  threads =  []
 	  ObjectSpace.garbage_collect
 	  sleep 0.2 # sleep to give garbage collect time to run
-	  ObjectSpace.each_object(Thread) {|t| threads << t.object_id}
+	  
+    # JRuby limits ObjectSpace to only work for Class by default
+	  # so this line has to be made less elegant and a little slower
+	  #   ObjectSpace.each_object(Thread) {|t| threads << t.object_id}
+	  ObjectSpace.each_object(Class) {|t| threads << t.object_id if t.kind_of?(Thread)}
 	  threads
 	end
 	
@@ -605,11 +814,13 @@ class AppTest < Test::Unit::TestCase
   # terminate test
   #
   
+  # TODO -- REWORD
   def test_terminate_from_main_thread_raises_run_error
     extended_test do
       was_not_terminated = false
       task = Task.new do |task, inputs|
         app.terminate
+        task.check_terminate
         was_not_terminated = true
       end
       
@@ -629,12 +840,14 @@ class AppTest < Test::Unit::TestCase
   	end
   end
 
+  # TODO -- REWORD
   def test_terminate_from_main_thread_when_error_is_handled_still_raises_error
     extended_test do
       terminate_error_handled = false
       task = Task.new do |task, inputs|
         begin
           app.terminate
+          task.check_terminate
         rescue
           terminate_error_handled = true
         end
@@ -656,6 +869,7 @@ class AppTest < Test::Unit::TestCase
   	end
   end
 
+  # TODO -- REWORD
   def test_terminate_raises_error_on_each_execution_thread_and_requeues_thread_queue
     extended_test do
       count = 0
@@ -664,7 +878,8 @@ class AppTest < Test::Unit::TestCase
         Task.new do |task, inputs|
           count += 1
           app.terminate if count == 2
-          sleep 2
+          sleep 1
+          task.check_terminate
           some_thread_was_not_terminated = true
         end 
       end
@@ -704,6 +919,8 @@ class AppTest < Test::Unit::TestCase
   	end
   end
 
+  # TODO -- REWORD
+  # JRuby inconsistent test
   def test_terminate_on_thread_when_error_is_handled_still_raises_error
     extended_test do
       count = 0
@@ -715,7 +932,8 @@ class AppTest < Test::Unit::TestCase
           count += 1
           begin
             app.terminate if count == 2
-            sleep 2
+            sleep 1
+            task.check_terminate
             some_thread_was_not_terminated = true
           rescue
             handled_count += 1
@@ -758,6 +976,7 @@ class AppTest < Test::Unit::TestCase
     assert_equal 'state: 0 (READY) queue: 0 waiting: 0 (0) threads: 0', app.info
   end
 
+  # TODO -- JRuby inconsistent test
   def test_info_can_be_called_during_a_run
     extended_test do
       count = 0
@@ -766,9 +985,11 @@ class AppTest < Test::Unit::TestCase
       tasks = Array.new(5) do
         Task.new do |task, inputs|
           count += 1
-          info_str = app.info if count == 2
-          app.stop if count == 2
-          sleep 0.2
+          if count == 2
+            info_str = app.info 
+            app.stop
+          end
+          sleep 2
         end 
       end
   		tasks.each do |task| 
@@ -780,7 +1001,11 @@ class AppTest < Test::Unit::TestCase
         app.run
     	end
     	
-    	assert_equal 'state: 1 (RUN) queue: 3 waiting: 3 (0) threads: 2', info_str
+      # There is some ambiguity in the info string  -- threads could be 
+      # waiting in the queue or in the thread queue, but their sum must be 3
+      # Regexp patterned from 'state: 1 (RUN) queue: 3 waiting: 3 (0) threads: 2'
+    	assert info_str =~ /state: 1 \(RUN\) queue: 3 waiting: (\d) \((\d)\) threads: 2/, info_str  
+      assert_equal 3, $1.to_i + $2.to_i
     	assert_equal 'state: 0 (READY) queue: 3 waiting: 3 (0) threads: 0', app.info
   	end
   end
@@ -942,6 +1167,7 @@ class AppTest < Test::Unit::TestCase
 			2 => [[nil,3], [t1_1,24]])
 	end
 	
+	# TODO -- JRuby inconsistent test
 	def test_multithread_batched_tasks_execute_cosynchronously
     extended_test do
       max_threads = 0
@@ -953,8 +1179,8 @@ class AppTest < Test::Unit::TestCase
         
         # sleep is necessary so the other threads
         # have an opportunity to execute
-				sleep(0.2) 
-        
+				sleep(1) 
+ 
 				n_threads -= 1
 				nil
 			end
@@ -1167,31 +1393,31 @@ class AppTest < Test::Unit::TestCase
 	  assert_equal 3, not_threaded_count
 	end
 	
-  def test_execute_is_allowed_within_non_threaded_task
-    # execute within a threaded task deadlocks
-    t2 = Task.new(&add_one)
-    t1 = Task.new do |task, input|
-      runlist << input
-      app.queue.enq(t2, input)
-      app.execute(t2)
-
-      input += 1
-    end
-
-		app.run(t1, 1,2,3)
-
-		# remember t2, will only show the LAST input 
-		# to have been processed
-		assert_inputs(t1 => [1,2,3], t2 => [3])
-		assert_outputs(t1 => [2,3,4], t2 => [4])
-		assert_equal [1,1,2,2,3,3], runlist
-		assert_audits(t1.results, 
-			0 => [[nil,1], [t1,2]],
-			1 => [[nil,2], [t1,3]],
-			2 => [[nil,3], [t1,4]])
-		assert_audits(t2.results, 
-			0 => [[nil,3], [t2,4]])
-  end
+  # def test_execute_is_allowed_within_non_threaded_task
+  #   # execute within a threaded task deadlocks
+  #   t2 = Task.new(&add_one)
+  #   t1 = Task.new do |task, input|
+  #     runlist << input
+  #     app.queue.enq(t2, input)
+  #     app.execute(t2)
+  # 
+  #     input += 1
+  #   end
+  # 
+  #     app.run(t1, 1,2,3)
+  # 
+  #     # remember t2, will only show the LAST input 
+  #     # to have been processed
+  #     assert_inputs(t1 => [1,2,3], t2 => [3])
+  #     assert_outputs(t1 => [2,3,4], t2 => [4])
+  #     assert_equal [1,1,2,2,3,3], runlist
+  #     assert_audits(t1.results, 
+  #       0 => [[nil,1], [t1,2]],
+  #       1 => [[nil,2], [t1,3]],
+  #       2 => [[nil,3], [t1,4]])
+  #     assert_audits(t2.results, 
+  #       0 => [[nil,3], [t2,4]])
+  # end
 
   def test_run_is_allowed_within_non_threaded_task
     # run within a threaded task deadlocks
@@ -1263,6 +1489,9 @@ class AppTest < Test::Unit::TestCase
     assert string =~ /RuntimeError error/
   end
   
+  # Ruby inconsistent test
+  #   <"error"> expected but was
+  #   <"Tap::App::TerminateError">.
   def test_unhandled_exception_raises_run_error_on_thread_when_debug
     t = Task.new {|t,i| raise "error"}
     t.multithread = true
@@ -1280,6 +1509,11 @@ class AppTest < Test::Unit::TestCase
   	end
   end
   
+  # TODO -- REWORD
+
+  # Ruby inconsistent test
+  #  <"error"> expected but was
+  #  <"Tap::App::TerminateError">.
   def test_unhandled_exception_on_thread_teminates_threads
    extended_test do
       count = 0
@@ -1291,7 +1525,8 @@ class AppTest < Test::Unit::TestCase
           count += 1  
           
           terminated_count += 1
-          sleep 2
+          sleep 1
+          t.check_terminate
           
           # this should not happen
           terminated_count -= 1
@@ -1322,6 +1557,14 @@ class AppTest < Test::Unit::TestCase
     end
   end
 
+  # Ruby inconsistent test
+  #  <"error"> expected but was
+  #  <"Tap::App::TerminateError">.
+  #
+  # <"term error 0"> expected but was
+  # <"term error 1">.
+  #
+  # JRuby inconsistent test 
   def test_exceptions_from_handling_termination_error_are_collected
     extended_test do
       count = 0
@@ -1332,7 +1575,8 @@ class AppTest < Test::Unit::TestCase
           n = count
           begin
             count += 1
-            sleep 2
+            sleep 1
+            t.check_terminate
           rescue
             count_in_threaded_error_handling += 1
             raise "term error #{n}"