assert 2.16.3 → 2.16.4

data/lib/assert/runner.rb

@@ -29,10 +29,20 @@ module Assert
         self.view.puts ", seeded with \"#{self.runner_seed}\""
       end
 
+      # if INFO signal requested (Ctrl+T on Macs), process it
+      @current_running_test = nil
+      trap("INFO") do
+        self.on_info(@current_running_test)
+        self.suite.on_info(@current_running_test)
+        self.view.on_info(@current_running_test)
+      end
+
       begin
         self.suite.start_time = Time.now
         self.suite.setups.each(&:call)
         tests_to_run.tap{ self.suite.clear_tests_to_run }.delete_if do |test|
+          @current_running_test = test
+
           self.before_test(test)
           self.suite.before_test(test)
           self.view.before_test(test)
@@ -76,6 +86,7 @@ module Assert
     def on_result(result);       end
     def after_test(test);        end
     def on_finish;               end
+    def on_info(test);           end
     def on_interrupt(err);       end
 
     private

data/lib/assert/stub.rb

@@ -6,8 +6,7 @@ module Assert
 
   def self.stub(obj, meth, &block)
     (self.stubs[Assert::Stub.key(obj, meth)] ||= begin
-      orig_caller = caller
-      Assert::Stub.new(obj, meth, orig_caller)
+      Assert::Stub.new(obj, meth, caller_locations)
     end).tap{ |s| s.do = block }
   end
 
@@ -20,10 +19,9 @@ module Assert
   end
 
   def self.stub_send(obj, meth, *args, &block)
-    orig_caller = caller
+    orig_caller = caller_locations
     stub = self.stubs.fetch(Assert::Stub.key(obj, meth)) do
-      msg = "`#{meth}` not stubbed"
-      raise NotStubbedError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
+      raise NotStubbedError, "`#{meth}` not stubbed.", orig_caller.map(&:to_s)
     end
     stub.call_method(args, &block)
   end
@@ -45,7 +43,7 @@ module Assert
     attr_reader :method_name, :name, :ivar_name, :do
 
     def initialize(object, method_name, orig_caller = nil, &block)
-      orig_caller ||= caller
+      orig_caller ||= caller_locations
       @metaclass = class << object; self; end
       @method_name = method_name.to_s
       @name = "__assert_stub__#{object.object_id}_#{@method_name}"
@@ -67,12 +65,12 @@ module Assert
     end
 
     def call(args, orig_caller = nil, &block)
-      orig_caller ||= caller
+      orig_caller ||= caller_locations
       unless arity_matches?(args)
         msg = "arity mismatch on `#{@method_name}`: " \
               "expected #{number_of_args(@method.arity)}, " \
               "called with #{args.size}"
-        raise StubArityError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
+        raise StubArityError, msg, orig_caller.map(&:to_s)
       end
       lookup(args, orig_caller).call(*args, &block)
     rescue NotStubbedError => exception
@@ -81,12 +79,12 @@ module Assert
     end
 
     def with(*args, &block)
-      orig_caller = caller
+      orig_caller = caller_locations
       unless arity_matches?(args)
         msg = "arity mismatch on `#{@method_name}`: " \
               "expected #{number_of_args(@method.arity)}, " \
               "stubbed with #{args.size}"
-        raise StubArityError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
+        raise StubArityError, msg, orig_caller.map(&:to_s)
       end
       @lookup[args] = block
     end
@@ -104,12 +102,12 @@ module Assert
       ">"
     end
 
-    protected
+    private
 
     def setup(object, orig_caller)
       unless object.respond_to?(@method_name)
         msg = "#{object.inspect} does not respond to `#{@method_name}`"
-        raise StubError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
+        raise StubError, msg, orig_caller.map(&:to_s)
       end
       is_constant = object.kind_of?(Module)
       local_object_methods = object.methods(false).map(&:to_s)
@@ -130,13 +128,11 @@ module Assert
       Assert.instance_variable_set(@ivar_name, self)
       @metaclass.class_eval <<-stub_method
         def #{@method_name}(*args, &block)
