tap-test 0.1.0

data/lib/tap/test/shell_test.rb

@@ -0,0 +1,208 @@
+if RUBY_PLATFORM =~ /mswin32/
+  begin
+    require 'rubygems'
+    require 'win32/open3'
+  rescue(LoadError)
+    puts %q{
+Tap:Test::ShellTest requires the win32-open3 gem on Windows.
+Use this command and try again:
+
+  % gem install win32-open3
+
+}
+    raise
+  end
+else
+  require 'open3'
+end
+
+require 'tap/test/shell_test/class_methods'
+
+module Tap
+  module Test
+    
+    # A module for testing shell scripts.
+    #
+    #   require 'test/unit'
+    #   class ShellTestSample < Test::Unit::TestCase
+    #     include Tap::Test::ShellTest
+    #
+    #     # these are the default sh_test options used 
+    #     # in tests like test_sh_command_alias
+    #     self.sh_test_options = {
+    #       :cmd_pattern => '% inspect_argv',
+    #       :cmd => 'ruby -e "puts ARGV.inspect"'
+    #     }
+    #
+    #     def test_echo
+    #       assert_equal "goodnight moon", sh("echo goodnight moon").strip
+    #     end
+    #
+    #     def test_echo_using_sh_test
+    #       sh_test %q{
+    #   echo goodnight moon
+    #   goodnight moon
+    #   }
+    #     end
+    #
+    #     def test_sh_command_alias
+    #       sh_test("% inspect_env") do |output|
+    #         assert output !~ /NEW_ENV_VAR/
+    #       end
+    #
+    #       sh_test("NEW_ENV_VAR=blue % inspect_env") do |output|
+    #         assert output =~ /NEW_ENV_VAR=blue/
+    #       end
+    #     end
+    #   end
+    #
+    module ShellTest
+      
+      def self.included(base) # :nodoc:
+        super
+        base.extend ShellTest::ClassMethods
+      end
+      
+      # Sets up the ShellTest module.  Be sure to call super if you override
+      # setup in an including module.
+      def setup
+        super
+        @shell_test_notification = false
+      end
+      
+      # Returns true if the ENV variable 'VERBOSE' is true.  When verbose,
+      # ShellTest prints the expanded commands of sh_test to $stdout.
+      def verbose?
+        ENV['VERBOSE'] == 'true'
+      end
+      
+      # Returns true if the ENV variable 'QUIET' is true.  When quiet,
+      # ShellTest does not print any extra information to $stdout.
+      def quiet?
+        ENV['QUIET'] == 'true'
+      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.
+      def with_env(env={}, replace=false)
+        current_env = {}
+        ENV.each_pair do |key, value|
+          current_env[key] = value
+        end
+        
+        begin
+          ENV.clear if replace
+          env.each_pair do |key, value|
+            ENV[key] = value
+          end if env
+          
+          yield
+          
+        ensure
+          ENV.clear
+          current_env.each_pair do |key, value|
+            ENV[key] = value
+          end
+        end
+      end
+      
+      # Executes the command using IO.popen and returns the stdout content.
+      #
+      # ==== Note
+      # On Windows this method requires the {win32-popen3}[http://rubyforge.org/projects/win32utils]
+      # utility.  If it is not available, it will have to be installed:
+      #
+      #   % gem install win32-open3 
+      # 
+      def sh(cmd)
+        Open3.popen3(cmd) do |i,o,s|
+          yield(i,o,s) if block_given?
+          return o.read
+        end
+      end
+      
+      # Peforms a shell test.  Shell tests execute the command and yield the
+      # $stdout result to the block for validation.  The command is executed
+      # through sh, ie using IO.popen.
+      #
+      # Options provided to sh_test are merged with the sh_test_options set
+      # for the class.
+      #
+      # ==== Command Aliases
+      #
+      # The options allow specification of a command pattern that gets
+      # replaced with a command alias.  Only the first instance of the command
+      # pattern is replaced.  In addition, shell tests allow the expected result
+      # to be specified inline with the command.  Used together, these allow
+      # multiple tests of a complex command to be specified easily:
+      #
+      #   opts = {
+      #     :cmd_pattern => '% argv_inspect',
+      #     :cmd => 'ruby -e "puts ARGV.inspect"'
+      #   }
+      #
+      #   sh_test %Q{
+      #   % argv_inspect goodnight moon
+      #   ["goodnight", "moon"]
+      #   }, opts
+      #
+      #   sh_test %Q{
+      #   % argv_inspect hello world
+      #   ["hello", "world"]
+      #   }, opts
+      #
+      # ==== ENV variables
+      #
+      # Options may specify a hash of env variables that will be set in the
+      # subprocess.
+      #
+      #   sh_test %Q{
+      #   ruby -e "puts ENV['SAMPLE']"
+      #   value
+      #   }, :env => {'SAMPLE' => 'value'}
+      #
+      # Note it is better to specify env variables in this way rather than
+      # through the command trick 'VAR=value cmd ...', as that syntax does
+      # not work on Windows.  As a point of interest, see
+      # http://gist.github.com/107363 for a demonstration of ENV
+      # variables being inherited by subprocesses.
+      # 
+      def sh_test(cmd, options={})
+        options = sh_test_options.merge(options)
+        
+        unless quiet? || @shell_test_notification
+          @shell_test_notification = true
+          puts
+          puts method_name 
+        end
+        
+        cmd, expected = cmd.lstrip.split(/\r?\n/, 2)
+        original_cmd = cmd
+        
+        if cmd_pattern = options[:cmd_pattern]
+          cmd = cmd.sub(cmd_pattern, options[:cmd].to_s)
+        end
+        
+        start = Time.now
+        result = with_env(options[:env], options[:replace_env]) do
+          sh(cmd)
+        end
+        finish = Time.now
+        
+        elapsed = "%.3f" % [finish-start]
+        puts "  (#{elapsed}s) #{verbose? ? cmd : original_cmd}" unless quiet?
+        
+        assert_equal(expected, result, cmd) if expected
+        yield(result) if block_given?
+        result
+      end
+      
+      # Returns a hash of the default sh_test options.  See
+      # ShellTest::ClassMethods#sh_test_options.
+      def sh_test_options
+        self.class.sh_test_options
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Tap
+  module Test
+    module SubsetTest
+      
+      # Class methods associated with SubsetTest.
+      module ClassMethods
+        
+        # Passes conditions to subclass
+        def inherited(child) # :nodoc:
+          super
+          dup = {}
+          conditions.each_pair {|key, value| dup[key] = value.dup }
+          child.instance_variable_set(:@conditions, dup)
+        end
+      
+        # Initialize conditions.
+        def self.extended(base) # :nodoc:
+          base.instance_variable_set(:@conditions, {})
+        end
+      
+        # A hash of [name, [msg, condition_block]] pairs defined by condition.
+        attr_reader :conditions
+    
+        # Defines a condition block and associated message.  
+        # Raises an error if no condition block is given.
+        def condition(name, msg=nil, &block)
+          raise ArgumentError, "no condition block given" unless block_given?
+          conditions[name] = [msg, block]
+        end
+      
+        # Returns true if the all blocks for the specified conditions return true.
+        #
+        #   condition(:is_true) { true }
+        #   condition(:is_false) { false }
+        #   satisfied?(:is_true)              # => true
+        #   satisfied?(:is_true, :is_false)   # => false
+        #
+        # Yields the name and message for each unsatisfied condition to the
+        # block, if given.
+        def satisfied?(*names) # :yields: name-of-unsatisfied-condition, msg
+          unsatisfied = unsatisfied_conditions(*names)
+        
+          unsatisfied.each do |name| 
+            yield(name, condition[name][0])
+          end if block_given?
+          
+          unsatisfied.empty?
+        end
+        
+        # Returns an array of the unsatified conditions.  Raises 
+        # an error if a condition has not been defined.
+        #
+        #   condition(:is_true) { true }
+        #   condition(:is_false) { false }
+        #   unsatisfied_conditions(:is_true, :is_false)   # => [:is_false]
+        #
+        def unsatisfied_conditions(*condition_names)
+          condition_names = conditions.keys if condition_names.empty?
+          unsatified = []
+          condition_names.each do |name|
+            unless condition = conditions[name]
+              raise ArgumentError, "Unknown condition: #{name}"
+            end
+          
+            unsatified << name unless condition.last.call
+          end
+          unsatified
+        end
+      
+        # Returns true if RUBY_PLATFORM matches one of the specfied
+        # platforms.  Use the prefix 'non_' to specify any plaform 
+        # except the specified platform (ex: 'non_mswin').  Returns
+        # true if no platforms are specified.
+        #
+        # Some common platforms:
+        #   mswin    Windows
+        #   darwin   Mac
+        def match_platform?(*platforms)
+          platforms.each do |platform|
+            platform.to_s =~ /^(non_)?(.*)/
+
+            non = true if $1
+            match_platform = !RUBY_PLATFORM.index($2).nil?
+            return false unless (non && !match_platform) || (!non && match_platform)
+          end
+
+          true
+        end
+      
+        # Returns true if type or 'ALL' is specified as 'true' in ENV.
+        def run_subset?(type)
+          ENV[type] == "true" || ENV['ALL'] == "true" ? true : false
+        end
+      end
+    end
+  end
+end

