test 0.2.0

data/lib/test/recorder.rb

@@ -0,0 +1,53 @@
+module Test
+
+  # Recorder class is an observer that tracks all tests
+  # that are run and categorizes them according to their
+  # test status.
+  class Recorder
+
+    def initialize
+      @table = Hash.new{ |h,k| h[k] = [] }
+    end
+
+    def [](key)
+      @table[key.to_sym]
+    end
+
+    #
+    def skip(test)
+      self[:skip] << test
+    end
+
+    # Add `test` to pass set.
+    def pass(test)
+      self[:pass] << test
+    end
+
+    def fail(test, exception)
+      self[:fail] << [test, exception]
+    end
+
+    def error(test, exception)
+      self[:error] << [test, exception]
+    end
+
+    def todo(test, exception)
+      self[:todo] << [test, exception]
+    end
+
+    def omit(test, exception)
+      self[:omit] << [test, exception]
+    end
+
+    # Returns true if their are no test errors or failures.
+    def success?
+      self[:error].size + self[:fail].size > 0 ? false : true
+    end
+
+    # Ignore any other signals.
+    def method_missing(*a)
+    end
+
+  end
+
+end

data/lib/test/reporters/abstract.rb

@@ -0,0 +1,238 @@
+require 'ansi/core'
+require 'test/core_ext'
+require 'test/code_snippet'
+
+ignore_path   = File.expand_path(File.join(__FILE__, '../../..'))
+ignore_regexp = Regexp.new(Regexp.escape(ignore_path))
+
+RUBY_IGNORE_CALLERS = [] unless defined? RUBY_IGNORE_CALLERS
+RUBY_IGNORE_CALLERS << ignore_regexp
+RUBY_IGNORE_CALLERS << /bin\/ruby-test/
+
+module Test
+
+  #
+  module Reporters
+
+    # Test Reporter Base Class
+    class Abstract
+
+      #
+      def self.inherited(base)
+        registry << base
+      end
+
+      #
+      def self.registry
+        @registry ||= []
+      end
+
+      #
+      def initialize(runner)
+        @runner = runner
+        #@source = {}
+
+        # in case start_suite is overridden
+        @start_time = Time.now
+      end
+
+      #
+      attr :runner
+
+      #
+      def begin_suite(test_suite)
+        @start_time = Time.now
+      end
+
+      #
+      def begin_case(test_case)
+      end
+
+      #
+      def begin_test(test)
+      end
+
+      #
+      def skip_case(test_case)
+      end
+
+      #
+      def skip_test(test)
+      end
+
+      #
+      #def test(test)
+      #end
+
+      #
+      def pass(test)
+      end
+
+      #
+      def fail(test, exception)
+      end
+
+      #
+      def error(test, exception)
+      end
+
+      # Report a pending test.
+      def todo(test, exception)
+      end
+
+      # Report an omitted test.
+      def omit(test, exception)
+      end
+
+      #
+      def end_test(test)
+      end
+
+      #
+      def end_case(test_case)
+      end
+
+      #
+      def end_suite(test_suite)
+      end
+
+    protected
+
+      def record
+        runner.recorder
+      end
+
+      # Is coverage information requested?
+      #def cover?
+      #  runner.cover?
+      #end
+
+      # Count up the total number of tests.
+      def total_count(suite)
+        c = 0
+        suite.each do |tc|
+          if tc.respond_to?(:each)
+            c += total_count(tc)
+          else
+            c += 1
+          end
+        end
+        return c
+      end
+
+      # Common timestamp any reporter can use.
+      def timestamp
+        seconds = Time.now - @start_time
+
+        "Finished in %.5fs, %.2f tests/s." % [seconds, total/seconds]
+      end
+
+      #
+      def total
+        @total ||= subtotal
+      end
+
+      #
+      def subtotal
+        [:todo, :pass, :fail, :error, :omit].inject(0) do |s,r|
+          s += record[r.to_sym].size; s
+        end
+      end
+
+      # TODO: Add assertion counts (if reasonably possible).
+
+      # Common tally stamp any reporter can use.
+      #
+      # @return [String] tally stamp
+      def tally
+        sizes = %w{pass fail error todo omit}.map{ |r| record[r.to_sym].size }
+        data  = [total] + sizes
+
+        s = "%s tests: %s passing, %s failures, %s errors, %s pending, %s omissions" % data
+        #s += "(#{uncovered_units.size} uncovered, #{undefined_units.size} undefined)" if cover?
+        s
+      end
+
+      #--
+      # TODO: Matching `bin/ruby-test` is not robust.
+      #++
+
+      # Remove reference to lemon library from backtrace.
+      #
+      # @param [Exception] exception
+      #   The error that was rasied.
+      #
+      # @return [Array] filtered backtrace
+      def clean_backtrace(exception)
+        trace = (Exception === exception ? exception.backtrace : exception)
+        return trace if $DEBUG
+        trace = trace.reject{ |t| RUBY_IGNORE_CALLERS.any?{ |r| r =~ t }}
+        trace = trace.map do |t|
+          i = t.index(':in')
+          i ? t[0...i] : t
+        end
+        #if trace.empty?
+        #  exception
+        #else
+        #  exception.set_backtrace(trace) if Exception === exception
+        #  exception
+        #end
+        trace.uniq
+      end
+
+      # That an exception, backtrace or source code text and line
+      # number and return a CodeSnippet object.
+      #
+      # @return [CodeSnippet] code snippet
+      def code(source, line=nil)
+        case source
+        when Exception, Array
+          CodeSnippet.from_backtrace(clean_backtrace(source))
+        else
+          CodeSnippet.new(source, line)
+        end
+      end
+
+      #--
+      # TODO: Show more of the file name than just the basename.
+      #++
+
+      #
+      def file_and_line(exception)
+        line = clean_backtrace(exception)[0]
+        return "" unless line
+        i = line.rindex(':in')
+        line = i ? line[0...i] : line
+        File.basename(line)
+      end
+
+      #
+      def file_and_line_array(exception)
+        case exception
+        when Exception
+          line = exception.backtrace[0]
+        else
+          line = exception[0] # backtrace
+        end
+        return ["", 0] unless line
+        i = line.rindex(':in')
+        line = i ? line[0...i] : line
+        f, l = File.basename(line).split(':')
+        return [f, l.to_i]
+      end
+
+      #
+      def file(exception)
+        file_and_line_array(exception).first
+      end
+
+      #
+      def line(exception)
+        file_and_line_array(exception).last
+      end
+
+    end
+
+  end
+
+end

