assert 2.15.2 → 2.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  data.tar.gz: 87349e6848472856f049017257486230a2b69f52bcf4d5ebdf4d4a23f88dd5b479d1499890ea1c63e890186c4c86d665c982d162ebd86a51e07762b809029e26
-  metadata.gz: 539e868afc215555b585a85dd4caf52e9fbc7082e2eada2c33aea41900e22bb3a547c193b40f5433192bcd27571efd79254d93f54b7a973eab8fef0489398a55
 SHA1: 
-  data.tar.gz: fd4a2030e5b99394b4461d7673324e00fad58647
-  metadata.gz: bb7bf7dd4fb2b739e897932d9499487ac730e1fc
+  data.tar.gz: 05d9e740571423b4946bf4744e82d1c329635de5
+  metadata.gz: 059d25ec7c38612afd6e776156ca4e81459eafc7
+SHA512: 
+  data.tar.gz: 863376fa7090c85130e651358ddbe6a1c53e47de4d0c1698d51ca94ce665bb51f13ef2029909b6e4c6f84768fb5e4a0b606939c39642f8b4f64ee3e446585356
+  metadata.gz: c9dfcbdc44401730b6bf66f9adca789657d82911b784ed453a5f2b077717a98160334ddecf96bcc5198c999d556c3984b4e29a0037b09f6af0247442e8c015a0

data/lib/assert/assertions.rb

@@ -264,6 +264,12 @@ module Assert
       end
     end
 
+    private
+
+    def __assert_config__
+      raise NotImplementedError # should be defined by the config mixing this in
+    end
+
     # exception raised utility classes
 
     class CheckException

data/lib/assert/config_helpers.rb

@@ -18,28 +18,43 @@ module Assert
       self.config.single_test_file_line
     end
 
-    def count(type)
-      self.config.suite.count(type)
+    def tests_to_run?;      self.config.suite.tests_to_run?;      end
+    def tests_to_run_count; self.config.suite.tests_to_run_count; end
+
+    def test_count;          self.config.suite.test_count;          end
+    def result_count;        self.config.suite.result_count;        end
+    def pass_result_count;   self.config.suite.pass_result_count;   end
+    def fail_result_count;   self.config.suite.fail_result_count;   end
+    def error_result_count;  self.config.suite.error_result_count;  end
+    def skip_result_count;   self.config.suite.skip_result_count;   end
+    def ignore_result_count; self.config.suite.ignore_result_count; end
+
+    def all_pass?
+      self.pass_result_count == self.result_count
     end
 
-    def tests?
-      self.count(:tests) > 0
+    def formatted_run_time(run_time, format = '%.6f')
+      format % run_time
     end
 
-    def all_pass?
-      self.count(:pass) == self.count(:results)
+    def formatted_test_rate(test_rate, format = '%.6f')
+      format % test_rate
     end
 
-    def formatted_run_time(format = '%.6f')
-      format % self.config.suite.run_time
+    def formatted_result_rate(result_rate, format = '%.6f')
+      format % result_rate
     end
 
-    def formatted_test_rate(format = '%.6f')
-      format % self.config.suite.test_rate
+    def formatted_suite_run_time(format = '%.6f')
+      formatted_run_time(self.config.suite.run_time, format)
     end
 
-    def formatted_result_rate(format = '%.6f')
-      format % self.config.suite.result_rate
+    def formatted_suite_test_rate(format = '%.6f')
+      formatted_test_rate(self.config.suite.test_rate, format)
+    end
+
+    def formatted_suite_result_rate(format = '%.6f')
+      formatted_result_rate(self.config.suite.result_rate, format)
     end
 
     def show_test_profile_info?
@@ -50,13 +65,19 @@ module Assert
       !!self.config.verbose
     end
 
-    # return a list of result symbols that have actually occurred
+    # return a list of result type symbols that have actually occurred
     def ocurring_result_types
       @result_types ||= [:pass, :fail, :ignore, :skip, :error].select do |sym|
-        self.count(sym) > 0
+        self.send("#{sym}_result_count") > 0
       end
     end
 
+    private
+
+    def get_rate(count, time)
+      time == 0 ? 0.0 : (count.to_f / time.to_f)
+    end
+
   end
 
 end

data/lib/assert/context.rb

@@ -39,22 +39,28 @@ module Assert
           self.suite.test_methods << klass_method_name
         end
 
-        self.suite.tests << Test.for_method(
+        self.suite.on_test(Test.for_method(
           method_name.to_s,
           ContextInfo.new(self, nil, caller.first),
           self.suite.config
-        )
+        ))
       end
     end
 
     def initialize(running_test, config, result_callback)
