assert 2.15.2 → 2.16.0

data/lib/assert/file_line.rb

@@ -3,7 +3,7 @@ module Assert
   class FileLine
 
     def self.parse(file_line_path)
-      self.new(*(file_line_path.to_s.match(/(^[^\:]*)\:*(\d*)$/) || [])[1..2])
+      self.new(*(file_line_path.to_s.match(/(^[^\:]*)\:*(\d*).*$/) || [])[1..2])
     end
 
     attr_reader :file, :line

data/lib/assert/result.rb

@@ -1,3 +1,5 @@
+require 'assert/file_line'
+
 module Assert; end
 module Assert::Result
 
@@ -30,11 +32,11 @@ module Assert::Result
 
     def self.for_test(test, message, bt)
       self.new({
-        :test_name => test.name,
-        :test_id   => test.file_line.to_s,
-        :message   => message,
-        :output    => test.output,
-        :backtrace => Backtrace.new(bt)
+        :test_name      => test.name,
+        :test_file_line => test.file_line,
+        :message        => message,
+        :output         => test.output,
+        :backtrace      => Backtrace.new(bt)
       })
     end
 
@@ -42,17 +44,43 @@ module Assert::Result
       @build_data = build_data
     end
 
-    def type;      @type      ||= (@build_data[:type]      || self.class.type).to_sym;      end
-    def name;      @name      ||= (@build_data[:name]      || self.class.name.to_s);        end
-    def test_name; @test_name ||= (@build_data[:test_name] || '');                          end
-    def test_id;   @test_id   ||= (@build_data[:test_id]   || '');                          end
-    def message;   @message   ||= (@build_data[:message]   || '');                          end
-    def output;    @output    ||= (@build_data[:output]    || '');                          end
-    def backtrace; @backtrace ||= (@build_data[:backtrace] || Backtrace.new([]));           end
-    def trace;     @trace     ||= (@build_data[:trace]     || build_trace(self.backtrace)); end
+    def type
+      @type ||= (@build_data[:type] || self.class.type).to_sym
+    end
 
-    Assert::Result.types.keys.each do |type|
-      define_method("#{type}?"){ self.type == type }
+    def name
+      @name ||= (@build_data[:name] || self.class.name.to_s)
+    end
+
+    def test_name
+      @test_name ||= (@build_data[:test_name] || '')
+    end
+
+    def test_file_line
+      @test_file_line ||= (@build_data[:test_file_line] || Assert::FileLine.parse(''))
+    end
+
+    def test_file_name; self.test_file_line.file;      end
+    def test_line_num;  self.test_file_line.line.to_i; end
+
+    def test_id
+      self.test_file_line.to_s
+    end
+
+    def message
+      @message ||= (@build_data[:message] || '')
+    end
+
+    def output
+      @output ||= (@build_data[:output] || '')
+    end
+
+    def backtrace
+      @backtrace ||= (@build_data[:backtrace] || Backtrace.new([]))
+    end
+
+    def trace
+      @trace ||= (@build_data[:trace] || build_trace(self.backtrace))
     end
 
     # we choose to implement this way instead of using an `attr_writer` to be
@@ -60,18 +88,18 @@ module Assert::Result
     def set_backtrace(bt)
       @backtrace = Backtrace.new(bt)
       @trace     = build_trace(@backtrace)
+      @file_line = Assert::FileLine.parse(first_filtered_bt_line(@backtrace))
     end
 
-    def data
-      { :type      => self.type,
-        :name      => self.name,
-        :test_name => self.test_name,
-        :test_id   => self.test_id,
-        :message   => self.message,
-        :output    => self.output,
-        :backtrace => self.backtrace,
-        :trace     => self.trace,
-      }
+    def file_line
+      @file_line ||= Assert::FileLine.parse(first_filtered_bt_line(self.backtrace))
+    end
+
+    def file_name; self.file_line.file;      end
+    def line_num;  self.file_line.line.to_i; end
+
+    Assert::Result.types.keys.each do |type|
+      define_method("#{type}?"){ self.type == type }
     end
 
     def to_sym; self.type; end
@@ -88,14 +116,26 @@ module Assert::Result
     end
 
     def inspect
-      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @message=#{self.message.inspect}>"
+      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} "\
+      "@message=#{self.message.inspect} "\
+      "@file_line=#{self.file_line.to_s.inspect} "\
+      "@test_file_line=#{self.test_file_line.to_s.inspect}>"
     end
 
     private
 
     # by default, a result's trace is the first line of its filtered backtrace
