assert 2.14.0 → 2.15.0

data/lib/assert/result.rb

@@ -9,84 +9,100 @@ module Assert::Result
   class Skip < Base; end
 
   def self.types
-    { :pass => Pass,
-      :fail => Fail,
-      :ignore => Ignore,
-      :skip => Skip,
-      :error => Error
-    }
+    @types ||= Hash.new{ |h, k| Base }.tap do |hash|
+      hash[:pass]   = Pass
+      hash[:fail]   = Fail
+      hash[:ignore] = Ignore
+      hash[:skip]   = Skip
+      hash[:error]  = Error
+    end.freeze
   end
 
-  class Base
+  def self.new(data = nil)
+    data ||= {}
+    self.types[data[:type]].new(data)
+  end
 
-    attr_reader :test, :message, :backtrace
+  class Base
 
-    def initialize(test, message, backtrace=nil)
-      @test = test
-      @backtrace = Backtrace.new(backtrace)
-      @message = message && !message.empty? ? message : nil
-    end
+    def self.type; :unknown; end
+    def self.name; '';       end
 
-    Assert::Result.types.keys.each do |meth|
-      define_method("#{meth}?") { false }
+    def self.for_test(test, message, bt)
+      self.new({
+        :test_name => test.name,
+        :message   => message,
+        :backtrace => Backtrace.new(bt)
+      })
     end
 
-    def test_name
-      @test.name
+    def initialize(build_data)
+      @build_data = build_data
     end
 
-    def to_sym; nil; 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 message;   @message   ||= (@build_data[:message]   || '');                          end
+    def backtrace; @backtrace ||= (@build_data[:backtrace] || Backtrace.new([]));           end
+    def trace;     @trace     ||= (@build_data[:trace]     || build_trace(self.backtrace)); end
 
-    def to_s
-      [ "#{self.name.upcase}: #{self.test_name}",
-        self.message,
-        self.trace
-      ].compact.join("\n")
+    Assert::Result.types.keys.each do |type|
+      define_method("#{type}?"){ self.type == type }
     end
 
-    def name
-      ""
+    # 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)
     end
 
-    def trace
-      (self.backtrace.filtered.first || self.test.context_info.called_from).to_s
+    def data
+      { :type      => self.type,
+        :name      => self.name,
+        :test_name => self.test_name,
+        :message   => self.message,
+        :backtrace => self.backtrace,
+        :trace     => self.trace,
+      }
     end
 
-    # chose 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 || [])
+    def to_sym; self.type; end
+
+    def to_s
+      [ "#{self.name.upcase}: #{self.test_name}",
+        self.message,
+        self.trace
+      ].reject(&:empty?).join("\n")
     end
 
-    def ==(other)
-      self.class == other.class && self.message == other.message
+    def ==(other_result)
+      self.type == other_result.type && self.message == other_result.message
     end
 
     def inspect
       "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @message=#{self.message.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
+
   end
 
   class Pass < Base
 
-    def pass?; true; end
-    def to_sym; :pass; end
-
-    def name
-      "Pass"
-    end
+    def self.type; :pass;  end
+    def self.name; 'Pass'; end
 
   end
 
   class Ignore < Base
 
-    def ignore?; true; end
-    def to_sym; :ignore; end
-
-    def name
-      "Ignore"
-    end
+    def self.type; :ignore;  end
+    def self.name; 'Ignore'; end
 
   end
 
@@ -95,24 +111,20 @@ module Assert::Result
 
   class Fail < Base
 
+    def self.type; :fail;  end
+    def self.name; 'Fail'; end
+
     # fail results can be generated manually or by raising Assert::Result::TestFailure
-    def initialize(test, message_or_exception, backtrace=nil)
+    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 || [])
+        super(test, message_or_exception.message, message_or_exception.backtrace)
       elsif message_or_exception.kind_of?(Exception)
         raise ArgumentError, "generate fail results by raising Assert::Result::TestFailure"
       else
-        super(test, message_or_exception, backtrace)
+        super(test, message_or_exception, bt)
       end
     end
 
-    def fail?; true; end
-    def to_sym; :fail; end
-
-    def name
-      "Fail"
-    end
-
   end
 
   # raised by the 'skip' context helper to break test execution
@@ -120,71 +132,52 @@ module Assert::Result
 
   class Skip < Base
 
+    def self.type; :skip;  end
+    def self.name; 'Skip'; end
+
     # skip results are generated by raising Assert::Result::TestSkipped
-    def initialize(test, exception)
+    def self.for_test(test, exception)
       if exception.kind_of?(TestSkipped)
-        super(test, exception.message, exception.backtrace || [])
+        super(test, exception.message, exception.backtrace)
       else
         raise ArgumentError, "generate skip results by raising Assert::Result::TestSkipped"
       end
     end
 
-    def skip?; true; end
-    def to_sym; :skip; end
-
-    def name
-      "Skip"
-    end
-
   end
 
   class Error < Base
 
+    def self.type; :error;  end
+    def self.name; 'Error'; end
+
     # error results are generated by raising exceptions in tests
