tap 0.8.0 → 0.9.0

data/test/support/validation_test.rb

@@ -0,0 +1,54 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/validation'
+
+class ValidationTest < Test::Unit::TestCase
+  include Tap::Support::Validation
+  
+  #
+  # validate test
+  #
+  
+  def test_validate
+    assert_equal 1, validate(1, Integer)
+    assert_raise(ValidationError) { validate(nil, Integer) }
+    assert_equal 1, validate(1, [Integer, nil])
+    assert_equal nil, validate(nil, [Integer, nil])
+    
+    assert_equal "str", validate("str", /str/)
+    assert_raise(ValidationError) { validate("str", /non/) }
+  end
+  
+  #
+  # check test
+  #
+  
+  def test_check_returns_validation_block
+    m = check(Integer)
+    assert_equal Proc, m.class
+    assert_equal 1, m.call(1)
+    assert_raise(ValidationError) { m.call(nil) }
+  end
+  
+  #
+  # yaml test
+  #
+  
+  def test_yaml_doc
+    b = yaml(Integer, nil)
+    assert_equal Proc, b.class
+    assert_equal 1, b.call(1)
+    assert_equal 1, b.call("1")
+    assert_equal nil, b.call(nil)
+    assert_raise(ValidationError) { b.call("str") }
+  end
+  
+  def test_yaml_block_loads_strings_as_yaml_and_checks_result
+    m = yaml(Integer)
+    assert_equal Proc, m.class
+    assert_equal 1, m.call(1)
+    assert_equal 1, m.call("1")
+    assert_raise(ValidationError) { m.call(nil) }
+    assert_raise(ValidationError) { m.call("str") }
+  end
+  
+end

data/test/support/versions_test.rb

@@ -2,7 +2,7 @@ require  File.join(File.dirname(__FILE__), '../tap_test_helper')
 require 'tap/support/versions'
 
 class VersionTest < Test::Unit::TestCase
-	include Tap::Support::Versions
+  include Tap::Support::Versions
   include Tap::Test::SubsetMethods
 
   def test_documentation
@@ -17,58 +17,58 @@ class VersionTest < Test::Unit::TestCase
   # 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_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
+    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_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
-	
-	#
+    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_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
+    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
   
   #
   # compare versions test

data/test/tap_test_helper.rb

@@ -3,12 +3,26 @@ require 'rubygems'
 require File.dirname(__FILE__) + '/../lib/tap'
 require 'tap/test'
 
+# Apply version-specific patches
+case RUBY_VERSION
+when /^1.9/
+  require 'tap/patches/ruby19/backtrace_filter'
+end
+
+unless defined?(ObjectWithExecute)
+  class ObjectWithExecute
+    def execute(input)
+      input
+    end
+  end
+end
+
 unless defined?(TapTestMethods)
   
   # Some convenience methods used in testing tasks, workflows, app, etc.
   module TapTestMethods # :nodoc:
     attr_accessor  :runlist
-
+    
     # Setup clears the test using clear_tasks and assures that Tap::App.instance 
     # is the test-specific application.
     def setup
@@ -25,12 +39,12 @@ unless defined?(TapTestMethods)
 
     # A tracing procedure.  echo adds input to runlist then returns input.
     def echo
-      lambda do |task, input| 
-        @runlist << input
-        input
+      lambda do |task, *inputs| 
+        @runlist << inputs
+        inputs
       end
     end
-
+    
     # A tracing procedure for numeric inputs.  add_one adds the input to 
     # runlist then returns input + 1.
     def add_one

data/test/tap_test_suite.rb

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

data/test/task_base_test.rb

@@ -2,114 +2,23 @@ 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
-  #
+  include Tap
 
-  def test_multithread_returns_value_of_multithread
-    t.multithread = false
-    assert !t.multithread?
-    t.multithread = true
-    assert t.multithread?
+  attr_accessor :t
+  
+  def setup
+    super
+    @t = ObjectWithExecute.new
+    Tap::Task::Base.initialize(@t, :execute)
   end
   
   #
-  # iterate test
+  # initialize tests
   #
-
-  def test_iterate_can_be_set
-    t.iterate = false
-    assert !t.iterate?
-    t.iterate = true
-    assert t.iterate?
+  
+  def test_initialize
+    assert_equal [t], t.batch
+    assert_equal Tap::App.instance, t.app
   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
+end

data/test/task_syntax_test.rb

