baretest 0.2.4 → 0.4.0.pre1

data/examples/tests/06_advanced_III_requires.rb

@@ -0,0 +1,21 @@
+# pretend the lib 'baretest/demo/06_advanced_requires' was already loaded
+$LOADED_FEATURES << 'baretest/demo/06_advanced_requires'
+
+
+# You can baretest tell that a suite depends on an external lib using the
+# :requires option, it accepts either a String or an Array of strings.
+BareTest.suite do
+  # Baretest will load all libraries mentioned in :requires via a standard
+  # Kernel.require upon suite definition
+  suite "Depends on an existing lib", :requires => 'baretest/demo/06_advanced_requires' do
+    assert "Succeeds because library-dependency is met" do
+      true
+    end
+  end
+
+  suite "Depends on a missing lib", :requires => 'baretest/demo/06_advanced_requires_missing' do
+    assert "Skipped because library-dependency is NOT met" do
+      true
+    end
+  end
+end

data/examples/tests/07_advanced_IV_components.rb

@@ -0,0 +1,48 @@
+# This code should be in 'baretest/use/demo_component', somewhere in rubys
+# $LOAD_PATH.
+module DemoComponent
+  module DemoMethods
+    def demo
+      demo_component  = @demo_component
+      @demo_component = :executed
+      same(:setup, demo_component)
+    end
+  end
+end
+
+BareTest.new_component :demo_component do
+  # Make our components' assertion helpers available in assertions
+  BareTest::Assertion::Context.send :include, DemoComponent::DemoMethods
+
+  setup do
+    @demo_component = :setup
+  end
+
+  teardown do
+    same(:executed, @demo_component, "@demo_component after the assertion")
+  end
+end
+
+
+BareTest.suite do
+  suite "Using DemoComponent", :use => :demo_component do
+    assert "Successful assertions must use the 'demo' method" do
+      demo
+    end
+
+    assert "Fails if 'demo' is not invoked, even if otherwise successful" do
+      true
+    end
+
+    assert "Fails if @demo_component was changed prior to calling 'demo'" do
+      @demo_component = :unexpected
+      demo
+    end
+
+    assert "Fails if @demo_component was changed after to calling 'demo'" do
+      demo
+      @demo_component = :unexpected
+      true
+    end
+  end
+end

data/examples/tests/08_expert_I_setup_variants.rb

@@ -0,0 +1,46 @@
+# The thing we want to test
+class String
+  def numeric?
+    self =~ /[+-]?(?:[1-9]\d*|0)(?:\.\d+)?(?:[eE][+-]?\d+)?/
+  end
+end
+
+BareTest.suite do
+  suite "Variations - Notation I" do
+    setup :number, '123' do |number|
+      @number = '123'
+    end
+
+    setup :number, '-123' do |number|
+      @number = '-123'
+    end
+
+    setup :number, '1.23' do |number|
+      @number = '1.23'
+    end
+
+    assert ":number should be a numeric" do
+      @number.numeric?
+    end
+  end
+
+  suite "Variations - Notation II" do
+    setup :number, %w[123 -123 1.23 -1.23 1e3 -1e3 1e-3 -1e-3] do |number|
+      @number = number
+    end
+
+    assert ":number should be a numeric" do
+      @number.numeric?
+    end
+  end
+
+  suite "Variations - Notation III" do
+    setup :number, {'"123"' => "123", '"1.23"' => "1.23", '"1e3"' => "1e3"} do |number|
+      @number = number
+    end
+
+    assert ":number should be a numeric" do
+      @number.numeric?
+    end
+  end
+end

data/lib/baretest.rb

@@ -7,6 +7,9 @@
 
 
 require 'baretest/assertion'
+require 'baretest/commandline'
+require 'baretest/formatter'
+require 'baretest/invalidselectors'
 require 'baretest/irb_mode'
 require 'baretest/run'
 require 'baretest/suite'
@@ -17,7 +20,45 @@ require 'ruby/kernel'
 
 
 module BareTest
