tap 0.7.9 → 0.8.0

data/test/task_base_test.rb

@@ -0,0 +1,115 @@
+require  File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/task'
+
+class TaskBaseTest < Test::Unit::TestCase
+	include Tap
+	include Benchmark
+	
+	acts_as_tap_test :root => File.dirname(__FILE__) + "/task"
+	attr_accessor :t
+	
+	class ObjectWithProcess
+	  def process(input)
+	    input
+	  end
+	end
+	
+	def setup
+		super
+		@t = ObjectWithProcess.new
+		@t.extend Tap::Task::Base
+	end
+	
+	#
+	# extend tests
+	#
+	
+	def test_initialization_of_variables_on_extend
+		assert_equal [], t.results
+		assert_equal [t], t.batch
+		assert_nil t.condition_block
+		assert_nil t.on_complete_block
+		assert !t.multithread
+		assert !t.iterate
+	end
+	
+	#
+  # multithread test
+  #
+
+  def test_multithread_returns_value_of_multithread
+    t.multithread = false
+    assert !t.multithread?
+    t.multithread = true
+    assert t.multithread?
+  end
+  
+  #
+  # iterate test
+  #
+
+  def test_iterate_can_be_set
+    t.iterate = false
+    assert !t.iterate?
+    t.iterate = true
+    assert t.iterate?
+  end
+  
+  #
+	# executable? test
+	#
+	
+	def test_executable_evaluates_condition_block_with_inputs
+		t.condition do |task, inputs|
+			inputs == [1,2,3]
+		end
+		
+		assert t.executable?([1,2,3])
+		assert !t.executable?(1)
+	end
+
+	def test_executable_returns_true_if_condition_block_is_nil
+		assert_nil t.condition_block
+		assert t.executable?(nil)
+	end
+	
+	#
+	# on_complete block test
+	#
+	
+	def test_on_complete_sets_on_complete_block
+		block = lambda {}
+		t.on_complete(&block)
+		assert_equal block, t.on_complete_block
+	end
+	
+	def test_on_complete_can_only_be_set_once
+		t.on_complete {}
+		assert_raise(RuntimeError) { t.on_complete {} }
+		assert_raise(RuntimeError) { t.on_complete }
+	end
+	
+	#
+	# condition block test
+	#
+	
+	def test_condition_sets_condition_block
+		block = lambda {}
+		t.condition(&block)
+		assert_equal block, t.condition_block
+	end
+	
+	def test_condition_can_only_be_set_once
+		t.condition {}
+		assert_raise(RuntimeError) { t.condition {} }
+		assert_raise(RuntimeError) { t.condition }
+	end
+	
+	#
+	# process test
+	#
+
+	def test_process_returns_input
+	  assert_equal 1, t.process(1)
+	end
+end

data/test/task_class_test.rb

@@ -8,11 +8,34 @@ class TaskClassTest < Test::Unit::TestCase
 	#
 	
 	class TaskWithDefaultConfig < Tap::Task
-		set_default_config :one => 1, :two => 2, :three => 3
+    declare_config
+
+	  config :one, 1
+    config :two, 2
+    config :three, 3
+
     config_accessor :one
     config_writer :two
     config_reader :three
 	end
+	
+	class SomeTask < Tap::Task
+    config :key, 'value'  # a sample config
+  end
+
+	def test_class_configurations_doc 
+    t = SomeTask.new
+    assert_equal 'value', t.key 
+    t.key = 'another'
+    assert_equal({:key => 'another'}, t.config)
+	end
+	
+	def test_task_class_configurations_and_default_config_set_by_class_configurations
+	  assert_equal(
+    {TaskWithDefaultConfig => [0, :one, :two, :three]},
+	  TaskWithDefaultConfig.configurations.declarations)
+    assert_equal({:one => 1, :two => 2, :three => 3}, TaskWithDefaultConfig.configurations.default)
+  end
 
   def test_task_default_config_set_by_default_config
     t = TaskWithDefaultConfig.new
@@ -54,12 +77,32 @@ class TaskClassTest < Test::Unit::TestCase
     assert_equal "two", t.config[:two]
 	end
 
+  # class ConfigFormats < Tap::Task
+  #   config :a, [:b, 'b']
+  #   config_accessor [:d, 'd'], :e
+  # end
+  # 
+  # def test_config_formats_create_configs_as_expected
+  #   assert_equal({:a => nil, :b => 'b', :d => 'd', :e => nil}, ConfigFormats.configurations.hash)
+  #   
+  #     t = ConfigFormats.new
+  #     assert !t.respond_to?(:a)
+  #     assert !t.respond_to?(:b)
+  #     assert t.respond_to?(:d)
+  #     assert t.respond_to?(:e)
+  #     assert_nil t.config[:a]
+  #     assert_equal 'b', t.config[:b]
+  #     assert_equal 'd', t.d
+  #     assert_nil t.e
+  # end
+  
 	#
 	# test subclass behavior
 	#
 	
 	class SubclassedTask < TaskWithDefaultConfig
