baretest 0.1.0 → 0.2.3

data/lib/baretest/irb_mode.rb

@@ -0,0 +1,263 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'stringio' # for silencing HAX
+
+
+
+module Kernel
+  alias lv! local_variables
+  private :lv!
+end
+
+module BareTest
+
+  # For internal use only.
+  #
+  # This module extends BareTest::Run if --interactive/-i is used
+  #
+  # See BareTest::IRBMode::AssertionContext for some methods IRBMode adds to Assertion for
+  # use within the irb session.
+  module IRBMode # :nodoc:
+    @irb_setup = false
+
+    def self.irb_setup! # :nodoc:
+      @irb_setup = true
+    end
+
+    def self.irb_setup? # :nodoc:
+      @irb_setup
+    end
+
+    # The class used to recreate the failed/errored assertion's context.
+    # Adds several methods over plain Assertion.
+    module IRBContext
+
+      attr_accessor :__original__
+
+      # Prints a list of available helper methods
+      def help
+        puts "Available methods:",
+             "s!          - the original assertions' status",
+             "e!          - prints the error message and full backtrace",
+             "em!         - prints the error message",
+             "bt!         - prints the full backtrace",
+             "iv!         - lists all available instance variables",
+             "cv!         - lists all available class variables",
+             "gv!         - lists all available global variables",
+             "file        - the file this assertion was defined in",
+             "line        - the line number in the file where this assertion's definition starts",
+             "nesting     - a >-separated list of suite descriptions this assertion is nested in",
+             "description - this assertion's description",
+             "code        - the code of this assertion",
+             #"restart! - Restart this irb session, resetting everything",
+             "irb_help    - irb's original help",
+             "help        - this text you're reading right now"
+      end
+
+      def to_s # :nodoc:
+        "Context"
+      end
+
+      # Returns the original assertion's status
+      def s!
+        p @__original__.status
+      end
+
+      # Prints the original assertion's error message and backtrace
+      def e!
+        em!
+        bt!(caller.size+3)
+      end
+
+      # Prints the original assertion's error message
+      def em!
+        if @__original__.exception then
+          puts @__original__.exception.message
+        elsif @__original__.reason
+          puts @__original__.reason
+        else
+          puts "No exception occurred, therefore no error message is available"
+        end
+      end
+
+      # Prints the original assertion's backtrace
+      def bt!(size=nil)
+        if @__assertion__.exception then
+          size ||= caller.size+3
+          puts @__assertion__.exception.backtrace[0..-size]
+        else
+          puts "No exception occurred, therefore no backtrace is available"
+        end
+      end
+
+      # Returns an array of all instance variable names
+      def iv!
+        puts *instance_variables.sort
+      end
+
+      # Returns an array of all class variable names
+      def cv!
+        puts *self.class.class_variables.sort
+      end
+
+      # Returns an array of all global variable names
+      def gv!
+        puts *global_variables.sort
+      end
+
+      # Prints a string of the original assertion's nesting within suites
+      def description
+        puts @__assertion__.description
+      end
+
+      # Prints a string of the original assertion's nesting within suites
+      def nesting
+        puts @__assertion__.suite.ancestors[0..-2].reverse.map { |s| s.description }.join(' > ')
+      end
+
+      # Prints the code of the assertion
+      # Be aware that this relies on your code being properly indented.
+      def code!
+        if code = @__assertion__.code then
+          puts(insert_line_numbers(code, @__assertion__.line-1))
+        else
+          puts "Code could not be extracted"
+        end
+      end
+
+      def insert_line_numbers(code, start_line=1)
+        digits       = Math.log10(start_line+code.count("\n")).floor+1
+        current_line = start_line-1
+        code.gsub(/^/) { sprintf '  %0*d  ', digits, current_line+=1 }
+      end
+    end
+
+    # Install the init handler
+    def self.extended(by) # :nodoc:
+      by.init do
+        require 'irb'
+        require 'pp'
+        require 'yaml'
+        IRB.setup(nil) unless ::BareTest::IRBMode.irb_setup? # must only be called once
+        ::BareTest::IRBMode.irb_setup!
+      end
+    end
+
+    # Formatter callback.
+    # Invoked once for every assertion.
+    # Gets the assertion to run as single argument.
+    def run_test(assertion, setup)
+      rv = super
+      # drop into irb if assertion failed
+      case rv.status
+        when :failure
+          start_irb_failure_mode(assertion)
+          irb_mode_for_assertion(assertion)
+          stop_irb_mode(assertion)
+        when :error
+          start_irb_error_mode(assertion)
+          irb_mode_for_assertion(assertion)
+          stop_irb_mode(assertion)
+      end
+
+      rv
+    end
+
+    # Invoked when we have to drop into irb mode due to a failure
+    def start_irb_failure_mode(assertion) # :nodoc:
+      ancestry = assertion.suite.ancestors.reverse.map { |suite| suite.description }
+
+      puts
+      puts "#{assertion.status.to_s.capitalize} in:  #{ancestry[1..-1].join(' > ')}"
+      puts "Description: #{assertion.description}"
+      if file = assertion.file then
+        code  = irb_code_reindented(file, assertion.line-1,20)
+        match = code.match(/\n^  [^ ]/)
+        code[-(match.post_match.size-3)..-1] = ""
+        assertion.code = code
+        puts "Code (#{file}):", insert_line_numbers(code, assertion.line-1)
+      end
+    end
+
+    # Invoked when we have to drop into irb mode due to an error
+    def start_irb_error_mode(assertion) # :nodoc:
+      ancestry = assertion.suite.ancestors.reverse.map { |suite| suite.description }
+
+      puts
+      puts "#{assertion.status.to_s.capitalize} in:    #{ancestry[1..-1].join(' > ')}"
+      puts "Description: #{assertion.description}"
+      puts "Exception:   #{assertion.exception} in file #{assertion.exception.backtrace.first}"
+      if assertion.file && match = assertion.exception.backtrace.first.match(/^([^:]+):(\d+)(?:$|:in .*)/) then
+        file, line = match.captures
+        file = File.expand_path(file)
+        if assertion.file == file then
+          code = irb_code_reindented(file, (assertion.line-1)..(line.to_i))
+          assertion.code = code
+          puts "Code (#{file}):", insert_line_numbers(code, assertion.line-1)
+        end
+      end
+    end
+
+    # Nicely reformats the assertion's code
+    def irb_code_reindented(file, *slice) # :nodoc:
+      lines  = File.readlines(file)
+      string = lines[*slice].join("").sub(/[\r\n]*\z/, '')
+      string.gsub!(/^\t+/) { |m| "  "*m.size }
+      indent = string[/^ +/]
+      string.gsub!(/^#{indent}/, '  ')
+
+      string
+    end
+
+    def insert_line_numbers(code, start_line=1)
+      digits       = Math.log10(start_line+code.count("\n")).floor+1
+      current_line = start_line-1
+      code.gsub(/^/) { sprintf '  %0*d  ', digits, current_line+=1 }
+    end
+
+    # This method is highlevel hax, try to add necessary API to Test::Assertion
+    # Drop into an irb shell in the context of the assertion passed as an argument.
+    # Uses Assertion#clean_copy(AssertionContext) to create the context.
+    # Adds the code into irb's history.
+    def irb_mode_for_assertion(original_assertion) # :nodoc:
+      assertion = original_assertion.clone
+      assertion.reset
+      irb_context = assertion.context
+      irb_context.extend IRBContext
+      irb_context.__original__ = original_assertion
+      assertion.setup
+
+      $stdout = StringIO.new # HAX - silencing 'irb: warn: can't alias help from irb_help.' - find a better way
+      irb = IRB::Irb.new(IRB::WorkSpace.new(irb_context))
+      $stdout = STDOUT # /HAX
+      # HAX - cargo cult, taken from irb.rb, not yet really understood.
+      IRB.conf[:IRB_RC].call(irb.context) if IRB.conf[:IRB_RC] # loads the irbrc?
+      IRB.conf[:MAIN_CONTEXT] = irb.context # why would the main context be set here?
+      # /HAX
+
+      trap("SIGINT") do irb.signal_handle end
+
+      if code = original_assertion.code then
+        #irb_context.code = code
+        Readline::HISTORY.push(*code.split("\n")[1..-2])
+      end
+
+      catch(:IRB_EXIT) do irb.eval_input end
+
+      assertion.teardown
+    end
+
+    # Invoked when we leave the irb session
+    def stop_irb_mode(assertion) # :nodoc:
+      puts
+      super
+    rescue NoMethodError # HAX, not happy about that. necessary due to order of extend
+    end
+  end
+end

data/lib/{test/assertion/failure.rb → baretest/layout.rb}

@@ -6,9 +6,10 @@
 
 
 
-module Test
-  class Assertion
-    class Failure < StandardError
-    end
-  end
+module BareTest
+  # :stopdoc:
+  Layout = Struct.new(
+    :foo
+  )
+  # :startdoc:
 end

data/lib/baretest/mocha.rb

@@ -0,0 +1,18 @@
+# Created by dominikh
+
+# This file provides integration with the "mocha" mocking framework.
+
+require 'mocha'
+
+BareTest.extend Mocha::API
+
+BareTest.toplevel_suite.teardown do
+  begin
+    BareTest.mocha_verify
+  rescue Mocha::ExpectationError => e
+    @reason = e.message
+    @status = :failure
+  ensure
+    BareTest.mocha_teardown
+  end
+end

data/lib/baretest/run/cli.rb

@@ -0,0 +1,104 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  class Run
+
+    # CLI runner is invoked with `-f cli` or `--format cli`.
+    # It is intended for use with an interactive shell, to provide a comfortable, human
+    # readable output.
+    # It prints colored output (requires ANSI colors compatible terminal).
+    #
+    module CLI # :nodoc:
+      Formats = {
+        :pending => "\e[43m%9s\e[0m  %s%s\n",
+        :skipped => "\e[43m%9s\e[0m  %s%s\n",
+        :success => "\e[42m%9s\e[0m  %s%s\n",
+        :failure => "\e[41m%9s\e[0m  %s%s\n",
+        :error   => "\e[37;40;1m%9s\e[0m  %s%s\n"  # ]]]]]]]] - bbedit hates open brackets...
+      }
+
+      FooterFormats = {
+        :incomplete => "\e[43m%9s\e[0m\n",
+        :success    => "\e[42m%9s\e[0m\n",
+        :failure    => "\e[41m%9s\e[0m\n",
+        :error      => "\e[37;40;1m%9s\e[0m\n"  # ]]]]]]]] - bbedit hates open brackets...
+      }
+
+      def run_all(*args)
+        @depth = 0
+        puts "Running all tests#{' verbosly' if $VERBOSE}"
+        start = Time.now
+        super # run all suites
+        status = global_status
+        printf "\n%2$d tests run in %1$.1fs\n%3$d successful, %4$d pending, %5$d failures, %6$d errors\n",
+          Time.now-start, *@count.values_at(:test, :success, :pending, :failure, :error)
+        print "Final status: "
+        printf FooterFormats[status], status_label(status)
+      end
+
+      def run_suite(suite)
+        return super unless suite.description
+        skipped = suite.skipped.size
+        case size = suite.assertions.size
+          when 0
+            if skipped.zero? then
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m"
+            else
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{skipped} skipped)"
+            end
+          when 1
+            if skipped.zero? then
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (1 test)"
+            else
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (1 test/#{skipped} skipped)"
+            end
+          else
+            if skipped.zero? then
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{size} tests)"
+            else
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{size} tests/#{skipped} skipped)"
+            end
+        end
+        @depth += 1
+        super(suite) # run the suite
+        @depth -= 1
+      end
+
+      def run_test(assertion, setup)
+        rv               = super # run the assertion
+        indent           = '           '+'  '*@depth
+        message          = []
+        deeper           = []
+
+        printf(Formats[rv.status], status_label(rv.status), '  '*@depth, rv.interpolated_description)
+        if rv.status == :error then
+          message = (rv.exception.message || "no error message given").split("\n")
+          deeper  = $VERBOSE ? rv.exception.backtrace : rv.exception.backtrace.first(1)
+        elsif rv.status == :failure
+          message = (rv.reason || "no failure reason given").split("\n")
+          deeper  = ["#{rv.file}:#{rv.line}"]
+        end
+        message.each do |line| print(indent, line, "\n") end
+        deeper.each do |line| print(indent, '  ', line, "\n") end
+
+        rv
+      end
+
+      def word_wrap(string, cols)
+        str.scan(/[^ ]+ /)
+      end
+
+      def status_label(status)
+        status.to_s.capitalize.center(9)
+      end
+    end
+  end
+
+  @format["baretest/run/cli"] = Run::CLI # register the extender
+end

data/lib/{test → baretest}/run/errors.rb

@@ -6,9 +6,14 @@
 
 
 
-module Test
+module BareTest
   class Run
-    module Errors
+
+    # Errors runner is invoked with `-f errors` or `--format errors`.
+    # This runner is specifically built to provide the most possible information about
+    # errors in the suite.
+    #
+    module Errors # :nodoc:
       def run_all
         @depth = 0
         puts "Running all tests, reporting errors"
@@ -19,24 +24,24 @@ module Test
 
       def run_suite(suite)
         return super unless suite.description
-        puts "#{'  '*@depth+suite.description} (#{suite.tests.size} tests)"
+        puts "#{'  '*@depth+suite.description} (#{suite.assertions.size} tests, #{suite.skipped.size} skipped)"
         @depth += 1
         super # run the suite
         @depth -= 1
       end
 
-      def run_test(assertion)
+      def run_test(assertion, setup)
         rv = super # run the assertion
         puts('  '*@depth+rv.description)
         if rv.exception then
           size = caller.size+5
-          puts((['-'*80, rv.exception]+rv.exception.backtrace[0..-size]+['-'*80, '']).map { |l|
-          	('  '*(@depth+1))+l
+          puts((['-'*80, rv.exception.message]+rv.exception.backtrace[0..-size]+['-'*80, '']).map { |l|
+            ('  '*(@depth+1))+l
           })
         end
       end
     end
   end
 
-  @format["test/run/errors"] = Run::Errors # register the extender
+  @format["baretest/run/errors"] = Run::Errors # register the extender
 end

data/lib/{test → baretest}/run/minimal.rb

@@ -6,9 +6,14 @@
 
 
 
-module Test
+module BareTest
   class Run
-    module Minimal
+
+    # Minimal runner is invoked with `-f minimal` or `--format minimal`.
+    # This runner is mainly written as an example. It will provide the final
+    # statistics (number of tests, successes, etc.).
+    #
+    module Minimal # :nodoc:
       def run_all(*args)
         start  = Time.now
         super              # run all suites
@@ -27,5 +32,5 @@ module Test
     end
   end
 
-  @format["test/run/minimal"] = Run::Minimal # register the extender
+  @format["baretest/run/minimal"] = Run::Minimal # register the extender
 end

data/lib/baretest/run/profile.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  class Run
+
+    # CLI runner is invoked with `-f cli` or `--format cli`.
+    # It is intended for use with an interactive shell, to provide a comfortable, human
+    # readable output.
+    # It prints colored output (requires ANSI colors compatible terminal).
+    #
+    module Profile # :nodoc:
+      Formats = {
+        :pending => "\e[43m%9s\e[0m  %s%s (%s)\n",
+        :skipped => "\e[43m%9s\e[0m  %s%s (%s)\n",
+        :success => "\e[42m%9s\e[0m  %s%s (%s)\n",
+        :failure => "\e[41m%9s\e[0m  %s%s (%s)\n",
+        :error   => "\e[37;40;1m%9s\e[0m  %s%s (%s)\n"  # ]]]]]]]] - bbedit hates open brackets...
+      }
+
+      FooterFormats = {
+        :incomplete => "\e[43m%9s\e[0m\n",
+        :success    => "\e[42m%9s\e[0m\n",
+        :failure    => "\e[41m%9s\e[0m\n",
+        :error      => "\e[37;40;1m%9s\e[0m\n"  # ]]]]]]]] - bbedit hates open brackets...
+      }
+
+      def run_all(*args)
+        @depth = 0
+        puts "Running all tests#{' verbosly' if $VERBOSE}"
+        start = Time.now
+        super # run all suites
+        status = global_status
+        printf "\n%2$d tests run in %1$.1fs\n%3$d successful, %4$d pending, %5$d failures, %6$d errors\n",
+          Time.now-start, *@count.values_at(:test, :success, :pending, :failure, :error)
+        print "Final status: "
+        printf FooterFormats[status], status_label(status)
+      end
+
+      def run_suite(suite)
+        return super unless suite.description
+        skipped = suite.skipped.size
+        case size = suite.assertions.size
+          when 0
+            if skipped.zero? then
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m"
+            else
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{skipped} skipped)"
+            end
+          when 1
+            if skipped.zero? then
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (1 test)"
+            else
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (1 test/#{skipped} skipped)"
+            end
+          else
+            if skipped.zero? then
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{size} tests)"
+            else
+              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{size} tests/#{skipped} skipped)"
+            end
+        end
+        @depth += 1
+        super(suite) # run the suite
+        @depth -= 1
+      end
+
+      def run_test(assertion, setup)
+        start            = Time.now
+        rv               = super # run the assertion
+        times            = [Time.now-start]
+
+        if times.first < 1e-3 then
+          iters = 19
+        elsif times.first < 1
+          iters = 2
+        else
+          iters = 0
+        end
+
+        iters.times do
+          assertion.reset
+          start = Time.now
+          assertion.execute
+          times << (Time.now-start)
+        end
+
+        time = times.inject{ |a,b| a+b }/iters
+
+        indent           = '           '+'  '*@depth
+        message          = []
+        deeper           = []
+
+        printf(
+          Formats[rv.status],
+          status_label(rv.status),
+          '  '*@depth,
+          rv.description,
+          humanized_duration(time)
+        )
+        if rv.status == :error then
+          message = (rv.exception.message || "no error message given").split("\n")
+          deeper  = $VERBOSE ? rv.exception.backtrace : rv.exception.backtrace.first(1)
+        elsif rv.status == :failure
+          message = (rv.reason || "no failure reason given").split("\n")
+          deeper  = ["#{rv.file}:#{rv.line}"]
+        end
+        message.each do |line| print(indent, line, "\n") end
+        deeper.each do |line| print(indent, '  ', line, "\n") end
+
+        rv
+      end
+
+      def word_wrap(string, cols)
+        str.scan(/[^ ]+ /)
+      end
+
+      def status_label(status)
+        status.to_s.capitalize.center(9)
+      end
+
+      def humanized_duration(duration)
+        case
+          when duration < 1e-3
+            "%dµs" % (duration*1e6)
+          when duration < 1
+            "%.1fms" % (duration*1e3)
+          when duration < 60
+            "%.1fs" % duration
+          else
+            minutes, seconds = *duration.divmod(60)
+            hours, minutes   = *minutes.divmod(60)
+            # lets assume unit tests don't take more than a day :)
+            if hours > 0 then
+              "#{hours}h #{minutes}m #{seconds}s"
+            else
+              "#{minutes}m #{seconds}s"
+            end
+        end
+      end
+    end
+  end
+
+  @format["baretest/run/profile"] = Run::Profile # register the extender
+end

data/lib/{test → baretest}/run/spec.rb

@@ -6,9 +6,15 @@
 
 
 
-module Test
+module BareTest
   class Run
-    module Spec
+
+    # Spec runner is invoked with `-f spec` or `--format spec`.
+    # This runner will not actually run the tests. It only extracts the descriptions and
+    # prints them. Handy if you just want an overview over what a library is supposed to do
+    # and be capable of.
+    #
+    module Spec # :nodoc:
       def run_all
         @depth = 0
         super
@@ -22,11 +28,11 @@ module Test
         @depth -= 1
       end
 
-      def run_test(assertion)
+      def run_test(assertion, setup)
         puts('  '*@depth+assertion.description)
       end
     end
   end
 
-  @format["test/run/spec"] = Run::Spec
+  @format["baretest/run/spec"] = Run::Spec
 end

data/lib/baretest/run/tap.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  class Run
+
+    # TAP runner is invoked with `-f tap` or `--format tap`.
+    # TAP (Test Anything Protocol) output is intended as a universal, machine readable
+    # output format of test frameworks. The are various tools that can further process
+    # that information and leverage it in various ways of automation.
+    # This runner currently implements the TA Protocol in version 13.
+    #
+    module TAP # :nodoc:
+      def run_all
+        puts "TAP version 13"
+        count = proc { |acc,csuite|
+          acc+
+          csuite.assertions.size+
+          csuite.skipped.size+
+          csuite.suites.map { |d,suite| suite }.inject(0, &count)
+        }
+        puts "1..#{count[0, suite]}"
+        @current = 0
+        super
+      end
+
+      def run_test(assertion, setup)
+        rv = super
+        printf "%sok %d - %s%s\n",
+          rv.status == :success ? '' : 'not ',
+          @current+=1,
+          rv.description,
+          rv.status == :success ? '' : " # #{rv.status}"
+      end
+    end
+  end
+
+  @format["baretest/run/tap"] = Run::TAP
+end