@@ -0,0 +1,300 @@
+require  File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/task'
+
+
+class TaskSyntaxTest < Test::Unit::TestCase
+  include Tap
+  include TapTestMethods
+  
+  acts_as_tap_test
+  
+  #
+  # syntax and arity tests
+  #
+
+  class ProcessTestBase < Tap::Task
+    attr_reader :runlist
+
+    def initialize(*args)
+      super
+      @runlist = []
+    end
+  end
+
+  ##
+  class ProcessWithNoInput < Tap::Task
+    attr_reader :was_in_process
+
+    def initialize(*args)
+      super
+      @was_in_process = false
+    end
+
+    def process
+      @was_in_process = true
+    end
+  end
+    
+  def test_process_with_no_input
+    t = ProcessWithNoInput.new
+    assert !t.was_in_process
+    
+    with_options :debug => true do
+      assert_raise(Tap::Support::RunError) do
+        t.enq 1
+        app.run
+      end
+      
+      t.enq
+      app.run
+      assert t.was_in_process
+    end
+  end
+
+  def test_block_with_no_input
+    was_in_block = false
+    t = Tap::Task.new do |task|
+      was_in_block = true
+    end
+
+    with_options :debug => true do
+      assert_raise(Tap::Support::RunError) do
+        t.enq 1
+        app.run
+      end
+      
+      t.enq
+      app.run
+      assert was_in_block
+    end
+  end
+  
+  ##
+  class ProcessWithOneInput < ProcessTestBase
+    def process(input)
+      runlist << input
+    end
+  end
+
+  def test_process_with_one_input
+    t = ProcessWithOneInput.new
+
+    with_options :debug => true do
+      assert_raise(Tap::Support::RunError) do
+        t.enq
+        app.run
+      end
+
+      t.enq 1
+      app.run
+      assert_equal [1], t.runlist
+      
+      assert_raise(Tap::Support::RunError) do
+        t.enq 1, 2, 3
+        app.run
+      end
+    end
+  end
+
+  def test_block_with_one_input
+    runlist = []
+    t = Tap::Task.new do |task, input|
+      runlist << input
+    end
+
+    with_options :debug => true do
+      assert_raise(Tap::Support::RunError) do
+        t.enq
+        app.run
+      end
+      assert_raise(Tap::Support::RunError) do 
+        t.enq 1, 2
+        app.run
+      end
+      
+      t.enq 1
+      app.run
+      assert_equal [1], runlist
+    end
+  end
+  
+  ##
+  class ProcessWithMultipleInputs < ProcessTestBase
+    def process(a, b)
+      runlist << [a,b]
+    end
+  end
+
+  def test_process_with_multiple_inputs
+    t = ProcessWithMultipleInputs.new
+
+    with_options :debug => true do
+      assert_raise(Tap::Support::RunError) do
+        t.enq
+        app.run
+      end
+      assert_raise(Tap::Support::RunError) do 
+        t.enq 1
+        app.run
+      end
+      
+      t.enq 1, 2
+      app.run
+      assert_equal [[1, 2]], t.runlist
+    end
+  end
+  
+  def test_block_with_multiple_inputs
+    runlist = []
+    t = Tap::Task.new do |task, a, b|
+      runlist << [a,b]
+    end
+  
+    with_options :debug => true do
+      assert_raise(Tap::Support::RunError) do
+        t.enq
+        app.run
+      end
+      assert_raise(Tap::Support::RunError) do 
+        t.enq 1
+        app.run
+      end
+      
+      t.enq 1, 2
+      app.run
+      assert_equal [[1, 2]], runlist
+    end
+  end
+  
+  ##
+  class ProcessWithArbitraryInputs < ProcessTestBase
+    def process(*args)
+      runlist << args
+    end
+  end
+
+  def test_process_with_arbitrary_inputs
+    t = ProcessWithArbitraryInputs.new
+  
+    with_options :debug => true do
+      t.enq
+      app.run
+      assert_equal [[]], t.runlist
+    
+      t.enq 1
+      app.run
+      assert_equal [[], [1]], t.runlist
+    
+      t.enq 1, 2, 3
+      app.run
+      assert_equal [[], [1], [1,2,3]], t.runlist
+    end
+  end
+
+  def test_block_with_arbitrary_inputs
+    runlist = []
+    t = Tap::Task.new do |task, *args|
+      runlist << args
+    end
+
+    with_options :debug => true do
+      t.enq
+      app.run
+      assert_equal [[]], runlist
+    
+      t.enq 1
+      app.run
+      assert_equal [[], [1]], runlist
+    
+      t.enq 1, 2, 3
+      app.run
+      assert_equal [[], [1], [1,2,3]], runlist
+    end
+  end
+
+  ##
+  class ProcessWithMixedArbitraryInputs < ProcessTestBase
+    def process(a, b, *args)
+      runlist << [a, b, args]
+    end
+  end
+
+  def test_process_with_mixed_arbitrary_inputs
+    t = ProcessWithMixedArbitraryInputs.new
+    
+    with_options :debug => true do
+      assert_raise(Tap::Support::RunError) do
+        t.enq
+        app.run
+      end
+      assert_raise(Tap::Support::RunError) do 
+        t.enq 1
+        app.run
+      end
+      
+      t.enq 1, 2
+      app.run
+      assert_equal [[1, 2, []]], t.runlist
+      
+      t.enq 1, 2, 3
+      app.run
+      assert_equal [[1, 2, []], [1, 2, [3]]], t.runlist
+    end
+  end
+  
+  def test_block_with_mixed_arbitrary_inputs
+    runlist = []
+    t = Tap::Task.new do |task, a, b, *args|
+      runlist << [a, b, args]
+    end
+
+    with_options :debug => true do
+      assert_raise(Tap::Support::RunError) do
+        t.enq
+        app.run
+      end
+      assert_raise(Tap::Support::RunError) do 
+        t.enq 1
+        app.run
+      end
+      
+      t.enq 1, 2
+      app.run
+      assert_equal [[1, 2, []]], runlist
+      
+      t.enq 1, 2, 3
+      app.run
+      assert_equal [[1, 2, []], [1, 2, [3]]], runlist
+    end
+  end
+
+  #
+  # process with default values
+  #
+  
+  class ProcessWithDefaultValues < ProcessTestBase
+    def process(input=10)
+      runlist << input
+    end
+  end
+
+  def test_process_with_default_values
+    t = ProcessWithDefaultValues.new
+    
+    with_options :debug => true do
+      t.enq
+      app.run
+      assert_equal [10], t.runlist
+      
+      t.enq 1
+      app.run
+      assert_equal [10, 1], t.runlist
+      
+      assert_raise(Tap::Support::RunError) do
+        t.enq 1, 2
+        app.run
+      end
+    end
+  end
+  
+end