assert 2.15.0 → 2.15.1

data/lib/assert/context.rb

@@ -3,6 +3,7 @@ require 'assert/context/setup_dsl'
 require 'assert/context/subject_dsl'
 require 'assert/context/suite_dsl'
 require 'assert/context/test_dsl'
+require 'assert/context_info'
 require 'assert/macros/methods'
 require 'assert/result'
 require 'assert/suite'
@@ -40,7 +41,7 @@ module Assert
 
         self.suite.tests << Test.for_method(
           method_name.to_s,
-          Suite::ContextInfo.new(self, nil, caller.first),
+          ContextInfo.new(self, nil, caller.first),
           self.suite.config
         )
       end
@@ -116,13 +117,13 @@ module Assert
     # alter the backtraces of fail results generated in the given block
     def with_backtrace(bt, &block)
       bt ||= []
-      current_results.count.tap do |count|
+      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[count..-1].each{ |r| r.set_backtrace(bt) }
+          current_results[size..-1].each{ |r| r.set_backtrace(bt) }
         end
       end
     end

data/lib/assert/context/test_dsl.rb

@@ -1,3 +1,4 @@
+require 'assert/context_info'
 require 'assert/macro'
 require 'assert/suite'
 require 'assert/test'
@@ -14,7 +15,7 @@ class Assert::Context
         # create a test from the given code block
         self.suite.tests << Assert::Test.for_block(
           desc_or_macro.kind_of?(Assert::Macro) ? desc_or_macro.name : desc_or_macro,
-          Assert::Suite::ContextInfo.new(self, called_from, first_caller || caller.first),
+          Assert::ContextInfo.new(self, called_from, first_caller || caller.first),
           self.suite.config,
           &block
         )
@@ -25,7 +26,7 @@ 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::Suite::ContextInfo.new(self, called_from, first_caller || caller.first)
+      ci = Assert::ContextInfo.new(self, called_from, first_caller || caller.first)
       self.suite.tests << Assert::Test.for_block(
         desc_or_macro.kind_of?(Assert::Macro) ? desc_or_macro.name : desc_or_macro,
         ci,

data/lib/assert/context_info.rb

@@ -0,0 +1,19 @@
+module Assert
+
+  class ContextInfo
+
+    attr_reader :called_from, :klass, :file
+
+    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/default_runner.rb

@@ -0,0 +1,12 @@
+require 'assert/runner'
+
+module Assert
+
+  # This is the default runner used by assert.  It adds no special behavior on
+  # top of the base runner's behavior
+
+  class DefaultRunner < Assert::Runner
+
+  end
+
+end

data/lib/assert/default_suite.rb

@@ -0,0 +1,64 @@
+require 'assert/suite'
+
+module Assert
+
+  # This is the default suite used by assert.  It stores test/result data in-memory.
+
+  class DefaultSuite < Assert::Suite
+
+    # Test data
+
+    def ordered_tests
+      self.tests
+    end
+
+    def reversed_tests
+      self.tests.reverse
+    end
+
+    def ordered_tests_by_run_time
+      self.ordered_tests.sort{ |a, b| a.run_time <=> b.run_time }
+    end
+
+    def reversed_tests_by_run_time
+      self.ordered_tests_by_run_time.reverse
+    end
+
+    def test_count
+      self.tests.size
+    end
+
+    # Result data
+
+    def ordered_results
+      self.ordered_tests.inject([]){ |results, test| results += test.results }
+    end
+
+    def reversed_results
+      self.ordered_results.reverse
+    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
+
+    def reversed_results_for_dump
+      self.ordered_results_for_dump.reverse
+    end
+
+    def result_count(type = nil)
+      self.tests.inject(0){ |count, test| count += test.result_count(type) }
+    end
+
+    # Callbacks
+
+    # no custom callbacks
+
+  end
+
+end

data/lib/assert/default_view.rb

@@ -1,11 +1,13 @@
 require 'assert/view'
+require 'assert/view_helpers'
 
 module Assert
 
   # This is the default view used by assert.  It renders ansi test output
   # designed for terminal viewing.
 
-  class DefaultView < Assert::View::Base
+  class DefaultView < Assert::View
+    include Assert::ViewHelpers::Ansi
 
     # setup options and their default values
 
@@ -69,7 +71,9 @@ module Assert
 
       puts "#{result_count_statement}: #{styled_results_sentence}"
       puts
-      puts "(#{run_time} seconds, #{test_rate} tests/s, #{result_rate} results/s)"
+      puts "(#{formatted_run_time} seconds, " \
+           "#{formatted_test_rate} tests/s, " \
+           "#{formatted_result_rate} results/s)"
     end
 
     def on_interrupt(err)
@@ -82,22 +86,20 @@ module Assert
       print "\n"
       puts
 
-      # output detailed results for the tests in reverse test/result order
-      tests = config.suite.ordered_tests.reverse
-      result_details_for(tests, :reversed).each do |details|
-        if show_result_details?(details.result)
-          # output the styled result details
-          result = details.result
-          puts ansi_styled_msg(result.to_s, result)
+      config.suite.reversed_results_for_dump.each do |result|
+        # output the styled result details
+        puts ansi_styled_msg(result.to_s, result)
 
-          # output any captured stdout
-          output = details.output
-          puts captured_output(output) if output && !output.empty?
+        # output any captured stdout
+        puts captured_output(result.output) if result.output && !result.output.empty?
 
-          # add an empty line between each result detail
-          puts
-        end
+        # output re-run CLI cmd
+        puts re_run_test_cmd(result.test_id)
+
+        # add an empty line between each result detail
+        puts
       end
+
     end
 
   end

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(/(.+)\:(.+)/) || [])[1..2])
+      self.new(*(file_line_path.to_s.match(/(^[^\:]*)\:*(\d*)$/) || [])[1..2])
     end
 
     attr_reader :file, :line
