tap 0.9.1 → 0.10.0

data/test/test/file_methods_doc/test_sub/input/two.txt

@@ -1 +0,0 @@
-test input 2

data/test/test/file_methods_doc_test.rb

@@ -1,29 +0,0 @@
-require File.join(File.dirname(__FILE__), '../tap_test_helper.rb') 
-require 'tap/test/file_methods'
-
-# documentation test
-class FileMethodsDocTest < Test::Unit::TestCase
-  acts_as_file_test
-
-  def test_something
-    dir = File.expand_path( File.dirname(__FILE__) )
-    assert_equal dir + "/file_methods_doc", trs.root
-    assert_equal dir + "/file_methods_doc/test_something", method_root
-    assert_equal dir + "/file_methods_doc/test_something/input", method_dir(:input)  
-  end
-  
-  def test_sub
-    assert_files do |input_files|
-      input_files.collect do |filepath|
-        input = File.read(filepath)
-        output_file = method_filepath(:output, File.basename(filepath))
-
-        File.open(output_file, "w") do |f|
-          f << input.gsub(/input/, "output")
-        end 
-        
-        output_file
-      end
-    end
-  end
-end

data/test/test/file_methods_test.rb

@@ -1,275 +0,0 @@
-require File.join(File.dirname(__FILE__), '../tap_test_helper.rb') 
-require 'tap/test/file_methods'
-
-class FileMethodsTest < Test::Unit::TestCase
-  include Tap::Test::SubsetMethods
-  acts_as_file_test
-  
-  def test_method_name_returns_test_method_name1
-    assert_equal "test_method_name_returns_test_method_name1", method_name_str  
-  end
-  
-  def test_method_name_returns_test_method_name2
-    assert_equal "test_method_name_returns_test_method_name2", method_name_str  
-  end
-  
-  def test_make_test_directories 
-    root = File.expand_path(File.join(File.dirname(__FILE__), "file_methods"))
-    begin
-      assert_equal root, trs[:root]
-      assert_equal({
-          :input => 'input', 
-          :output => 'output', 
-          :expected => 'expected'}, trs.directories)
-      
-      trs.directories.values.each do |dir|
-        assert !File.exists?(File.join(root, "test_make_test_directories", dir.to_s)), dir
-      end
-      
-      make_test_directories # alias for make_test_directories
-   
-      trs.directories.values.each do |dir|
-        assert File.exists?(File.join(root, "test_make_test_directories", dir.to_s)), dir
-      end
-    ensure
-      dir =  File.join(File.join(root, "test_make_test_directories"))
-      FileUtils.rm_r dir if File.exists?(dir)
-    end
-  end
-
-  #
-  # method filepath tests
-  #
-
-  def test_method_dir_adds_method_to_path  
-    assert_equal File.join(trs.root, method_name_str, "input"), method_dir(:input)
-  end
-  
-  def test_method_filepath_adds_method_to_path
-    input_root = File.join(trs.root, method_name_str, "input")
-    assert_equal File.join(input_root, "file.txt"), method_filepath(:input, 'file.txt')
-    assert_equal File.join(input_root, "folder/file.txt"), method_filepath(:input, 'folder', 'file.txt')
-  end
-
-  #
-  # method relative filepath tests
-  #
-
-  def test_method_relative_filepath_removes_method_dir  
-    input_root = File.join(trs.root, method_name_str, "input")
-    assert_equal 'file.txt', method_relative_filepath(:input,  File.join(input_root, "file.txt"))
-    assert_equal 'folder/file.txt', method_relative_filepath(:input, File.join(input_root, "folder/file.txt"))
-  end
-
-  def test_method_relative_filepath_expands_filepaths
-    input_root = File.join(trs.root, method_name_str, "input")
-    assert_equal 'file.txt', method_relative_filepath(:input, File.join(input_root, "folder/.././file.txt") )
-  end
-  
-  def test_method_relative_filepath_raises_error_unless_filepath_begins_with_method_dir
-    assert_raise(RuntimeError) { method_relative_filepath(:input, File.join('some/path', trs[:input], 'file.txt') ) }
-  end
-  
-  #
-  # method translate tests
-  #
-  
-  def test_method_translate
-    ['file.txt', 'folder/file.txt'].each do |path|
-      filepath = File.join(trs.root, method_name_str, "input", path)
-      expected = File.join(trs.root, method_name_str, "output", path)
-    
-      assert_equal expected, method_translate(filepath, :input, :output)
-    end
-  end  
-  
-  #
-  # method glob tests
-  #
-  
-  def test_method_glob
-    {
-      [:expected] => ["file.yml", "file_1.txt", "file_2.txt"],
-      [:expected, "*"] => ["file.yml", "file_1.txt", "file_2.txt"],
-      [:expected, "*.txt"] => ["file_1.txt", "file_2.txt"],
-      [:expected, "*.txt", "*.yml"] => ["file.yml", "file_1.txt", "file_2.txt"]
-    }.each_pair do |testcase, expected|
-      expected.collect! { |file| method_filepath(:expected, file) }
-      
-      assert_equal expected.sort, method_glob(*testcase).sort
-    end
-  end  
-  
-  #
-  # output_tempfile test
-  #
-  
-  def test_output_tempfile_returns_new_file_in_output_dir
-    output_root = File.join(trs.root, method_name_str, "output")
-    
-    filepath =File.join(output_root, "file#{$$}.0")
-    assert_equal filepath, output_tempfile('file')
-    
-    filepath = File.join(output_root,  "file#{$$}.0")
-    assert_equal filepath, output_tempfile('file')
-    
-    FileUtils.touch filepath
-    filepath = File.join(output_root,  "file#{$$}.1")
-    assert_equal filepath, output_tempfile('file')
-    
-    FileUtils.touch filepath
-    filepath = File.join(output_root,  "file#{$$}.2")
-    assert_equal filepath, output_tempfile('file')
-  end
-  
-  #
-  # assert_files
-  #
-  
-  def setup_file(dir, path, content)
-    path = method_filepath(dir, path)
-    dir = File.dirname(path)
-    FileUtils.mkdir_p(dir) unless File.exists?(dir)
-    
-    File.open(path, "w") {|f| f << content}
-    path
-  end
-  
-  def test_assert_files
-    setup_file :input, "one.txt", "file one"
-    setup_file :input, "two.txt", "file two"
-    setup_file :expected, "one.txt", "processed file one"
-    setup_file :expected, "two.txt", "processed file two"
-    
-    assert_files do |input_files|
-      input_files.collect do |input_file|
-        target = method_filepath(:output, File.basename(input_file))
-        File.open(target, "w") do |file|
-          file << "processed "
-          file << File.read(input_file)
-        end
-        target
-      end
-    end
-  end
-  
-  def test_assert_files_fails_for_missing_expected_file
-    setup_file :input, "one.txt", "file one"
-    setup_file :input, "two.txt", "file two"
-    setup_file :expected, "one.txt", "processed file one"
-    
-    failed = false
-    begin
-      assert_files do |input_files|
-        input_files.collect do |input_file|
-          target = method_filepath(:output, File.basename(input_file))
-          File.open(target, "w") do |file|
-            file << "processed "
-            file << File.read(input_file)
-          end
-          target
-        end
-      end
-    rescue
-      failed = true 
-    end
-    
-    assert failed
-  end
-  
-  def test_assert_files_fails_for_missing_output_file
-    setup_file :input, "one.txt", "file one"
-    setup_file :input, "two.txt", "file two"
-    setup_file :expected, "one.txt", "processed file one"
-    setup_file :expected, "two.txt", "processed file two"
-     
-    failed = false
-    begin
-      assert_files do |input_files|
-        input_files.collect do |input_file|
-          target = method_filepath(:output, File.basename(input_file))
-          File.open(target, "w") do |file|
-            file << "processed "
-            file << File.read(input_file)
-          end
-          target
-        end.first
-      end
-    rescue
-      failed = true 
-    end
-    
-    assert failed
-  end
-  
-  def test_assert_files_fails_for_different_content
-    setup_file :input, "one.txt", "file one"
-    setup_file :input, "two.txt", "file two"
-    setup_file :expected, "one.txt", "processed file FLUNK"
-    setup_file :expected, "two.txt", "processed file two"
-    
-    failed = false
-    begin
-      assert_files do |input_files|
-        input_files.collect do |input_file|
-          target = method_filepath(:output, File.basename(input_file))
-          File.open(target, "w") do |file|
-            file << "processed "
-            file << File.read(input_file)
-          end
-          target
-        end
-      end
-    rescue
-      failed = true 
-    end
-    
-    assert failed
-  end
-  
-  def test_assert_files_fails_for_no_expected_files
-    setup_file :input, "one.txt", "file one"
-    setup_file :input, "two.txt", "file two"
-   
-    was_in_block = false
-    failed = false
-    begin
-      assert_files do |input_files| 
-        was_in_block = true
-        []
-      end
-    rescue
-      failed = true 
-    end
-    
-    assert failed
-    assert !was_in_block
-  end
-  
-  def test_assert_files_can_have_no_expected_files_if_specified
-    setup_file :input, "one.txt", "file one"
-    setup_file :input, "two.txt", "file two"
-   
-    was_in_block = false
-    assert_files :expected_files => [] do |input_files| 
-      assert_equal 2, input_files.length
-      was_in_block = true
-      []
-    end
-
-    assert was_in_block
-  end
-end
-
-class FileTestTestWithOptions < Test::Unit::TestCase
-  acts_as_file_test :root => "some/root/dir"
-  
-  def test_test_setup
-    assert_equal File.expand_path("some/root/dir"), trs[:root]
-    assert_equal({
-        :input => 'input', 
-        :output => 'output', 
-        :expected => 'expected'}, trs.directories)
-  end
-end
-