-      @__running_test__    = running_test
-      @__assert_config__   = config
-      @__result_callback__ = result_callback
+      @__assert_running_test__ = running_test
+      @__assert_config__       = config
+      @__assert_with_bt__      = nil
+
+      @__assert_result_callback__ = proc do |result|
+        result.set_backtrace(@__assert_with_bt__) if @__assert_with_bt__
+        result_callback.call(result)
+        result
+      end
     end
 
-    # check if the assertion is a truthy value, if so create a new pass result, otherwise
-    # create a new fail result with the desc and what failed msg.
+    # check if the assertion is a truthy value, if so create a new pass result,
+    # otherwise create a new fail result with the desc and what failed msg.
     # all other assertion helpers use this one in the end
     def assert(assertion, desc = nil)
       if assertion
@@ -63,7 +69,8 @@ module Assert
         what = if block_given?
           yield
         else
-          "Failed assert: assertion was `#{Assert::U.show(assertion, __assert_config__)}`."
+          "Failed assert: assertion was "\
+          "`#{Assert::U.show(assertion, __assert_config__)}`."
         end
         fail(fail_message(desc, what))
       end
@@ -73,7 +80,8 @@ module Assert
     # result, otherwise create a new fail result with the desc and it's what failed msg
     def assert_not(assertion, fail_desc = nil)
       assert(!assertion, fail_desc) do
-        "Failed assert_not: assertion was `#{Assert::U.show(assertion, __assert_config__)}`."
+        "Failed assert_not: assertion was "\
+        "`#{Assert::U.show(assertion, __assert_config__)}`."
       end
     end
     alias_method :refute, :assert_not
@@ -81,17 +89,13 @@ 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 do |test, backtrace|
-        Assert::Result::Pass.for_test(test, pass_msg, backtrace)
-      end
+      capture_result(Assert::Result::Pass, pass_msg)
     end
 
     # adds an Ignore result to the end of the test's results
     # does not break test execution
     def ignore(ignore_msg = nil)
-      capture_result do |test, backtrace|
-        Assert::Result::Ignore.for_test(test, ignore_msg, backtrace)
-      end
+      capture_result(Assert::Result::Ignore, ignore_msg)
     end
 
     # adds a Fail result to the end of the test's results
@@ -100,31 +104,29 @@ module Assert
       if halt_on_fail?
         raise Result::TestFailure, message || ''
       else
-        capture_result do |test, backtrace|
-          Assert::Result::Fail.for_test(test, message || '', backtrace)
-        end
+        capture_result(Assert::Result::Fail, message || '')
       end
     end
     alias_method :flunk, :fail
 
-    # adds a Skip result to the end of the test's results and breaks test execution
+    # 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)
     end
 
-    # alter the backtraces of fail results generated in the given block
+    # alter the backtraces of fail/skip results generated in the given block
     def with_backtrace(bt, &block)
       bt ||= []
-      current_results.size.tap do |size|
-        begin
-          instance_eval(&block)
-        rescue Result::TestSkipped, Result::TestFailure => e
-          e.set_backtrace(bt); raise(e)
-        ensure
-          current_results[size..-1].each{ |r| r.set_backtrace(bt) }
-        end
+      begin
+        @__assert_with_bt__ = bt
+        instance_eval(&block)
+      rescue Result::TestSkipped, Result::TestFailure => e
+        e.set_backtrace(@__assert_with_bt__); raise(e)
+      ensure
+        @__assert_with_bt__ = nil
       end
     end
 
@@ -140,7 +142,8 @@ module Assert
 
     protected
 
-    # Returns a Proc that will output a custom message along with the default fail message.
+    # Returns a Proc that will output a custom message along with the default
+    # fail message.
     def fail_message(fail_desc = nil, what_failed_msg = nil)
       [ fail_desc, what_failed_msg ].compact.join("\n")
     end
@@ -151,20 +154,10 @@ module Assert
       __assert_config__.halt_on_fail
     end
 
-    def capture_result
-      if block_given?
-        result = yield __running_test__, caller
-        __running_test__.capture_result(result, @__result_callback__)
-        result
-      end
-    end
-
-    def current_results
-      __running_test__.results
-    end
-
-    def __running_test__
-      @__running_test__
+    def capture_result(result_klass, msg)
+      @__assert_result_callback__.call(
+        result_klass.for_test(@__assert_running_test__, msg, caller)
+      )
     end
 
     def __assert_config__

data/lib/assert/context/test_dsl.rb

@@ -13,12 +13,12 @@ class Assert::Context
         instance_eval(&desc_or_macro)
       elsif block_given?
         # create a test from the given code block
-        self.suite.tests << Assert::Test.for_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),
           self.suite.config,
           &block
-        )
+        ))
       else
         test_eventually(desc_or_macro, called_from, first_caller || caller.first, &block)
       end