@@ -18,7 +18,8 @@ module Assert
 
     def ==(other_file_line)
       if other_file_line.kind_of?(FileLine)
-        self.file == other_file_line.file && self.line == other_file_line.line
+        self.file == other_file_line.file &&
+        self.line == other_file_line.line
       else
         super
       end

data/lib/assert/result.rb

@@ -31,7 +31,9 @@ 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)
       })
     end
@@ -43,7 +45,9 @@ module Assert::Result
     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
 
@@ -62,7 +66,9 @@ module Assert::Result
       { :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,
       }

data/lib/assert/runner.rb

@@ -1,5 +1,6 @@
 require 'assert/config_helpers'
 require 'assert/suite'
+require 'assert/view'
 
 module Assert
 
@@ -12,40 +13,76 @@ module Assert
       @config = config
     end
 
+    def runner; self; end
+
     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}\""
+      self.on_start
+      self.suite.on_start
+      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}\""
       end
-      view.fire(:on_start)
 
       begin
-        suite.setup
-
-        suite.start_time = Time.now
-        tests_to_run(suite).each do |test|
-          view.fire(:before_test, test)
-          test.run{ |result| view.fire(:on_result, result) }
-          view.fire(:after_test, test)
+        self.suite.start_time = Time.now
+        self.suite.setups.each(&:call)
+        tests_to_run.each do |test|
+          self.before_test(test)
+          self.suite.before_test(test)
+          self.view.before_test(test)
+          test.run do |result|
+            self.on_result(result)
+            self.suite.on_result(result)
+            self.view.on_result(result)
+          end
+          self.after_test(test)
+          self.suite.after_test(test)
+          self.view.after_test(test)
         end
-        suite.end_time = Time.now
-
-        suite.teardown
+        self.suite.teardowns.each(&:call)
+        self.suite.end_time = Time.now
       rescue Interrupt => err
-        view.fire(:on_interrupt, err)
+        self.on_interrupt(err)
+        self.suite.on_interrupt(err)
+        self.view.on_interrupt(err)
         raise(err)
       end
 
-      view.fire(:on_finish)
-      suite.count(:failed) + suite.count(:errored)
+      (self.suite.count(:fail) + self.suite.count(:error)).tap do
+        self.view.on_finish
+        self.suite.on_finish
+        self.on_finish
+      end
     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
+
     private
 
-    def tests_to_run(suite)
-      srand self.config.runner_seed
-      suite.tests.sort.sort_by{ rand suite.tests.size }
+    def tests_to_run
+      if self.single_test?
+        [ self.suite.tests.find{ |t| t.file_line == self.single_test_file_line }
+        ].compact
+      else
+        srand self.runner_seed
+        self.suite.tests.sort.sort_by{ rand self.suite.tests.size }
+      end
     end
 
   end

