tap-test 0.4.0 → 0.6.0

data/History

@@ -1,3 +1,15 @@
+== 0.6.0 / 2010-05-02
+
+This release removes crufty methods that are rarely used and
+add confusion to otherwise focused test modules.  Updated to
+Tap-1.3.0.
+
+* updated to simplified Tap::Root
+* removed FileTest#assert_files (and associated methods)
+* removed SubsetTest#prompt_test
+* added indent stripping to ShellTest#assert_output_equal
+* added indent stripping to ShellTest#assert_alike
+
 == 0.4.0 / 2009-19-09
 
 Various improvements to the test modules.  Note that FileTest now will

data/MIT-LICENSE

@@ -1,6 +1,6 @@
 Copyright (c) 2009, Regents of the University of Colorado.
 
-Copyright (c) 2009, Simon Chiang.
+Copyright (c) 2009-2010, Simon Chiang.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README

@@ -13,10 +13,6 @@ the shell behavior of executables and to define conditions for tests (ex
 integrates with Test::Unit and Mini::Test, but it is possible to include the
 test modules into other test frameworks.
 
-{Tap-Test}[http://tap.rubyforge.org/tap-test] is a part of the
-{Tap-Suite}[http://tap.rubyforge.org/tap-suite]. Check out these links for
-documentation, development, and bug tracking.
-
 * Website[http://tap.rubyforge.org] 
 * Github[http://github.com/bahuvrihi/tap/tree/master] 
 * {Google Group}[http://groups.google.com/group/ruby-on-tap]
@@ -40,9 +36,9 @@ saved on a failure (using ENV['KEEP_OUTPUTS']='true').
     acts_as_file_test
 
     def test_method_root
-      assert_equal "test_method_root", File.basename(method_root.root)
+      assert_equal "test_method_root", File.basename(method_root.path)
       
-      path = method_root.prepare(:tmp, 'file.txt') {|io| io << 'content' }
+      path = method_root.prepare('tmp/file.txt') {|io| io << 'content' }
       assert_equal "content", File.read(path)
     end
   end
@@ -94,15 +90,14 @@ or all tests using an ENV variable (ex ENV['ALL']='true').
 
 ==== {TapTest}[link:classes/Tap/Test/TapTest.html]  (acts_as_tap_test)
 
-Sets up Tap::App.instance for testing tasks.
+Sets up Tap::App.current for testing tasks.
 
   require 'tap/test/unit'
   class TapTestTest < Test::Unit::TestCase
     acts_as_tap_test
 
-    def test_node
-      n = app.node { "result" }
-      assert_equal "result", n.call
+    def test_info
+      assert_equal 'state: 0 (READY) queue: 0', app.info
     end
   end
 

data/lib/tap/test.rb

@@ -1,79 +1,85 @@
-require 'tap/root'
-
 module Tap
   
-  # Tap::Test provides several convenience methods for including and
-  # setting up Tap::Test modules.  The manual use of this module looks
-  # like this: 
+  # Tap::Test provides several convenience methods for including and setting
+  # up Tap::Test modules.  The manual use of this module looks like this: 
   #
   #   class SampleTest < Test::Unit::TestCase
   #     extend Tap::Test
   #     acts_as_tap_test
   #   end
   #
-  # The 'tap/test/unit' file performs this setup for Test::Unit
-  # (ruby < 1.9) and Mini::Test (ruby >= 1.9); simply require it and
-  # call the setup methods as necessary.
+  # The 'tap/test/unit' file performs this setup for Test::Unit (ruby < 1.9)
+  # and Mini::Test (ruby >= 1.9); simply require it and call the setup methods
+  # as necessary.
+  #
+  #   require 'tap/test/unit'
+  #   class SampleTest < Test::Unit::TestCase
+  #     acts_as_tap_test
+  #   end
   #
   module Test
-    autoload(:SubsetTest, 'tap/test/subset_test')
-    autoload(:FileTest, 'tap/test/file_test')
-    autoload(:ShellTest, 'tap/test/shell_test')
-    autoload(:TapTest, 'tap/test/tap_test')
-    autoload(:Utils, 'tap/test/utils')
+    autoload :SubsetTest, 'tap/test/subset_test'
+    autoload :FileTest, 'tap/test/file_test'
+    autoload :ShellTest, 'tap/test/shell_test'
+    autoload :TapTest, 'tap/test/tap_test'
+    autoload :Utils, 'tap/test/utils'
     
     # Includes SubsetTest in the calling class.
     def acts_as_subset_test
       include Tap::Test::SubsetTest
     end
   
-    # Includes FileTest in the calling class and instantiating class_test_root
-    # (a Tap::Root).  Options may be used to configure the class_test_root.  
+    # Includes FileTest in the calling class and instantiates class_root.
+    # Options:
+    #
+    #   :root:: Specifies the class_root.  String roots are used to 
+    #           instantiate a new Tap::Root.
+    #   :cleanup_dirs:: Specifies directories to cleanup under root.
     #
-    # Note: by default acts_as_file_test determines a root directory 
-    # <em>based on the calling file</em>.  Be sure to specify the root 
-    # directory manually if you call acts_as_file_test from a file that 
-    # isn't the test file.
+    # By default acts_as_file_test guesses a root directory using brittle
+    # logic that examines caller.  Be sure to specify the root directory
+    # manually if you call acts_as_file_test from a file that isn't the test
+    # file, or via some proxy method.
     def acts_as_file_test(options={})
       include Tap::Test::FileTest
       
-      options[:root] ||= test_root_dir
+      root = options[:root] || test_root_dir
+      root = Tap::Root.new(root) unless root.kind_of?(Tap::Root)
+      self.class_root = root
       
-      if options.has_key?(:cleanup_dirs)
-        self.cleanup_dirs = options.delete(:cleanup_dirs)
+      if cleanup_dirs = options[:cleanup_dirs]
+        self.cleanup_dirs = cleanup_dirs
       end
-      
-      self.class_test_root = Tap::Root.new(options)
     end
     
     # Includes ShellTest in the calling class.  Options are set as the default
     # sh_test_options.
     def acts_as_shell_test(options=nil)
       include Tap::Test::ShellTest
-      self.sh_test_options.merge!(options) if options
+      define_method(:sh_test_options) { super().merge(options) } unless options.nil?
     end
     
-    # Includes TapTest in the calling class and calls acts_as_file_test with
-    # the options.
+    # Includes TapTest in the calling class and calls acts_as_file_test.  See
+    # acts_as_file_test for valid options.
     def acts_as_tap_test(options={})
       options[:root] ||= test_root_dir
       acts_as_file_test(options)
+      
       include Tap::Test::TapTest
     end
     
     private
-  
+    
     # Infers the test root directory from the calling file.
-    #   'some_class.rb' => 'some_class'
-    #   'some_class_test.rb' => 'some_class'
+    #   'some_class_test.rb' => 'some_class_test'
     def test_root_dir # :nodoc:
       # caller[1] is considered the calling file (which should be the test case)
       # note that caller entries are like this:
       #   ./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)).chomp("_test") 
+      calling_file.chomp(File.extname(calling_file))
     end
   end
 end

data/lib/tap/test/env.rb

@@ -0,0 +1,23 @@
+module Tap
+  module Test
+    class Env
+      def path(type)
+        [File.expand_path(type.to_s)]
+      end
+      
+      def constant(const_str, type=nil)
+        return const_str if const_str.kind_of?(Module)
+        
+        begin
+          current = Object
+          const_str.split(/::/).each do |const_name|
+            current = current.const_get(const_name)
+          end
+          current
+        rescue(NameError)
+          raise "uninitialized constant: #{const_str.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/tap/test/file_test.rb

@@ -4,59 +4,21 @@ require 'tap/test/utils'
 module Tap
   module Test  
     
-    # FileTest facilitates access and utilization of test-specific files and
-    # directories. FileTest provides each test method with a Tap::Root
-    # (method_root) specific for the method, and defines a new assertion
-    # method (assert_files) to facilitate tests which involve the production
-    # and/or modification of files.
-    #
-    #   [file_test_doc_test.rb]
-    #   class FileTestDocTest < Test::Unit::TestCase
-    #     acts_as_file_test
-    #  
-    #     def test_something
-    #       # each test class has a class test root (ctr)
-    #       # and each test method has a method-specific
-    #       # root (method_root)
-    #
-    #       ctr.root                        # => File.expand_path(__FILE__.chomp('_test.rb'))
-    #       method_root.root                # => File.join(ctr.root, "/test_something")
-    #       method_root[:input]             # => File.join(ctr.root, "/test_something/input")
-    #
-    #       # files in the :output and :tmp directories are cleared
-    #       # before and after each test; this passes each time the
-    #       # test is run with no additional cleanup:
-    #
-    #       assert !File.exists?(method_root[:tmp])
-    #
-    #       tmp_file = method_root.prepare(:tmp, 'sample.txt') {|file| file << "content" }
-    #       assert_equal "content", File.read(tmp_file)
-    #
-    #       # the assert_files method compares files produced
-    #       # by the block the expected files, ensuring they
-    #       # are the same (see the documentation for the 
-    #       # simplest use of assert_files)
-    #        
-    #       expected_file = method_root.prepare(:expected, 'output.txt') {|file| file << 'expected output' }
-    #
-    #       # passes
-    #       assert_files do 
-    #         method_root.prepare(:output, 'output.txt') {|file| file << 'expected output' }
-    #       end 
-    #     end
-    #   end
+    # FileTest simplifies testing of code that works with files.  FileTest
+    # provides a method-specific Tap::Root (method_root) that expedites the
+    # creation and access of files, as well as a couple standard cleanup
+    # methods.
     #
     # ==== Cleanup
     #
-    # By default the method_root directory is cleaned up at the end of the
-    # test, making FileTest very conveient for creating temporary test files. 
-    # To prevent cleanup, either set the KEEP_OUTPUTS or KEEP_FAILURES ENV
-    # variable to 'true'.  The cleanup directories can be specified manually
-    # using cleanup_dirs class variable:
+    # By default the entire method_root directory is cleaned up at the end of
+    # the test. To prevent cleanup, either set the KEEP_OUTPUTS or
+    # KEEP_FAILURES ENV variable to 'true'.  The cleanup directories can be
+    # specified manually using cleanup_dirs class variable:
     #
     #   class LimitedCleanupTest < Test::Unit::TestCase
     #
-    #     # only cleanup the method_root[:output] directory
+    #     # only cleanup the output directory under root
     #     acts_as_file_test :cleanup_dirs => [:output]
     #   end
     #
@@ -66,46 +28,41 @@ module Tap
     # ==== Requirements
     #
     # FileTest requires that a method_name method is provided by the including
-    # class, in order to properly set the directory for method_root. 
+    # class, in order to properly set the directory for root.
     # Test::Unit::TestCase satisfies this requirement already.
     module FileTest
       
       def self.included(base) # :nodoc:
         super
         base.extend FileTest::ClassMethods
-        base.cleanup_dirs = [:root]
       end
       
-      # The test-method-specific Tap::Root which may be used to access test
-      # files.  method_root is a duplicate of ctr reconfigured so that
-      # method_root.root is ctr[method_name.to_sym]
+      # The method-specific Tap::Root
       attr_reader :method_root
       
       # Sets up method_root and calls cleanup.  Be sure to call super when
       # overriding this method.
       def setup
         super
-        @method_root = ctr.dup.reconfigure(:root => ctr[method_name.to_sym])
+        @method_root = class_root.sub(method_name)
         cleanup
       end
       
-      # Cleans up the method_root.root directory by removing the class
-      # cleanup_dirs (by default :root, ie the method_root directory itself).
-      # The root directory will be removed if it is empty.
+      # Cleans up the method_root directory by removing the cleanup_dirs 
+      # specified for the class.  (by default the entire method_root directory
+      # is removed). The method_root directory will be removed if it is empty.
       #  
       # Override as necessary in subclasses.
       def cleanup
-        self.class.cleanup_dirs.each do |dir|
-          clear_dir(method_root[dir])
-        end
-        try_remove_dir(method_root.root)
+        cleanup_dirs = self.class.cleanup_dirs
+        cleanup_dirs.each {|dir| clear_dir(method_root.path(dir)) }
+        
+        try_remove_dir(method_root.path)
       end
     
       # Calls cleanup unless flagged otherwise by an ENV variable (see above).
       # Be sure to call super when overriding this method.
       def teardown
-        # check that method_root still exists (nil may
-        # indicate setup was overridden without super)
         unless method_root
           raise "teardown failure: method_root is nil (does setup call super?)"
         end
@@ -119,188 +76,12 @@ module Tap
           end
         end
         
-        try_remove_dir(ctr.root)
+        try_remove_dir(class_root.path)
       end 
       
-      # Convenience method to access the class_test_root.
-      def ctr
-        self.class.class_test_root or raise "setup failure: no class_test_root has been set for #{self.class}"
-      end
-      
-      # Runs a file-based test that compares files created by the block with
-      # files in an expected directory.  The block receives files from the
-      # input directory, and should return a list of files relative to the
-      # output directory.  Only the files returned by the block are compared;
-      # additional files in the output directory are effectively ignored.
-      #
-      # === Example
-      # Lets define a test that transforms input files into output files in a
-      # trivial way, simply by replacing 'input' with 'output' in the file.
-      #
-      #   class FileTestDocTest < Test::Unit::TestCase
-      #     acts_as_file_test
-      #    
-      #     def test_assert_files
-      #       assert_files do |input_files|
-      #         input_files.collect do |path|
-      #           input = File.read(path)
-      #           output_file = method_root.path(:output, File.basename(path))
-      #
-      #           File.open(output_file, "w") do |f|
-      #             f << input.gsub(/input/, "output")
-      #           end 
-      #
-      #           output_file
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # Now say you had some input and expected files for test_assert_files:
-      #
-      #   file_test_doc/test_assert_files
-      #   |- expected
-      #   |   |- one.txt
-      #   |   `- two.txt
-      #   `- input
-      #       |- one.txt
-      #       `- two.txt
-      #    
-      #   [input/one.txt]
-      #   test input 1
-      #
-      #   [input/two.txt]
-      #   test input 2
-      #
-      #   [expected/one.txt]
-      #   test output 1
-      #
-      #   [expected/two.txt]
-      #   test output 2
-      #
-      # When you run the test, the assert_files passes the input files to the
-      # block.  When the block completes, assert_files compares the output
-      # files returned by the block with the files in the expected directory.
-      # In this case, the files are equal and the test passes.
-      #
-      # Say you changed the content of one of the expected files:
-      #
-      #   [expected/one.txt]
-      #   test flunk 1
-      #
-      # Now the test fails because the output files aren't equal to the
-      # expected files.  The test also fails if there are missing or extra
-      # files. 
-      #
-      # === Options
-      # A variety of options adjust the behavior of assert_files:
-      #    
-      #   :input_dir                      specify the directory to glob for input files
-      #                                     (default method_root[:input])
-      #   :output_dir                     specify the output directory
-      #                                     (default method_root[:output])
-      #   :expected_dir                   specify the directory to glob for expected files
-      #                                     (default method_root[:expected])
-      #   :input_files                    directly specify the input files for the block
-      #   :expected_files                 directly specify the expected files for comparison
-      #   :include_input_directories      specifies directories to be included in the 
-      #                                     input_files array (by default dirs are excluded)
-      #   :include_expected_directories   specifies directories to be included in the
-      #                                     expected-output file list comparison 
-      #                                     (by default dirs are excluded)  
-      #                     
-      # assert_files will fail if <tt>:expected_files</tt> was not specified
-      # in the options and no files were found in <tt>:expected_dir</tt>. This
-      # check tries to prevent silent false-positive results when you forget
-      # to put expected files in their place.
-      #
-      # === File References
-      #
-      # Sometimes the same files will get used across multiple tests.  To
-      # allow separate management of test files and prevent duplication, file
-      # references can be provided in place of test files.  For instance, with
-      # a test directory like:
-      #
-      #   method_root
-      #   |- expected
-      #   |   |- one.txt.ref
-      #   |   `- two.txt.ref
-      #   |- input
-      #   |   |- one.txt.ref
-      #   |   `- two.txt.ref
-      #   `- ref
-      #       |- one.txt
-      #       `- two.txt
-      #      
-      # The input and expected files (all references in this case) can be
-      # dereferenced to the 'ref' paths like so:
-      #
-      #   assert_files :reference_dir => method_root[:ref] do |input_files|
-      #     input_files # => ['method_root/ref/one.txt', 'method_root/ref/two.txt']
-      #
-      #     input_files.collect do |input_file|
-      #       output_file = method_root.path(:output, File.basename(input_file)
-      #       FileUtils.cp(input_file, output_file)
-      #       output_file
-      #     end
-      #   end
-      #
-      # Dereferencing occurs relative to the input_dir/expected_dir
-      # configurations; a reference_dir must be specified for dereferencing to
-      # occur (see Utils.dereference for more details).
-      #
-      #--
-      # TODO:
-      # * add debugging information to indicate, for instance,  when
-      #   dereferencing is going on.
-      def assert_files(options={}, &block) # :yields: input_files
-        transform_test(block, options) do |expected_file, output_file|
-          unless FileUtils.cmp(expected_file, output_file) 
-            flunk "<#{expected_file}> not equal to\n<#{output_file}>"
-          end
-        end
-      end
-      
-      # The default assert_files options
-      def assert_files_options
-        {
-          :input_dir => method_root[:input],
-          :output_dir => method_root[:output],
-          :expected_dir => method_root[:expected],
-          
-          :input_files => nil,
-          :expected_files => nil,
-          :include_input_directories => false,
-          :include_expected_directories => false,
-          
-          :reference_dir => nil,
-          :reference_extname => '.ref'
-        }
-      end
-      
-      private
-      
-      # Yields to the input block for each pair of entries in the input 
-      # arrays.  An error is raised if the input arrays do not have equal 
-      # numbers of entries.
-      def each_pair(a, b, &block) # :yields: entry_a, entry_b,
-        each_pair_with_index(a,b) do |entry_a, entry_b, index|
-          yield(entry_a, entry_b)
-        end
-      end
-
-      # Same as each_pair but yields the index of the entries as well.
-      def each_pair_with_index(a, b, error_msg=nil, &block) # :yields: entry_a, entry_b, index
-        a = [a] unless a.kind_of?(Array)
-        b = [b] unless b.kind_of?(Array)
-        
-        unless a.length == b.length
-          raise ArgumentError, (error_msg || "The input arrays must have an equal number of entries.")
-        end
-        
-        0.upto(a.length-1) do |index|
-          yield(a[index], b[index], index)
-        end
+      # Convenience method to access the class_root.
+      def class_root
+        self.class.class_root or raise "setup failure: no class_root has been set for #{self.class}"
       end
       
       # Attempts to recursively remove the specified method directory and all 
@@ -310,80 +91,15 @@ module Tap
         FileUtils.rm_r(dir) if File.exists?(dir)
       end
       
-      # Attempts to remove the specified directory.  The root 
-      # will not be removed if the directory does not exist, or
-      # is not empty.  
+      # Attempts to remove the specified directory.  The directory will not be
+      # removed unless fully empty (including hidden files).
       def try_remove_dir(dir)
-        # Remove the directory if possible
         begin
-          FileUtils.rmdir(dir) if File.exists?(dir) && Dir.glob(File.join(dir, "*")).empty?
+          FileUtils.rmdir(dir) if File.directory?(dir) && Dir.glob(File.join(dir, "*")).empty?
         rescue
           # rescue cases where there is a hidden file, for example .svn
         end
       end
-      
-      def transform_test(block, options={}) # :yields: expected_files, output_files
-        options = assert_files_options.merge(options)
-        input_dir = options[:input_dir]
-        output_dir = options[:output_dir] 
-        expected_dir = options[:expected_dir]
-        
-        reference_dir = options[:reference_dir]
-        reference_pattern = options[:reference_pattern]
-        
-        Utils.dereference([input_dir, expected_dir], reference_dir, reference_pattern || '**/*.ref') do
-
-          # Get the input and expected files in this manner:
-          # - look for manually specified files
-          # - glob for files if none were specified
-          # - expand paths and sort
-          # - remove directories unless specified not to do so
-          input_files, expected_files = [:input, :expected].collect do |key|
-            files = options["#{key}_files".to_sym]
-            if files.nil?
-              pattern = File.join(options["#{key}_dir".to_sym], "**/*")
-              files = Dir.glob(pattern)
-            end
-            files = [files].flatten.collect {|file| File.expand_path(file) }.sort
-
-            unless options["include_#{key}_directories".to_sym]
-              files.delete_if {|file| File.directory?(file)} 
-            end
-          
-            files
-          end
-        
-          # check at least one expected file was found
-          if expected_files.empty? && options[:expected_files] == nil
-            flunk "No expected files specified."
-          end
-        
-          # get output files from the block, expand and sort
-          output_files = [*block.call(input_files)].collect do |output_file| 
-            File.expand_path(output_file)
-          end.sort
-        
-          # check that the expected and output paths are the same
-          translated_expected_files = expected_files.collect do |expected_file|
-            Tap::Root::Utils.translate(expected_file, expected_dir, output_dir)
-          end
-          assert_equal translated_expected_files, output_files, "Missing, extra, or unexpected output files"
-        
-          # check that the expected and output file contents are equal
-          errors = []
-          each_pair(expected_files, output_files) do |expected_file, output_file|
-            unless (File.directory?(expected_file) && File.directory?(output_file)) || FileUtils.cmp(expected_file, output_file)
-              begin
-                yield(expected_file, output_file)
-              rescue
-                errors << $!
-              end
-            end
-          end
-          flunk "File compare failed:\n" + errors.join("\n") unless errors.empty?
-        end
-      end
-      
     end
   end
 end

data/lib/tap/test/file_test/class_methods.rb

@@ -1,3 +1,5 @@
+require 'tmpdir'
+
 module Tap
   module Test
     module FileTest
@@ -5,12 +7,21 @@ module Tap
       # Class methods extending tests which include FileTest.
       module ClassMethods
       
-        # The class-level test root (a Tap::Root)
-        attr_accessor :class_test_root
+        # Sets the class_root
+        attr_writer :class_root
       
-        # An array of directories to be cleaned up by cleanup
-        attr_accessor :cleanup_dirs
+        # The class-level test root (a Tap::Root)
+        def class_root
+          @class_root ||= Root.new(Dir.tmpdir)
+        end
+        
+        # Sets cleanup_dirs
+        attr_writer :cleanup_dirs
         
+        # An array of directories to be cleaned up by cleanup (default ['.'])
+        def cleanup_dirs
+          @cleanup_dirs ||= ['.']
+        end
       end
     end
   end

data/lib/tap/test/shell_test.rb

@@ -1,5 +1,5 @@
-require 'tap/test/shell_test/class_methods'
 require 'tap/test/shell_test/regexp_escape'
+require 'tap/utils'
 
 module Tap
   module Test
@@ -40,11 +40,7 @@ module Tap
     #   end
     #
     module ShellTest
-      
-      def self.included(base) # :nodoc:
-        super
-        base.extend ShellTest::ClassMethods
-      end
+      include Tap::Utils
       
       # Sets up the ShellTest module.  Be sure to call super if you override
       # setup in an including module.
@@ -60,7 +56,7 @@ module Tap
         verbose && verbose =~ /^true$/i ? true : false
       end
       
-      # Returns true if the ENV variable 'QUIET' is true.  When quiet,
+      # Returns true if the ENV variable 'QUIET' is true or nil.  When quiet,
       # ShellTest does not print any extra information to $stdout.
       #
       # If 'VERBOSE' and 'QUIET' are both set, verbose wins.
@@ -68,42 +64,7 @@ module Tap
         return false if verbose?
         
         quiet = ENV['QUIET']
-        quiet && quiet =~ /^true$/i ? true : false
-      end
-      
-      # Sets the specified ENV variables and returns the *current* env.
-      # If replace is true, current ENV variables are replaced; otherwise
-      # the new env variables are simply added to the existing set.
-      def set_env(env={}, replace=false)
-        current_env = {}
-        ENV.each_pair do |key, value|
-          current_env[key] = value
-        end
-        
-        ENV.clear if replace
-        
-        env.each_pair do |key, value|
-          ENV[key] = value
-        end if env
-        
-        current_env
-      end
-      
-      # Sets the specified ENV variables for the duration of the block.
-      # If replace is true, current ENV variables are replaced; otherwise
-      # the new env variables are simply added to the existing set.
-      #
-      # Returns the block return.
-      def with_env(env={}, replace=false)
-        current_env = nil
-        begin
-          current_env = set_env(env, replace)
-          yield
-        ensure
-          if current_env
-            set_env(current_env, true)
-          end
-        end
+        quiet.nil? || quiet =~ /^true$/i ? true : false
       end
       
       # Executes the command using IO.popen and returns the stdout content.
@@ -212,12 +173,13 @@ module Tap
       def sh_test(cmd, options={})
         options = sh_test_options.merge(options)
         
-        if cmd =~ /\A\s*?\n?(\s*)(.*?\n)(.*)\z/m
+        # strip indentiation if possible
+        if cmd =~ /\A(?:\s*?\n)?( *)(.*?\n)(.*)\z/m
           indent, cmd, expected = $1, $2, $3
           cmd.strip!
           
           if indent.length > 0 && options[:indents]
-            expected.gsub!(/^\s{0,#{indent.length}}/, '')
+            expected.gsub!(/^ {0,#{indent.length}}/, '')
           end
         end
         
@@ -228,8 +190,13 @@ module Tap
         result
       end
       
+      # Similar to sh_test, but matches the output against each of the
+      # regexps.  A hash of sh options can be provided as the last argument;
+      # it will be merged with the default sh_test_options.
+      #
+      # The output is yielded to the block, if given, for further validation.
+      # Returns the sh output.
       def sh_match(cmd, *regexps)
-        
         options = regexps.last.kind_of?(Hash) ? regexps.pop : {}
         options = sh_test_options.merge(options)
         result = sh(cmd, options)
@@ -241,14 +208,54 @@ module Tap
         result
       end
       
-      # Returns a hash of the default sh_test options.  See
-      # ShellTest::ClassMethods#sh_test_options.
+      # Returns a hash of default sh_test options.
       def sh_test_options
-        self.class.sh_test_options
+        {
+          :cmd_pattern => '% ',
+          :cmd => '2>&1 ',
+          :indents => true,
+          :env => {
+            'TAPFILE'   => nil,
+            'TAP_GEMS'  => nil, 
+            'TAP_PATH'  => nil,
+            'TAPENV'    => nil,
+            'TAPRC'     => nil,
+            'TAP_DEBUG' => nil
+          },
+          :replace_env => false
+        }
       end
       
+      # Asserts whether or not the a and b strings are equal, with a more
+      # readable output than assert_equal for large strings (especially large
+      # strings with significant whitespace).
+      #
+      # One gotcha is that assert_output_equal lstrips indentation off of 'a',
+      # so that these all pass:
+      #
+      #   assert_output_equal %q{
+      #   line one
+      #   line two
+      #   }, "line one\nline two\n"
+      #
+      #   assert_output_equal %q{
+      #     line one
+      #     line two
+      #   }, "line one\nline two\n
+      #
+      #     assert_output_equal %q{
+      #     line one
+      #     line two
+      #     }, "line one\nline two\n"
+      #
+      # Use the assert_output_equal! method to prevent indentation stripping.
       def assert_output_equal(a, b, msg=nil)
-        a = a[1..-1] if a[0] == ?\n
+        a = strip_indent(a)
+        assert_output_equal!(a, b, msg)
+      end
+      
+      # Same as assert_output_equal but without indentation stripping.
+      def assert_output_equal!(a, b, msg=nil)
         if a == b
           assert true
         else
@@ -262,8 +269,40 @@ module Tap
 }
         end
       end
-
+      
+      # Asserts whether or not b is like a (which should be a Regexp), and
+      # provides a more readable output in the case of a failure as compared
+      # with assert_match.
+      #
+      # If a is a string, then indentation is stripped off and it is turned
+      # into a RegexpEscape. Using that syntax, all these pass:
+      #
+      #   assert_alike %q{
+      #   the time is: :...:
+      #   now!
+      #   }, "the time is: #{Time.now}\nnow!\n"
+      #
+      #   assert_alike %q{
+      #     the time is: :...:
+      #     now!
+      #   }, "the time is: #{Time.now}\nnow!\n"
+      #
+      #     assert_alike %q{
+      #     the time is: :...:
+      #     now!
+      #     }, "the time is: #{Time.now}\nnow!\n"
+      #
+      # Use assert_alike! to prevent indentation stripping (conversion to a
+      # RegexpEscape is still in effect).
       def assert_alike(a, b, msg=nil)
+        a = strip_indent(a) if a.kind_of?(String)
+        assert_alike!(a, b, msg)
+      end
+      
+      # Same as assert_alike but without indentation stripping.
+      def assert_alike!(a, b, msg=nil)
+        a = RegexpEscape.new(a) if a.kind_of?(String)
+        
         if b =~ a
           assert true
         else
@@ -280,7 +319,21 @@ module Tap
       
       private
       
-      def whitespace_escape(str)
+      # helper for stripping indentation off a string
+      def strip_indent(str) # :nodoc:
+        if str =~ /\A\s*?\n( *)(.*)\z/m
+          indent, str = $1, $2, $3
+        
+          if indent.length > 0
+            str.gsub!(/^ {0,#{indent.length}}/, '')
+          end
+        end
+        
+        str
+      end
+      
+      # helper for formatting escaping whitespace into readable text
+      def whitespace_escape(str) # :nodoc:
         str.to_s.gsub(/\s/) do |match|
           case match
           when "\n" then "\\n\n"

data/lib/tap/test/subset_test.rb

@@ -5,37 +5,37 @@ module Tap
   module Test
     
     # SubsetTest provides methods to conditionally run tests.
-    # 
+    #  
     #   require 'tap/test'
     #
     #   class Test::Unit::TestCase
     #     # only true if running on windows
     #     condition(:windows) { match_platform?('mswin') }
-    # 
+    #  
     #     # only true if running on anything but windows
     #     condition(:non_windows) { match_platform?('non_mswin') }
     #   end
     #
     # Here the WindowsOnlyTest will only run on a Windows platform. Conditions
-    # like these may be targeted at specific tests when only some tests need 
+    # like these may be targeted at specific tests when only some tests need
     # to be skipped.
-    # 
+    #  
     #   class RunOnlyAFewTest < Test::Unit::TestCase
     #     include SubsetTest
-    # 
+    #  
     #     def test_runs_all_the_time
     #       assert true
     #     end
-    # 
+    #  
     #     def test_runs_only_if_non_windows_condition_is_true
     #       condition_test(:non_windows) { assert true }
     #       end
     #     end
-    # 
+    #  
     #     def test_runs_only_when_ENV_variable_EXTENDED_is_true
     #       extended_test { assert true }
     #     end
-    # 
+    #  
     #     def test_runs_only_when_ENV_variable_BENCHMARK_is_true
     #       benchmark_test do |x|
     #         x.report("init speed") { 10000.times { Object.new } }
@@ -46,24 +46,10 @@ module Tap
     #       subset_test('CUSTOM') { assert true }
     #     end
     #   end
-    # 
+    #  
     # In the example, the ENV variables EXTENDED, BENCHMARK, and CUSTOM act as
-    # flags to run specific tests.  If you're running your test using Rake, ENV
-    # variables can be set from the command line like so:
-    # 
-    #   % EXTENDED=true rake test 
-    #   % BENCHMARK=true rake test
-    # 
-    # Since tap and rap can run rake tasks as well, these are equivalent:
-    #
-    #   % EXTENDED=true tap run test
-    #   % BENCHMARK=true rap test
-    #
-    # To run all tests that get switched using an ENV variable, set ALL=true.
-    #
-    #   % ALL=true rap test
-    #
-    # See SubsetTest::ClassMethods for more information.
+    # flags to run specific tests.  See SubsetTest::ClassMethods for more
+    # information.
     module SubsetTest
       
       def self.included(base) # :nodoc:
@@ -209,37 +195,6 @@ module Tap
           Benchmark.bm(length, &block)
         end
       end
-
-      # Declares a subset_test for the ENV variable 'PROMPT'. When run, prompts
-      # the user for each input specified in array.  Inputs will then be passed
-      # as a hash to the block.  Prints 'p' unless run.
-      # 
-      #   def test_requiring_inputs
-      #     prompt_test(:a, :b, :c) {|a, b, c| ... }
-      #   end
-      #
-      # If run, the command line prompt will be like the following:
-      #
-      #   test_requiring_inputs: Enter values or 'skip'
-      #   a: avalue
-      #   b: bvalue      
-      #   c: cvalue
-      #
-      # The block recieves ['avalue', 'bvalue', 'cvalue'].  
-      def prompt_test(*keys, &block)
-        subset_test("PROMPT", "p") do
-          puts "\n#{name} -- Enter values or 'skip'."
-  
-          values = keys.collect do |key|
-            print "#{key}: "
-            value = gets.strip
-            flunk "skipped test" if value =~ /skip/i
-            value
-          end
-        
-          yield(*values)
-        end
-      end
     end
   end
 end

data/lib/tap/test/tap_test.rb

@@ -1,10 +1,8 @@
 require 'tap/app'
+require 'tap/test/env'
 
 module Tap
   module Test
-    
-    # Sets up and tears down Tap::App.instance.  This prevents tests that modify
-    # either from inadvertently conflicting with one another.
     module TapTest
       
       # The test specific app
@@ -12,21 +10,21 @@ module Tap
       
       def setup
         super
-        Tap::App.instance = @app = Tap::App.new(app_config)
-      end
-      
-      def env_config
-        {:gems => :none, :root => @method_root || Dir.pwd}
-      end
-      
-      def app_config
-        {:debug => true, :quiet => true, :env => Tap::Env.new(env_config)}
+        @app = Tap::App.new({:debug => true}, {:env => Env.new})
+        @context = Tap::App.set_context(Tap::App::CURRENT => @app)
+        @desc = nil
+        @baseclass = '/tap/task'
+        @namespace = self.class
       end
       
       def teardown
-        Tap::App.instance = nil
+        Tap::App.set_context(@context)
         super
       end
+      
+      def signal(sig, args=[], &block)
+        app.call({'sig' => sig, 'args' => args}, &block)
+      end
     end
   end
 end

data/lib/tap/test/tracer.rb

@@ -0,0 +1,24 @@
+require 'tap/middleware'
+
+module Tap
+  module Test
+    class Tracer < Middleware
+      attr_reader :stack
+      attr_reader :results
+      attr_reader :runlist
+      
+      def initialize(stack)
+        @stack = stack
+        @results = {}
+        @runlist = []
+      end
+      
+      def call(node, inputs=[])
+        runlist << node
+        result = stack.call(node, inputs)
+        (results[node] ||= []) << result
+        result
+      end
+    end
+  end
+end

data/lib/tap/test/utils.rb

@@ -58,17 +58,19 @@ module Tap
       #  # !> DereferenceError
       #
       def reference_map(source_dir, reference_dir, pattern='**/*.ref')
-        Dir.glob(File.join(source_dir, pattern)).sort.collect do |source|
+        source_root = Root.new(source_dir)
+        reference_root = Root.new(reference_dir)
+        source_root.glob(pattern).sort.collect do |source|
           # use the path specified in the source file
           relative_path = File.read(source).gsub(/#.*$/, "").strip
           
           # use the relative filepath of the source file to the
           # source dir (minus the extname) if no path is specified
           if relative_path.empty?
-            relative_path = Tap::Root::Utils.relative_path(source_dir, source).chomp(File.extname(source))
+            relative_path = source_root.rp(source).chomp(File.extname(source))
           end
           
-          reference = File.join(reference_dir, relative_path)
+          reference = reference_root.path(relative_path)
           
           # raise an error if no reference file is found
           unless File.exists?(reference)

data/lib/tap/test/version.rb

@@ -1,7 +1,7 @@
 module Tap
   module Test
     MAJOR = 0
-    MINOR = 3
+    MINOR = 6
     TINY = 0
 
     VERSION="#{MAJOR}.#{MINOR}.#{TINY}"

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: tap-test
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,19 +14,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-19 00:00:00 -07:00
+date: 2010-05-02 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: tap
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.19.0
-    version: 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: simon.a.chiang@gmail.com
 executables: []
@@ -34,23 +43,23 @@ extra_rdoc_files:
 - MIT-LICENSE
 files: 
 - lib/tap/test.rb
+- lib/tap/test/env.rb
 - lib/tap/test/file_test.rb
 - lib/tap/test/file_test/class_methods.rb
 - lib/tap/test/shell_test.rb
-- lib/tap/test/shell_test/class_methods.rb
 - lib/tap/test/shell_test/regexp_escape.rb
 - lib/tap/test/subset_test.rb
 - lib/tap/test/subset_test/class_methods.rb
 - lib/tap/test/tap_test.rb
+- lib/tap/test/tracer.rb
 - lib/tap/test/unit.rb
 - lib/tap/test/utils.rb
 - lib/tap/test/version.rb
-- tap.yml
 - History
 - README
 - MIT-LICENSE
 has_rdoc: true
-homepage: http://tap.rubyforge.org/tap-test/
+homepage: http://tap.rubyforge.org/tap-test
 licenses: []
 
 post_install_message: 
@@ -67,18 +76,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: tap
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Test modules for Tap

data/lib/tap/test/shell_test/class_methods.rb

@@ -1,28 +0,0 @@
-module Tap
-  module Test
-    module ShellTest
-      # Class methods extending tests which include ShellTest.
-      module ClassMethods
-      
-        # Sets the default sh_test_options
-        attr_writer :sh_test_options
-        
-        # Returns a hash of the default sh_test options.
-        def sh_test_options
-          @sh_test_options ||= {
-            :cmd_pattern => '% ',
-            :cmd => '2>&1 ',
-            :indents => true
-          }
-        end
-
-        private
-
-        # helper to retrieve class constants
-        def class_const(const_name) # :nodoc:
-          const_defined?(const_name) ? const_get(const_name) : nil
-        end
-      end
-    end
-  end
-end