tap 0.7.9

data/test/support/versions_test.rb

@@ -0,0 +1,71 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/versions'
+
+class VersionTest < Test::Unit::TestCase
+	include Tap::Support::Versions
+
+  def test_documentation
+    assert_equal "path/to/file-1.0.txt", version("path/to/file.txt", 1.0)  
+    assert_equal "path/to/file-1.0.1.txt", increment("path/to/file-1.0.txt", "0.0.1")  
+    assert_equal "path/to/file-1.0.txt", increment("path/to/file.txt", 1.0)  
+    assert_equal ["path/to/file.txt", "1.0"], deversion("path/to/file-1.0.txt")  
+    assert_equal ["path/to/file.txt", nil], deversion("path/to/file.txt")
+  end
+
+  #
+  # version tests
+  #
+  
+	def test_version_accepts_string_or_numeric_versions
+		assert_equal "path/to/file-1.1.txt", version("path/to/file.txt", "1.1")
+		assert_equal "path/to/file-1.1.txt", version("path/to/file.txt", 1.1)
+		
+		assert_equal "path/to/file-1.1", version("path/to/file", "1.1")
+	end
+  
+  def test_version_defaults_to_filepath_when_no_version_is_specified
+		assert_equal "path/to/file.txt", version("path/to/file.txt", "")
+		assert_equal "path/to/file.txt", version("path/to/file.txt", "  ")
+		assert_equal "path/to/file.txt", version("path/to/file.txt", nil)
+		
+		assert_equal "path/to/file", version("path/to/file", "")
+	end
+  
+  #
+  # deversion tests
+  #
+
+	def test_deversion_returns_filepath_and_version
+		assert_equal ["path/to/file.txt", "1.1"], deversion("path/to/file-1.1.txt")
+		assert_equal ["path/to/file", "1.1"], deversion("path/to/file-1.1")
+	end
+  
+  def test_deversion_returns_nil_for_version_when_no_version_is_specified
+		assert_equal ["path/to/file.txt", nil], deversion("path/to/file.txt")
+		assert_equal ["path/to/file", nil], deversion("path/to/file")
+	end
+	
+	#
+  # increment tests
+  #
+
+	def test_increment_adds_increment_to_current_version
+		assert_equal "path/to/file-1.0.1.txt", increment("path/to/file-1.0.txt", "0.0.1")
+		assert_equal "path/to/file-2.1.txt", increment("path/to/file-1.0.txt", 1.1)
+		assert_equal "path/to/file-2.0.txt", increment("path/to/file-1.0.txt", 1)
+		assert_equal "path/to/file-1.1.txt", increment("path/to/file.txt", 1.1)
+		
+		assert_equal "path/to/file-1.0.1", increment("path/to/file-1.0", "0.0.1")
+		assert_equal "path/to/file-2.1", increment("path/to/file-1.0", 1.1)
+		assert_equal "path/to/file-2.0", increment("path/to/file-1.0", 1)
+		assert_equal "path/to/file-1.1", increment("path/to/file", 1.1)
+	end
+  
+  def test_increment_adds_zero_if_increment_is_nil
+    assert_equal "path/to/file-1.0.txt", increment("path/to/file-1.0.txt", nil)
+		assert_equal "path/to/file.txt", increment("path/to/file.txt", nil)
+		
+		assert_equal "path/to/file-1.0", increment("path/to/file-1.0", nil)
+		assert_equal "path/to/file", increment("path/to/file", nil)
+	end
+end

data/test/tap_test_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+
+require File.dirname(__FILE__) + '/../lib/tap'
+require 'tap/test'

data/test/tap_test_suite.rb

@@ -0,0 +1,4 @@
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+ENV["ALL"] = 'true'
+Dir.glob("./**/*_test.rb").each {|test| require test}

data/test/task/config/batch.yml

@@ -0,0 +1,2 @@
+- one: ONE
+- one: ANOTHER ONE

data/test/task/config/batched.yml

@@ -0,0 +1,2 @@
+- key: first
+- key: second

data/test/task/config/configured.yml

@@ -0,0 +1 @@
+key: value

data/test/task/config/example.yml

@@ -0,0 +1 @@
+one: ONE

data/test/task/config/overriding.yml

@@ -0,0 +1,2 @@
+two: TWO
+three: THREE

data/test/task/config/task_with_config.yml

@@ -0,0 +1 @@
+config: value

data/test/task/config/template.yml

@@ -0,0 +1,4 @@
+one: ONE
+variations!:
+  - two: TWO
+  - three: THREE

data/test/task_class_test.rb

