tap 0.7.9

data/test/task_test.rb

@@ -0,0 +1,424 @@
+require  File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/task'
+
+# used in documentation test
+class ConfiguredTask < Tap::Task
+  set_default_config :one => 'one', :two => 'two'
+end
+
+class TaskTest < Test::Unit::TestCase
+	include Tap
+	include Benchmark
+	
+	acts_as_tap_test
+	attr_accessor :t
+	
+	def setup
+		super
+		@t = Task.new
+	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)
+
+    ###
+    # [/path/to/app/config/example.yml]
+    # one: ONE
+
+    t = ConfiguredTask.new "example", :three => 'three'
+    assert_equal("example", t.name)
+    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 = []
+    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)        
+
+    ####
+    # [/path/to/app/config/batch.yml]
+    # - one: ONE
+    # - one: ANOTHER ONE
+
+    t = ConfiguredTask.new "batch"
+    assert_equal(2, t.batch.size)
+    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
+
+    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)
+  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_task_init_speed
+    benchmark_test do |x|
+			x.report("10k") { 10000.times { Task.new } }
+    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
+  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.default_config)
+	  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)  
+  
+	  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
+
+	#
+  # 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_defaults_to_class_iterative_variable
+    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
+	#
+	
+	class TaskWithDefaultConfig < Task
+		set_default_config :one => 'one', :two => 'two', :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.default_config)
+	  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.default_config)
+	  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
+	
+	#
+	# 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
+		
+		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
+	
+	#
+	# 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
+	
+	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

data/test/test/inference_methods/test_assert_expected/expected/file.txt

@@ -0,0 +1 @@
+file

data/test/test/inference_methods/test_assert_expected/expected/folder/file.txt

@@ -0,0 +1 @@
+folder/file

data/test/test/inference_methods/test_assert_expected/input/file.txt

@@ -0,0 +1 @@
+file

data/test/test/inference_methods/test_assert_expected/input/folder/file.txt

@@ -0,0 +1 @@
+folder/file

data/test/test/inference_methods/test_file_compare/expected/output_1.txt

@@ -0,0 +1,3 @@
+some 
+multiline file
+content!

data/test/test/inference_methods/test_file_compare/expected/output_2.txt

@@ -0,0 +1 @@
+different content

data/test/test/inference_methods/test_file_compare/input/input_1.txt

@@ -0,0 +1,3 @@
+some 
+multiline file
+content!