data/test/test/subset_methods_test.rb

@@ -1,171 +0,0 @@
-require File.join(File.dirname(__FILE__), '../tap_test_helper.rb') 
-require 'tap/test/subset_methods'
-
-class SubsetMethodsTest < Test::Unit::TestCase
-  include Tap::Test::SubsetMethods
-  include Benchmark
-  
-  def setup
-    @env_hold = {}
-    ENV.each_pair do |key, value|
-      @env_hold[key] = value
-    end
-    ENV.clear
-  end
-  
-  def teardown
-    ENV.clear
-    @env_hold.each_pair do |key, value|
-      ENV[key] = value
-    end
-  end
-  
-  #
-  # env_true test
-  #
-  
-  def test_env_true_is_true_if_var_is_true
-    assert !ENV['type']
-    assert !env_true?('type')
-    
-    ENV['type'] = "false"
-    assert !env_true?('type')
-    
-    ENV['type'] = "true"
-    assert env_true?('type')
-    
-    ENV['type'] = "True"
-    assert env_true?('type')
-    
-    ENV['type'] = "TRUE"
-    assert env_true?('type')
-  end
-  
-  #
-  # extended_test test
-  #
-  
-  def test_extended_test_runs_only_if_extended_true
-    was_in_test = false
-    extended_test { was_in_test = true }
-    assert !was_in_test
-    
-    ENV['EXTENDED'] = 'true'
-    extended_test { was_in_test = true }
-    assert was_in_test
-  end
-  
-  #
-  # condition test
-  #
-  
-  condition(:is_true) {true}
-  condition(:is_false) {false}
-  
-  def test_conditional_test_runs_only_if_all_conditions_are_true
-    test_ran = false
-    condition_test(:is_true) { test_ran = true}
-    assert test_ran
-    
-    test_ran = false
-    condition_test(:is_false) { test_ran = true}
-    assert !test_ran
-    
-    test_ran = false
-    condition_test(:is_true, :is_false) { test_ran = true}
-    assert !test_ran
-  end
-  
-  #
-  # benchmark_test test
-  #
-  
-  # TODO - find a way to test this is a quiet fashion
-  
-  #
-  # run subset test
-  #
-  
-  def test_run_subset_true_if_ENV_type_is_true
-    assert_equal false, run_subset?('type')
-    
-    ENV['type'] = "true"
-    assert_equal true, run_subset?('type')
-  end
-
-  def test_run_subset_true_if_ENV_all_is_true
-    ENV['ALL'] = "true"
-    assert_equal true, run_subset?('type')
-  end
-
-  #
-  # match_regexp test
-  #
-  
-  def test_match_regexp
-    ENV['type'] = "one.*"
-    assert_equal true, match_regexp?('type', "one")
-    assert_equal true, match_regexp?('type', "one_two")
-    assert_equal true, match_regexp?('type', "two_one")
-    assert_equal false, match_regexp?('type', "non")
-  end
-
-  def test_match_regexp_returns_true_if_ENV_all_true
-    ENV['ALL'] = "true"
-    assert_equal true, match_regexp?('type', "str", "default")
-  end
-
-  def test_match_regexp_returns_default_unless_ENV_type_is_set
-    assert_equal "default", match_regexp?('type', "str", "default")
-  end
-end
-
-class SkippedTest < Test::Unit::TestCase
-  include Tap::Test::SubsetMethods
-  
-  if !conditions.empty?
-    raise "conditions were NOT empty in subclass"
-  end
-  
-  condition(:unsatisfied) do 
-    false
-  end
-  
-  unless satisfied?(:unsatisfied)
-    skip_test
-  end
-  
-  def test_method
-    flunk "test WAS run"
-  end
-end
-
-class SkippedSubTest < SkippedTest
-  if conditions.empty?
-    raise "conditions WERE empty in subclass"
-  end
-  
-  condition(:unsatisfied) do 
-    true
-  end
-
-  def test_method
-    assert true
-  end
-end
-
-class NonSkippedTest < Test::Unit::TestCase
-  include Tap::Test::SubsetMethods
-  
-  condition(:unsatisfied) do 
-    true    
-  end
-  
-  unless satisfied?(:unsatisfied)
-    skip_test
-  end
-  
-  def test_method
-    assert true
-  end
-end