-          Assert.instance_variable_get("#{@ivar_name}").call(args, caller, &block)
+          Assert.instance_variable_get("#{@ivar_name}").call(args, caller_locations, &block)
         end
       stub_method
     end
 
-    private
-
     def lookup(args, orig_caller)
       @lookup.fetch(args) do
         self.do || begin
@@ -144,7 +140,7 @@ module Assert
           inspect_lookup_stubs.tap do |stubs|
             msg += "\nStubs:\n#{stubs}" if !stubs.empty?
           end
-          raise NotStubbedError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
+          raise NotStubbedError, msg, orig_caller.map(&:to_s)
         end
       end
     end

data/lib/assert/suite.rb

@@ -93,6 +93,7 @@ module Assert
     def on_result(result); end
     def after_test(test);  end
     def on_finish;         end
+    def on_info(test);     end
     def on_interrupt(err); end
 
     def inspect

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.16.3"
+  VERSION = "2.16.4"
 end

data/lib/assert/view.rb

@@ -74,9 +74,10 @@ module Assert
     # * `after_test`:   called after a test finishes running
     #                   the test is passed as an arg
     # * `on_finish`:    called when the test suite is finished running
+    # * `on_info`:      called when the INFO signal is triggered whil runninng
+    #                   the test suite
     # * `on_interrupt`: called when the test suite is interrupted while running
     #                   the interrupt exception is passed as an arg
-
     def before_load(test_files); end
     def after_load;              end
     def on_start;                end
@@ -84,6 +85,7 @@ module Assert
     def on_result(result);       end
     def after_test(test);        end
     def on_finish;               end
+    def on_info(test);           end
     def on_interrupt(err);       end
 
     # IO capture

data/test/unit/assert_tests.rb

@@ -96,7 +96,9 @@ module Assert
     end
 
     should "be able to call a stub's original method" do
-      assert_raises(NotStubbedError){ Assert.stub_send(@myobj, :mymeth) }
+      err = assert_raises(NotStubbedError){ Assert.stub_send(@myobj, :mymeth) }
+      assert_includes 'not stubbed.',              err.message
+      assert_includes 'test/unit/assert_tests.rb', err.backtrace.first
 
       Assert.stub(@myobj, :mymeth){ @stub_value }
 

data/test/unit/context_tests.rb

@@ -2,6 +2,7 @@ require 'assert'
 require 'assert/context'
 
 require 'assert/config'
+require 'assert/result'
 require 'assert/utils'
 
 class Assert::Context
@@ -32,14 +33,36 @@ class Assert::Context
     should have_cmeths :should, :should_eventually, :should_skip
 
     should have_imeths :assert, :assert_not, :refute
-    should have_imeths :skip, :pass, :fail, :flunk, :ignore
-    should have_imeths :with_backtrace, :subject
+    should have_imeths :pass, :ignore, :fail, :flunk, :skip
+    should have_imeths :pending, :with_backtrace, :subject
 
-    def test_should_collect_context_info
+    should "collect context info" do
       test = @__assert_running_test__
       assert_match /test\/unit\/context_tests.rb$/, test.context_info.file
       assert_equal self.class, test.context_info.klass
     end
+    private
+
+    ASSERT_TEST_PATH_REGEX = /\A#{File.join(ROOT_PATH, 'test', '')}/
+
+    def assert_with_bt_set(exp_with_bt, result)
+      with_backtrace(caller) do
+        assert_true result.with_bt_set?
+
+        exp = Assert::Result::Backtrace.to_s(exp_with_bt+[(result.backtrace.filtered.first)])
+        assert_equal exp,               result.trace
+        assert_equal exp_with_bt.first, result.src_line
+      end
+    end
+
+    def assert_not_with_bt_set(result)
+      with_backtrace(caller) do
+        assert_false result.with_bt_set?
+
+        assert_equal result.src_line,                      result.trace
+        assert_equal result.backtrace.filtered.first.to_s, result.src_line
+      end
+    end
 
   end
 
@@ -47,7 +70,7 @@ class Assert::Context
     desc "skip method"
     setup do
       @skip_msg = "I need to implement this in the future."
