rubytest 0.3.0

data/lib/rubytest/reporters/summary.rb

@@ -0,0 +1,145 @@
+# encoding: UTF-8
+
+module Test::Reporters
+
+  # Summary Reporter
+  class Summary < Abstract
+
+    #
+    SEP = '  '
+
+    #
+    def begin_suite(suite)
+      timer_reset
+      @tc = []
+    end
+
+    #
+    def begin_case(tc)
+      @tc << tc.to_s.split("\n").first
+    end
+
+    #
+    #def report_instance(instance)
+    #  puts
+    #  puts instance #"== #{concern.description}\n\n" unless concern.description.empty?
+    #  #timer_reset
+    #end
+
+    #
+    #def begin_test(test)
+    #   context = test.context
+    #   if @instance != context
+    #     @context = context
+    #     puts
+    #     puts "  #{context}"
+    #     puts
+    #   end
+    #end
+
+    #
+    def pass(test)
+      print "PASS  ".ansi(:green, :bold)
+      e = @tc + [test.to_s]
+      puts e.join(SEP).ansi(:green)
+    end
+
+    #
+    def fail(test, exception)
+      print "FAIL  ".ansi(:red, :bold)
+      e = @tc + [test.to_s]
+      puts e.join(SEP).ansi(:red)
+    end
+
+    #
+    def error(test, exception)
+      print "ERROR  ".ansi(:red, :bold)
+      e = @tc + [test.to_s]
+      puts e.join(SEP).ansi(:red)
+    end
+
+    #
+    def todo(test, exception)
+      print "TODO  ".ansi(:yellow, :bold)
+      e = @tc + [test.to_s]
+      puts e.join(SEP).ansi(:yellow)
+    end
+
+    #
+    def omit(test)
+      print "OMIT  ".ansi(:cyan, :bold)
+      e = @tc + [test.to_s]
+      puts e.join(SEP).ansi(:cyan)
+    end
+
+    #
+    def skip_test(test)
+      print "SKIP ".ansi(:blue, :bold)
+      e = @tc + [test.to_s]
+      puts e.join(SEP).ansi(:blue)
+    end
+
+    #
+    def end_case(test_case)
+      @tc.pop
+    end
+
+    #
+    def end_suite(suite)
+      puts
+
+      unless record[:pending].empty?
+        puts "PENDING:\n\n"
+        record[:pending].each do |test, exception|
+          puts "    #{test}"
+          puts "    #{file_and_line(exception)}"
+          puts
+        end
+      end
+
+      unless record[:fail].empty?
+        puts "FAILURES:\n\n"
+        record[:fail].each do |test, exception|
+          puts "    #{test}"
+          puts "    #{file_and_line(exception)}"
+          puts "    #{exception}"
+          puts code(exception).to_s
+          #puts "    #{exception.backtrace[0]}"
+          puts
+        end
+      end
+
+      unless record[:error].empty?
+        puts "ERRORS:\n\n"
+        record[:error].each do |test, exception|
+          puts "    #{test}"
+          puts "    #{file_and_line(exception)}"
+          puts "    #{exception}"
+          puts code(exception).to_s
+          #puts "    #{exception.backtrace[0]}"
+          puts
+        end
+      end
+
+      puts timestamp
+      puts
+      puts tally
+    end
+
+  private
+
+    #
+    def timer
+      secs  = Time.now - @time
+      @time = Time.now
+      return "%0.5fs" % [secs.to_s]
+    end
+
+    #
+    def timer_reset
+      @time = Time.now
+    end
+
+  end
+
+end

