baretest 0.2.4 → 0.4.0.pre1

data/lib/baretest/assertion/context.rb

@@ -8,10 +8,19 @@
 
 module BareTest
   class Assertion
+
+    # Serves as the exercise- and verify-container for Assertions. Upon
+    # Assertion#execute, a new Context is created, the setups, the assertions'
+    # defining block and the teardowns instance evaled.
+    # Components will want to extend this class.
     class Context
+
+      # The Assertion instance this Context was created for
       attr_reader :__assertion__
       alias assertion __assertion__
 
+      # Accepts the Assertion instance this Context is created for as first
+      # and only argument.
       def initialize(assertion)
         @__assertion__ = assertion
       end

data/lib/baretest/assertion/support.rb

@@ -18,7 +18,7 @@ module BareTest
   @touch = {}
 
   # We don't want to litter in Assertion
-  # Touches are associated withx
+  # Touches are associated with
   # Used by BareTest::Assertion::Support#touch
   def self.touch(assertion, thing=nil) # :nodoc:
     @touch[assertion] ||= Hash.new(0)
@@ -72,26 +72,24 @@ module BareTest
 
       # FIXME: incomplete and untested
       def throws(symbol) # :nodoc:
-        begin
-          passed = false
-          catch(sym) {
-            yield
-            passed = true
-            return false
-          }
-          passed = true
-          return true
-        rescue NameError => e
-          return false if e.message =~ 'uncaught throw'
-          raise
-        rescue Exception
-          passed = true
+        passed = false
+        catch(symbol) {
+          yield
+          failure "Expected the code to throw %p, but nothing was thrown", symbol
+        }
+        return true
+      # throw raises a NameError if no catch with appropriate symbol is set up
+      rescue ArgumentError, NameError => e
+        # Make sure it's not a NameError with a different reason than the throw
+        # ruby 1.8.7: NameError, "uncaught throw `symbol'"
+        # ruby 1.9.1: ArgumentError, "uncaught throw :symbol"
+        threw_instead = e.message[/\Auncaught throw `(.*)'\z/, 1] || e.message[/\Auncaught throw :(.*)\z/, 1]
+        if threw_instead then
+          failure "Expected the code to throw %p, but it threw %p instead", symbol, threw_instead.to_sym
+        else
+          # It was some other name error, reraise
           raise
-        ensure
-          raise ThrewSomethingElse unless passed
         end
-      rescue ThrewSomethingElse => e
-        return false
       end
 
       # FIXME: incomplete and untested
@@ -109,21 +107,28 @@ module BareTest
       #   raises :with_message => "bar" do raise "bar" end # => true
       #   raises SomeException, :with_message => "bar"; raise SomeException, "bar" end # => true
       #   raises :with_message => /\Aknown \w+\z/; raise "known unknown" end # => true
-      def raises(exception_class=StandardError, opts={})
+      def raises(expected_exception_class=nil, with_message=nil, opts={})
+        exception_class = expected_exception_class || StandardError
         yield
       rescue exception_class => exception
-        if opts[:with_message] && !(opts[:with_message] === exception.message) then
-          failure "Expected block to raise with the message %p, but the message was %p",
-                  exception.message, opts[:with_message]
+        if expected_exception_class && exception.class != expected_exception_class then
+          failure "Expected the code to raise #{expected_exception_class}, but it raised #{exception.class} instead"
+        elsif with_message && !(with_message === exception.message) then
+          failure "Expected the code to raise with the message %p, but the message was %p",
+                  with_message, exception.message
         else
           true
         end
       rescue ::BareTest::Assertion::Failure, *::BareTest::Assertion::PassthroughExceptions
         ::Kernel.raise
       rescue => exception
-        failure "Expected block to raise #{exception_class}, but it raised #{exception.class}."
+        failure "Expected the code to raise #{expected_exception_class}, but it raised #{exception.class} instead"
       else
-        failure "Expected block to raise #{exception_class}, but nothing was raised."
+        if expected_exception_class then
+          failure "Expected the code to raise #{expected_exception_class}, but nothing was raised"
+        else
+          failure "Expected the code to raise, but nothing was raised"
+        end
       end
 
       # Will raise a Failure if the given block raises.
@@ -132,7 +137,7 @@ module BareTest
       rescue ::BareTest::Assertion::Failure, *::BareTest::Assertion::PassthroughExceptions
         ::Kernel.raise
       rescue Exception => exception
-        failure "Expected block to raise nothing, but it raised #{exception.class}."
+        failure "Expected the code to raise nothing, but it raised #{exception.class} (#{exception.message})"
       else
         true
       end
@@ -141,7 +146,12 @@ module BareTest
       # for example a delta comparison instead, to take care
       # of the possible rounding differences.
       def within_delta(a, b, delta)
-        (a-b).abs < delta
+        actual_delta = (a-b).abs
+        if actual_delta >= delta then
+          failure "Expected %p and %p to differ less than %p, but they were different by %p", a, b, delta, actual_delta
+        else
+          true
+        end
       rescue ::BareTest::Assertion::Failure, *::BareTest::Assertion::PassthroughExceptions
         ::Kernel.raise
       rescue Exception => e
@@ -152,7 +162,7 @@ module BareTest
       # touch marks that it was reached, #touched tests for whether it was reached.
       #
       # Example:
-      #   assert "Code in a Proc object is executed when invoking #call on it." do
+      #   assert "Code in a Proc object is executed when invoking #call on it" do
       #     a_proc = proc { touch :executed }
       #     a_proc.call
       #     touched(:executed)
@@ -170,16 +180,16 @@ module BareTest
         if times then
           unless touched_times == times then
             if thing then
-              failure "Expected the code to touch %p %s times, but did %s times.", thing, times, touched_times
+              failure "Expected the code to touch %p %s times, but did %s times", thing, times, touched_times
             else
-              failure "Expected the code to touch %s times, but did %s times.", times, touched_times
+              failure "Expected the code to touch %s times, but did %s times", times, touched_times
             end
           end
         elsif touched_times < 1 then
           if thing then
-            failure "Expected the code to touch %p, but it was not touched.", thing
+            failure "Expected the code to touch %p, but it was not touched", thing
           else
-            failure "Expected the code to touch, but no touch happened."
+            failure "Expected the code to touch, but no touch happened"
           end
         end
         true
@@ -202,9 +212,9 @@ module BareTest
 
         unless expected.equal?(actual) then
           if message then
-            failure "Expected %s to be the same (equal?) as %p but was %p.", message, expected, actual
+            failure "Expected %s to be the same (equal?) as %p but was %p", message, expected, actual
           else
-            failure "Expected %p but got %p.", expected, actual
+            failure "Expected %p but got %p", expected, actual
           end
         end
         true
@@ -225,9 +235,9 @@ module BareTest
 
         unless expected.eql?(actual) then
           if message then
-            failure "Expected %s to be hash-key equal (eql?) to %p but was %p.", message, expected, actual
+            failure "Expected %s to be hash-key equal (eql?) to %p but was %p", message, expected, actual
           else
-            failure "Expected %p but got %p.", expected, actual
+            failure "Expected %p but got %p", expected, actual
           end
         end
         true
@@ -248,9 +258,9 @@ module BareTest
 
         unless expected == actual then
           if message then
-            failure "Expected %s to be order equal (==) to %p but was %p.", message, expected, actual
+            failure "Expected %s to be order equal (==) to %p but was %p", message, expected, actual
           else
-            failure "Expected %p but got %p.", expected, actual
+            failure "Expected %p but got %p", expected, actual
           end
         end
         true
@@ -272,8 +282,8 @@ module BareTest
 
         unless expected === actual then
           failure_with_optional_message \
-            "Expected %s to be case equal (===) to %p but was %p.",
-            "Expected %p but got %p.",
+            "Expected %s to be case equal (===) to %p but was %p",
+            "Expected %p but got %p",
             message, expected, actual
         end
         true
@@ -299,11 +309,11 @@ module BareTest
           only_in_actual   = count.select { |ele, n| n < 0 }.map { |ele, n| ele }
           if message then
             failure "Expected %s to have the same items the same number of times, " \
-                    "but %p are only in expected, and %p only in actual.",
+                    "but %p are only in expected, and %p only in actual",
                     message, only_in_expected, only_in_actual
           else
             failure "Expected %p and %p to have the same items the same number of times, " \
-                    "but %p are only in expected, and %p only in actual.",
+                    "but %p are only in expected, and %p only in actual",
                     expected, actual, only_in_expected, only_in_actual
           end
         end
@@ -330,7 +340,42 @@ module BareTest
       rescue ::BareTest::Assertion::Failure, *::BareTest::Assertion::PassthroughExceptions
         ::Kernel.raise
       rescue Exception => e
-        failure "Could not test whether %p is a child of %p due to %s", actual, expected, e
+        failure "Could not test whether %p is a kind of %p due to %s", actual, expected, e
+      end
+
+      # Raises a Failure if the given object is not an instance of the given class
+      def instance_of(*args)
+        expected, actual, message = extract_args(args, :expected, :actual, :message)
+        unless actual.instance_of?(expected) then
+          failure_with_optional_message \
+            "Expected %1$s to be an instance of %3$p, but was a %4$p",
+            "Expected %2$p to be an instance of %1$p, but was a %3$p",
+            message, expected, actual, actual.class
+        end
+        true
+
+      rescue ::BareTest::Assertion::Failure, *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not test whether %p is an instance of %p due to %s", actual, expected, e
+      end
+
+      # Raises a Failure if the given object does not respond to all of the given
+      # method names. The method names may be specified as String or Symbol.
+      def respond_to(obj, *methods)
+        not_responded_to = methods.reject { |method_name| obj.respond_to?(method_name) }
+        unless not_responded_to.empty? then
+          must_respond_to  = methods.map { |m| m.to_sym.inspect }.join(', ')
+          not_responded_to = not_responded_to.map { |m| m.to_sym.inspect }.join(', ')
+          failure "Expected %1$s to respond to all of %2$s, but it did not respond to %3$s",
+             obj, must_respond_to, not_responded_to
+        end
+        true
+
+      rescue ::BareTest::Assertion::Failure, *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not test whether %p responds to %p due to %s", obj, methods, e
       end
 
       # A method to make raising failures that only optionally have a message easier.
@@ -356,7 +401,6 @@ module BareTest
         raise ::BareTest::Assertion::Skip, sprintf(message, *args)
       end
 
-    private
       # extract arg allows to use named or positional args
       #
       # Example:
@@ -384,20 +428,3 @@ module BareTest
     end
   end # Assertion
 end # BareTest
-
-module Enumerable
-
-  # Part of BareTest - require 'baretest/assertion/support'
-  #
-  # Returns true if all elements of self occur the same amount of times in other, regardless
-  # of order. Uses +eql?+ to determine equality.
-  #
-  # Example:
-  #   [2,1,3,2].equal_unordered?([3,2,2,1]) # => true
-  def equal_unordered?(other)
-    count = Hash.new(0)
-    other.each { |element| count[element] += 1 }
-    each { |element| count[element] -= 1 }
-    count.all? { |key, value| value.zero? }
-  end
-end

data/lib/baretest/commandline.rb

@@ -0,0 +1,268 @@
+#--
+# Copyright 2009-2010 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'baretest/assertion/context'
+require 'baretest/assertion/failure'
+require 'baretest/assertion/skip'
+
+
+
+module BareTest
+
+  # The CommandLine module provides all the functionality the
+  # baretest executable uses in a programmatic way.
+  # It in fact even is what the baretest executable itself uses.
+  module CommandLine
+
+    # Load a formatter (see Run::new)
+    def load_formatter(format)
+      require "baretest/run/#{format}" if String === format
+      BareTest.format["baretest/run/#{format}"]
+    end
+    module_function :load_formatter
+
+    # Run the tests and display information about them.
+    # * arguments: array of dirs/globs of files to load and run as tests
+    # * options: a hash with options (all MUST be provided)
+    #
+    # :format      => String - the formatter
+    # :interactive => Boolean - activate interactive mode (drops into irb on failure/error)
+    # :verbose     => Boolean - provide verbose output
+    def run(arguments, options)
+      setup_path              = nil
+      selectors               = BareTest.process_selectors(arguments)
+      options                 = selectors.merge(options)
+      options[:persistence] ||= Persistence.new
+
+      # Load the setup file, all helper files and all test files
+      BareTest.load_standard_test_files(
+        :verbose    => options[:verbose],
+        :setup_path => options[:setup_path],
+        :files      => options[:files],
+        :chdir      => '.'
+      )
+
+      # Run the tests
+      puts if options[:verbose]
+      ARGV.clear # IRB is being stupid
+      runner = BareTest::Run.new(BareTest.toplevel_suite, options)
+      runner.run_all
+
+      # Return whether all tests ran successful
+      runner.global_status == :success
+    end
+    module_function :run
+
+    # Create a basic skeleton of directories and files to contain baretests
+    # test-suite. Non-destructive (existing files won't be overriden or
+    # deleted).
+    def init(arguments, options)
+      core = %w[
+        test
+        test/external
+        test/helper
+        test/helper/suite
+        test/suite
+      ]
+      mirror = {
+        'bin'  => %w[test/helper/suite test/suite],
+        'lib'  => %w[test/helper/suite test/suite],
+        'rake' => %w[test/helper/suite test/suite],
+      }
+      files = {
+        'test/setup.rb' => <<-END_OF_SETUP.gsub(/^ {10}/, '')
+          BareTest.require_ruby     #{RUBY_VERSION.inspect}
+          BareTest.require_baretest #{BareTest::VERSION.to_a.first(3).join('.').inspect}
+          $LOAD_PATH.unshift(File.expand_path("\#{__FILE__}/../../lib")) # Add PROJECT/lib to $LOAD_PATH
+        END_OF_SETUP
+      }
+
+      puts "Creating all directories and files needed in #{File.expand_path('.')}"
+      core.each do |dir|
+        if File.exist?(dir) then
+          puts "Directory #{dir} exists already -- skipping"
+        else
+          puts "Creating #{dir}"
+          Dir.mkdir(dir)
+        end
+      end
+      mirror.each do |path, destinations|
+        if File.exist?(path) then
+          destinations.each do |destination|
+            destination = File.join(destination,path)
+            if File.exist?(destination) then
+              puts "Mirror #{destination} of #{path} exists already -- skipping"
+            else
+              puts "Mirroring #{path} in #{destination}"
+              Dir.mkdir(destination)
+            end
+          end
+        end
+      end
+      files.each do |path, data|
+        if File.exist?(path) then
+          puts "File #{path} exists already -- skipping"
+        else
+          puts "Writing #{path}"
+          File.open(path, 'wb') do |fh|
+            fh.write(data)
+          end
+        end
+      end
+    end
+    module_function :init
+
+    # Shows all formats available in run's -f/--format option.
+    def formats(arguments, options)
+      puts "Available formats:"
+      Dir.glob("{#{$LOAD_PATH.join(',')}}/baretest/run/*.rb") { |path|
+        puts "- #{File.basename(path, '.rb')}"
+      }
+    end
+    module_function :formats
+
+    # List the available commands.
+    def commands(arguments, options)
+      colors = $stdout.tty?
+
+      description = <<-END_OF_DESCRIPTION.gsub(/^ {8}/, '') #                           |<- 80 cols ends here
+        \e[1mCOMMANDS\e[0m
+
+        The following commands are available in baretest:
+
+        \e[1mcommands\e[0m
+            List the available commands.
+
+        \e[1menv\e[0m
+            Show the baretest environment. This contains all data that influences
+            baretests behaviour. That is: ruby version, ruby engine, determined
+            test directory, stored data about this suite etc.
+
+        \e[1mformats\e[0m
+            Shows all formats available in \e[34mrun\e[0m's -f/--format option.
+
+        \e[1mhelp\e[0m
+            Provides help for all commands. Describes options, arguments and env
+            variables each command accepts.
+
+        \e[1minit\e[0m
+            Create a basic skeleton of directories and files to contain baretests test-
+            suite. Non-destructive (existing files won't be overriden or deleted).
+
+        \e[1mrun\e[0m (default command)
+            Run the tests and display information about them.
+
+        \e[1mselectors\e[0m
+            Detailed information about the selectors available to \e[34mrun\e[0m's
+            arguments.
+
+        \e[1mversion\e[0m
+            Show the baretest executable and library versions.
+
+      END_OF_DESCRIPTION
+      #'#                                                                               |<- 80 cols ends here
+      description.gsub!(/\e.*?m/, '') unless colors
+
+      puts description
+    end
+    module_function :commands
+
+    # Detailed information about the selectors available to run's arguments.
+    def selectors(arguments, options)
+      colors = $stdout.tty?
+
+      description = <<-END_OF_DESCRIPTION.gsub(/^ {8}/, '') #                           |<- 80 cols ends here
+        \e[1mSELECTORS\e[0m
+
+        \e[1mDescription\e[0m
+            Selectors are used to identify what tests to run. Baretest knows 3 kinds of
+            selectors: globs, tags and last-run-states. All of these can be preceeded
+            with a minus sign (-), to negate the expression.
+            Beware that you must use negated expressions only after a -- separator,
+            as otherwise baretest will try to interpret them as short options (like -f).
+        
+        \e[1mExample\e[0m
+            `baretest -- test/suite -test/suite/foo :a -:b #failure -#pending`
+
+            This will run all tests that
+            * Are in the directory test/suite or any of its subdirectories
+            * Are NOT in the directory test/suite/foo, or any of its subdirectories
+            * Have the tag 'a'
+            * Do NOT have the tag 'b'
+            * Terminated with a failure status on the last run
+            * Did NOT terminate with a pending status on the last run
+        
+        \e[1mGlobs\e[0m
+            * '**' recursively matches all files and directories
+            * '*' wildcard, matches any amount of any character
+            * '?' wildcard, matches one character 
+            * '{a,b,c}' alternation, matches any pattern in the comma separated list
+            * Directories are equivalent to `directory/**/*` patterns
+
+        \e[1mTags\e[0m
+            Tags are preceeded with an :.
+            Examples:
+              baretest :focus
+              baretest -- -:hocus
+              baretest -- :focus :important -:irrelevant -:obsolete
+
+        \e[1mLast-run-status\e[0m
+            Last run states are preceeded with a %.
+            * %success, %failure, %error, %skipped, %pending
+            * %error, %skipped and %pending are a subset of %failure
+            * %pending is a subset of %skipped
+
+      END_OF_DESCRIPTION
+
+      description.gsub!(/\e.*?m/, '') unless colors
+
+      puts description
+    end
+    module_function :selectors
+
+    # Provides help for all commands. Describes options, arguments and env
+    # variables each command accepts.
+    def help(arguments, options)
+      colors = $stdout.tty?
+
+      description = <<-END_OF_DESCRIPTION.gsub(/^ {8}/, '') #                           |<- 80 cols ends here
+        \e[1mHELP\e[0m
+
+        See `#{$0} commands` for a list of available commands.
+        You can also use `#{$0} COMMAND --help` to get information about
+        the command COMMAND.
+      END_OF_DESCRIPTION
+
+      description.gsub!(/\e.*?m/, '') unless colors
+
+      puts description
+    end
+    module_function :help
+
+    # Show the baretest environment. This contains all data that influences
+    # baretests behaviour. That is: ruby version, ruby engine, determined test
+    # directory, stored data about this suite etc.
+    def env(arguments, options)
+      puts "Versions:",
+           "* executable: #{Version}",
+           "* library: #{BareTest::VERSION}",
+           "* ruby #{RUBY_VERSION}",
+           ""
+    end
+    module_function :env
+
+    # Show the baretest executable and library versions.
+    def version(arguments, options)
+      puts "baretest executable version #{Version}",
+           "library version #{BareTest::VERSION}",
+           "ruby version #{RUBY_VERSION}",
+           ""
+    end
+    module_function :version
+  end
+end