-      begin; @context.skip(@skip_msg); rescue Exception => @exception; end
+      begin; @context.skip(@skip_msg); rescue StandardError => @exception; end
       @result = Factory.skip_result(@exception)
     end
     subject{ @result }
@@ -66,7 +89,7 @@ class Assert::Context
       assert_not_equal 1, @exception.backtrace.size
 
       called_from = Factory.string
-      begin; @context.skip(@skip_msg, called_from); rescue Exception => exception; end
+      begin; @context.skip(@skip_msg, called_from); rescue StandardError => exception; end
       assert_equal 1,           exception.backtrace.size
       assert_equal called_from, exception.backtrace.first
     end
@@ -139,7 +162,7 @@ class Assert::Context
 
     should "create a fail result and set its backtrace" do
       assert_kind_of Assert::Result::Fail, subject
-      assert_equal subject.backtrace.filtered.first, subject.trace
+      assert_equal subject.backtrace.filtered.first.to_s, subject.trace
       assert_kind_of Array, subject.backtrace
     end
 
@@ -165,11 +188,7 @@ class Assert::Context
     subject{ @result }
 
     should "raise an exception with the failure's message" do
-      err = begin
-        @context.fail @fail_msg
-      rescue Exception => exception
-        exception
-      end
+      begin; @context.fail(@fail_msg); rescue StandardError => err; end
       assert_kind_of Assert::Result::TestFailure, err
       assert_equal @fail_msg, err.message
 
@@ -275,14 +294,59 @@ class Assert::Context
 
   end
 
+  class PendingTests < UnitTests
+    desc "`pending` method"
+    setup do
+      block2  = proc { fail; pass; }
+      @block1 = proc { pending(&block2) } # test nesting
+    end
+
+    should "make fails skips and make passes fails" do
+      @context.fail 'not affected'
+      @context.pass
+      @context.pending(&@block1)
+
+      assert_equal 4, @test_results.size
+      norm_fail, norm_pass, pending_fail, pending_pass = @test_results
+
+      assert_kind_of Assert::Result::Fail, norm_fail
+      assert_kind_of Assert::Result::Pass, norm_pass
+
+      assert_kind_of Assert::Result::Skip, pending_fail
+      assert_includes "Pending fail", pending_fail.message
+
+      assert_kind_of Assert::Result::Fail, pending_pass
+      assert_includes "Pending pass", pending_pass.message
+    end
+
+  end
+
+  class PendingWithHaltOnFailTests < PendingTests
+    desc "when halting on fails"
+    setup do
+      @halt_config = Assert::Config.new(:halt_on_fail => true)
+      @context = @context_class.new(@test, @halt_config, @result_callback)
+    end
+    subject{ @result }
+
+    should "make fails skips and stop the test" do
+      begin; @context.pending(&@block1); rescue StandardError => err; end
+      assert_kind_of Assert::Result::TestSkipped, err
+      assert_includes "Pending fail", err.message
+
+      assert_equal 0, @test_results.size # it halted before the pending pass
+    end
+
+  end
+
   class WithBacktraceTests < UnitTests
-    desc "with_backtrace method"
+    desc "`with_backtrace` method"
     setup do
-      @from_bt = ['called_from_here']
+      @from_bt    = ['called_from_here', Factory.string]
       @from_block = proc { ignore; fail; pass; skip 'todo'; }
     end
 
-    should "replace the fail results from the block with the given backtrace" do
+    should "alter non-error block results' bt with given bt's first line" do
       @context.fail 'not affected'
       begin
         @context.with_backtrace(@from_bt, &@from_block)
@@ -293,11 +357,45 @@ class Assert::Context
       assert_equal 5, @test_results.size
       norm_fail, with_ignore, with_fail, with_pass, with_skip = @test_results
 