-    def initialize(test, exception)
+    def self.for_test(test, exception)
       if exception.kind_of?(Exception)
-        super(test, "#{exception.message} (#{exception.class.name})", exception.backtrace || [])
+        super(test, "#{exception.message} (#{exception.class.name})", exception.backtrace)
       else
         raise ArgumentError, "generate error results by raising an exception"
       end
     end
 
-    def error?; true; end
-    def to_sym; :error; end
-
-    def name
-      "Error"
-    end
+    private
 
     # override of the base, always show the full unfiltered backtrace for errors
-    def trace
-      self.backtrace.to_s
-    end
+    def build_trace(backtrace); backtrace.to_s; end
 
   end
 
-  # Utility Classes
-
-  class Set < ::Array
-    attr_accessor :callback
+  class Backtrace < ::Array
 
-    def initialize(callback=nil)
-      @callback = callback
-      super()
-    end
+    DELIM = "\n".freeze
 
-    def <<(result)
-      super
-      @callback.call(result) if @callback
-    end
-  end
+    def self.parse(bt); self.new(bt.to_s.split(DELIM)); end
 
-  class Backtrace < ::Array
     def initialize(value = nil)
       super([*(value || "No backtrace")])
     end
 
-    def to_s; self.join("\n"); end
+    def to_s; self.join(DELIM); end
 
     def filtered
       self.class.new(self.reject { |line| filter_out?(line) })
@@ -199,6 +192,7 @@ module Assert::Result
       assert_bin_regex = /bin\/assert\:/
       line.rindex(assert_lib_path, 0) || line =~ assert_bin_regex
     end
+
   end
 
 end

data/lib/assert/runner.rb

@@ -1,8 +1,10 @@
+require 'assert/config_helpers'
 require 'assert/suite'
 
 module Assert
 
   class Runner
+    include Assert::ConfigHelpers
 
     attr_reader :config
 
@@ -10,8 +12,12 @@ module Assert
       @config = config
     end
 
-    def run(suite, view)
+    def run
+      suite, view = @config.suite, @config.view
       raise ArgumentError if !suite.kind_of?(Suite)
+      if tests?
+        view.puts "Running tests in random order, seeded with \"#{runner_seed}\""
+      end
       view.fire(:on_start)
 
       begin
@@ -39,7 +45,7 @@ module Assert
 
     def tests_to_run(suite)
       srand self.config.runner_seed
-      suite.tests.sort.sort_by { rand suite.tests.size }
+      suite.tests.sort.sort_by{ rand suite.tests.size }
     end
 
   end

data/lib/assert/suite.rb

@@ -14,8 +14,8 @@ module Assert
       @config = config
       @tests = []
       @test_methods = []
-      @start_time = 0
-      @end_time = 0
+      @start_time = Time.now
+      @end_time = @start_time
     end
 
     def run_time
@@ -32,8 +32,12 @@ module Assert
 
     alias_method :ordered_tests, :tests
 
+    def ordered_tests_by_run_time
+      self.ordered_tests.sort{ |a, b| a.run_time <=> b.run_time }
+    end
+
     def results
-      tests.inject([]) {|results, test| results += test.results}
+      tests.inject([]){ |results, test| results += test.results }
     end
     alias_method :ordered_results, :results
 
@@ -62,7 +66,7 @@ module Assert
       self.tests.size
     end
 
-    def result_count(type=nil)
+    def result_count(type = nil)
       if type
         self.tests.inject(0) do |count, test|
           count += test.result_count(type)
@@ -130,13 +134,19 @@ module Assert
     end
 
     class ContextInfo
+
       attr_reader :called_from, :klass, :file
 
-      def initialize(klass, called_from=nil, first_caller=nil)
+      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
       end
+
+      def test_name(name)
+        [klass.description.to_s, name.to_s].compact.reject(&:empty?).join(' ')
+      end
+
     end
 
   end

data/lib/assert/test.rb

@@ -6,62 +6,113 @@ module Assert
 
   class Test
 
-    # a Test is some code/method to run in the scope of a Context.  After a
-    # a test runs, it should have some assertions which are its results.
+    # a Test is some code/method to run in the scope of a Context that may
+    # produce results
 
-    attr_reader :context_info, :config
-    attr_reader :name, :file_line, :code
-    attr_accessor :results, :output, :run_time
+    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
+      }
+    end
+
+    def self.for_block(name, context_info, config, &block)
+      self.new(self.name_file_line_context_data(context_info, name).merge({
+        :context_info => context_info,
+        :config       => config,
+        :code         => block
+      }))
+    end
+
+    def self.for_method(method_name, context_info, config)
+      self.new(self.name_file_line_context_data(context_info, method_name).merge({
+        :context_info => context_info,
+        :config       => config,
+        :code         => proc{ self.send(method_name) }
+      }))
+    end
+
+    attr_reader :results
+    attr_writer :total_result_count
+
+    def initialize(build_data = nil)
+      @build_data, @results = build_data || {}, []
+    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)
+    end
 