-		set_default_config :one => "one", :four => 4
+		config :one, "one"
+		config :four, 4
 	end
 	
 	def test_config_accessors_are_inherited
@@ -72,10 +115,19 @@ class TaskClassTest < Test::Unit::TestCase
     assert t.respond_to?(:three)
     assert !t.respond_to?("three=")
     
-    assert !t.respond_to?(:four)
-    assert !t.respond_to?("four=")
+    assert t.respond_to?(:four)
+    assert t.respond_to?("four=")
 	end
 	
+	def test_class_configurations_are_inherited_but_can_be_overridden
+	  assert_equal({
+      TaskWithDefaultConfig => [0, :one, :two, :three],
+      SubclassedTask => [1, :four]},
+    SubclassedTask.configurations.declarations)
+    
+    assert_equal({:one => 1, :two => 2, :three => 3}, TaskWithDefaultConfig.configurations.default)
+  end
+  
 	def test_default_configs_are_inherited_but_can_be_overridden
     s = SubclassedTask.new
     assert_equal({:one => "one", :two => 2, :three => 3, :four => 4}, s.config)

data/test/task_execute_test.rb

@@ -3,6 +3,7 @@ require 'tap/task'
 
 class TaskExecuteTest < Test::Unit::TestCase
 	include Tap
+	include TapTestMethods
 	
 	acts_as_tap_test
 	
@@ -165,6 +166,34 @@ class TaskExecuteTest < Test::Unit::TestCase
 			t.results,
 			0 => [ [[nil, nil], [[1,2], 3]], [t, [[1,2], 3]] ])
   end
+    
+  def test_non_iterative_execute_without_inputs
+    was_in_block = false
+    t = NonIterativeTask.new do |task, input|
+      assert_nil input
+      was_in_block = true
+    end
+    
+		t.execute
+		assert was_in_block
+    
+    was_in_block = false
+    t.app.run(t)
+		assert was_in_block
+    
+    was_in_block = false
+    t = NonIterativeTask.new do
+      was_in_block = true
+    end
+    
+		t.execute
+		assert was_in_block
+    
+    was_in_block = false
+    t.app.run(t)
+		assert was_in_block
+  end
+  
   
 	#
 	# non iterative audit tests

data/test/task_test.rb

@@ -3,12 +3,14 @@ require 'tap/task'
 
 # used in documentation test
 class ConfiguredTask < Tap::Task
-  set_default_config :one => 'one', :two => 'two'
+  config :one, 'one'
+  config :two, 'two'
 end
 
 class TaskTest < Test::Unit::TestCase
 	include Tap
 	include Benchmark
+	include TapTestMethods
 	
 	acts_as_tap_test
 	attr_accessor :t
@@ -39,11 +41,18 @@ class TaskTest < Test::Unit::TestCase
     t1.enq 1
     t1.enq 2,3
     t1.app.run
-
     assert_equal([1,2,3], runlist)
 
+    runlist = []
+    t1.iterate = false
+    t1.enq 1
+    t1.enq 2,3
+    t1.app.run
+    assert_equal([[1,2,3]], runlist)
+
     ###
     runlist = []
+    t1 = Task.new {|task, input| runlist << input}
     assert_equal([t1], t1.batch)
     t2 = t1.create_batch_task    
     assert_equal([t1, t2], t1.batch)
@@ -181,7 +190,7 @@ class TaskTest < Test::Unit::TestCase
 
 	def test_create_batch_task_uses_input_template_and_overrides
 	  t = TaskWithDefaultConfig.new "overriding", :three => 3
-    assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.class.default_config)
+    assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.class.configurations.default)
 	  assert_equal({:two => 'TWO', :three => 'THREE'}, t.config_template)
 	  assert_equal({:one => 'one', :two => 'TWO', :three => 3}, t.config)
 	  
@@ -228,17 +237,6 @@ class TaskTest < Test::Unit::TestCase
 	  assert_equal File.join(t.app['config'], t.name + ".yml"), t.config_file
 	end
 
-	#
-  # multithread test
-  #
-
-  def test_multithread_returns_value_of_multithread
-    t.multithread = false
-    assert !t.multithread?
-    t.multithread = true
-    assert t.multithread?
-  end
-  
   #
   # iterate test
   #
@@ -247,20 +245,33 @@ class TaskTest < Test::Unit::TestCase
     assert Task.iterative
     assert t.iterate?
   end
-  
-  def test_iterate_can_be_set
-    t.iterate = false
-    assert !t.iterate?
-    t.iterate = true
-    assert t.iterate?
-  end
 	
 	#
-	# configuration tests
+	# config tests
 	#
 	
