assert 2.16.3 → 2.16.4

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  metadata.gz: 2f4a1019a10e96ae935cb6aa9fc17f93e5965659f3e401d367f5a81fe260960b28f1741218eaf2b9f9ca7993ba0fc6cbce5b447c78f9289812014daeb8c74108
-  data.tar.gz: d6a0657a4041933cadd0e238571cabd9092bbe4e4e7db2470deb75c80689c3ccf6df4601136ae8a4e910eaa815bb5066c7a5df875750aea5bd1300cdf1e5ff34
 SHA1: 
-  metadata.gz: b2d74dbdecb01c84ed0131687f80d59da6b020ce
-  data.tar.gz: c9b15366dba845affe5b51466c6e6c836b5c7658
+  data.tar.gz: 1140a1218d3b3df2195ab376b494b275155951e2
+  metadata.gz: e696cad6f5a6a309c43c72c059f7072ad7b5fa28
+SHA512: 
+  data.tar.gz: d819e6364e40bd86571d63e87b93ca4277f441914d25b862543504a58eef9ab6cc8c29a95e7db502288e526b8de62abc52c355c3f21bf372ab57d2f1a87cc00d
+  metadata.gz: 6bd08bca020ce2e980da50aec61e574270c2e77e1441d3fc84c50d91b60651713c367b00c8aa78478abdb5bb2b0a379eb120ec73cd14c27d94a049f07bb0ac25

data/README.md

@@ -557,6 +557,7 @@ Available callbacks from the runner, and when they are called:
 * `on_result`: when a running tests generates a result, the result is passed as an arg
 * `after_test`: after a test finishes running, the test is passed as an arg
 * `on_finish`: when the test suite is finished running
+* `on_info`: called when the INFO signal is triggered while running the test suite (Ctrl-T on Macs)
 * `on_interrupt`: called when the test suite is interrupted while running
 
 Beyond that, each view can do as it sees fit.  Initialize how you wish, take whatever settings you'd like, and output results as you see fit, given the available callbacks.

data/lib/assert.rb

@@ -23,3 +23,12 @@ module Assert
   end
 
 end
+
+# Kernel#caller_locations polyfill for pre ruby 2.0.0
+if RUBY_VERSION =~ /\A1\..+/ && !Kernel.respond_to?(:caller_locations)
+  module Kernel
+    def caller_locations(start = 1, length = nil)
+      length ? caller[start, length] : caller[start..-1]
+    end
+  end
+end

data/lib/assert/context.rb

@@ -34,14 +34,14 @@ module Assert
 
         if self.suite.test_methods.include?(klass_method_name)
           puts "WARNING: redefining '#{klass_method_name}'"
-          puts "  from: #{caller.first}"
+          puts "  from: #{caller_locations(1,1)}"
         else
           self.suite.test_methods << klass_method_name
         end
 
         self.suite.on_test(Test.for_method(
           method_name.to_s,
-          ContextInfo.new(self, nil, caller.first),
+          ContextInfo.new(self, nil, caller_locations(1,1)),
           self.suite.config
         ))
       end
@@ -50,10 +50,13 @@ module Assert
     def initialize(running_test, config, result_callback)
       @__assert_running_test__ = running_test
       @__assert_config__       = config
-      @__assert_with_bt__      = nil
+      @__assert_with_bt__      = []
+      @__assert_pending__      = 0
 
       @__assert_result_callback__ = proc do |result|
-        result.set_backtrace(@__assert_with_bt__) if @__assert_with_bt__
+        if !@__assert_with_bt__.empty?
+          result.set_with_bt(@__assert_with_bt__.dup)
+        end
         result_callback.call(result)
         result
       end
@@ -89,7 +92,12 @@ module Assert
     # adds a Pass result to the end of the test's results
     # does not break test execution
     def pass(pass_msg = nil)
-      capture_result(Assert::Result::Pass, pass_msg)
+      if @__assert_pending__ == 0
+        capture_result(Assert::Result::Pass, pass_msg)
+      else
+        capture_result(Assert::Result::Fail, "Pending pass (make it "\
+                                             "not pending)")
+      end
     end
 
     # adds an Ignore result to the end of the test's results
@@ -101,10 +109,18 @@ module Assert
     # adds a Fail result to the end of the test's results
     # break test execution if assert is configured to halt on failures
     def fail(message = nil)