-    def initialize(name, suite_ci, config, opts = nil, &block)
-      @context_info = suite_ci
-      @config = config
-      @name, @file_line = name_file_line_from_context(@context_info, name)
+    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
+    end
 
-      o = opts || {}
-      @code = o[:code] || block || Proc.new{}
+    def context_info; @context_info ||= @build_data[:context_info]; end
+    def config;       @config       ||= @build_data[:config];       end
+    def code;         @code         ||= @build_data[:code];         end
 
-      @results = Result::Set.new
-      @output  = ""
-      @run_time = 0
-      @result_rate = 0
+    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))
     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 run(&result_callback)
-      @results = Result::Set.new(result_callback)
+    def result_rate
+      get_rate(self.result_count, self.run_time)
+    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
+    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)
+    end
 
-      scope = self.context_class.new(self, self.config)
+    def run(&result_callback)
+      result_callback ||= proc{ |result| } # do nothing by default
+      scope = self.context_class.new(self, self.config, result_callback)
       start_time = Time.now
       capture_output do
-        self.context_class.send('run_arounds', scope){ run_test_main(scope) }
+        self.context_class.send('run_arounds', scope) do # TODO: why `send`?
+          run_test(scope, result_callback)
+        end
       end
       @run_time = Time.now - start_time
-
       @results
     end
 
     Assert::Result.types.each do |name, klass|
       define_method "#{name}_results" do
-        @results.select{|r| r.kind_of?(klass) }
-      end
-    end
-
-    def result_count(type=nil)
-      if Assert::Result.types.include?(type)
-        self.send("#{type}_results").size
-      else
-        @results.size
+        self.results.select{|r| r.kind_of?(klass) }
       end
     end
 
-    def result_rate
-      get_rate(self.result_count, self.run_time)
-    end
-
     def <=>(other_test)
       self.name <=> other_test.name
     end
@@ -75,57 +126,40 @@ module Assert
 
     private
 
-    def run_test_main(scope)
+    def run_test(scope, result_callback)
       begin
-        run_test_setup(scope)
-        run_test_code(scope)
+        # run any assert style 'setup do' setups
+        self.context_class.send('run_setups', scope) # TODO: why `send`?
+        # run any test/unit style 'def setup' setups
+        scope.setup if scope.respond_to?(:setup)
+        # run the code block
+        scope.instance_eval(&(self.code || proc{}))
       rescue Result::TestFailure => err
-        @results << Result::Fail.new(self, err)
+        capture_result(Result::Fail.for_test(self, err), result_callback)
       rescue Result::TestSkipped => err
-        @results << Result::Skip.new(self, err)
+        capture_result(Result::Skip.for_test(self, err), result_callback)
       rescue SignalException => err
         raise(err)
       rescue Exception => err
-        @results << Result::Error.new(self, err)
+        capture_result(Result::Error.for_test(self, err), result_callback)
       ensure
         begin
-          run_test_teardown(scope)
+          # run any assert style 'teardown do' teardowns
+          self.context_class.send('run_teardowns', scope) # TODO: why `send`?
+          # run any test/unit style 'def teardown' teardowns
+          scope.teardown if scope.respond_to?(:teardown)
         rescue Result::TestFailure => err
-          @results << Result::Fail.new(self, err)
+          capture_result(Result::Fail.for_test(self, err), result_callback)
         rescue Result::TestSkipped => err
-          @results << Result::Skip.new(self, err)
+          capture_result(Result::Skip.for_test(self, err), result_callback)
         rescue SignalException => err
           raise(err)
-        rescue Exception => teardown_err
-          @results << Result::Error.new(self, teardown_err)
+        rescue Exception => err
+          capture_result(Result::Error.for_test(self, err), result_callback)
         end
       end
     end
 
-    def run_test_setup(scope)
-      # run any assert style 'setup do' setups
-      self.context_class.send('run_setups', scope)
-
-      # run any classic test/unit style 'def setup' setups
-      scope.setup if scope.respond_to?(:setup)
-    end
-
-    def run_test_code(scope)
-      if @code.kind_of?(::Proc)
-        scope.instance_eval(&@code)
-      elsif scope.respond_to?(@code.to_s)
-        scope.send(@code.to_s)
-      end
-    end
-
-    def run_test_teardown(scope)
-      # run any classic test/unit style 'def teardown' teardowns
-      scope.teardown if scope.respond_to?(:teardown)
-
-      # run any assert style 'teardown do' teardowns
-      self.context_class.send('run_teardowns', scope)
-    end
-
     def capture_output(&block)
       if self.config.capture_output == true
         orig_stdout = $stdout.clone
@@ -138,15 +172,18 @@ module Assert
     end
 
     def capture_io
-      StringIO.new(@output, "a+")
+      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 name_file_line_from_context(context_info, name)
-      [ [ context_info.klass.description,
-          name
-        ].compact.reject(&:empty?).join(" "),
-        FileLine.parse(context_info.called_from)
-      ]
+    def result_count_meth(type)
+      self.class.result_count_meth(type)
     end
 
     def get_rate(count, time)