tap 0.8.0 → 0.9.0

data/test/task_test.rb

@@ -6,25 +6,42 @@ class ConfiguredTask < Tap::Task
   config :one, 'one'
   config :two, 'two'
 end
+class ValidatingTask < Tap::Task
+  config :string, 'str', &c.check(String)
+  config :integer, 1, &c.yaml(Integer)
+end 
+
+class SubclassTask < Tap::Task
+  attr_accessor :shared_variable, :instance_specific_variable
+  def initialize(*args)
+    @shared_variable = Object.new
+    super
+  end
+
+  def initialize_batch_obj(*args)
+    task = super
+    task.instance_specific_variable = Object.new
+    task
+  end
+end
 
 class TaskTest < Test::Unit::TestCase
-	include Tap
-	include Benchmark
-	include TapTestMethods
-	
-	acts_as_tap_test
-	attr_accessor :t
-	
-	def setup
-		super
-		@t = Task.new
-	end
-	
+  include Tap
+  include TapTestMethods
+  
+  acts_as_tap_test
+  attr_accessor :t
+  
+  def setup
+    super
+    @t = Task.new
+    app.root = trs.root
+  end
+  
   def test_documentation
     t = ConfiguredTask.new
-    assert_equal({:one => 'one', :two => 'two'}, t.config)           
     assert_equal("configured_task", t.name)
-    assert_equal(File.join(app[:config], "configured_task.yml"), t.config_file)
+    assert_equal({:one => 'one', :two => 'two'}, t.config)           
 
     ###
     # [/path/to/app/config/example.yml]
@@ -35,34 +52,13 @@ class TaskTest < Test::Unit::TestCase
     assert_equal(File.join(app[:config], "example.yml"), t.config_file)
     assert_equal({:one => 'ONE', :two => 'two', :three => 'three'}, t.config)
 
-    ###
-    runlist = []
-    t1 = Task.new {|task, input| runlist << input}
-    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)
-
-    t1.enq 1
-    t2.enq 2,3
-    t1.app.run
-
-    assert_equal([1,2,3, 1,2,3], runlist)        
-
+    t = ValidatingTask.new
+    assert_raise(Support::Validation::ValidationError) { t.string = 1 }
+    assert_raise(Support::Validation::ValidationError) { t.integer = 1.1 }
+  
+    t.integer = "1"
+    assert_equal 1, t.integer
+    
     ####
     # [/path/to/app/config/batch.yml]
     # - one: ONE
@@ -73,371 +69,252 @@ class TaskTest < Test::Unit::TestCase
     t1, t2 = t.batch
 
     assert_equal("batch", t1.name)           
-    assert_equal({:one => 'ONE'}, t1.config_template)   
     assert_equal({:one => 'ONE', :two => 'two'}, t1.config)            
 
     assert_equal("batch", t2.name)              
-    assert_equal({:one => 'ANOTHER ONE'}, t2.config_template)  
-    assert_equal({:one => 'ANOTHER ONE', :two => 'two'}, t2.config)            
-
-
-    ####
-    # [/path/to/app/config/template.yml]
-    # one: ONE
-    # variations!:
-    #   - two: TWO
-    #   - three: THREE
+    assert_equal({:one => 'ANOTHER ONE', :two => 'two'}, t2.config)
+    
+    ###
+    runlist = []
+    t1 = Task.new {|task, input| runlist << input}
+    assert_equal [t1], t1.batch
+  
+    t2 = t1.initialize_batch_obj            
+    assert_equal [t1, t2], t1.batch
+    assert_equal [t1, t2], t2.batch      
+    
+    t1.enq 1
+    t2.enq 2
+    t1.app.run
+    
+    assert_equal [1,1,2,2], runlist
+  end
+  
+  #
+  # initialization tests
+  #
 
-    t = ConfiguredTask.new "template"
-    assert_equal(2, t.batch.size) 
-    t1, t2 = t.batch
 
-    assert_equal({:one => 'ONE', :two => 'TWO'}, t1.config)            
-    assert_equal({:one => 'ONE', :two => 'two', :three => 'THREE'}, t2.config)
+  def test_initialize_documenation
+    t1 = SubclassTask.new
+    t2 = t1.initialize_batch_obj
+    
+    assert t1.shared_variable == t2.shared_variable
+    assert t1.instance_specific_variable != t2.instance_specific_variable
   end
   