+  # A lookup table to test which of two states is more important
+  # (MoreImportantStatus[[a,b]] # => a or b)
+  MoreImportantStatus = {}
+
+  # All states in the order of relevance, more relevant states first
+  StatusOrder         = :error,
+                        :failure,
+                        :pending,
+                        :manually_skipped,
+                        :dependency_missing,
+                        :library_missing,
+                        :component_missing,
+                        :ignored,
+                        :success
+
+  StatusOrder.combination(2) do |x,y|
+    more_important = StatusOrder.index(x) < StatusOrder.index(y) ? x : y
+    MoreImportantStatus[[x,y]] = more_important
+    MoreImportantStatus[[y,x]] = more_important
+  end
+  StatusOrder.each do |status|
+    MoreImportantStatus[[status,status]] = status
+    MoreImportantStatus[[nil,status]]    = status
+    MoreImportantStatus[[status,nil]]    = status
+  end
+
+  # The standard glob used by baretest to load test files
+  # :nodoc:
+  DefaultInitialPositiveGlob = 'test/{suite,unit,isolation,integration,system}/**/*.rb'
+
+  # Selectors that are valid to be passed into process_selectors
+  # :nodoc:
+  ValidStateSelectors = [:new, :success, :failure, :error, :skipped, :pending]
+
   class << self
+    # A hash of components - available via BareTest::use(name) and
+    # Suite#suite :use => name
+    attr_reader :components
+
     # A hash of formatters (require-string => module) to be used with Test::Run.
     attr_reader :format
 
@@ -33,6 +74,21 @@ module BareTest
     attr_reader :required_file # :nodoc:
   end
 
+  # Enure that the suite is run wiht a minimal version of baretest
+  def self.require_baretest(version)
+    if (version.split(".").map { |s| s.to_i } <=> BareTest::VERSION.to_a) == 0 then
+      abort "Requires baretest version #{version}, you have #{BareTest::VERSION}"
+    end
+  end
+
+  # Ensure that the suite is run with a minimal version of ruby
+  def self.require_ruby(version)
+    if (version.split(".").map { |s| s.to_i } <=> RUBY_VERSION.split(".").map { |s| s.to_i }) == 1 then
+      abort "Requires ruby version #{version}, you have #{RUBY_VERSION}"
+    end
+  end
+
+
   # Loads all files in a test directory in order to load the suites and
   # assertions. Used by the 'baretest' executable and the standard rake task.
   #
@@ -44,16 +100,20 @@ module BareTest
   def self.load_standard_test_files(opts={})
     verbose    = opts.delete(:verbose)
     setup_path = opts.delete(:setup_path) || 'test/setup.rb'
+    lib_path   = opts.delete(:lib_path) || 'test/lib'
     chdir      = opts.delete(:chdir) || '.'
-    files      = opts.delete(:files) || ['test/{suite,unit,integration,system}/**/*.rb']
+    files      = opts.delete(:files)
+    files      = [DefaultInitialPositiveGlob] if (files.nil? || files.empty?)
     Dir.chdir(chdir) do
+      $LOAD_PATH.unshift(File.expand_path(lib_path)) if File.exist?(lib_path)
       load(setup_path) if File.exist?(setup_path)
       files.each do |glob|
         glob = "#{glob}/**/*.rb" if File.directory?(glob)
         Dir.glob(glob) { |path|
           helper_path = path.sub(%r{^test/(suite|unit|integration|system)/}, 'test/helper/\1/')
-          puts(File.exist?(helper_path) ? "Loading helper file #{helper_path}" : "No helper file #{helper_path} to load") if verbose
-          load(helper_path) if File.exist?(helper_path)
+          exists = (helper_path != path && File.exist?(helper_path))
+          puts(exists ? "Loading helper file #{helper_path}" : "No helper file #{helper_path} to load") if verbose
+          load(helper_path) if exists
           puts "Loading test file #{path}" if verbose
           load(path)
         }
@@ -61,10 +121,70 @@ module BareTest
     end
   end
 