@@ -27,12 +27,12 @@ class Assert::Context
     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)
-      self.suite.tests << Assert::Test.for_block(
+      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) }
-      )
+      ))
     end
     alias_method :test_skip, :test_eventually
 

data/lib/assert/default_suite.rb

@@ -2,63 +2,58 @@ require 'assert/suite'
 
 module Assert
 
-  # This is the default suite used by assert.  It stores test/result data in-memory.
+  # This is the default suite used by assert. In addition to the base suite
+  # behavior, it accumulates test/result counts in memory.  This data is used
+  # by the runner/view for handling and presentation purposes.
 
   class DefaultSuite < Assert::Suite
 
-    # Test data
-
-    def ordered_tests
-      self.tests
-    end
-
-    def reversed_tests
-      self.tests.reverse
+    def initialize(config)
+      super
+      reset_run_data
     end
 
-    def ordered_tests_by_run_time
-      self.ordered_tests.sort{ |a, b| a.run_time <=> b.run_time }
-    end
+    def test_count;          @test_count;          end
+    def result_count;        @result_count;        end
+    def pass_result_count;   @pass_result_count;   end
+    def fail_result_count;   @fail_result_count;   end
+    def error_result_count;  @error_result_count;  end
+    def skip_result_count;   @skip_result_count;   end
+    def ignore_result_count; @ignore_result_count; end
 
-    def reversed_tests_by_run_time
-      self.ordered_tests_by_run_time.reverse
-    end
+    # Callbacks
 
-    def test_count
-      self.tests.size
+    def on_start
+      reset_run_data
     end
 
-    # Result data
-
-    def ordered_results
-      self.ordered_tests.inject([]){ |results, test| results += test.results }
+    def before_test(test)
+      @test_count += 1
     end
 
-    def reversed_results
-      self.ordered_results.reverse
+    def on_result(result)
+      @result_count += 1
+      self.send("increment_#{result.type}_result_count")
     end
 
-    # dump failed or errored results,
-    # dump skipped or ignored results if they have a message
-    def ordered_results_for_dump
-      self.ordered_results.select do |result|
-        [:fail, :error].include?(result.to_sym) ||
-        !!([:skip, :ignore].include?(result.to_sym) && result.message)
-      end
-    end
+    private
 
-    def reversed_results_for_dump
-      self.ordered_results_for_dump.reverse
-    end
+    def increment_pass_result_count;   @pass_result_count   += 1; end
+    def increment_fail_result_count;   @fail_result_count   += 1; end
+    def increment_error_result_count;  @error_result_count  += 1; end
+    def increment_skip_result_count;   @skip_result_count   += 1; end
+    def increment_ignore_result_count; @ignore_result_count += 1; end
 
-    def result_count(type = nil)
-      self.tests.inject(0){ |count, test| count += test.result_count(type) }
+    def reset_run_data
+      @test_count          = 0
+      @result_count        = 0
+      @pass_result_count   = 0
+      @fail_result_count   = 0
+      @error_result_count  = 0
+      @skip_result_count   = 0
+      @ignore_result_count = 0
     end
 
-    # Callbacks
-
-    # no custom callbacks
-
   end
 
 end

data/lib/assert/default_view.rb

@@ -22,58 +22,41 @@ module Assert
     end
 
     def after_load
-      puts "Loaded suite (#{test_count_statement})"
+      puts "Loaded suite (#{tests_to_run_count_statement})"
     end
 
     def on_start
-    end
-
-    def before_test(test)
-      if show_test_verbose_info?
-        puts  "#{test.name.inspect} (#{test.context_class})"
-        puts  "    #{test.file_line}"
-        print "    "
-      end
-    end
-
-    def on_result(result)
-      print ansi_styled_msg(self.send("#{result.to_sym}_abbrev"), result)
-    end
-
-    def after_test(test)
-      if show_test_verbose_info?
-        print " #{test_run_time(test)} seconds,"\
-              " #{test.result_count} results,"\
-              " #{test_result_rate(test)} results/s\n"
-      end
+      reset_run_data
+      set_callbacks
     end
 
     def on_finish
-      if tests?
+      if self.test_count > 0
         dump_test_results
       end
 
       # show profile output
       if show_test_profile_info?
-        config.suite.ordered_tests_by_run_time.each do |test|
-          puts "#{test_run_time(test)} seconds,"\
-               " #{test.result_count} results,"\
-               " #{test_result_rate(test)} results/s --"\
-               " #{test.context_class}: #{test.name.inspect}"
+        # sort the test datas fastest to slowest
+        @test_datas.values.sort{ |a, b| a.run_time <=> b.run_time }.each do |test_data|
+          puts "#{formatted_run_time(test_data.run_time)} seconds,"\
+               " #{test_data.result_count} results,"\
+               " #{formatted_result_rate(test_data.result_rate)} results/s --"\
+               " #{test_data.context}: #{test_data.name.inspect}"
         end
         puts
       end
 
       # style the summaries of each result set