data/lib/test/reporters/abstract_hash.rb

@@ -0,0 +1,224 @@
+require 'test/reporters/abstract'
+
+module Test::Reporters
+
+  # Hash Abstract is a base class for the TAP-Y
+  # and TAP-J reporters.
+  #
+  class AbstractHash < Abstract
+
+    #
+    def begin_suite(suite)
+      require 'yaml'
+
+      @start_time = Time.now
+      @case_level = 0
+      @test_index = 0
+
+      now = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+
+      h = {
+        'type'  => 'suite',
+        'start' => now,
+        'count' => total_count(suite)
+      }
+
+      return h
+    end
+
+    #
+    def begin_case(test_case)
+      h = {}
+      h['type' ] = 'case'
+      h['level'] = @case_level
+
+      merge_subtype      h, test_case
+      merge_setup        h, test_case
+      merge_description  h, test_case
+
+      @case_level += 1
+
+      return h
+    end
+
+    #
+    def begin_test(test)
+      @test_index += 1
+    end
+
+    #
+    def pass(test) #, backtrace=nil)
+      h = {}
+      h['type'  ] = 'test'
+      h['status'] = 'pass'
+
+      merge_subtype      h, test
+      merge_setup        h, test
+      merge_description  h, test
+      #merge_comparison  h, test, exception
+      #merge_coverage    h, test
+      merge_source       h, test
+      merge_time         h
+
+      return h
+    end
+
+    #
+    def fail(test, exception)
+      h = {}
+      h['type'  ] = 'test'
+      h['status'] = 'fail'
+
+      merge_subtype      h, test
+      merge_setup        h, test
+      merge_description  h, test
+      #merge_comparison  h, test, exception
+      #merge_coverage    h, test
+      merge_source       h, test
+      merge_exception    h, test, exception
+      merge_time         h
+ 
+      return h
+    end
+
+    #
+    def error(test, exception)
+      h = {}
+      h['type'  ] = 'test'
+      h['status'] = 'error'
+
+      merge_subtype      h, test
+      merge_setup        h, test
+      merge_description  h, test
+      #merge_comparison  h, test, exception
+      #merge_coverage    h, test
+      merge_source       h, test
+      merge_exception    h, test, exception, true
+      merge_time         h
+
+      return h
+    end
+
+    #
+    def todo(test, exception)
+      h = {}
+      h['type'  ] = 'test'
+      h['status'] = 'todo'
+
+      merge_subtype      h, test
+      merge_setup        h, test
+      merge_description  h, test
+      #merge_comparison  h, test, exception
+      #merge_coverage    h, test
+      merge_source       h, test
+      merge_exception    h, test, exception
+      merge_time         h
+
+      return h
+    end
+
+    #
+    def omit(test, exception)
+      h = {}
+      h['type'  ] = 'test'
+      h['status'] = 'omit'
+
+      merge_subtype      h, test
+      merge_setup        h, test
+      merge_description  h, test
+      #merge_comparison  h, test, exception
+      #merge_coverage    h, test
+      merge_source       h, test
+      merge_exception    h, test, exception
+      merge_time         h
+
+      return h
+    end
+
+    #
+    def end_case(test_case)
+      @case_level -= 1
+    end
+
+    #
+    def end_suite(suite)
+      h = {
+        'type'  => 'tally',
+        'time'  => Time.now - @start_time,
+        'counts' => {
+          'total' => total,
+          'pass'  => record[:pass].size,
+          'fail'  => record[:fail].size,
+          'error' => record[:error].size,
+          'omit'  => record[:omit].size,
+          'todo'  => record[:todo].size
+        }
+      }
+      return h
+    end
+
+  private
+
+    #
+    def merge_subtype(hash, test)
+      hash['subtype'] = test.type.to_s if test.respond_to?(:type)
+    end
+
+    # TODO: topic or setup ?
+    def merge_setup(hash, test)
+      #hash['setup'] = test.setup.to_s if test.respond_to?(:setup)
+      hash['setup'] = test.topic.to_s if test.respond_to?(:topic)
+    end
+
+    # Add test description to hash.
+    def merge_description(hash, test)
+      hash['description'] = test.to_s.strip
+    end
+
+    # NOTE: Not presently used.
+    def merge_comparison(hash, test, exception)
+      hash['returned'] = exception.returned
+      hash['expected'] = exception.expected
+    end
+
+    # Add source location information to hash.
+    def merge_source(hash, test)
+      if test.respond_to?('source_location')
+        file, line = source_location
+        hash['file'   ] = file
+        hash['line'   ] = line
+        hash['source' ] = code(file, line).to_str
+        hash['snippet'] = code(file, line).to_omap
+      end
+    end
+
+    # Add exception subsection of hash.
+    def merge_exception(hash, test, exception, bt=false)
+      hash['exception'] = {}
+      hash['exception']['file'     ] = code(exception).file
+      hash['exception']['line'     ] = code(exception).line
+      hash['exception']['source'   ] = code(exception).to_str
+      hash['exception']['snippet'  ] = code(exception).to_omap
+      hash['exception']['message'  ] = exception.message
+      hash['exception']['backtrace'] = clean_backtrace(exception) if bt
+    end
+
+    # TODO: Really?
+    def merge_coverage(hash, test)
+      if test.respond_to?(:file_coverage) or test.respond_to?(:code_coverage)
+        fc = test.file_coverage
+        cc = test.code_coverage
+        hash['coverage'] = {}
+        hash['coverage']['file'] = fc if fc
+        hash['coverage']['code'] = cc if cc
+      end
+    end
+
+    #
+    def merge_time(hash)
+      hash['time'] = Time.now - @start_time
+    end
+
+  end
+
+end