-    def build_trace(backtrace); backtrace.filtered.first.to_s; 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).  This is overridden for error results as they always show
+    # the entire backtrace
+    def build_trace(backtrace)
+      first_filtered_bt_line(backtrace)
+    end
 
+    def first_filtered_bt_line(backtrace)
+      ((fbt = backtrace.filtered).empty? ? backtrace : fbt).first.to_s
+    end
   end
 
   class Pass < Base

data/lib/assert/runner.rb

@@ -21,16 +21,18 @@ module Assert
       self.view.on_start
 
       if self.single_test?
-        self.view.puts "Running test: #{self.single_test_file_line}"
-      elsif self.tests?
-        self.view.puts "Running tests in random order, " \
-                       "seeded with \"#{self.runner_seed}\""
+        self.view.print "Running test: #{self.single_test_file_line}"
+      elsif self.tests_to_run?
+        self.view.print "Running tests in random order"
+      end
+      if self.tests_to_run?
+        self.view.puts ", seeded with \"#{self.runner_seed}\""
       end
 
       begin
         self.suite.start_time = Time.now
         self.suite.setups.each(&:call)
-        tests_to_run.each do |test|
+        tests_to_run.tap{ self.suite.clear_tests_to_run }.delete_if do |test|
           self.before_test(test)
           self.suite.before_test(test)
           self.view.before_test(test)
@@ -42,6 +44,9 @@ module Assert
           self.after_test(test)
           self.suite.after_test(test)
           self.view.after_test(test)
+
+          # always delete `test` from `tests_to_run` since it has been run
+          true
         end
         self.suite.teardowns.each(&:call)
         self.suite.end_time = Time.now
@@ -52,7 +57,7 @@ module Assert
         raise(err)
       end
 
-      (self.suite.count(:fail) + self.suite.count(:error)).tap do
+      (self.fail_result_count + self.error_result_count).tap do
         self.view.on_finish
         self.suite.on_finish
         self.on_finish
@@ -76,12 +81,11 @@ module Assert
     private
 
     def tests_to_run
+      srand self.runner_seed
       if self.single_test?
-        [ self.suite.tests.find{ |t| t.file_line == self.single_test_file_line }
-        ].compact
+        [self.suite.find_test_to_run(self.single_test_file_line)].compact
       else
-        srand self.runner_seed
-        self.suite.tests.sort.sort_by{ rand self.suite.tests.size }
+        self.suite.sorted_tests_to_run{ rand self.tests_to_run_count }
       end
     end
 

data/lib/assert/suite.rb

@@ -3,6 +3,12 @@ require 'assert/test'
 
 module Assert
 
+  # This is the base suite. It loads the tests to run in memory and provides
+  # methods for these tests that the runner/view uses for handling and
+  # presentation purposes. It also stores suite-level setups and teardowns.
+  # Override the test/result count methods and the callbacks as needed.  See
+  # the default suite for example usage.
+
   class Suite
     include Assert::ConfigHelpers
 
@@ -11,7 +17,7 @@ module Assert
     # A suite is a set of tests to run.  When a test class subclasses
     # the Context class, that test class is pushed to the suite.
 
-    attr_reader :config, :tests, :test_methods, :setups, :teardowns
+    attr_reader :config, :test_methods, :setups, :teardowns
     attr_accessor :start_time, :end_time
 
     def initialize(config)
@@ -36,6 +42,26 @@ module Assert
     end
     alias_method :shutdown, :teardown
 
+    def tests_to_run?;      @tests.size > 0; end
+    def tests_to_run_count; @tests.size;     end
+    def clear_tests_to_run; @tests.clear;    end
+
+    def find_test_to_run(file_line)
+      @tests.find{ |t| t.file_line == file_line }
+    end
+
+    def sorted_tests_to_run(&sort_by_proc)
+      @tests.sort.sort_by(&sort_by_proc)
+    end
+
+    def test_count;          end
+    def result_count;        end
+    def pass_result_count;   end
+    def fail_result_count;   end
+    def error_result_count;  end
+    def skip_result_count;   end
+    def ignore_result_count; end
+
     def run_time
       @end_time - @start_time
     end
@@ -48,55 +74,26 @@ module Assert
       get_rate(self.result_count, self.run_time)
     end
 