data/lib/tap/test/subset_test.rb

@@ -0,0 +1,245 @@
+require 'benchmark'
+require 'tap/test/subset_test/class_methods'
+
+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 
+    # 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 } }
+    #       end
+    #     end
+    #
+    #     def test_runs_only_when_ENV_variable_CUSTOM_is_true
+    #       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.
+    module SubsetTest
+      
+      def self.included(base) # :nodoc:
+        super
+        base.extend SubsetTest::ClassMethods
+      end
+      
+      # Returns true if the specified conditions are satisfied.
+      def satisfied?(*condition_names)
+        self.class.satisfied?(*condition_names)
+      end
+      
+      # Returns true if the subset type (ex 'BENCHMARK') or 'ALL' is
+      # specified in ENV.
+      def run_subset?(type)
+        self.class.run_subset?(type)
+      end
+
+      # Returns true if the input string matches the regexp specified in 
+      # ENV[type]. Returns the default value if ENV['ALL'] is 'true', and the
+      # default if type is not specified in ENV.
+      def match_regexp?(type, str, default=true)
+        return true if ENV["ALL"] == 'true'
+        return default unless value = ENV[type]
+    
+        str =~ Regexp.new(value) ? true : false
+      end
+
+      # Platform-specific test.  Useful for specifying test that should only 
+      # be run on a subset of platforms.  Prints ' ' if the test is not run.
+      #
+      #   def test_only_on_windows
+      #     platform_test('mswin') { ... }
+      #   end
+      #
+      # See SubsetTestClass#match_platform? for matching details.
+      def platform_test(*platforms)
+        if self.class.match_platform?(*platforms)
+          yield
+        else
+          print ' '
+        end
+      end
+      
+      # Conditonal test.  Only runs if the specified conditions are satisfied.
+      # If no conditons are explicitly set, condition_test only runs if ALL 
+      # conditions for the test are satisfied.
+      # 
+      #   condition(:is_true) { true }
+      #   condition(:is_false) { false }
+      #
+      #   def test_only_if_true_is_satisfied
+      #     condition_test(:is_true) { # runs }
+      #   end
+      #
+      #   def test_only_if_all_conditions_are_satisfied
+      #     condition_test {  # does not run }
+      #   end
+      #
+      # See SubsetTestClass#condition for more details.
+      def condition_test(*condition_names)
+        if self.class.unsatisfied_conditions(*condition_names).empty?
+          yield
+        else
+          print ' '
+        end
+      end
+      
+      # Defines a subset test.  The provided block will only run if:
+      # - the subset type is specified in ENV
+      # - the subset 'ALL' is specified in ENV
+      # - the test method name matches the regexp provided in the 
+      #   <TYPE>_TEST ENV variable
+      #  
+      # Otherwise the block will be skipped and +skip+ will be printed in the
+      # test output.  By default skip is the first letter of +type+.
+      #
+      # For example, with these methods:
+      #
+      #   def test_one
+      #     subset_test('CUSTOM') { assert true }
+      #   end
+      #
+      #   def test_two
+      #     subset_test('CUSTOM') { assert true }
+      #   end
+      #
+      #   Condition                    Tests that get run
+      #   ENV['ALL']=true              test_one, test_two
+      #   ENV['CUSTOM']=true           test_one, test_two
+      #   ENV['CUSTOM_TEST']=test_     test_one, test_two
+      #   ENV['CUSTOM_TEST']=test_one  test_one
+      #   ENV['CUSTOM']=nil            no tests get run
+      # 
+      # If you're running your tests with rake (or rap), ENV variables may be
+      # set from the command line.
+      #
+      #   # all tests
+      #   % rap test all=true
+      #
+      #   # custom subset tests
+      #   % rap test custom=true
+      #
+      #   # just test_one (it is the only test
+      #   # matching the '.est_on.' pattern)
+      #   % rap test custom_test=.est_on.
+      #
+      def subset_test(type, skip=type[0..0].downcase)
+        type = type.upcase
+        if run_subset?(type) || ENV[type]
+          if match_regexp?("#{type}_TEST", name.to_s)
+            yield
+          else
+            print skip
+          end
+        else
+          print skip
+        end
+      end
+  
+      # Declares a subset_test for the ENV variable 'EXTENDED'.
+      # Prints 'x' if the test is not run.
+      #
+      #   def test_some_long_process
+      #     extended_test { ... }
+      #   end
+      def extended_test(&block) 
+        subset_test("EXTENDED", "x", &block)
+      end
+  
+      # Declares a subset_test for the ENV variable 'BENCHMARK'. If run, 
+      # benchmark_test sets up benchmarking using the Benchmark.bm method 
+      # using the input length and block.  Prints 'b' if the test is not run.
+      #
+      #   include Benchmark
+      #   def test_speed
+      #     benchmark_test(10) {|x| ... }
+      #   end
+      def benchmark_test(length=10, &block) 
+        subset_test("BENCHMARK") do
+          puts
+          puts name
+          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

@@ -0,0 +1,22 @@
+module Tap
+  module Test
+    
+    # Simply sets up and tears down Tap::App.instance so that tests that
+    # instantiate classes will not inadvertently smush over into one another.
+    module TapTest
+      
+      # The test specific app
+      attr_reader :app
+
+      def setup
+        super
+        @app = Tap::App.instance = Tap::App.new(:debug => true, :quiet => true)
+      end
+
+      def teardown
+        Tap::App.instance = nil
+        super
+      end
+    end
+  end
+end

data/lib/tap/test/unit.rb

@@ -0,0 +1,83 @@
+require 'test/unit'
+require 'tap/test'
+
+if Object.const_defined?(:MiniTest)
+  
+  ################################
+  # MiniTest shims (ruby 1.9)
+  ################################
+  
+  # Tap-Test adds a class skip_test method to TestCase to allow a full class
+  # to be skipped (for instance due to a failed Tap::Test::SubsetTest
+  # condition).  The method is not required by any Tap-Test module.
+  class Test::Unit::TestCase
+    class << self
+      # Causes a test suite to be skipped.  If a message is given, it will
+      # print and notify the user the test suite has been skipped.
+      def skip_test(msg=nil)
+        @@test_suites.delete(self)
+        puts "Skipping #{self}#{msg.empty? ? '' : ': ' + msg}"
+      end
+    end
+  end
+  
+  # MiniTest renames method_name as name.  For backwards compatibility
+  # (and for Tap::Test::FileTest) it must be added back.
+  class MiniTest::Unit::TestCase
+    def method_name
+      name
+    end
+  end
+
+  MiniTest::Unit::TestCase.extend Tap::Test
+
+else
+  
+  ################################
+  # Test::Unit shims (< ruby 1.9)
+  ################################
+  # :stopdoc:
+  # Implementing skip_test in the original Test::Unit is considerably more
+  # tricky than in the Mini::Test Test::Unit.
+  class Test::Unit::TestCase
+    class << self
+      alias tap_original_test_case_inherited inherited
+    
+      def inherited(child)
+        super
+        tap_original_test_case_inherited(child)
+        child.instance_variable_set(:@skip_messages, [])
+        child.instance_variable_set(:@run_test_suite, true)
+      end
+    
+      # Causes a test suite to be skipped.  If a message is given, it will
+      # print and notify the user the test suite has been skipped.
+      def skip_test(msg=nil)
+        @run_test_suite = false
+        @skip_messages << msg
+      end
+    
+      alias :original_suite :suite
+
+      # Modifies the default suite method to skip the suit unless
+      # run_test_suite is true.  If the test is skipped, the skip_messages 
+      # will be printed along with the default 'Skipping <Test>' message.
+      def suite # :nodoc:
+        if @run_test_suite
+          original_suite
+        else
+          skip_message = @skip_messages.compact.join(', ')
+          puts "Skipping #{name}#{skip_message.empty? ? '' : ': ' + skip_message}"
+
+          # return an empty test suite of the appropriate name
+          Test::Unit::TestSuite.new(name)
+        end
+      end
+    end
+  end
+  
+  Test::Unit::TestCase.extend Tap::Test
+  # :startdoc:
+end
+
+