@@ -0,0 +1,118 @@
+require  File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/task'
+
+class TaskClassTest < Test::Unit::TestCase
+
+	#
+	# task config tests
+	#
+	
+	class TaskWithDefaultConfig < Tap::Task
+		set_default_config :one => 1, :two => 2, :three => 3
+    config_accessor :one
+    config_writer :two
+    config_reader :three
+	end
+
+  def test_task_default_config_set_by_default_config
+    t = TaskWithDefaultConfig.new
+    assert_equal({:one => 1, :two => 2, :three => 3}, t.config)
+    
+    t = TaskWithDefaultConfig.new nil, :one => "one"
+    assert_equal({:one => "one", :two => 2, :three => 3}, t.config)
+  end
+  
+	def test_config_reader_and_writer_defined_by_config_accessor
+		t = TaskWithDefaultConfig.new
+		assert t.respond_to?(:one)
+    assert t.respond_to?("one=")
+
+    assert_equal 1, t.one
+    assert_equal 1, t.config[:one]
+    
+    t.one = "one"
+    assert_equal "one", t.one
+    assert_equal "one", t.config[:one]
+	end
+  
+  def test_config_reader_defined_by_config_reader
+		t = TaskWithDefaultConfig.new
+		assert t.respond_to?(:three)
+    assert !t.respond_to?("three=")
+
+    assert_equal 3, t.three
+    assert_equal 3, t.config[:three]
+	end
+  
+  def test_config_writer_defined_by_config_writer
+		t = TaskWithDefaultConfig.new
+		assert !t.respond_to?(:two)
+    assert t.respond_to?("two=")
+    
+    assert_equal 2, t.config[:two]
+    t.two = "two"
+    assert_equal "two", t.config[:two]
+	end
+
+	#
+	# test subclass behavior
+	#
+	
+	class SubclassedTask < TaskWithDefaultConfig
+		set_default_config :one => "one", :four => 4
+	end
+	
+	def test_config_accessors_are_inherited
+		t = SubclassedTask.new
+    
+		assert t.respond_to?(:one)
+    assert t.respond_to?("one=")
+    assert !t.respond_to?(:two)
+    assert t.respond_to?("two=")
+    assert t.respond_to?(:three)
+    assert !t.respond_to?("three=")
+    
+    assert !t.respond_to?(:four)
+    assert !t.respond_to?("four=")
+	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)
+    
+    # assure subclass configs do not affect superclass
+    t = TaskWithDefaultConfig.new
+    assert_equal({:one => 1, :two => 2, :three => 3}, t.config)
+  end
+
+  #
+  # iterative tests
+  #
+  
+  def test_iterative_is_by_default_true
+    assert Tap::Task.iterative
+  end
+  
+  class NonIterativeTask < Tap::Task
+		do_not_iterate
+	end
+  
+  def test_do_not_iterate_sets_iterative_to_false
+    assert !NonIterativeTask.iterative
+  end
+  
+  class AnotherNonIterativeTask < NonIterativeTask
+	end
+  
+  def test_iterative_is_inherited
+    assert !AnotherNonIterativeTask.iterative
+  end
+  
+  class IterativeTask < NonIterativeTask
+    iterate
+	end
+	
+  def test_iterative_can_be_reset_with_iterate
+    assert IterativeTask.iterative
+  end
+end

data/test/task_execute_test.rb

