rubytest 0.3.0

data/lib/rubytest/core_ext/string.rb

@@ -0,0 +1,30 @@
+class String
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  #
+  # This is a Ruby Facet (http://rubyworks.github.com/facets).
+
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end unless method_defined?(:tabto)
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  #
+  # This is a Ruby Facet (http://rubyworks.github.com/facets).
+
+  def indent(n, c=' ')
+    if n >= 0
+      gsub(/^/, c * n)
+    else
+      gsub(/^#{Regexp.escape(c)}{0,#{-n}}/, "")
+    end
+  end unless method_defined?(:indent)
+
+end
+

data/lib/rubytest/core_ext.rb

@@ -0,0 +1,9 @@
+if RUBY_VERSION < '1.9'
+  require 'ruth/core_ext/assertion'
+  require 'ruth/core_ext/exception'
+  require 'ruth/core_ext/string'
+else
+  require_relative 'core_ext/assertion'
+  require_relative 'core_ext/exception'
+  require_relative 'core_ext/string'
+end

data/lib/rubytest/rake.rb

@@ -0,0 +1,124 @@
+require 'rake/tasklib'
+
+module Ruth
+
+  #
+  module Rake
+
+    # TODO: The test task uses #fork. Maybe it should shell out instead?
+    #  Or provide the option for either?
+
+    # Define a test rake task.
+    #
+    # The `TEST` environment variable can be used to select tests
+    # when using the task.
+    #
+    class TestTask < ::Rake::TaskLib
+
+      # Glob patterns are used by default to select test scripts.
+      DEFAULT_TESTS = [
+        'test/**/case_*.rb',
+        'test/**/*_case.rb',
+        'test/**/test_*.rb',
+        'test/**/*_test.rb'
+      ]
+
+      # Test scripts to load. Can be a file glob.
+      attr_accessor :tests
+
+      # Paths to add to $LOAD_PATH.
+      attr_accessor :loadpath
+
+      # Scripts to load prior to loading tests.
+      attr_accessor :requires
+
+      # Report format to use.
+      attr_accessor :format
+
+      # Filter tests based by tags.
+      attr_accessor :tags
+
+      # Filter tests by matching description.
+      attr_accessor :match
+
+      # From Rake's own TestTask.
+      alias_method :libs, :loadpath
+      alias_method :test_files, :tests
+
+      #
+      def initialize(name='test', desc="run tests", &block)
+        @name       = name
+        @desc       = desc
+
+        @loadpath   = ['lib']
+        @requires   = []
+        @tests      = [ENV['TEST'] || DEFAULT_TESTS].flatten
+        @format     = nil
+        @match      = nil
+        @tags       = []
+
+        block.call(self)
+
+        define_task
+      end
+
+      #
+      def define_task
+        desc @desc
+        task @name do
+          @tests ||= default_tests
+          run
+        end
+      end
+
+      #
+      def run
+        fork {
+          #require 'test'
+          require 'test/runner'
+
+          loadpath.each   { |d| $LOAD_PATH.unshift(d) }
+          requires.each   { |f| require f }
+          test_files.each { |f| require f }
+
+          suite   = $TEST_SUITE || []
+          runner  = new(suite, :format=>format, :tags=>tags, :match=>match)
+          success = runner.run
+
+          exit -1 unless success
+        }
+        Process.wait
+      end
+
+      # Resolve test globs.
+      #--
+      # TODO: simplify?
+      #++
+      def test_files
+        files = tests
+        files = files.map{ |f| Dir[f] }.flatten
+        files = files.map{ |f| File.directory?(f) ? Dir[File.join(f, '**/*.rb')] : f }
+        files = files.flatten.uniq
+        files = files.map{ |f| File.expand_path(f) }
+        files
+      end
+
+      #
+      def default_tests
+        if ENV['tests']
+          ENV['tests'].split(/[:;]/)
+        else
+          DEFAULT_TESTS
+        end
+      end
+
+      #
+      #def ruby_command
+      #  File.join(RbConfig::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+      #end
+
+    end
+
+  end
+
+end

data/lib/rubytest/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/rubytest/reporters/abstract.rb

@@ -0,0 +1,261 @@
+# encoding: UTF-8
+
+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, :skip].inject(0) do |s,r|
+          s += record[r.to_sym].size; s
+        end
+      end
+
+      # TODO: lump skipped and omitted into one group ?
+
+      TITLES = {
+        :pass  => 'passing',
+        :fail  => 'failures',
+        :error => 'errors',
+        :todo  => 'pending',
+        :omit  => 'omissions',
+        :skip  => 'skipped'
+      }
+
+      # TODO: Add assertion counts (if reasonably possible).
+
+      # Common tally stamp any reporter can use.
+      #
+      # @return [String] tally stamp
+      def tally
+        sizes  = {}
+        names  = %w{pass error fail todo omit skip}.map{ |n| n.to_sym }
+        names.each do |r|
+          sizes[r] = record[r].size
+        end
+
+        #names.unshift(:tests)
+        #sizes[:tests] = total
+
+        s = []
+        names.each do |n|
+          next unless sizes[n] > 0
+          s << tally_item(n, sizes)
+        end
+
+        'Executed ' + "#{total}".ansi(:bold) + ' tests with ' + s.join(', ') + '.'
+      end
+
+      #
+      def tally_item(name, sizes)
+        x = []
+        x << "%s" % sizes[name].to_s.ansi(:bold)
+        x << " %s" % TITLES[name].downcase
+        x << " (%.1f%%)" % ((sizes[name].to_f/total*100)) if runner.verbose?
+        x.join('')
+      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
+          CodeSnippet.from_backtrace(clean_backtrace(source.backtrace))
+        when 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/rubytest/reporters/abstract_hash.rb

@@ -0,0 +1,224 @@
+# encoding: UTF-8
+
+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_label   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_label        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_label        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_label        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_label        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_label        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_label(hash, test)
+      hash['label'] = 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