-      if halt_on_fail?
-        raise Result::TestFailure, message || ''
+      if @__assert_pending__ == 0
+        if halt_on_fail?
+          raise Result::TestFailure, message || ''
+        else
+          capture_result(Assert::Result::Fail, message || '')
+        end
       else
-        capture_result(Assert::Result::Fail, message || '')
+        if halt_on_fail?
+          raise Result::TestSkipped, "Pending fail: #{message || ''}"
+        else
+          capture_result(Assert::Result::Skip, "Pending fail: #{message || ''}")
+        end
       end
     end
     alias_method :flunk, :fail
@@ -112,21 +128,32 @@ module Assert
     # adds a Skip result to the end of the test's results
     # breaks test execution
     def skip(skip_msg = nil, called_from = nil)
-      err = Result::TestSkipped.new(skip_msg || '')
-      err.set_backtrace([called_from]) if called_from
-      raise(err)
+      raise Result::TestSkipped, (skip_msg || ''), called_from
+    end
+
+    # runs block and any fails are skips and any passes are fails
+    def pending(&block)
+      begin
+        @__assert_pending__ += 1
+        instance_eval(&block)
+      ensure
+        @__assert_pending__ -= 1
+      end
     end
 
     # alter the backtraces of fail/skip results generated in the given block
     def with_backtrace(bt, &block)
       bt ||= []
       begin
-        @__assert_with_bt__ = bt
+        @__assert_with_bt__.push(bt.first)
         instance_eval(&block)
       rescue Result::TestSkipped, Result::TestFailure => e
-        e.set_backtrace(@__assert_with_bt__); raise(e)
+        if e.assert_with_bt.nil? && !@__assert_with_bt__.empty?
+          e.assert_with_bt = @__assert_with_bt__.dup
+        end
+        raise(e)
       ensure
-        @__assert_with_bt__ = nil
+        @__assert_with_bt__.pop
       end
     end
 
@@ -156,7 +183,7 @@ module Assert
 
     def capture_result(result_klass, msg)
       @__assert_result_callback__.call(
-        result_klass.for_test(@__assert_running_test__, msg, caller)
+        result_klass.for_test(@__assert_running_test__, msg, caller_locations)
       )
     end
 

data/lib/assert/context/test_dsl.rb

@@ -15,23 +15,23 @@ class Assert::Context
         # create a test from the given code block
         self.suite.on_test(Assert::Test.for_block(
           desc_or_macro.kind_of?(Assert::Macro) ? desc_or_macro.name : desc_or_macro,
-          Assert::ContextInfo.new(self, called_from, first_caller || caller.first),
+          Assert::ContextInfo.new(self, called_from, first_caller || caller_locations.first),
           self.suite.config,
           &block
         ))
       else
-        test_eventually(desc_or_macro, called_from, first_caller || caller.first, &block)
+        test_eventually(desc_or_macro, called_from, first_caller || caller_locations.first, &block)
       end
     end
 
     def test_eventually(desc_or_macro, called_from = nil, first_caller = nil, &block)
       # create a test from a proc that just skips
-      ci = Assert::ContextInfo.new(self, called_from, first_caller || caller.first)
+      ci = Assert::ContextInfo.new(self, called_from, first_caller || caller_locations.first)
       self.suite.on_test(Assert::Test.for_block(
         desc_or_macro.kind_of?(Assert::Macro) ? desc_or_macro.name : desc_or_macro,
         ci,
         self.suite.config,
-        &proc { skip('TODO', ci.called_from) }
+        &proc { skip('TODO', [ci.called_from.to_s]) }
       ))
     end
     alias_method :test_skip, :test_eventually
@@ -40,14 +40,14 @@ class Assert::Context
       if !desc_or_macro.kind_of?(Assert::Macro)
         desc_or_macro = "should #{desc_or_macro}"
       end
-      test(desc_or_macro, called_from, first_caller || caller.first, &block)
+      test(desc_or_macro, called_from, first_caller || caller_locations.first, &block)
     end
 
     def should_eventually(desc_or_macro, called_from = nil, first_caller = nil, &block)
       if !desc_or_macro.kind_of?(Assert::Macro)
         desc_or_macro = "should #{desc_or_macro}"
       end
-      test_eventually(desc_or_macro, called_from, first_caller || caller.first, &block)
+      test_eventually(desc_or_macro, called_from, first_caller || caller_locations.first, &block)
     end
     alias_method :should_skip, :should_eventually
 

data/lib/assert/context_info.rb