-    def count(thing)
-      if thing == :tests
-        test_count
-      elsif thing == :results
-        result_count
-      elsif thing == :pass   || thing == :passed
-        result_count(:pass)
-      elsif thing == :fail   || thing == :failed
-        result_count(:fail)
-      elsif thing == :error  || thing == :errored
-        result_count(:error)
-      elsif thing == :skip   || thing == :skipped
-        result_count(:skip)
-      elsif thing == :ignore || thing == :ignored
-        result_count(:ignore)
-      else
-        0
-      end
-    end
-
-    # Test data
-
-    def ordered_tests;              end
-    def reversed_tests;             end
-    def ordered_tests_by_run_time;  end
-    def reversed_tests_by_run_time; end
-    def test_count;                 end
-
-    # Result data
-
-    def ordered_results;           end
-    def reversed_results;          end
-    def ordered_results_for_dump;  end
-    def reversed_results_for_dump; end
-    def result_count(type = nil);  end
-
     # Callbacks
 
     # define callback handlers to do special behavior during the test run.  These
     # will be called by the test runner
 
     def before_load(test_files); end
-    def after_load;              end
-    def on_start;                end
-    def before_test(test);       end
-    def on_result(result);       end
-    def after_test(test);        end
-    def on_finish;               end
-    def on_interrupt(err);       end
+
+    # this is required to load tests into the suite, be sure to `super` if you
+    # override this method
+    def on_test(test)
+      @tests << test
+    end
+
+    def after_load;        end
+    def on_start;          end
+    def before_test(test); end
+    def on_result(result); end
+    def after_test(test);  end
+    def on_finish;         end
+    def on_interrupt(err); end
 
     def inspect
       "#<#{self.class}:#{'0x0%x' % (object_id << 1)}"\
@@ -104,12 +101,6 @@ module Assert
       " result_count=#{self.result_count.inspect}>"
     end
 
-    private
-
-    def get_rate(count, time)
-      time == 0 ? 0.0 : (count.to_f / time.to_f)
-    end
-
   end
 
 end

data/lib/assert/test.rb

@@ -9,10 +9,6 @@ module Assert
     # a Test is some code/method to run in the scope of a Context that may
     # produce results
 
-    def self.result_count_meth(type)
-      "#{type}_result_count".to_sym
-    end
-
     def self.name_file_line_context_data(ci, name)
       { :name      => ci.test_name(name),
         :file_line => ci.called_from
@@ -35,82 +31,55 @@ module Assert
       }))
     end
 
-    attr_reader :results
-    attr_writer :total_result_count
-
     def initialize(build_data = nil)
-      @build_data, @results = build_data || {}, []
+      @build_data      = build_data || {}
+      @result_callback = nil
     end
 
-    def file_line; @file_line ||= FileLine.parse((@build_data[:file_line] || '').to_s); end
-    def name;      @name      ||= (@build_data[:name]                     || '');       end
-    def output;    @output    ||= (@build_data[:output]                   || '');       end
-    def run_time;  @run_time  ||= (@build_data[:run_time]                 || 0);        end
-
-    def total_result_count
-      @total_result_count ||= (@build_data[:total_result_count] || 0)
+    def file_line
+      @file_line ||= FileLine.parse((@build_data[:file_line] || '').to_s)
     end
 
-    Assert::Result.types.keys.each do |type|
-      n = result_count_meth(type)
-      define_method(n) do
-        instance_variable_get("@#{n}") || instance_variable_set("@#{n}", @build_data[n] || 0)
-      end
+    def file_name; self.file_line.file;      end
+    def line_num;  self.file_line.line.to_i; end
+
+    def name
+      @name ||= (@build_data[:name] || '')
     end
 
-    def context_info; @context_info ||= @build_data[:context_info]; end
-    def config;       @config       ||= @build_data[:config];       end
-    def code;         @code         ||= @build_data[:code];         end
+    def output
+      @output ||= (@build_data[:output] || '')
+    end
 
-    def data
-      { :file_line => self.file_line.to_s,
-        :name      => self.name.to_s,
-        :output    => self.output.to_s,
-        :run_time  => self.run_time
-      }.merge(result_count_data(:total_result_count => self.total_result_count))
+    def run_time
+      @run_time ||= (@build_data[:run_time] || 0)
     end
 
