tap 0.7.9

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

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

data/test/test/inference_methods/test_yml_compare/expected/output_1.yml

@@ -0,0 +1,6 @@
+# this file has equal yml, but with comments and a reversed hash order.
+
+array:
+  - one
+  - two
+field: value

data/test/test/inference_methods/test_yml_compare/expected/output_2.yml

@@ -0,0 +1,6 @@
+# this file has unequal yml
+
+array:
+  - one
+  - two
+field: different value

data/test/test/inference_methods/test_yml_compare/input/input_1.yml

@@ -0,0 +1,4 @@
+field: value
+array:
+  - one
+  - two

data/test/test/inference_methods/test_yml_compare/input/input_2.yml

@@ -0,0 +1,4 @@
+field: value
+array:
+  - one
+  - two

data/test/test/inference_methods_test.rb

@@ -0,0 +1,311 @@
+require File.join(File.dirname(__FILE__), '../tap_test_helper.rb') 
+require 'tap/test/inference_methods'
+
+class InferenceMethodsTest < Test::Unit::TestCase
+  include Tap::Test::SubsetMethods
+  acts_as_inference_test 
+  
+  def test_method_name_returns_test_method_name1
+    assert_equal "test_method_name_returns_test_method_name1", method_name  
+  end
+  
+  def test_method_name_returns_test_method_name2
+    assert_equal "test_method_name_returns_test_method_name2", method_name  
+  end
+  
+	def test_make_directory_structure 
+    root = File.join(File.dirname(__FILE__), "inference_methods")
+    begin
+		  assert_equal root, ifs[:root]
+		  assert_equal({
+				  :input => 'input', 
+				  :output => 'output', 
+				  :expected => 'expected', 
+				  :fail => 'fail'}, ifs.directories)
+      
+      ifs.directories.values.each do |dir|
+        assert !File.exists?(File.join(root, "test_make_directory_structure", dir.to_s)), dir
+      end
+      
+      make_directory_structure # alias for make_directory_structure
+   
+      ifs.directories.values.each do |dir|
+        assert File.exists?(File.join(root, "test_make_directory_structure", dir.to_s)), dir
+      end
+    ensure
+      dir =  File.join(File.join(root, "test_make_directory_structure"))
+      FileUtils.rm_r dir if File.exists?(dir)
+    end
+	end
+
+	#
+	# infer filepath tests
+	#
+
+	def test_infer_dir_adds_method_to_path	
+		assert_equal File.join(ifs.root, method_name, "input"), infer_dir(:input)
+	end
+	
+	def test_infer_filepath_adds_method_to_path
+    input_root = File.join(ifs.root, method_name, "input")
+		assert_equal File.join(input_root, "file.txt"), infer_filepath(:input, 'file.txt')
+		assert_equal File.join(input_root, "folder/file.txt"), infer_filepath(:input, 'folder', 'file.txt')
+	end
+
+	#
+	# infer relative filepath tests
+	#
+
+	def test_infer_relative_filepath_removes_infer_dir	
+    input_root = File.join(ifs.root, method_name, "input")
+		assert_equal 'file.txt', infer_relative_filepath(:input,  File.join(input_root, "file.txt"))
+		assert_equal 'folder/file.txt', infer_relative_filepath(:input, File.join(input_root, "folder/file.txt"))
+	end
+
+	def test_infer_relative_filepath_expands_filepaths
+    input_root = File.join(ifs.root, method_name, "input")
+		assert_equal 'file.txt', infer_relative_filepath(:input, File.join(input_root, "folder/.././file.txt") )
+	end
+	
+	def test_infer_relative_filepath_raises_error_unless_filepath_begins_with_infer_dir
+		assert_raise(RuntimeError) { infer_relative_filepath(:input, File.join('some/path', ifs[:input], 'file.txt') ) }
+	end
+	
+	#
+	# infer translate tests
+	#
+	
+	def test_infer_translate
+		acase_test('file.txt', 'folder/file.txt') do |path|
+			filepath = File.join(ifs.root, method_name, "input", path)
+			expected = File.join(ifs.root, method_name, "output", path)
+		
+			assert_equal expected, infer_translate(filepath, :input, :output)
+		end
+	end	
+	
+	#
+	# infer glob tests
+	#
+	
+	def test_infer_glob
+		case_test(
+			[: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"]
+		) do |testcase, expected|
+			expected.collect! { |file| infer_filepath(:expected, file) }
+			
+			assert_equal expected.sort, infer_glob(*testcase).sort
+		end
+	end	
+	
+	#
+	# tempfile test
+	#
+	
+	def test_tempfile_returns_new_file_in_output_dir
+    output_root = File.join(ifs.root, method_name, "output")
+    
+		filepath =File.join(output_root, "file#{$$}.0")
+		assert_equal filepath, tempfile('file')
+		
+		filepath = File.join(output_root,  "file#{$$}.0")
+		assert_equal filepath, tempfile('file')
+		
+		FileUtils.touch filepath
+		filepath = File.join(output_root,  "file#{$$}.1")
+		assert_equal filepath, tempfile('file')
+		
+		FileUtils.touch filepath
+		filepath = File.join(output_root,  "file#{$$}.2")
+		assert_equal filepath, tempfile('file')
+	end
+	
+	#
+	# segregate file test
+	#
+	
+	def segregate_file_setup(path)
+		filepath = File.join(ifs.root, method_name, "output", path)
+		segregated =  File.join(ifs.root, method_name, "fail", path)
+			
+		dirname = File.dirname(filepath)
+		FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
+		FileUtils.touch(filepath)
+		
+		[filepath, segregated]
+	end
+	
+	def test_segregate_file
+		acase_test('file.txt', 'folder/file.txt') do |path|
+			filepath, segregated = segregate_file_setup(path)
+			
+			assert File.exists?(filepath)
+			assert !File.exists?(segregated)
+			
+			segregate_file(filepath)
+			
+			assert File.exists?(filepath)
+			assert File.exists?(segregated)
+		end
+	end
+	
+	def test_segregate_file_only_segregates_if_block_returns_true
+		acase_test('file.txt', 'folder/file.txt') do |path|
+			filepath, segregated = segregate_file_setup(path)
+			
+			assert File.exists?(filepath)
+			assert !File.exists?(segregated)
+			
+			segregate_file(filepath) do |file|
+				false
+			end
+			
+			assert File.exists?(filepath)
+			assert !File.exists?(segregated)
+			
+			segregate_file(filepath) do |file|
+				true
+			end
+			
+			assert File.exists?(filepath)
+			assert File.exists?(segregated)
+		end
+	end
+		
+	def test_segregate_file_segregates_if_block_raises_error
+		acase_test('file.txt', 'folder/file.txt') do |path|
+			filepath, segregated = segregate_file_setup(path)
+			
+			assert File.exists?(filepath)
+			assert !File.exists?(segregated)
+			
+			begin
+				segregate_file(filepath) do |file|
+					raise "error"
+				end
+				
+				flunk("error was not re-raised")
+			rescue
+				assert File.exists?(filepath)
+				assert File.exists?(segregated)
+			end
+		end
+	end
+	
+	#
+	# assert expected tests
+	#
+	
+	def test_assert_expected
+		target = nil
+		infer_glob(:input).sort.each do |input_file|
+			target = ifs.translate(input_file, "#{method_name}/input", "#{method_name}/output")
+	
+			if File.file?(input_file)
+				dirname = File.dirname(target)
+				FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
+				FileUtils.cp(input_file, target)
+			else
+				FileUtils.mkdir_p(target)
+			end
+		end
+		
+		# all files
+		assert_expected
+		
+		# files globed
+		assert_expected(infer_filepath(:expected, 'file.txt'))
+		
+		# with block
+		assert_expected do | expected, output|
+			true
+		end
+		
+		# now with a block that fails
+		fail_file = ifs.translate(target, "#{method_name}/output", "#{method_name}/fail")
+		begin
+			assert_expected do |expected, output|
+				false
+			end
+			flunk		
+		rescue
+			assert File.exists?(fail_file)
+			File.delete(fail_file)
+		end
+		
+		# now with a file that is different
+		File.open(target, 'a') {|file| file << "additional contents" }
+		begin
+			assert_expected
+			flunk
+		rescue
+			assert File.exists?(fail_file)
+			File.delete(fail_file)
+		end
+		
+		#  now with a missing file -- note there is no file to segregate
+		File.delete(target)
+		begin
+			assert_expected
+			flunk		
+		rescue
+			assert $!.message =~ Regexp.new("Expected output file does not exist: #{target}")
+			assert !File.exists?(fail_file)
+		end
+	end
+	
+	#
+	# files equal test
+	#
+	
+	def test_file_compare
+		count = 0
+		each_pair(infer_glob(:input, "*1*"), infer_glob(:expected, "*1*") ) do |a, b|
+			assert files_equal?(a, b)
+			count += 1
+		end
+		assert_equal 1, count
+		
+		each_pair(infer_glob(:input, "*2*"), infer_glob(:expected, "*2*") ) do |a, b|
+			assert !files_equal?(a, b)
+			count += 1
+		end
+		assert_equal 2, count
+	end
+	
+	#
+	# yml equal test
+	#
+	
+	def test_yml_compare
+		count = 0
+		each_pair(infer_glob(:input, "*1*"), infer_glob(:expected, "*1*") ) do |a, b|
+			assert yml_equal?(a, b)
+			count += 1
+		end
+		assert_equal 1, count
+		
+		each_pair(infer_glob(:input, "*2*"), infer_glob(:expected, "*2*") ) do |a, b|
+			assert !yml_equal?(a, b)
+			count += 1
+		end
+		assert_equal 2, count
+	end
+end
+
+class InferenceTestTestWithOptions < Test::Unit::TestCase
+	acts_as_inference_test :root => "some/root/dir"
+	
+	def test_test_setup
+		assert_equal "some/root/dir", ifs[:root]
+		assert_equal({
+				:input => 'input', 
+				:output => 'output', 
+				:expected => 'expected', 
+				:fail => 'fail'}, ifs.directories)
+	end
+end
+

data/test/test/subset_methods_test.rb

@@ -0,0 +1,115 @@
+require File.join(File.dirname(__FILE__), '../tap_test_helper.rb') 
+require 'tap/test/subset_methods'
+
+class SubsetMethodsTest < Test::Unit::TestCase
+  include Tap::Test::SubsetMethods
+	
+	# TODO - replace ENV[] with env() throughout,
+	# and override env() so ENV is absolutely NOT
+	# modified
+	
+	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
+
+	#
+	# 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
+		[1, [1,2]].each do |input|
+			ENV['type'] = "1"
+			assert_equal true, match_regexp?('type', input)
+		end
+		
+		["one", ["one", "two"]].each do |input|
+			ENV['type'] = "one"
+			assert_equal true, match_regexp?('type', input)
+		end
+	end
+
+	def test_match_regexp_returns_true_if_ENV_all_true
+		ENV['ALL'] = "true"
+		assert_equal true, match_regexp?('type', 1, "default")
+	end
+
+	def test_match_regexp_returns_default_unless_ENV_type_is_set
+		assert_equal "default", match_regexp?('type', 1, "default")
+	end
+	
+	#
+	# calling method tests
+	#
+	
+	def nested_call_to_calling_method
+		assert_equal 'test_calling_method', calling_method
+	end
+	
+	def nested_call_with_alternate_pattern
+		assert_equal 'nested_call_with_alternate_pattern', calling_method(/^nested/)
+	end
+	
+	def test_calling_method
+		assert_equal 'test_calling_method', calling_method
+		nested_call_to_calling_method
+		nested_call_with_alternate_pattern
+	end
+	
+	#
+	# singleline pp test
+	#
+	
+	def test_format_pps_input
+		[1, "two", [:three, 4]].each do |input|
+			assert_equal PP.singleline_pp(input, ''), spp(input)
+		end
+	end
+end