+  # Determine which of the named states is the most important one (see
+  # StatusOrder)
+  def self.most_important_status(states)
+    (StatusOrder & states).first # requires Array#& to be stable (keep order of first operand)
+  end
+
+  # Convert an array of selectors into a hash with those selectors preprocessed
+  # as far as possible.
+  # Example:
+  #   BareTest.process_selectors %w[-some/**/glob/*.rb %failure :tag1 -:tag2]
+  #   # => {
+  #   #      :files          => ...an array with paths...,
+  #   #      :include_tags   => [:tag1],
+  #   #      :exclude_tags   => [:tag2],
+  #   #      :include_states => [:failure]
+  #   #      :exclude_states => nil,
+  #   #    }
+  def self.process_selectors(selectors, base_directory=".", default_initial_positive_glob=nil)
+    files           = []
+    include_tags    = []
+    exclude_tags    = []
+    include_states  = []
+    exclude_states  = []
+
+    default_initial_positive_glob ||= DefaultInitialPositiveGlob
+    Dir.chdir(base_directory) do
+      selectors.each do |selector|
+        case selector
+          when /\A-%(.*)/   then exclude_states << $1.to_sym
+          when /\A-:(.*)/   then exclude_tags << $1.to_sym
+          when /\A\+?%(.*)/ then include_states << $1.to_sym
+          when /\A\+?:(.*)/ then include_tags << $1.to_sym
+          when /\A-(.*)/    then
+            files  = Dir[default_initial_positive_glob] if files.empty? && default_initial_positive_glob
+            glob   = File.directory?($1) ? "#{$1}/**/*.rb" : $1
+            files -= Dir[glob]
+          when /\A\+?(.*)/  then
+            glob   = File.directory?(selector) ? "#{selector}/**/*.rb" : selector
+            files |= Dir[glob]
+          else
+            raise "Should never reach else - selector: #{selector.inspect}"
+        end
+      end
+      files  = Dir[default_initial_positive_glob] if files.empty? && default_initial_positive_glob
+      files.map! do |path| File.expand_path(path) end
+    end
+
+    invalid_states = (include_states|exclude_states)-ValidStateSelectors
+    raise InvalidSelectors.new(invalid_states) unless invalid_states.empty?
+
+    return {
+      :files          => files,
+      :include_tags   => include_tags,
+      :exclude_tags   => exclude_tags,
+      :include_states => include_states.empty? ? nil : include_states,
+      :exclude_states => exclude_states.empty? ? nil : exclude_states
+    }
+  end
+
   # Initializes BareTest, is automatically called
   #
   # Needed for bootstrapped selftest
   def self.init # :nodoc:
+    @components     = {}
     @format         = {}
     @extender       = []
     @toplevel_suite = BareTest::Suite.new
@@ -74,6 +194,17 @@ module BareTest
   end
   init
 
+  def self.component(name)
+    component = @components[name]
+    begin
+      require "baretest/use/#{name}"
+    rescue LoadError
+    else
+      component = @components[name]
+    end
+    component
+  end
+
   # If no description was given, it adds the contained assertions and suites to the toplevel suite,
   # if a description was given, a suite with the given description is created, added to the toplevel
   # suite, and all the contained assertions and suites are added to the created suite.
@@ -87,26 +218,16 @@ module BareTest
     end
   end
 
-  # Creates a Test::Run instance, adds the assertions and suites defined in its
-  # own block to that Test::Run instance's toplevel suite and if $PROGRAM_NAME
-  # (aka $0) is equal to \_\_FILE__ (means the current file is the file directly
-  # executed by ruby, and not just required/loaded/evaled by another file),
-  # subsequently also runs that suite.
-  def self.run_if_mainfile(description=nil, opts={}, &block)
-    suite(description, opts, &block)
-    if caller.first[/^[^:]*/] == $0 then # if is mainfile
-      run(:format => ENV['FORMAT'], :interactive => ENV['INTERACTIVE'])
-    end
+  # Create a new component for Suite's :use option (see BareTest::Suite::new)
+  def self.new_component(name, &block)
+    name = name.to_sym
+    raise ArgumentError, "Component named #{name.inspect} already exists" if @components.has_key?(name)
+    @components[name] = block
   end
 