-    def context_class; self.context_info.klass; end
-    def file;          self.file_line.file;     end
-    def line_number;   self.file_line.line;     end
+    def context_info
+      @context_info ||= @build_data[:context_info]
+    end
 
-    def result_rate
-      get_rate(self.result_count, self.run_time)
+    def context_class
+      self.context_info.klass
     end
 
-    def result_count(type = nil)
-      if Assert::Result.types.keys.include?(type)
-        self.send(result_count_meth(type))
-      else
-        self.total_result_count
-      end
+    def config
+      @config ||= @build_data[:config]
     end
 
-    def capture_result(result, callback)
-      self.results << result
-      self.total_result_count += 1
-      n = result_count_meth(result.to_sym)
-      instance_variable_set("@#{n}", (instance_variable_get("@#{n}") || 0) + 1)
-      callback.call(result)
+    def code
+      @code ||= @build_data[:code]
     end
 
     def run(&result_callback)
-      result_callback ||= proc{ |result| } # do nothing by default
-      scope = self.context_class.new(self, self.config, result_callback)
+      @result_callback = result_callback || proc{ |result| } # noop by default
+      scope = self.context_class.new(self, self.config, @result_callback)
       start_time = Time.now
       capture_output do
-        self.context_class.run_arounds(scope) do
-          run_test(scope, result_callback)
-        end
+        self.context_class.run_arounds(scope){ run_test(scope) }
       end
+      @result_callback = nil
       @run_time = Time.now - start_time
-      @results
-    end
-
-    Assert::Result.types.each do |name, klass|
-      define_method "#{name}_results" do
-        self.results.select{|r| r.kind_of?(klass) }
-      end
     end
 
     def <=>(other_test)
@@ -118,7 +87,7 @@ module Assert
     end
 
     def inspect
-      attributes_string = ([ :name, :context_info, :results ].collect do |attr|
+      attributes_string = ([:name, :context_info].collect do |attr|
         "@#{attr}=#{self.send(attr).inspect}"
       end).join(" ")
       "#<#{self.class}:#{'0x0%x' % (object_id << 1)} #{attributes_string}>"
@@ -126,7 +95,7 @@ module Assert
 
     private
 
-    def run_test(scope, result_callback)
+    def run_test(scope)
       begin
         # run any assert style 'setup do' setups
         self.context_class.run_setups(scope)
@@ -135,13 +104,13 @@ module Assert
         # run the code block
         scope.instance_eval(&(self.code || proc{}))
       rescue Result::TestFailure => err
-        capture_result(Result::Fail.for_test(self, err), result_callback)
+        capture_result(Result::Fail, err)
       rescue Result::TestSkipped => err
-        capture_result(Result::Skip.for_test(self, err), result_callback)
+        capture_result(Result::Skip, err)
       rescue SignalException => err
         raise(err)
       rescue Exception => err
-        capture_result(Result::Error.for_test(self, err), result_callback)
+        capture_result(Result::Error, err)
       ensure
         begin
           # run any assert style 'teardown do' teardowns
@@ -149,17 +118,21 @@ module Assert
           # run any test/unit style 'def teardown' teardowns
           scope.teardown if scope.respond_to?(:teardown)
         rescue Result::TestFailure => err
-          capture_result(Result::Fail.for_test(self, err), result_callback)
+          capture_result(Result::Fail, err)
         rescue Result::TestSkipped => err
-          capture_result(Result::Skip.for_test(self, err), result_callback)
+          capture_result(Result::Skip, err)
         rescue SignalException => err
           raise(err)
         rescue Exception => err
-          capture_result(Result::Error.for_test(self, err), result_callback)
+          capture_result(Result::Error, err)
         end
       end
     end
 
+    def capture_result(result_klass, err)
+      @result_callback.call(result_klass.for_test(self, err))
+    end
+
     def capture_output(&block)
       if self.config.capture_output == true
         orig_stdout = $stdout.clone
@@ -175,21 +148,6 @@ module Assert
       StringIO.new(self.output, "a+")
     end
 
-    def result_count_data(seed)
-      Assert::Result.types.keys.inject(seed) do |d, t|
-        d[result_count_meth(t)] = self.send(result_count_meth(t))
-        d
-      end
-    end
-
-    def result_count_meth(type)
-      self.class.result_count_meth(type)
-    end
-
-    def get_rate(count, time)
-      time == 0 ? 0.0 : (count.to_f / time.to_f)
-    end
-
   end
 
 end