tap 0.7.9 → 0.8.0

data/lib/tap/test/inference_methods.rb

@@ -1,298 +0,0 @@
-require 'tap/root'
-require 'test/unit'
-require 'active_support'
-require 'tap/test/env_vars'
-
-module Test # :nodoc:
-  module Unit # :nodoc:
-    class TestCase
-      class << self
-        
-        # Causes a unit test to act as an io test -- resulting in the following:
-        # - Definition of an Tap::Root object
-        # - Tap::Test::InferenceMethods are included, providing methods to easily access 
-        # files according to a standard file structure.
-        #
-        # Note:  Unless otherwise specified, +acts_as_io_test+ infers a root directory
-        # based on the calling file.  Therefore, to keep your directory structure from 
-        # referencing an unexpected locations, be sure to specify the root directory
-        # explicitly if you call +acts_as_io_test+ from a file that is NOT your test file.
-        def acts_as_inference_test(options={})
-          options = {
-            :root => infer_root,
-            :directories => {}, 
-            :keep_outputs => false,
-            :keep_failures => false}.merge(options.symbolize_keys)
-
-          # declare the testing directory structure
-          directories = default_directories.merge(options[:directories])
-          ifs = Tap::Root.new(options[:root], directories)
-    
-          write_inheritable_attribute(:ifs,  ifs)
-          class_inheritable_reader :ifs
-      
-          write_inheritable_attribute(:options,  options)
-          class_inheritable_reader :options
-      
-          include Tap::Test::InferenceMethods
-        end
-
-        # The default directories for an io test:
-        #
-        #  :input => 'input'
-        #  :output => 'output'
-        #  :expected => 'expected'
-        #  :fail => 'fail'
-        def default_directories
-          {:input => 'input', :output => 'output', :expected => 'expected', :fail => 'fail'}
-        end
-    
-        # Infers the root directory from the calling file by chomping the extension and '_test'.  Ex:
-        #   'some_class.rb' => 'some_class'
-        #   'some_class_test.rb' => 'some_class'
-        def infer_root
-          # the calling file is not the direct caller of +infer_root+... this method is 
-          # only accessed from within another method call, hence the target caller is caller[1] 
-          # rather than caller[0].
-      
-          # caller[1] is considered the calling file (which should be the test case)
-          # note that the output of calller.first is like:
-          #   ./path/to/file.rb:10
-          #   ./path/to/file.rb:10:in 'method'
-          calling_file = caller[1].gsub(/:\d+[:in .*]?$/, "" )
-          calling_file.chomp!("#{File.extname(calling_file)}") 
-          calling_file.chomp("_test") 
-        end
-      end
-    end
-  end
-end
-
-module Tap
-  module Test  
-    module InferenceMethods
-      include Tap::Test::EnvVars
-      
-      def method_name
-        @method_name
-      end
-  
-      # Convenience accessor for the inference structure
-      def ifs
-        self.class.ifs
-      end
-    
-      # Convenience accessor for the class options
-      def options
-        self.class.options
-      end
-  
-      def make_directory_structure
-        ifs.directories.values.each do |dir| 
-          FileUtils.mkdir_p(File.join(ifs.root, method_name, dir))
-        end
-      end
-    
-      # Teardown deletes the output and fail directories unless flagged otherwise.  Note that teardown
-      # also checks the environment variables for flags.  To keep all outputs (or failures) for all tests, 
-      # flag keep outputs from the command line like:
-      #
-      #   %rake test KEEP_OUTPUTS=true
-      #   %rake test KEEP_FAILURES=true
-      def teardown
-        # clear out the output folder if it exists, unless flagged otherwise
-        output_dir = infer_dir(:output, method_name)
-        unless !File.exists?(output_dir) || options[:keep_outputs] || env("KEEP_OUTPUTS")
-          begin
-            FileUtils.rm_r output_dir
-          rescue
-            raise("teardown failure: could not remove output files")
-          end
-        end
-      
-        # clear out the fail folder if it exists, unless flagged otherwise
-        fail_dir = infer_dir(:fail, method_name)
-        unless !File.exists?(fail_dir) || options[:keep_failures] || env("KEEP_FAILURES")
-          begin
-            FileUtils.rm_r fail_dir
-          rescue
-            raise("teardown failure: could not remove fail files")
-          end
-        end
-      
-        # Remove the directory if possible
-        begin
-          dir = ifs.filepath(method_name)
-          if File.exists?(dir) && Dir.glob(File.join(dir, "*")).empty?
-            FileUtils.rmdir dir 
-          end
-        rescue
-          # rescue cases where there is a hidden file, for example .svn
-        end
-      end 
-
-      def infer_root(method=method_name)
-        ifs.filepath(method)
-      end
-
-      # The method directory is defined as 'dir/method', where method is the calling method
-      # by default.  infer_dir returns the method directory if it exists, otherwise it returns
-      # ifs[dir].
-      def infer_dir(dir, method=method_name)
-        File.join(infer_root(method), ifs.directories[dir] || dir.to_s)
-      end
-    
-      # Returns a glob of files matching the input pattern, underneath the method directory
-      # if it exists, otherwise the <tt>ifs[dir]</tt> directory.
-      def infer_glob(dir, *patterns)
-        dir = ifs.relative_filepath(:root, infer_dir(dir))
-        ifs.glob(dir, *patterns) 
-      end
-    
-      # Returns a filepath constructed from the method directory if it exists, 
-      #  otherwise the filepath will be constructed from <tt>ifs[dir]</tt>. 
-      def infer_filepath(dir, *filenames)
-        File.join(infer_dir(dir), *filenames)
-      end
-    
-      # Removes the method directory from the input filepath, returning the resuting filename.
-      # If the method directory does not exist, <tt>ifs[dir]</tt> will be removed.
-      def infer_relative_filepath(dir, filepath)
-        dir = ifs.relative_filepath(:root, infer_dir(dir))
-        ifs.relative_filepath(dir, filepath)
-      end
-    
-      # Returns an output file corresponding to the input file, translated from the
-      # input directory to the output directory.  
-      #
-      # If the input method directory exists, it will be removed from the filepath.  
-      # If the output method directory exists, it will be inserted in the filepath.  
-      def infer_translate(filepath, input_dir, output_dir)
-        input_dir = ifs.relative_filepath(:root, infer_dir(input_dir))
-        output_dir = ifs.relative_filepath(:root, infer_dir(output_dir))
-        ifs.translate(filepath, input_dir, output_dir)
-      end
-    
-      # Generates a temporary filepath formatted like "output_dir\filename.pid.n.ext" where n 
-      # is a counter that will be incremented from until a non-existant filepath is achieved.
-      #
-      # Notes:
-      # - By default filename is the calling method
-      # - The extension is chomped off the end of the filename
-      # - If the directory for the filepath does not exist, the directory will be created
-      # - Like all files in the output directory, tempfiles will be deleted by the default 
-      # +teardown+ method
-      def tempfile(filename=method_name)
-        n = 0
-        ext = File.extname(filename)
-        basename = filename.chomp(ext)
-        filepath = make_tmpname(basename, n, ext)
-        while File.exists?(filepath)
-          n += 1
-          filepath = make_tmpname(basename, n, ext)
-        end
-      
-        dirname = File.dirname(filepath)
-        FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
-        filepath
-      end
-    
-      # Copies the output file to the :fail directory if no block is given, or if the
-      # given block returns true or raises an error.  Segregate file assumes the output 
-      # file is in the :output directory and determines the final filepath by using 
-      # the +translate+ method.
-      #
-      # If the block raises an error, then the error will be re-raised after the
-      # segregation.
-      def segregate_file(output_file, &block)
-        begin
-          segregate = block_given? ? yield(output_file) : true
-        rescue
-          segregate = true
-          error = $!
-        ensure
-          if segregate
-            target = infer_translate(output_file, :output, :fail)
-          
-            dirname = File.dirname(target)
-            FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
-            FileUtils.cp(output_file, target)
-          
-            # re-raise the error for further handling
-            raise $! if error
-          end
-        end
-      end
-    
-      #
-      def assert_expected(*expected_files, &block)
-        errors = []
-      
-        check_all_files = expected_files.empty?
-        if check_all_files
-          expected_files = infer_glob(:expected) 
-          begin
-            output_files = infer_glob(:output)
-          
-            efl = expected_files.collect { |file| infer_relative_filepath(:expected, file) }
-            ofl = output_files.collect { |file| infer_relative_filepath(:output, file) }
-          
-            unless efl == ofl 
-              raise "Inconsistent globs.\nexpected: #{PP.singleline_pp(efl, '')}\nbut was:  #{PP.singleline_pp(ofl, '')}\n"  
-            end
-          rescue
-            errors << $!.message
-          end
-        end
-      
-        expected_files.each do |expected_file|
-          begin
-            output_file = infer_translate(expected_file, :expected, :output)
-        
-            raise "Expected output file does not exist: #{output_file}" unless File.exists?(output_file)
-          
-            segregate_file(output_file) do |output_file|
-              pass = block_given? ? yield(expected_file, output_file) : files_equal?(expected_file, output_file)
-              !pass
-            end unless File.directory?(output_file)
-          rescue
-            errors << $!.message
-          end
-        end
-      
-        unless errors.empty?
-          flunk errors.join("\n")
-        end
-      end
-    
-      # Asserts that each pair of input files are equal, using FileUtils.cmp.
-      def files_equal?(a, b)
-        FileUtils.cmp(a, b)
-      end
-    
-      # Asserts that each pair of input files produce an equivalent object when
-      # loaded as a yaml file. 
-      def yml_equal?(a, b)
-        YAML.load_file(a) == YAML.load_file(b)
-      end
-
-      # Yields to the input block for each pair of input files.  An error is raised
-      # if the input arrays do not have equal numbers of entries.
-      def each_pair(a, b, &block)
-        a = [a] unless a.kind_of?(Array)
-        b = [b] unless b.kind_of?(Array)
-      
-        raise ArgumentError, "The input arrays must have an equal number of entries." unless a.length == b.length
-        a.each_index do |index|
-          yield(a[index], b[index])
-        end
-      end
-
-      private
-    
-      def make_tmpname(basename, n, ext="")
-        infer_filepath(:output, sprintf('%s%d.%d%s', basename, $$, n, ext))
-      end
-    end
-  end
-end

data/test/task/config/task_with_config.yml

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

data/test/test/inference_methods_test.rb

@@ -1,311 +0,0 @@
-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
-