-      styled_results_sentence = results_summary_sentence do |summary, result_sym|
-        ansi_styled_msg(summary, result_sym)
+      styled_results_sentence = results_summary_sentence do |summary, result_type|
+        ansi_styled_msg(summary, result_type)
       end
 
       puts "#{result_count_statement}: #{styled_results_sentence}"
       puts
-      puts "(#{formatted_run_time} seconds, " \
-           "#{formatted_test_rate} tests/s, " \
-           "#{formatted_result_rate} results/s)"
+      puts "(#{formatted_suite_run_time} seconds, " \
+           "#{formatted_suite_test_rate} tests/s, " \
+           "#{formatted_suite_result_rate} results/s)"
     end
 
     def on_interrupt(err)
@@ -82,24 +65,113 @@ module Assert
 
     private
 
+    def reset_run_data
+      @results_to_dump = []
+      @test_datas      = {}
+    end
+
+    def set_callbacks
+      @metaclass = class << self; self; end
+      if accumulate_test_data?
+        @metaclass.class_eval <<-callbacks
+          def before_test(test)
+            test_data = get_test_data(test)
+            puts  "\#{test_data.name.inspect} (\#{test_data.context})"
+            puts  "    \#{test_data.file_line}"
+            print "    "
+          end
+
+          def on_result(result)
+            print ansi_styled_msg(self.send("\#{result.to_sym}_abbrev"), result.type)
+            @results_to_dump << ResultData.for_result(result) if dumpable_result?(result)
+            find_test_data(result.test_file_line).result_count += 1
+          end
+
+          def after_test(test)
+            test_data = find_test_data(test.file_line)
+            test_data.run_time    = test.run_time
+            test_data.result_rate = get_rate(test_data.result_count, test_data.run_time)
+
+            if show_test_verbose_info?
+              print " \#{formatted_run_time(test_data.run_time)} seconds,"\
+                    " \#{test_data.result_count} results,"\
+                    " \#{formatted_result_rate(test_data.result_rate)} results/s\n"
+            end
+          end
+        callbacks
+      else
+        @metaclass.class_eval <<-callbacks
+          def on_result(result)
+            print ansi_styled_msg(self.send("\#{result.to_sym}_abbrev"), result.type)
+            @results_to_dump << ResultData.for_result(result) if dumpable_result?(result)
+          end
+        callbacks
+      end
+    end
+
+    def accumulate_test_data?
+      show_test_verbose_info? || show_test_profile_info?
+    end
+
+    def get_test_data(test)
+      @test_datas[test.file_line.to_s] ||= TestData.for_test(test)
+    end
+
+    def find_test_data(test_file_line)
+      @test_datas[test_file_line.to_s]
+    end
+
+    def dumpable_result?(result)
+      [:fail, :error].include?(result.type) ||
+      !!([:skip, :ignore].include?(result.type) && result.message)
+    end
+
     def dump_test_results
       print "\n"
       puts
 
-      config.suite.reversed_results_for_dump.each do |result|
+      @results_to_dump.sort.each do |result_data|
         # output the styled result details
-        puts ansi_styled_msg(result.to_s, result)
+        puts ansi_styled_msg(result_data.details, result_data.type)
 
         # output any captured stdout
-        puts captured_output(result.output) if result.output && !result.output.empty?
+        if result_data.output && !result_data.output.empty?
+          puts captured_output(result_data.output)
+        end
 
         # output re-run CLI cmd
-        puts re_run_test_cmd(result.test_id)
+        puts re_run_test_cmd(result_data.test_id)
 
-        # add an empty line between each result detail
+        # add an empty line between each dumped result
         puts
       end
+    end
+
+    attrs = [:name, :context, :file_line, :result_count, :run_time, :result_rate]
+    class TestData < Struct.new(*attrs)
+      def self.for_test(t)
+        self.new(t.name, t.context_class, t.file_line.to_s, 0, 0.0, 0.0)
+      end
+    end
+
+    attrs = [:type, :details, :output, :test_id, :sort_by]
+    class ResultData < Struct.new(*attrs)
+      def self.for_result(r)
+        self.new(r.type, r.to_s, r.output, r.test_id, self.sort_by(r))
+      end
 
+      def self.sort_by(r)
+        [r.test_file_name, r.test_line_num, r.file_name, r.line_num]
+      end
+
+      def <=>(other_rd)
+        # show in reverse definition order
+        if other_rd.kind_of?(ResultData)
+          other_rd.sort_by <=> self.sort_by
+        else
+          super
+        end
+      end
     end
 
   end