-      assert_not_equal @from_bt, norm_fail.backtrace
-      assert_equal @from_bt, with_ignore.backtrace
-      assert_equal @from_bt, with_fail.backtrace
-      assert_equal @from_bt, with_pass.backtrace
-      assert_equal @from_bt, with_skip.backtrace
+      assert_not_with_bt_set norm_fail
+
+      exp = [@from_bt.first]
+      assert_with_bt_set exp, with_ignore
+      assert_with_bt_set exp, with_fail
+      assert_with_bt_set exp, with_pass
+      assert_with_bt_set exp, with_ignore
+    end
+
+  end
+
+  class WithNestedBacktraceTests < UnitTests
+    desc "`with_backtrace` method nested"
+    setup do
+      @from_bt1            = ['called_from_here 1', Factory.string]
+      @from_bt2 = from_bt2 = ['called_from_here 2', Factory.string]
+
+      from_block2  = proc { ignore; fail; pass; skip 'todo'; }
+      @from_block1 = proc { with_backtrace(from_bt2, &from_block2) }
+    end
+
+    should "alter non-error block results' bt with nested wbt accrued first lines" do
+      @context.fail 'not affected'
+      begin
+        @context.with_backtrace(@from_bt1, &@from_block1)
+      rescue Assert::Result::TestSkipped => e
+        @test_results << Assert::Result::Skip.for_test(@test, e)
+      end
+
+      assert_equal 5, @test_results.size
+      norm_fail, with_ignore, with_fail, with_pass, with_skip = @test_results
+
+      assert_not_with_bt_set norm_fail
+
+      exp = [@from_bt1.first, @from_bt2.first]
+      assert_with_bt_set exp, with_ignore
+      assert_with_bt_set exp, with_fail
+      assert_with_bt_set exp, with_pass
+      assert_with_bt_set exp, with_ignore
     end
 
   end

data/test/unit/result_tests.rb

@@ -28,12 +28,18 @@ module Assert::Result
     end
 
     should "create results from data hashes" do
-      type   = Assert::Result.types.keys.sample
-      exp    = Assert::Result.types[type].new(:type => type)
-
+      type = Assert::Result.types.keys.sample
+      exp  = Assert::Result.types[type].new(:type => type)
       assert_equal exp, Assert::Result.new(:type => type)
     end
 
+    private
+
+    def build_backtrace
+      assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
+      (Factory.integer(3).times.map{ Factory.string } + [assert_lib_path]).shuffle
+    end
+
   end
 
   class BaseTests < UnitTests
@@ -46,8 +52,7 @@ module Assert::Result
         :test_file_line => Assert::FileLine.new(Factory.string, Factory.integer),
         :message        => Factory.string,
         :output         => Factory.text,
-        :backtrace      => Backtrace.new(caller),
-        :trace          => Factory.string
+        :backtrace      => Backtrace.new(build_backtrace)
       }
       @result = Base.new(@given_data)
     end
@@ -56,10 +61,12 @@ module Assert::Result
     should have_cmeths :type, :name, :for_test
     should have_imeths :type, :name, :test_name, :test_file_line
     should have_imeths :test_file_name, :test_line_num, :test_id
-    should have_imeths :message, :output, :backtrace, :trace
-    should have_imeths :file_line, :file_name, :line_num
+    should have_imeths :message, :output
+    should have_imeths :backtrace, :trace
+    should have_imeths :set_backtrace, :set_with_bt, :with_bt_set?
+    should have_imeths :src_line, :file_line, :file_name, :line_num
     should have_imeths *Assert::Result.types.keys.map{ |k| "#{k}?" }
-    should have_imeths :set_backtrace, :to_sym, :to_s
+    should have_imeths :to_sym, :to_s
 
     should "know its class-level type/name" do
       assert_equal :unknown, subject.class.type
@@ -80,6 +87,8 @@ module Assert::Result
       assert_equal message,       result.message
       assert_equal exp_backtrace, result.backtrace
       assert_equal exp_trace,     result.trace
+
+      assert_false result.with_bt_set?
     end
 
     should "use any given attrs" do
@@ -90,7 +99,6 @@ module Assert::Result
       assert_equal @given_data[:message],        subject.message
       assert_equal @given_data[:output],         subject.output
       assert_equal @given_data[:backtrace],      subject.backtrace
-      assert_equal @given_data[:trace],          subject.trace
     end
 
     should "default its attrs" do
@@ -114,7 +122,7 @@ module Assert::Result
     end
 
     should "allow setting a new backtrace" do