-	#
-	# initialization tests
-	#
-	
-	def test_default_task_initialization
-		assert_equal App.instance, t.app
-		assert_equal [], t.results
-		assert_equal({}, t.config)
-		assert_equal({}, t.config_template)
-		assert_equal [t], t.batch
-		assert_nil t.condition_block
-		assert_nil t.task_block
-		assert_nil t.on_complete_block
-		assert !t.multithread
-		assert t.iterate
-		assert_equal "tap/task", t.name
-	end
+  def test_default_initialization
+    assert_equal App.instance, t.app
+    assert_equal({}, t.config)
+    assert_equal [t], t.batch
+    assert_nil t.task_block
+    assert_equal "tap/task", t.name
+  end
+  
+  def test_initialization_inputs
+    a = App.new
+    b = lambda {}
+    
+    t = Task.new("name", {:key => 'value'}, a, &b) 
+    assert_equal "name", t.name
+    assert_equal({:key => 'value'}, t.config)
+    assert_equal a, t.app
+    assert_equal b, t.task_block
+  end
 
   def test_task_init_speed
-    benchmark_test do |x|
-			x.report("10k") { 10000.times { Task.new } }
+    benchmark_test(20) do |x|
+      x.report("10k") { 10000.times { Task.new } }
+      x.report("10k {}") { 10000.times { Task.new {} } }
+      x.report("10k name {}") { 10000.times { Task.new('name') {} } }
     end
   end
 
-	def test_by_default_tasks_share_application_instance
-		t1 = Task.new
-		t2 = Task.new
-		
-		assert_equal t1.app, t2.app
-		assert_equal App.instance, t1.app
-	end
-	
-  class NamedTask < Task
+  def test_by_default_tasks_share_application_instance
+    t1 = Task.new
+    t2 = Task.new
+    
+    assert_equal t1.app, t2.app
+    assert_equal App.instance, t1.app
   end
   
-	def test_name_is_initialized_to_task_class_underscored
-	  t = NamedTask.new
-	  assert_equal "task_test/named_task", t.name
-	end
-	
-	def test_name_configs_app_and_task_block_are_set_from_initialize
-	  a = App.new
-	  b = lambda {}
-	  
-	  t = Task.new("name", {:key => 'value'}, a, &b) 
-	  assert_equal "name", t.name
-	  assert_equal({:key => 'value'}, t.config)
-	  assert_equal a, t.app
-	  assert_equal b, t.task_block
-	end
-	
-	def test_config_template_is_loaded_from_config_file
-	  t = Task.new "configured"
-	  assert File.exists?(t.config_file)
-	  assert_equal "key: value", File.read(t.config_file)
-	  assert_equal({:key => 'value'}, t.config_template)
-	end
-	
-	def test_batched_tasks_are_defined_with_corresponding_config_template_for_batched_config_files
-	  t = Task.new "batched"
-	  assert File.exists?(t.config_file)
-	  assert_equal "- key: first\n- key: second", File.read(t.config_file)
-	  
-	  assert_equal 2, t.batch.size
-	  
-	  t1, t2 = t.batch
-	  assert_equal({:key => 'first'}, t1.config_template)
-	  assert_equal({:key => 'second'}, t2.config_template)
-	end
-	
-	def test_configs_are_merged_to_each_batched_task
-	  t = Task.new "batched", :another => 'value'
-	  t1, t2 = t.batch
-	  assert_equal({:key => 'first', :another => 'value'}, t1.config)
-	  assert_equal({:key => 'second', :another => 'value'}, t2.config)
-	end
-	
-	#
-	# create_batch_task test
-	#
-	
-	def test_created_batch_tasks_are_added_to_and_share_the_same_batch
-	  assert_equal [t], t.batch
-	  
-	  t1 = t.create_batch_task
-	  t2 = t1.create_batch_task
-	  
-	  assert_equal [t, t1, t2], t.batch
-	  assert_equal t.batch.object_id, t1.batch.object_id
-	  assert_equal t.batch.object_id, t2.batch.object_id
-	end
-
-	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.configurations.default)
-	  assert_equal({:two => 'TWO', :three => 'THREE'}, t.config_template)
-	  assert_equal({:one => 'one', :two => 'TWO', :three => 3}, t.config)
-	  
-	  t1 = t.create_batch_task
-	  assert_equal({}, t1.config_template)  
-	  assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t1.config)  
+  #
+  # config tests
+  #
+  
+  def test_config_is_loaded_from_config_file
+    t = Task.new "configured"
+    assert File.exists?(t.config_file)
+    assert_equal "key: value", File.read(t.config_file)
+    assert_equal({:key => 'value'}, t.config)
+  end
+  
+  def test_batched_tasks_are_defined_with_corresponding_configs_for_batched_config_files
+    t = Task.new "batched"
+    assert File.exists?(t.config_file)
+    assert_equal "- key: first\n- key: second", File.read(t.config_file)
+    
+    assert_equal 2, t.batch.size
+    
+    t1, t2 = t.batch
+    assert_equal({:key => 'first'}, t1.config)
+    assert_equal({:key => 'second'}, t2.config)
+  end
+  
+  def test_configs_are_merged_to_each_batched_task
+    t = Task.new "batched", :another => 'value'
+    t1, t2 = t.batch
+    assert_equal({:key => 'first', :another => 'value'}, t1.config)
+    assert_equal({:key => 'second', :another => 'value'}, t2.config)
+  end
   