+  class ConfigDocSampleTask < Tap::Task
+    config :key, 'value'
+    
+    config_reader
+    config :reader_only
+  end
+
+	def test_config_doc
+    t = ConfigDocSampleTask.new
+    assert t.respond_to?(:reader_only)
+    assert !t.respond_to?(:reader_only=)
+  
+    assert_equal({:key => 'value', :reader_only => nil}, t.config)
+    assert_equal 'value', t.key  
+    t.key = 'another'
+    assert_equal({:key => 'another', :reader_only => nil}, t.config)
+	end
+	
 	class TaskWithDefaultConfig < Task
-		set_default_config :one => 'one', :two => 'two', :three => 'three'
+		config :one, 'one'
+    config :two, 'two'
+    config :three, 'three'
 	end
 	
 	def test_config_sets_config
@@ -271,7 +282,7 @@ class TaskTest < Test::Unit::TestCase
 	
 	def test_config_merges_class_defaults_and_config_template_and_inputs_in_order
 	  t = TaskWithDefaultConfig.new "overriding"
-	  assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.class.default_config)
+	  assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.class.configurations.default)
 	  assert_equal({:two => 'TWO', :three => 'THREE'}, t.config_template)
 	  
 	  t.config = {:three => 3}
@@ -280,7 +291,7 @@ class TaskTest < Test::Unit::TestCase
 	
 	def test_nil_is_treated_as_empty_hash
 	  t = TaskWithDefaultConfig.new "overriding"
-	  assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.class.default_config)
+	  assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.class.configurations.default)
 	  assert_equal({:two => 'TWO', :three => 'THREE'}, t.config_template)
 	  
 	  t.config[:three] = 3
@@ -290,54 +301,61 @@ class TaskTest < Test::Unit::TestCase
 	  assert_equal({:one => 'one', :two => 'TWO', :three => 'THREE'}, t.config)
 	end
 	
-	#
-	# condition block test
-	#
-	
-	def test_condition_sets_condition_block
-		block = lambda {}
-		t.condition(&block)
-		assert_equal block, t.condition_block
-	end
-	
-	def test_condition_can_only_be_set_once
-		t.condition {}
-		assert_raise(RuntimeError) { t.condition {} }
-		assert_raise(RuntimeError) { t.condition }
-	end
-	
-	#
-	# executable? test
-	#
-	
-	def test_executable_evaluates_condition_block_with_inputs
-		t.condition do |task, inputs|
-			inputs == [1,2,3]
-		end
+	class TaskWithManyConfigs < Task
+		config :one, 'one'
 		
-		assert t.executable?([1,2,3])
-		assert !t.executable?(1)
+		declare_config
+    config :two, 'two'
+    
+    config_reader
+    config :three, 'three'
+    
+    config_writer
+    config :four, 'four'
+    
+    config_accessor
+    config :five, 'five'
+    
+    declare_config :six
+    config_reader :seven
+    config_writer :eight
+    config_accessor :nine
 	end
-
-	def test_executable_returns_true_if_condition_block_is_nil
-		assert_nil t.condition_block
-		assert t.executable?(nil)
-	end
-	
-	#
-	# on_complete block test
-	#
 	
-	def test_on_complete_sets_on_complete_block
-		block = lambda {}
-		t.on_complete(&block)
-		assert_equal block, t.on_complete_block
-	end
-	
-	def test_on_complete_can_only_be_set_once
-		t.on_complete {}
-		assert_raise(RuntimeError) { t.on_complete {} }
-		assert_raise(RuntimeError) { t.on_complete }
+	def test_config_with_many_configs
+	  t = TaskWithManyConfigs.new
+	  
+	  assert_equal({
+	    :one => 'one',     :six => nil, 
+	    :two => 'two',     :seven => nil,
+	    :three => 'three', :eight => nil,
+	    :four => 'four',   :nine => nil,
+	    :five => 'five'},
+	  t.config)
+	  
+	  # readers only
+	  [:three, :seven].each do |config|
+	    assert t.respond_to?(config)
+	    assert !t.respond_to?("#{config}=")
+	  end
+	  
+	  # writers only
+	  [:four, :eight].each do |config|
+	    assert !t.respond_to?(config)
+	    assert t.respond_to?("#{config}=")
+	  end
+
+	  # both
+	  [:one, :five, :nine].each do |config|
+	    assert t.respond_to?(config)
+	    assert t.respond_to?("#{config}=")
+	  end
+	  
+	  # neither
+	  [:two, :six].each do |config|
+	    assert !t.respond_to?(config)
+	    assert !t.respond_to?("#{config}=")
+	  end
 	end
 	
 	#
@@ -392,6 +410,7 @@ class TaskTest < Test::Unit::TestCase
 	  assert was_in_block
 	end
 	
+	# JRuby inconsistent test?
 	def test_duplicate_tasks_are_monitored_separately
 	  extended_test do
 	    count = 0