-      new_bt        = Factory.integer(3).times.map{ Factory.string }
+      new_bt        = build_backtrace
       exp_backtrace = Backtrace.new(new_bt)
       exp_trace     = exp_backtrace.filtered.first.to_s
       subject.set_backtrace(new_bt)
@@ -123,7 +131,7 @@ module Assert::Result
 
       # test that the first bt line is used if filtered is empty
       assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
-      new_bt          = Factory.integer(3).times.map{ assert_lib_path }
+      new_bt          = (Factory.integer(3)+1).times.map{ assert_lib_path }
       exp_backtrace   = Backtrace.new(new_bt)
       exp_trace       = exp_backtrace.first.to_s
       subject.set_backtrace(new_bt)
@@ -131,19 +139,52 @@ module Assert::Result
       assert_equal exp_trace,     subject.trace
     end
 
-    should "know its file line attrs" do
-      new_bt = Factory.integer(3).times.map{ Factory.string }
+    should "allow setting a with bt backtrace and know if one has been set" do
+      assert_false subject.with_bt_set?
+
+      orig_backtrace = subject.backtrace
+      with_bt        = build_backtrace
+
+      subject.set_with_bt(with_bt)
+
+      assert_true subject.with_bt_set?
+      assert_equal orig_backtrace, subject.backtrace
+      assert_equal with_bt.first,  subject.src_line
+
+      exp = Backtrace.to_s(with_bt + [orig_backtrace.filtered.first])
+      assert_equal exp, subject.trace
+    end
+
+    should "know its src/file line attrs" do
+      new_bt = build_backtrace
       subject.set_backtrace(new_bt)
-      exp = Assert::FileLine.parse(subject.backtrace.filtered.first.to_s)
+
+      exp = Backtrace.new(new_bt).filtered.first.to_s
+      assert_equal exp, subject.src_line
+
+      exp = Assert::FileLine.parse(subject.src_line)
+      assert_equal exp,           subject.file_line
+      assert_equal exp.file,      subject.file_name
+      assert_equal exp.line.to_i, subject.line_num
+
+      # test you get the same file line attrs using `set_with_bt`
+      subject.set_with_bt(new_bt)
+      assert_equal new_bt.first.to_s, subject.src_line
+
+      exp = Assert::FileLine.parse(subject.src_line)
       assert_equal exp,           subject.file_line
       assert_equal exp.file,      subject.file_name
       assert_equal exp.line.to_i, subject.line_num
 
       # test that the first bt line is used if filtered is empty
       assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
-      new_bt = Factory.integer(3).times.map{ assert_lib_path }
+      new_bt          = (Factory.integer(3)+1).times.map{ assert_lib_path }
       subject.set_backtrace(new_bt)
-      exp = Assert::FileLine.parse(subject.backtrace.first.to_s)
+
+      exp = new_bt.first.to_s
+      assert_equal exp, subject.src_line
+
+      exp = Assert::FileLine.parse(subject.src_line)
       assert_equal exp,           subject.file_line
       assert_equal exp.file,      subject.file_name
       assert_equal exp.line.to_i, subject.line_num
@@ -225,12 +266,24 @@ module Assert::Result
 
   end
 
+  class HaltingTestResultErrorTests < UnitTests
+    desc "HaltingTestResultError"
+    subject{ HaltingTestResultError.new }
+
+    should have_accessors :assert_with_bt
+
+    should "be a runtime error" do
+      assert_kind_of RuntimeError, subject
+    end
+
+  end
+
   class TestFailureTests < UnitTests
     desc "TestFailure"
     subject{ TestFailure }
 
-    should "be a runtime error" do
-      assert_kind_of RuntimeError, subject.new
+    should "be a halting test result error" do
+      assert_kind_of HaltingTestResultError, subject.new
     end
 
   end
@@ -250,13 +303,24 @@ module Assert::Result
 
     should "allow creating for a test with TestFailure exceptions" do
       err = TestFailure.new
-      err.set_backtrace(caller)
+      err.set_backtrace(build_backtrace)
       result = Fail.for_test(@test, err)
 
       assert_equal err.message, result.message
 