@@ -7,7 +7,7 @@ module Assert
     def initialize(klass, called_from = nil, first_caller = nil)
       @called_from = called_from || first_caller
       @klass = klass
-      @file = @called_from.gsub(/\:[0-9]+.*$/, '') if @called_from
+      @file = @called_from.to_s.gsub(/\:[0-9]+.*$/, '') if @called_from
     end
 
     def test_name(name)

data/lib/assert/default_view.rb

@@ -59,6 +59,15 @@ module Assert
            "#{formatted_suite_result_rate} results/s)"
     end
 
+    def on_info(test)
+      dump_test_results
+
+      puts "Current test:"
+      puts test.name
+      puts test.file_line.to_s
+      puts
+    end
+
     def on_interrupt(err)
       dump_test_results
     end

data/lib/assert/macros/methods.rb

@@ -10,7 +10,7 @@ module Assert::Macros
     module ClassMethods
 
       def have_instance_method(*methods)
-        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller).first
+        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller_locations).first
         Assert::Macro.new do
           methods.each{ |m| _methods_macro_instance_methods << [m, called_from] }
           _methods_macro_test called_from
@@ -21,7 +21,7 @@ module Assert::Macros
       alias_method :have_imeths, :have_instance_method
 
       def not_have_instance_method(*methods)
-        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller).first
+        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller_locations).first
         Assert::Macro.new do
           methods.each{ |m| _methods_macro_not_instance_methods << [m, called_from] }
           _methods_macro_test called_from
@@ -32,7 +32,7 @@ module Assert::Macros
       alias_method :not_have_imeths, :not_have_instance_method
 
       def have_class_method(*methods)
-        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller).first
+        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller_locations).first
         Assert::Macro.new do
           methods.each{ |m| _methods_macro_class_methods << [m, called_from] }
           _methods_macro_test called_from
@@ -43,7 +43,7 @@ module Assert::Macros
       alias_method :have_cmeths, :have_class_method
 
       def not_have_class_method(*methods)
-        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller).first
+        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller_locations).first
         Assert::Macro.new do
           methods.each{ |m| _methods_macro_not_class_methods << [m, called_from] }
           _methods_macro_test called_from
@@ -54,19 +54,19 @@ module Assert::Macros
       alias_method :not_have_cmeths, :not_have_class_method
 
       def have_reader(*methods)
-        methods << caller if !methods.last.kind_of?(Array)
+        methods << caller_locations if !methods.last.kind_of?(Array)
         have_instance_methods(*methods)
       end
       alias_method :have_readers, :have_reader
 
       def not_have_reader(*methods)
-        methods << caller if !methods.last.kind_of?(Array)
+        methods << caller_locations if !methods.last.kind_of?(Array)
         not_have_instance_methods(*methods)
       end
       alias_method :not_have_readers, :not_have_reader
 
       def have_writer(*methods)
-        called = methods.last.kind_of?(Array) ? methods.pop : caller
+        called = methods.last.kind_of?(Array) ? methods.pop : caller_locations
         writer_meths = methods.collect{|m| "#{m}="}
         writer_meths << called
         have_instance_methods(*writer_meths)
@@ -74,7 +74,7 @@ module Assert::Macros
       alias_method :have_writers, :have_writer
 
       def not_have_writer(*methods)
-        called = methods.last.kind_of?(Array) ? methods.pop : caller
+        called = methods.last.kind_of?(Array) ? methods.pop : caller_locations
         writer_meths = methods.collect{|m| "#{m}="}
         writer_meths << called
         not_have_instance_methods(*writer_meths)
@@ -82,7 +82,7 @@ module Assert::Macros
       alias_method :not_have_writers, :not_have_writer
 
       def have_accessor(*methods)
-        called = methods.last.kind_of?(Array) ? methods.pop : caller
+        called = methods.last.kind_of?(Array) ? methods.pop : caller_locations
         accessor_meths = methods.collect{|m| [m, "#{m}="]}.flatten
         accessor_meths << called
         have_instance_methods(*accessor_meths)
@@ -90,7 +90,7 @@ module Assert::Macros
       alias_method :have_accessors, :have_accessor
 
       def not_have_accessor(*methods)
-        called = methods.last.kind_of?(Array) ? methods.pop : caller
+        called = methods.last.kind_of?(Array) ? methods.pop : caller_locations
         accessor_meths = methods.collect{|m| [m, "#{m}="]}.flatten
         accessor_meths << called
         not_have_instance_methods(*accessor_meths)