@@ -0,0 +1,233 @@
+require  File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/task'
+
+class TaskExecuteTest < Test::Unit::TestCase
+	include Tap
+	
+	acts_as_tap_test
+	
+	attr_accessor :t1, :t2, :t3, :t4
+	
+	def setup
+		super
+		1.upto(4) do |index|
+			var = "t#{index}".to_sym
+			self.send("#{var}=", Task.new(&echo))
+		end
+	end
+
+  #
+  # check t1-t4 are iterative
+  #
+
+  def test_t1_to_t4_tasks_are_iterative
+    assert t1.iterate?
+    assert t2.iterate?
+    assert t3.iterate?
+    assert t4.iterate?
+  end
+
+  #
+  # condition and on_complete tests
+  #
+  
+	def test_execute_raises_error_unless_condtion_block_returns_true
+	  t = Task.new
+		t.condition {false}
+		assert_raise(RuntimeError) { t.execute }
+	end
+	
+	def test_on_complete_executes_after_execute_and_recieves_results
+		t = Task.new
+		
+		recieved = nil
+		t.on_complete do |results|
+			recieved = results
+		end
+		
+		t.execute(1,2,3)
+	
+		assert_equal t.results, recieved
+	end
+
+	#
+	# iterative execute tests
+	#
+    
+  def test_execute_without_inputs_produces_empty_results
+	  t1.execute
+	    
+	  assert_equal [], runlist
+	  assert_equal [], t1.results
+	end
+
+	def test_execute_iteratively_processes_and_audits_each_input
+		t1.execute([1,2], 3)
+
+		assert_equal [[1,2], 3], runlist
+		assert_inputs(t1 => [[1,2], 3])
+		assert_outputs(t1 => [[1,2], 3])
+		assert_audits( 
+			t1.results,
+			0 => [[nil, [1,2]], [t1, [1,2]]],
+			1 => [[nil, 3], [t1, 3]])
+  end
+
+	#
+	# iterative audit tests
+	#
+	
+	def test_each_result_is_an_audit
+		t1.execute 1,2
+			
+		t1.results.each do |r|
+			assert r.kind_of?(Support::Audit)
+		end
+	end
+	
+	def test_execute_passes_audit_trails
+		t1.execute 1,2
+		t2.execute(*t1.results)
+		t3.execute(*t2.results)
+			
+		assert_outputs(
+			t1 => [1,2],
+			t2 => [1,2],
+			t3 => [1,2])
+		assert_audits(
+			t3.results,
+			0 => [[nil, 1],[t1, 1],[t2, 1],[t3, 1]],
+			1 => [[nil, 2],[t1, 2],[t2, 2],[t3, 2]])
+	end
+	
+	def test_execute_audits_additional_inputs
+		t1.execute 1,2
+		t2.execute(*(t1.results + [3])) 
+		t3.execute(*(t2.results + [4]))
+			
+		assert_outputs(
+			t1 => [1,2],
+			t2 => [1,2,3],
+			t3 => [1,2,3,4])
+		assert_audits(
+			t3.results,
+			0 => [[nil, 1], [t1, 1],[t2, 1],[t3, 1]],
+			1 => [[nil, 2], [t1, 2],[t2, 2],[t3, 2]],
+			2 => [[nil, 3], [t2, 3],[t3, 3]],
+			3 => [[nil, 4], [t3, 4]])
+      
+    check_audit(t3.results[0]) do
+      1._from nil
+      1._from t1
+      1._from t2
+      1._from t3
+    end
+	end
+	
+	class NonIterativeTask < Task
+    do_not_iterate
+  end
+
+  #
+  # check NonIterativeTask is set to not iterate
+  #
+
+  def test_do_not_iterate
+    assert !NonIterativeTask.iterative
+    t = NonIterativeTask.new
+    assert !t.iterate?
+  end
+
+	#
+	# non iterative execute tests
+	#
+
+  def test_non_iterative_execute_processes_inputs_as_one_input	
+    t = NonIterativeTask.new(&echo)
+		t.execute(1,2,3)
+
+		assert_equal [[1,2,3]], runlist
+		assert_inputs(t => [[1,2,3]])
+		assert_outputs(t => [[1,2,3]])
+		assert_audits( 
+			t.results,
+			0 => [ [[nil, nil, nil], [1,2,3]], [t, [1,2,3]] ])
+  end
+  
+	def test_non_iterative_execute_respects_array_inputs	
+	  t = NonIterativeTask.new(&echo)
+		t.execute([1,2], 3)
+
+		assert_equal [[[1,2], 3]], runlist
+		assert_inputs(t => [[[1,2], 3]])
+		assert_outputs(t => [[[1,2], 3]])
+		assert_audits( 
+			t.results,
+			0 => [ [[nil, nil], [[1,2], 3]], [t, [[1,2], 3]] ])
+  end
+  
+	#
+	# non iterative audit tests
+	#
+
+	def test_non_iterative_execute_audits_inputs_as_one_unit
+	  t = NonIterativeTask.new(&echo)
+		t.execute 1,2
+
+		assert_outputs(t => [[1,2]])
+		assert_audits(
+			t.results,
+			0 => [
+			  [[nil, nil], [1,2]], # original source
+			  [t, [1,2]]]          # final value
+			  )
+	end
+
+	def test_non_iterative_execute_audits_additional_inputs_as_one_unit
+	  t1 = NonIterativeTask.new(&echo)
+	  t2 = NonIterativeTask.new(&echo)
+	  
+		t1.execute 1,2
+		assert_outputs(t1 => [[1,2]])
+		
+		t2.execute(t1.results.first, 3) 
+			
+		assert_outputs(
+			t2 => [ [[1,2],3] ])
+		assert_audits(
+			t2.results,
+			0 => [ 
+			  [[[[nil, nil], t1], nil], [[1, 2], 3]], # original source
+			  [t2, [[1, 2], 3]]]                      # final value source
+			  )
+
+    check_audit(t2.results[0]) do
+      [[1,2], 3]._from(t2) {
+        [1,2]._from(t1) {
+          1._from nil 
+          2._from nil }
+        3._from nil }
+    end
+	end
+	
+	
+	#
+	# synchronization tests
+	#
+	
+	def test_execute_is_synchronized
+		extended_test do
+			count = 0
+			counter = Task.new do 
+				count += 1
+			end
+			
+			t1 = Thread.new { 10000.times { counter.execute(1) } }
+			t2 = Thread.new { 10000.times { counter.execute(1) } }
+			t1.join
+			t2.join
+			
+			assert_equal 20000, count
+		end
+	end
+end