-	  t2 = t.create_batch_task({:two => "TWO", :three => "THREE"}, {:three => 3})
-	  assert_equal({:two => "TWO", :three => "THREE"}, t2.config_template)  
-	  assert_equal({:one => 'one', :two => 'TWO', :three => 3}, t2.config)
-	end
-
-	#
-	# batched? test
-	#
-	
-	def test_batched_returns_true_if_batch_size_is_greater_than_one
-	  assert !t.batched?
-	  assert_equal 1, t.batch.size
-	  
-	  t1 = t.create_batch_task
-	  
-	  assert t.batched?
-	  assert t1.batched?
-	end
-	
-	#
-	# batch_index test
-	#
-	
-	def test_batch_index_returns_the_index_of_the_task_in_batch
-	  t1 = t.create_batch_task
-	  
-	  assert_equal [t, t1], t.batch
-	  assert_equal 0, t.batch_index
-	  assert_equal 1, t1.batch_index
-	end
-	
-	#
-	# config_file test
-	#
-	
-	def test_config_file_returns_yml_filepath_for_name_relative_to_app_config_dir
-	  assert_equal File.join(t.app['config'], t.name + ".yml"), t.config_file
-	end
-
   #
-  # iterate test
+  # enq test
   #
+  
+  def test_enq_enqueues_task_to_app_queue_with_inputs
+    assert t.app.queue.empty?
+    
+    t.enq 1
+    
+    assert_equal 1, t.app.queue.size
+    assert_equal [[t, [1]]], t.app.queue.to_a
+    
+    t.enq 1
+    t.enq 2
+    
+    assert_equal [[t, [1]], [t, [1]], [t, [2]]], t.app.queue.to_a
+  end
 
-  def test_iterate_defaults_to_class_iterative_variable
-    assert Task.iterative
-    assert t.iterate?
+  def test_enq_enqueues_task_batch
+    t2 = t.initialize_batch_obj
+    
+    assert t.app.queue.empty?
+    assert_equal 2, t.batch.size
+    
+    t.enq 1
+    
+    assert_equal 2, t.app.queue.size
+    assert_equal [[t, [1]], [t2, [1]]], t.app.queue.to_a
   end
-	
-	#
-	# config tests
-	#
-	
-  class ConfigDocSampleTask < Tap::Task
-    config :key, 'value'
+  
+  def test_unbatched_enq_only_enqueues_task
+    t2 = t.initialize_batch_obj
     
-    config_reader
-    config :reader_only
+    assert_equal 2, t.batch.size
+    assert t.app.queue.empty?
+    t.unbatched_enq 1
+    
+    assert_equal 1, t.app.queue.size
+    assert_equal [[t, [1]]], t.app.queue.to_a
   end
+  
+  #
+  # on_complete test
+  #
+  
+  def test_on_complete_completes_task_batch
+    t2 = t.initialize_batch_obj
+    
+    assert_nil t.on_complete_block
+    assert_nil t2.on_complete_block
+
+    b = lambda {}
+    t.on_complete(&b)
+    
+    assert_equal b, t.on_complete_block
+    assert_equal b, t2.on_complete_block
+  end
+  
+  def test_unbatched_on_complete_only_completes_task
+    t2 = t.initialize_batch_obj
+    
+    assert_nil t.on_complete_block
+    assert_nil t2.on_complete_block
 
-	def test_config_doc
-    t = ConfigDocSampleTask.new
-    assert t.respond_to?(:reader_only)
-    assert !t.respond_to?(:reader_only=)
+    b = lambda {}
+    t.unbatched_on_complete(&b)
+    
+    assert_equal b, t.on_complete_block
+    assert_nil t2.on_complete_block
+  end
+  
+  #
+  # multithread= test
+  #
   
-    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
-		config :one, 'one'
-    config :two, 'two'
-    config :three, 'three'
-	end
-	
-	def test_config_sets_config
-	  assert_equal({}, t.config)
-	  t.config = {:key => 'value'}
-	  assert_equal({:key => 'value'}, t.config)
-	end
-	
-	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.configurations.default)
-	  assert_equal({:two => 'TWO', :three => 'THREE'}, t.config_template)
-	  
-	  t.config = {:three => 3}
-	  assert_equal({:one => 'one', :two => 'TWO', :three => 3}, t.config)
-	end
-	
-	def test_nil_is_treated_as_empty_hash
-	  t = TaskWithDefaultConfig.new "overriding"
-	  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
-	  assert_equal({:one => 'one', :two => 'TWO', :three => 3}, t.config)
-	  
-	  t.config = nil
-	  assert_equal({:one => 'one', :two => 'TWO', :three => 'THREE'}, t.config)
-	end
-	
-	class TaskWithManyConfigs < Task
-		config :one, 'one'
-		
-		declare_config
-    config :two, 'two'
+  def test_set_multithread_sets_multithread_for_task_batch
+    t2 = t.initialize_batch_obj
     