@@ -104,28 +104,28 @@ module Assert::Macros
 
           self.class._methods_macro_instance_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} does not have instance method ##{method}"
-            with_backtrace(called_from) do
+            with_backtrace([called_from]) do
               assert_respond_to method, subject, msg
             end
           end
 
           self.class._methods_macro_class_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} does not have class method ##{method}"
-            with_backtrace(called_from) do
+            with_backtrace([called_from]) do
               assert_respond_to method, subject.class, msg
             end
           end
 
           self.class._methods_macro_not_instance_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} has instance method ##{method}"
-            with_backtrace(called_from) do
+            with_backtrace([called_from]) do
               assert_not_respond_to method, subject, msg
             end
           end
 
           self.class._methods_macro_not_class_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} has class method ##{method}"
-            with_backtrace(called_from) do
+            with_backtrace([called_from]) do
               assert_not_respond_to method, subject.class, msg
             end
           end

data/lib/assert/result.rb

@@ -3,12 +3,12 @@ require 'assert/file_line'
 module Assert; end
 module Assert::Result
 
-  class Base; end
-  class Pass < Base; end
-  class Ignore < Base; end
-  class Fail < Base; end
-  class Error < Base; end
-  class Skip < Base; end
+  class Base          ; end
+  class Pass   < Base ; end
+  class Ignore < Base ; end
+  class Fail   < Base ; end
+  class Error  < Base ; end
+  class Skip   < Base ; end
 
   def self.types
     @types ||= Hash.new{ |h, k| Base }.tap do |hash|
@@ -42,6 +42,7 @@ module Assert::Result
 
     def initialize(build_data)
       @build_data = build_data
+      @with_bt    = nil
     end
 
     def type
@@ -80,19 +81,37 @@ module Assert::Result
     end
 
     def trace
-      @trace ||= (@build_data[:trace] || build_trace(self.backtrace))
+      @trace ||= build_trace
     end
 
     # we choose to implement this way instead of using an `attr_writer` to be
     # consistant with how you override exception backtraces.
     def set_backtrace(bt)
       @backtrace = Backtrace.new(bt)
-      @trace     = build_trace(@backtrace)
-      @file_line = Assert::FileLine.parse(first_filtered_bt_line(@backtrace))
+      @src_line  = nil
+      @file_line = nil
+      @trace     = nil
+    end
+
+    # set the given with bt and the src line for with bt
+    def set_with_bt(with_bt)
+      return if with_bt.nil?
+      @with_bt   = with_bt
+      @src_line  = with_bt.first
+      @file_line = nil
+      @trace     = nil
+    end
+
+    def with_bt_set?
+      !@with_bt.nil?
+    end
+
+    def src_line
+      @src_line ||= first_filtered_bt_line(self.backtrace)
     end
 
     def file_line
-      @file_line ||= Assert::FileLine.parse(first_filtered_bt_line(self.backtrace))
+      @file_line ||= Assert::FileLine.parse(self.src_line)
     end
 
     def file_name; self.file_line.file;      end
@@ -124,15 +143,21 @@ module Assert::Result
 
     private
 
-    # by default, a result's trace is the first line of its filtered backtrace
-    # if the filtered backtrace is empty, just use the backtrace itself (this
-    # should only occur if the result is an error from a line in assert's
-    # non-test code).  This is overridden for error results as they always show
-    # the entire backtrace
-    def build_trace(backtrace)
-      first_filtered_bt_line(backtrace)
+    # By default, a result's trace is its `src_line`.  If a with bt has been
+    # set, display it in full along with the "original src line" (the first
+    # filtered line of the backtrace).  This is overridden for error results
+    # as they always show their full backtrace.
+    def build_trace
+      if self.with_bt_set?
+        Backtrace.to_s(@with_bt+[first_filtered_bt_line(self.backtrace)])
+      else
+        self.src_line
+      end
     end
 
+    # if the filtered backtrace is empty, just use the backtrace itself (this
+    # should only occur if the result is an error from a line in assert's
+    # non-test code).
     def first_filtered_bt_line(backtrace)
       ((fbt = backtrace.filtered).empty? ? backtrace : fbt).first.to_s
     end
@@ -152,8 +177,12 @@ module Assert::Result
 
   end
 
+  class HaltingTestResultError < RuntimeError
+    attr_accessor :assert_with_bt
+  end
+
   # raised by the 'fail' context helper to break test execution