data/lib/assert/suite.rb

@@ -1,98 +1,102 @@
+require 'assert/config_helpers'
 require 'assert/test'
 
 module Assert
+
   class Suite
+    include Assert::ConfigHelpers
 
-    TEST_METHOD_REGEX = /^test./
+    TEST_METHOD_REGEX = /^test./.freeze
 
     # 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_accessor :config, :tests, :test_methods, :start_time, :end_time
+    attr_reader :config, :tests, :test_methods, :setups, :teardowns
+    attr_accessor :start_time, :end_time
 
     def initialize(config)
-      @config = config
-      @tests = []
+      @config       = config
+      @tests        = []
       @test_methods = []
-      @start_time = Time.now
-      @end_time = @start_time
+      @setups       = []
+      @teardowns    = []
+      @start_time   = Time.now
+      @end_time     = @start_time
     end
 
-    def run_time
-      @end_time - @start_time
-    end
+    def suite; self; end
 
-    def test_rate
-      get_rate(self.tests.size, self.run_time)
+    def setup(&block)
+      self.setups << (block || proc{})
     end
+    alias_method :startup, :setup
 
-    def result_rate
-      get_rate(self.results.size, self.run_time)
+    def teardown(&block)
+      self.teardowns << (block || proc{})
     end
+    alias_method :shutdown, :teardown
 
-    alias_method :ordered_tests, :tests
+    def run_time
+      @end_time - @start_time
+    end
 
-    def ordered_tests_by_run_time
-      self.ordered_tests.sort{ |a, b| a.run_time <=> b.run_time }
+    def test_rate
+      get_rate(self.test_count, self.run_time)
     end
 
-    def results
-      tests.inject([]){ |results, test| results += test.results }
+    def result_rate
+      get_rate(self.result_count, self.run_time)
     end
-    alias_method :ordered_results, :results
 
     def count(thing)
-      case thing
-      when :tests
+      if thing == :tests
         test_count
-      when :results
+      elsif thing == :results
         result_count
-      when :passed, :pass
+      elsif thing == :pass   || thing == :passed
         result_count(:pass)
-      when :failed, :fail
+      elsif thing == :fail   || thing == :failed
         result_count(:fail)
-      when :ignored, :ignore
-        result_count(:ignore)
-      when :skipped, :skip
-        result_count(:skip)
-      when :errored, :error
+      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
 
-    def test_count
-      self.tests.size
-    end
+    # Test data
 
-    def result_count(type = nil)
-      if type
-        self.tests.inject(0) do |count, test|
-          count += test.result_count(type)
-        end
-      else
-        self.results.size
-      end
-    end
+    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
 
-    def setup(&block)
-      if block_given?
-        self.setups << block
-      else
-        self.setups.each{ |setup| setup.call }
-      end
-    end
-    alias_method :startup, :setup
+    # Result data
 
-    def teardown(&block)
-      if block_given?
-        self.teardowns << block
-      else
-        self.teardowns.reverse.each{ |teardown| teardown.call }
-      end
-    end
-    alias_method :shutdown, :teardown
+    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
 
     def inspect
       "#<#{self.class}:#{'0x0%x' % (object_id << 1)}"\
@@ -100,55 +104,12 @@ module Assert
       " result_count=#{self.result_count.inspect}>"
     end
 
-    protected
-
-    def setups
-      @setups ||= []
-    end
-
-    def teardowns
-      @teardowns ||= []
-    end
-
-    def local_public_test_methods(klass)
-      # start with all public meths, store off the local ones
-      methods = klass.public_instance_methods
-      local_methods = klass.public_instance_methods(false)
-
-      # remove any from the superclass
-      while (klass.superclass)
-        methods -= (klass = klass.superclass).public_instance_methods
-      end
-
-      # add back in the local ones (to work around super having the same methods)
-      methods += local_methods
-
-      # uniq and remove any that don't start with 'test'
-      methods.uniq.delete_if {|method_name| method_name !~ TEST_METHOD_REGEX }
-    end
-
     private
 
     def get_rate(count, time)
       time == 0 ? 0.0 : (count.to_f / time.to_f)
     end
 
-    class ContextInfo
-
-      attr_reader :called_from, :klass, :file
-
-      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
 
 end