-      exp_bt = Backtrace.new(err.backtrace)
-      assert_equal exp_bt, result.backtrace
+      err_backtrace = Backtrace.new(err.backtrace)
+      assert_equal err_backtrace, result.backtrace
+
+      # test assert with bt errors
+      err.assert_with_bt = build_backtrace
+      result = Fail.for_test(@test, err)
+
+      assert_equal err.message,              result.message
+      assert_equal err.backtrace,            result.backtrace
+      assert_equal err.assert_with_bt.first, result.src_line
+
+      exp = Backtrace.to_s(err.assert_with_bt + [err_backtrace.filtered.first])
+      assert_equal exp, result.trace
     end
 
     should "not allow creating for a test with non-TestFailure exceptions" do
@@ -269,8 +333,8 @@ module Assert::Result
     desc "TestSkipped"
     subject{ TestSkipped }
 
-    should "be a runtime error" do
-      assert_kind_of RuntimeError, subject.new
+    should "be a halting test result error" do
+      assert_kind_of HaltingTestResultError, subject.new
     end
 
   end
@@ -290,13 +354,24 @@ module Assert::Result
 
     should "allow creating for a test with TestSkipped exceptions" do
       err = TestSkipped.new
-      err.set_backtrace(caller)
+      err.set_backtrace(build_backtrace)
       result = Skip.for_test(@test, err)
 
       assert_equal err.message, result.message
 
-      exp_bt = Backtrace.new(err.backtrace)
-      assert_equal exp_bt, result.backtrace
+      err_backtrace = Backtrace.new(err.backtrace)
+      assert_equal err_backtrace, result.backtrace
+
+      # test assert with bt errors
+      err.assert_with_bt = build_backtrace
+      result = Skip.for_test(@test, err)
+
+      assert_equal err.message,              result.message
+      assert_equal err.backtrace,            result.backtrace
+      assert_equal err.assert_with_bt.first, result.src_line
+
+      exp = Backtrace.to_s(err.assert_with_bt + [err_backtrace.filtered.first])
+      assert_equal exp, result.trace
     end
 
     should "not allow creating for a test with non-TestSkipped exceptions" do
@@ -319,15 +394,15 @@ module Assert::Result
 
     should "allow creating for a test with exceptions" do
       err = Exception.new
-      err.set_backtrace(caller)
+      err.set_backtrace(build_backtrace)
       result = Error.for_test(@test, err)
 
       exp_msg = "#{err.message} (#{err.class.name})"
       assert_equal exp_msg, result.message
 
       exp_bt = Backtrace.new(err.backtrace)
-      assert_equal exp_bt,      result.backtrace
-      assert_equal exp_bt.to_s, result.trace
+      assert_equal exp_bt,                 result.backtrace
+      assert_equal Backtrace.to_s(exp_bt), result.trace
     end
 
     should "not allow creating for a test without an exception" do
@@ -339,15 +414,19 @@ module Assert::Result
   class BacktraceTests < UnitTests
     desc "Backtrace"
     setup do
-      @backtrace = Backtrace.new(caller)
+      @backtrace = Backtrace.new(build_backtrace)
     end
     subject { @backtrace }
 
-    should have_cmeths :parse
-    should have_imeths :to_s, :filtered
+    should have_cmeths :parse, :to_s
+    should have_imeths :filtered
 
     should "be parseable from its string representation" do
-      assert_equal subject, Backtrace.parse(subject.to_s)
+      assert_equal subject, Backtrace.parse(Backtrace.to_s(subject))
+    end
+
+    should "render as a string by joining on the newline" do
+      assert_equal subject.join(Backtrace::DELIM), Backtrace.to_s(subject)
     end
 
     should "be an Array" do
@@ -358,10 +437,6 @@ module Assert::Result
       assert_equal "\n", Backtrace::DELIM
     end
 
-    should "render as a string by joining on the newline" do
-      assert_equal subject.join(Backtrace::DELIM), subject.to_s
-    end
-
     should "another backtrace when filtered" do
       assert_kind_of Backtrace, subject
     end