-  TestFailure = Class.new(RuntimeError)
+  TestFailure = Class.new(HaltingTestResultError)
 
   class Fail < Base
 
@@ -161,20 +190,22 @@ module Assert::Result
     def self.name; 'Fail'; end
 
     # fail results can be generated manually or by raising Assert::Result::TestFailure
-    def self.for_test(test, message_or_exception, bt = nil)
-      if message_or_exception.kind_of?(TestFailure)
-        super(test, message_or_exception.message, message_or_exception.backtrace)
-      elsif message_or_exception.kind_of?(Exception)
+    def self.for_test(test, msg_or_err, bt = nil)
+      if msg_or_err.kind_of?(TestFailure)
+        super(test, msg_or_err.message, msg_or_err.backtrace).tap do |result|
+          result.set_with_bt(msg_or_err.assert_with_bt)
+        end
+      elsif msg_or_err.kind_of?(Exception)
         raise ArgumentError, "generate fail results by raising Assert::Result::TestFailure"
       else
-        super(test, message_or_exception, bt)
+        super(test, msg_or_err, bt)
       end
     end
 
   end
 
   # raised by the 'skip' context helper to break test execution
-  TestSkipped = Class.new(RuntimeError)
+  TestSkipped = Class.new(HaltingTestResultError)
 
   class Skip < Base
 
@@ -182,11 +213,15 @@ module Assert::Result
     def self.name; 'Skip'; end
 
     # skip results are generated by raising Assert::Result::TestSkipped
-    def self.for_test(test, exception)
-      if exception.kind_of?(TestSkipped)
-        super(test, exception.message, exception.backtrace)
-      else
+    def self.for_test(test, msg_or_err, bt = nil)
+      if msg_or_err.kind_of?(TestSkipped)
+        super(test, msg_or_err.message, msg_or_err.backtrace).tap do |result|
+          result.set_with_bt(msg_or_err.assert_with_bt)
+        end
+      elsif msg_or_err.kind_of?(Exception)
         raise ArgumentError, "generate skip results by raising Assert::Result::TestSkipped"
+      else
+        super(test, msg_or_err, bt)
       end
     end
 
@@ -198,9 +233,9 @@ module Assert::Result
     def self.name; 'Error'; end
 
     # error results are generated by raising exceptions in tests
-    def self.for_test(test, exception)
-      if exception.kind_of?(Exception)
-        super(test, "#{exception.message} (#{exception.class.name})", exception.backtrace)
+    def self.for_test(test, err)
+      if err.kind_of?(Exception)
+        super(test, "#{err.message} (#{err.class.name})", err.backtrace)
       else
         raise ArgumentError, "generate error results by raising an exception"
       end
@@ -209,7 +244,9 @@ module Assert::Result
     private
 
     # override of the base, always show the full unfiltered backtrace for errors
-    def build_trace(backtrace); backtrace.to_s; end
+    def build_trace
+      Backtrace.to_s(backtrace)
+    end
 
   end
 
@@ -217,16 +254,20 @@ module Assert::Result
 
     DELIM = "\n".freeze
 
-    def self.parse(bt); self.new(bt.to_s.split(DELIM)); end
+    def self.parse(bt)
+      self.new(bt.to_s.split(DELIM))
+    end
+
+    def self.to_s(bt_array)
+      bt_array.join(DELIM)
+    end
 
     def initialize(value = nil)
       super([*(value || "No backtrace")])
     end
 
-    def to_s; self.join(DELIM); end
-
     def filtered
-      self.class.new(self.reject { |line| filter_out?(line) })
+      self.class.new(self.reject { |line| filter_out?(line.to_s) })
     end
 
     protected
@@ -234,9 +275,13 @@ module Assert::Result
     # filter a line out if it's an assert lib/bin line
     def filter_out?(line)
       # './lib' in project dir, or '/usr/local/blahblah' if installed
-      assert_lib_path = File.expand_path('../..', __FILE__)
+      assert_lib_path    = File.expand_path('../..', __FILE__)
+      assert_macros_path = File.join(assert_lib_path, 'assert/macros')
       assert_bin_regex = /bin\/assert\:/
-      line.rindex(assert_lib_path, 0) || line =~ assert_bin_regex
+      ( line.rindex(assert_lib_path, 0) &&
+        !line.rindex(assert_macros_path, 0)
+      ) ||
+      line =~ assert_bin_regex
     end
 
   end