-  # Runs the toplevel suite (which usually contains all suites and assertions
-  # defined in all loaded test files).
-  #
-  # Returns the Run instance.
-  def self.run(opts=nil)
-    runner = BareTest::Run.new(@toplevel_suite, opts)
-    runner.run_all
-    runner
+  # Shortcut for toplevel_suite.use. Preferably use the :use option instead.
+  def self.use(component)
+    @toplevel_suite.use(component)
   end
 end
 

data/lib/baretest/assertion.rb

@@ -9,6 +9,7 @@
 require 'baretest/assertion/context'
 require 'baretest/assertion/failure'
 require 'baretest/assertion/skip'
+require 'baretest/status'
 
 
 
@@ -30,42 +31,16 @@ module BareTest
   # * Kernel#equal_unordered(a,b)
   # * Enumerable#equal_unordered(other)
   class Assertion
-
     # The exceptions baretest will not rescue (NoMemoryError, SignalException, Interrupt
     # and SystemExit)
     PassthroughExceptions = [NoMemoryError, SignalException, Interrupt, SystemExit]
 
-    # An assertion has 5 possible states:
-    # :success:: The assertion passed. This means the block returned a trueish value.
-    # :failure:: The assertion failed. This means the block returned a falsish value.
-    #            Alternatively it raised a Test::Failure (NOT YET IMPLEMENTED).
-    #            The latter has the advantage that it can provide nicer diagnostics.
-    # :pending:: No block given to the assertion to be run
-    # :skipped:: If one of the parent suites is missing a dependency, its assertions
-    #            will be skipped
-    # :error::   The assertion errored out. This means the block raised an exception
-    attr_reader :status
-
-    # If an exception occured in Assertion#execute, this will contain the
-    # Exception object raised.
-    attr_reader :exception
-
     # The description of this assertion.
     attr_reader :description
 
-    # The failure/error/skipping/pending reason.
-    attr_reader :reason
-
     # The suite this assertion belongs to
     attr_reader :suite
 
-    # The Context-instance the assertions setup, assert and teardown are run
-    attr_reader :context
-
-    # The Setup instances whose #block is to be executed before this assertion
-    # is ran
-    attr_accessor :setups
-
     # The block specifying the assertion
     attr_reader :block
 
@@ -85,90 +60,106 @@ module BareTest
     # description:: A descriptive string about what this Assertion tests.
     # &block::      The block definition. Without one, the Assertion will have a
     #               :pending status.
-    def initialize(suite, description, &block)
-      @suite          = suite
-      @description    = (description || "No description given")
-      @setups         = nil
-      @block          = block
-      reset
+    def initialize(suite, description, opt=nil, &block)
+      @suite       = suite
+      @description = (description || "No description given")
+      @block       = block
+      @skipped     = false
+      if opt then
+        skip_reason = opt[:skip]
+        skip(skip_reason == true ? "Tagged as skipped" : skip_reason) if skip_reason
+      end
+    end
+
+    # An ID, usable for persistence
+    def id
+      @id ||= [
+        @description,
+        *(@suite && @suite.ancestors.map { |suite| suite.description })
+      ].compact.join("\f")
     end
 
-    def reset
-      @status    = nil
-      @reason    = nil
-      @exception = nil
-      @context   = ::BareTest::Assertion::Context.new(self)
+    # Returns whether this assertion has been marked as manually skipped.
+    def skipped?
+      !!@skipped
     end
 
-    def interpolated_description
-      setups = @setups ? @setups.select { |s| s.component } : []
-      if setups.empty? then
+    # Marks this assertion as manually skipped.
+    def skip(reason=nil)
+      @skipped ||= []
+      @skipped  |= reason ? Array(reason) : ['Manually skipped']
+    end
+
+    # The description allows substitutes in the form ":identifier" and
+    # ":{identifier}" (the latter in case of ajanced characters that don't
+    # belong to the identifier, like ":{identifier}stuff").
+    # This method will interploate those substitutes.
+    # This is relevant with regards to setup variants.
+    def interpolated_description(substitutes)
+      if substitutes.empty? then
         @description
       else