-    config_reader
-    config :three, 'three'
+    assert !t.multithread
+    assert !t2.multithread
+
+    t.multithread = true
     
-    config_writer
-    config :four, 'four'
+    assert t.multithread
+    assert t2.multithread
+  end
+  
+  def test_unbatched_set_multithread_sets_multithread_for_task_only
+    t2 = t.initialize_batch_obj
     
-    config_accessor
-    config :five, 'five'
+    assert !t.multithread
+    assert !t2.multithread
+
+    t.unbatched_multithread = true
     
-    declare_config :six
-    config_reader :seven
-    config_writer :eight
-    config_accessor :nine
-	end
-	
-	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
+    assert t.multithread
+    assert !t2.multithread
+  end
+  
+  #
+  # to_s test
+  #
+  
+  def test_to_s_returns_name
+    assert_equal t.name, t.to_s
+    t = Task.new("alt_name")
+    assert_equal "alt_name", t.to_s
+  end
+  
+  #
+  # process test
+  #
+  
+  class TaskWithTwoInputsForProcessDoc < Tap::Task
+    def process(a, b)
+      [b,a]
+    end
+  end
+  
+  def test_process_documentation
+    t = TaskWithTwoInputsForProcessDoc.new
+    t.enq(1,2).enq(3,4)
+    t.app.run
+    assert_equal [[2,1], [4,3]], t.app.results(t)
+
+    t = Task.new {|task, a, b| [b,a] }
+    t.enq(1,2).enq(3,4)
+    t.app.run
+    assert_equal [[2,1], [4,3]], t.app.results(t)
+  end
+  
+  def test_process_calls_task_block_with_input
+    b = lambda do |task, input|
+      runlist << input
+      input += 1
+    end
+    t = Task.new(&b)
+  
+    assert_equal b, t.task_block
+    assert_equal 2, t.process(1)
+    assert_equal [1], runlist
+  end
+  
+  def test_process_returns_inputs_if_task_block_is_not_set
+    t = Task.new
+    assert_nil t.task_block
+    assert_equal [1,2,3], t.process(1,2,3)
+  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
-	
-	#
-	# queue test
-	#
-	
-	def test_queue_enqueues_task_to_app_queue_with_inputs
-	  assert t.app.queue.empty?
-	  
-	  t.enq 1
-	  
-	  assert_equal 1, t.app.queue.size
-	  assert_equal [t, [1]], t.app.queue.deq
-	  
-	  t.enq 1
-	  t.enq 2
-	  
-	  assert_equal [t, [1,2]], t.app.queue.deq
-	end
-	
-	#
-	# process test
-	#
-	
-	def test_process_calls_task_block_with_input
-	  b = lambda do |task, input|
-	    runlist << input
-	    input += 1
-	  end
-	  t = Task.new(&b)
-	  
-	  assert_equal b, t.task_block
-	  assert_equal 2, t.process(1)
-	  assert_equal [1], runlist
-	end
-	
-	def test_process_returns_input_if_task_block_is_not_set
-	  t = Task.new
-	  
-	  assert_nil t.task_block
-	  assert_equal 1, t.process(1)
-	end
-	
-	#
-	# synchronize tests
-	#
-	
-	def test_tasks_publically_respond_to_synchronize
-	  assert t.respond_to?(:synchronize)
-	  was_in_block = false
-	  t.synchronize { was_in_block = true }
-	  assert was_in_block
-	end
-	
-	# JRuby inconsistent test?
-	def test_duplicate_tasks_are_monitored_separately
-	  extended_test do
-	    count = 0
-	    max_count = 0
-	    
-	    t1 = Task.new do |task, inputs|
-	      task.synchronize do
-	        count += 1
-	        
-	        # max count will be 2 if both tasks execute
-	        # simultaneously (ie they are monitored 
-	        # separately)
-	        max_count = count if count > max_count
-	        sleep 0.1
-	        count -= 1
-	      end
-	    end
-	    t2 = t1.dup
-	    
-	    th_1 = Thread.new { t1.execute nil }
-	    th_2 = Thread.new { t2.execute nil }
-	    
-	    th_1.join
-	    th_2.join
-	    
-	    assert_equal 0, count
-	    assert_equal 2, max_count
-	  end
-	end
 end