data/lib/rubytest/reporters/tap.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+
+module Test::Reporters
+
+  # Classic TAP Reporter
+  #
+  # This reporter conforms to v12 of TAP. It could do with some
+  # imporvements yet, and eventually upgraded to v13 of standard.
+  class Tap < Abstract
+
+    #
+    def begin_suite(suite)
+      @start_time = Time.now
+      @i = 0
+      @n = total_count(suite)
+      puts "1..#{@n}"
+    end
+
+    def begin_test(test)
+      @i += 1
+    end
+
+    #
+    def pass(test)
+      puts "ok #{@i} - #{test}"
+    end
+
+    #
+    def fail(test, exception)
+      puts "not ok #{@i} - #{test}"
+      puts "  FAIL #{exception.class}"
+      puts "  #{exception}"
+      puts "  #{clean_backtrace(exception)[0]}"
+    end
+
+    #
+    def error(test, exception)
+      puts "not ok #{@i} - #{test}"
+      puts "  ERROR #{exception.class}"
+      puts "  #{exception}"
+      puts "  " + clean_backtrace(exception).join("\n        ")
+    end
+
+    #
+    def todo(test, exception)
+      puts "not ok #{@i} - #{test}"
+      puts "  PENDING"
+      puts "  #{clean_backtrace(exception)[1]}"
+    end
+
+    #
+    def omit(test, exception)
+      puts "ok #{@i} - #{test}"
+      puts "  OMIT"
+      puts "  #{clean_backtrace(exception)[1]}"
+    end
+
+  end
+
+end
+

data/lib/rubytest/reporters/tapj.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module Test::Reporters
+
+  # TAP-J Reporter
+  #
+  class Tapj < AbstractHash
+
+    #
+    def initialize(runner)
+      require 'json'
+      super(runner)
+    end
+
+    #
+    def begin_suite(suite)
+      puts super(suite).to_json
+    end
+
+    #
+    def begin_case(test_case)
+      puts super(test_case).to_json
+    end
+
+    #
+    def pass(test) #, backtrace=nil)
+      puts super(test).to_json
+    end
+
+    #
+    def fail(test, exception)
+      puts super(test, exception).to_json
+    end
+
+    #
+    def error(test, exception)
+      puts super(test, exception).to_json
+    end
+
+    #
+    def todo(test, exception)
+      puts super(test, exception).to_json
+    end
+
+    #
+    def end_suite(suite)
+      puts super(suite).to_json
+      puts "..."
+    end
+
+  end
+
+end

data/lib/rubytest/reporters/tapy.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+module Test::Reporters
+
+  # TAP-Y Reporter
+  #
+  class Tapy < AbstractHash
+
+    #
+    def initialize(runner)
+      require 'json'
+      super(runner)
+    end
+
+    #
+    def begin_suite(suite)
+      puts super(suite).to_yaml
+    end
+
+    #
+    def begin_case(test_case)
+      puts super(test_case).to_yaml
+    end
+
+    #
+    def pass(test) #, backtrace=nil)
+      puts super(test).to_yaml
+    end
+
+    #
+    def fail(test, exception)
+      puts super(test, exception).to_yaml
+    end
+
+    #
+    def error(test, exception)
+      puts super(test, exception).to_yaml
+    end
+
+    #
+    def todo(test, exception)
+      puts super(test, exception).to_yaml
+    end
+
+    #
+    def omit(test, exception)
+      puts super(test, exception).to_yaml
+    end
+
+    #
+    def end_suite(suite)
+      puts super(suite).to_yaml
+      puts "..."
+    end
+
+  end
+
+end

data/lib/rubytest/reporters/test.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+module Test::Reporters
+
+  # Test Reporter is used to test Ruby Test itself.
+  #
+  class Test < AbstractHash
+
+    #
+    def initialize(runner)
+      super(runner)
+    end
+
+    #
+    def begin_suite(suite)
+      super(suite)
+    end
+
+    #
+    def begin_case(test_case)
+      super(test_case)
+    end
+
+    #
+    def pass(test) #, backtrace=nil)
+      super(test)
+    end
+
+    #
+    def fail(test, exception)
+      super(test, exception)
+    end
+
+    #
+    def error(test, exception)
+      super(test, exception)
+    end
+
+    #
+    def todo(test, exception)
+      super(test, exception)
+    end
+
+    #
+    def end_suite(suite)
+      super(suite)
+    end
+
+  end
+
+end

data/lib/rubytest/runner.rb

@@ -0,0 +1,349 @@
+module Test
+
+  # The Test::Runner class handles the execution of tests.
+  #
+  class Runner
+
+    # Default report is in the old "dot-progress" format.
+    DEFAULT_FORMAT = 'dotprogress'
+
+    # Exceptions that are not caught by test runner.
+    OPEN_ERRORS = [NoMemoryError, SignalException, Interrupt, SystemExit]
+
+    # / / / D E F A U L T S / / /
+
+    # Default test suite ($TEST_SUITE).
+    def self.suite
+      $TEST_SUITE
+    end
+
+    # Default list of test files to load.
+    def self.files
+      @files ||= []
+    end
+
+    #
+    def self.format
+      @format || DEFAULT_FORMAT
+    end
+
+    #
+    def self.format=(format)
+      @format = format
+    end
+
+    #
+    def self.verbose
+      @verbose
+    end
+
+    #
+    def self.verbose=(boolean)
+      @verbose = !!boolean
+    end
+
+    # Default description match for filtering tests.
+    def self.match
+      @match ||= []
+    end
+
+    # Default selection of tags for filtering tests.
+    def self.tags
+      @tags ||= []
+    end
+
+    # Default selection of units for filtering tests.
+    def self.units
+      @unit ||= []
+    end
+
+    #
+    def self.hard
+      @hard
+    end
+
+    #
+    def self.hard=(boolean)
+      @hard = !!boolean
+    end
+
+    # / / / A T T R I B U T E S / / /
+
+    # Test suite to run. This is a list of compliant test units and test cases.
+    attr :suite
+
+    # Test files to load.
+    attr :files
+
+    # Reporter format name, or name fragment, used to look up reporter class.
+    attr :format
+
+    #
+    def format=(name)
+      @format = name.to_s
+    end
+
+    # Matching text used to filter which tests are run.
+    attr :match
+
+    # Selected tags used to filter which tests are run.
+    attr :tags
+
+    # List of units with which to filter tests. It is an array of strings
+    # which are matched against module, class and method names.
+    attr :units
+
+    # Show extra details in reports.
+    def verbose?
+      @verbose
+    end
+
+    #
+    def verbose=(boolean)
+      @verbose = !!boolean
+    end
+
+    # Use "hard" test mode?
+    def hard?
+      @hard
+    end
+
+    #
+    def hard=(boolean)
+      @hard = !!boolean
+    end
+
+    # New Runner.
+    #
+    # @param [Array] suite
+    #   A list of compliant tests/testcases.
+    #
+    def initialize(options={}, &block)
+      @suite     = options[:suite]   || self.class.suite
+      @files     = options[:files]   || self.class.files
+      @format    = options[:format]  || self.class.format
+      @tags      = options[:tags]    || self.class.tags
+      @units     = options[:units]   || self.class.units
+      @match     = options[:match]   || self.class.match
+      @verbose   = options[:verbose] || self.class.verbose
+      @hard      = options[:hard]    || self.class.hard
+
+      block.call(self) if block
+    end
+
+    # The reporter to use for ouput.
+    attr :reporter
+
+    # Record pass, fail, error, pending and omitted tests.
+    attr :recorder
+
+    # Array of observers, typically this just contains the recorder and
+    # reporter instances.
+    attr :observers
+
+    # Run test suite.
+    #
+    # @return [Boolean]
+    #   That the tests ran without error or failure.
+    #
+    def run
+      ignore_callers
+
+      files_resolved.each do |file|
+        require file
+      end
+
+      @reporter  = reporter_load(format)
+      @recorder  = Recorder.new
+      @observers = [@reporter, @recorder]
+
+      #cd_tmp do
+        observers.each{ |o| o.begin_suite(suite) }
+        run_thru(suite)
+        observers.each{ |o| o.end_suite(suite) }
+      #end
+
+      recorder.success?
+    end
+
+  private
+
+    # Add to RUBY_IGNORE_CALLERS.
+    #
+    # @todo Improve on this!
+    def ignore_callers
+      ignore_path   = File.expand_path(File.join(__FILE__, '../../..'))
+      ignore_regexp = Regexp.new(Regexp.escape(ignore_path))
+
+      ::RUBY_IGNORE_CALLERS << ignore_regexp
+      ::RUBY_IGNORE_CALLERS << /bin\/rubytest/
+    end
+
+    #
+    def run_thru(list)
+      list.each do |t|
+        if t.respond_to?(:each)
+          run_case(t)
+        elsif t.respond_to?(:call)
+          run_test(t)
+        else
+          #run_note(t) ?
+        end
+      end
+    end
+
+    # Run a test case.
+    #
+    def run_case(tcase)
+      if tcase.respond_to?(:skip?) && tcase.skip?
+        return observers.each{ |o| o.skip_case(tcase) }
+      end
+
+      observers.each{ |o| o.begin_case(tcase) }
+
+      if tcase.respond_to?(:call)
+        tcase.call do
+          run_thru( select(tcase) )
+        end
+      else
+        run_thru( select(tcase) )
+      end
+
+      observers.each{ |o| o.end_case(tcase) }
+    end
+
+    # Run a test.
+    #
+    # @param [Object] test
+    #   The test to run, must repsond to #call.
+    #
+    def run_test(test)
+      if test.respond_to?(:skip?) && test.skip?
+        return observers.each{ |o| o.skip_test(test) }
+      end
+
+      observers.each{ |o| o.begin_test(test) }
+      begin
+        success = test.call
+        if hard? && !success  # TODO: separate run_test method to speed things up?
+          raise Assertion, "failure of #{test}"
+        else
+          observers.each{ |o| o.pass(test) }
+        end
+      rescue *OPEN_ERRORS => exception
+        raise exception
+      rescue NotImplementedError => exception
+        if exception.assertion?
+          observers.each{ |o| o.omit(test, exception) }
+        else
+          observers.each{ |o| o.todo(test, exception) }
+        end
+      rescue Exception => exception
+        if exception.assertion?
+          observers.each{ |o| o.fail(test, exception) }
+        else
+          observers.each{ |o| o.error(test, exception) }
+        end
+      end
+      observers.each{ |o| o.end_test(test) }
+    end
+
+    # TODO: Make sure this filtering code is correct for the complex 
+    #       condition that that ordered testcases can't have their tests
+    #       filtered individually (since they may depend on one another).
+
+    # Filter cases based on selection criteria.
+    #
+    # @return [Array] selected test cases
+    def select(cases)
+      selected = []
+      if cases.respond_to?(:ordered?) && cases.ordered?
+        cases.each do |tc|
+          selected << tc
+        end
+      else
+        cases.each do |tc|
+          next if tc.respond_to?(:skip?) && tc.skip?
+          next if !match.empty? && !match.any?{ |m| m =~ tc.to_s }
+
+          if !units.empty?
+            next unless tc.respond_to?(:unit)
+            next unless units.find{ |u| tc.unit.start_with?(u) }
+          end
+
+          if !tags.empty?
+            next unless tc.respond_to?(:tags)
+            tc_tags = [tc.tags].flatten.map{ |t| t.to_s }
+            next if (tags & tc_tags).empty?
+          end
+
+          selected << tc
+        end
+      end
+      selected
+    end
+
+    # Get a reporter instance be name fragment.
+    #
+    # @return [Reporter::Abstract]
+    #   The test reporter instance.
+    #
+    def reporter_load(format)
+      format = DEFAULT_REPORT_FORMAT unless format
+      format = format.to_s.downcase
+      name   = reporter_list.find{ |r| /^#{format}/ =~ r }
+
+      raise "unsupported report format" unless format
+
+      if RUBY_VERSION < '1.9'
+        require "rubytest/reporters/#{name}"
+      else
+        require_relative "reporters/#{name}"
+      end
+
+      reporter = Test::Reporters.const_get(name.capitalize)
+      reporter.new(self)
+    end
+
+    # Returns a list of available report types.
+    #
+    # @return [Array<String>]
+    #   The names of available reporters.
+    #
+    def reporter_list
+      list = Dir[File.dirname(__FILE__) + '/reporters/*.rb']
+      list = list.map{ |r| File.basename(r).chomp('.rb') }
+      list = list.reject{ |r| /^abstract/ =~ r }
+      list.sort
+    end
+
+    # Files can be globs and directories which need to be
+    # resolved to a list of files.
+    #
+    def files_resolved
+      list = files.flatten
+      list = list.map{ |f| Dir[f] }.flatten
+      list = list.map{ |f| File.directory?(f) ? Dir[File.join(f, '**/*.rb')] : f }
+      list = list.flatten.uniq
+      list = list.map{ |f| File.expand_path(f) } 
+      list
+    end
+
+=begin
+  # TODO ?
+  def cd_tmp(&block)
+    dir = Test::Config.root + '/tmp'
+    if Directory.exist?(dir)
+      dir = File.join(dir, 'test')
+      FileUtils.mkdir(dir) unless File.exist?(dir)
+    else
+      dir = File.join(Dir.tmpdir)
+    end
+
+    Dir.chdir(dir, &block)
+  end
+=end
+
+  end
+
+end