-        substitutes = {}
-        setups.each do |setup| substitutes[setup.component] = setup.substitute end
         @description.gsub(/:(?:#{substitutes.keys.join('|')})\b/) { |m|
           substitutes[m[1..-1].to_sym]
         }
       end
     end
 
-    # Run all setups in the order of their nesting (outermost first, innermost last)
-    def setup
-      @setups  ||= @suite ? @suite.first_component_variant : []
-      @setups.each do |setup| @context.instance_exec(setup.value, &setup.block) end
-      true
-    rescue *PassthroughExceptions
-      raise # pass through exceptions must be passed through
-    rescue Exception => exception
-      @reason    = "An error occurred during setup"
-      @exception = exception
-      @status    = :error
-      false
-    end
+    # Returns a Status
+    # Executes with_setup, then the assertions defining block, and in the end
+    # and_teardown. Usually with_setup and and_teardown are supplied by the
+    # containing suite.
+    def execute(with_setup=nil, and_teardown=nil)
+      if @skipped then
+        status = Status.new(self, :manually_skipped)
+      elsif !@block
+        status = Status.new(self, :pending)
+      else
+        context  = ::BareTest::Assertion::Context.new(self)
+        status   = execute_phase(:setup, context, with_setup) if with_setup
+        status   = execute_phase(:exercise, context, @block) unless status
+        status   = execute_phase(:teardown, context, and_teardown) unless (status || !and_teardown)
+        status ||= Status.new(self, :success, context)
+      end
 
-    # Run all teardowns in the order of their nesting (innermost first, outermost last)
-    def teardown
-      @suite.ancestry_teardown.each do |teardown|
-        @context.instance_eval(&teardown)
-      end if @suite
-    rescue *PassthroughExceptions
-      raise # pass through exceptions must be passed through
-    rescue Exception => exception
-      @reason    = "An error occurred during setup"
-      @exception = exception
-      @status    = :error
+      status
     end
 
-    # Runs the assertion and sets the status and exception
-    def execute(setups=nil)
-      @setups    = setups if setups
-      @exception = nil
-      if @block then
-        if setup() then
-          # run the assertion
-          begin
-            @status = @context.instance_eval(&@block) ? :success : :failure
-            @reason = "Assertion failed" if @status == :failure
-          rescue *PassthroughExceptions
-            raise # pass through exceptions must be passed through
-          rescue ::BareTest::Assertion::Failure => failure
-            @status = :failure
-            @reason = failure.message
-          rescue ::BareTest::Assertion::Skip => skip
-            @status = :skipped
-            @reason = skip.message
-          rescue Exception => exception
-            @reason    = "An error occurred during execution"
-            @exception = exception
-            @status    = :error
+    # A phase can result in either success, skip, failure or error
+    # Execute_phase will simply return nil upon success, all other cases
+    # will generate a full Status instance.
+    # This is for practical reasons - it means you can go through several
+    # phases, looking for the first non-nil one.
+    def execute_phase(name, context, code)
+      status         = nil
+      skip_reason    = nil
+      failure_reason = nil
+      exception      = nil
+
+      begin
+        if code.is_a?(Array) then
+          code.each do |block| context.instance_eval(&block) end
+        else
+          unless context.instance_eval(&code)
+            failure_reason = "Assertion failed" 
+            status         = :failure
           end
         end
-        teardown
-      else
-        @status = :pending
+      rescue *PassthroughExceptions
+        raise # passthrough-exceptions must be passed through
+      rescue ::BareTest::Assertion::Failure => failure
+        status         = :failure
+        failure_reason = failure.message
+      rescue ::BareTest::Assertion::Skip => skip
+        status         = :manually_skipped
+        skip_reason    = skip.message
+      rescue Exception => exception
+        status         = :error
+        failure_reason = "An error occurred during #{name}: #{exception}"
+        exception      = exception
       end
-      self
+
+      status && Status.new(self, status, context, skip_reason, failure_reason, exception)
     end
 
     def to_s # :nodoc: