assert 2.15.0 → 2.15.1

data/lib/assert/test.rb

@@ -99,7 +99,7 @@ module Assert
       scope = self.context_class.new(self, self.config, result_callback)
       start_time = Time.now
       capture_output do
-        self.context_class.send('run_arounds', scope) do # TODO: why `send`?
+        self.context_class.run_arounds(scope) do
           run_test(scope, result_callback)
         end
       end
@@ -129,7 +129,7 @@ module Assert
     def run_test(scope, result_callback)
       begin
         # run any assert style 'setup do' setups
-        self.context_class.send('run_setups', scope) # TODO: why `send`?
+        self.context_class.run_setups(scope)
         # run any test/unit style 'def setup' setups
         scope.setup if scope.respond_to?(:setup)
         # run the code block
@@ -145,7 +145,7 @@ module Assert
       ensure
         begin
           # run any assert style 'teardown do' teardowns
-          self.context_class.send('run_teardowns', scope) # TODO: why `send`?
+          self.context_class.run_teardowns(scope)
           # run any test/unit style 'def teardown' teardowns
           scope.teardown if scope.respond_to?(:teardown)
         rescue Result::TestFailure => err

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.15.0"
+  VERSION = "2.15.1"
 end

data/lib/assert/view.rb

@@ -1,10 +1,13 @@
 require 'assert/config'
+require 'assert/config_helpers'
 require 'assert/suite'
 require 'assert/view_helpers'
 
 module Assert
 
-  module View
+  class View
+    include Assert::ConfigHelpers
+    include Assert::ViewHelpers
 
     # this method is used to bring in custom user-specific views
     # require views by passing either a full path to the view ruby file
@@ -26,87 +29,68 @@ module Assert
       end
     end
 
-    class Base
-      include Assert::ViewHelpers
+    # setup options and their default values
 
-      # setup options and their default values
+    option 'styled',        false
+    option 'pass_styles'    # none
+    option 'fail_styles'    # none
+    option 'error_styles'   # none
+    option 'skip_styles'    # none
+    option 'ignore_styles'  # none
 
-      option 'styled',        false
-      option 'pass_styles'    # none
-      option 'fail_styles'    # none
-      option 'error_styles'   # none
-      option 'skip_styles'    # none
-      option 'ignore_styles'  # none
+    option 'pass_abbrev',   '.'
+    option 'fail_abbrev',   'F'
+    option 'ignore_abbrev', 'I'
+    option 'skip_abbrev',   'S'
+    option 'error_abbrev',  'E'
 
-      option 'pass_abbrev',   '.'
-      option 'fail_abbrev',   'F'
-      option 'ignore_abbrev', 'I'
-      option 'skip_abbrev',   'S'
-      option 'error_abbrev',  'E'
+    attr_reader :config
 
-      attr_reader :config
-
-      def initialize(config, output_io)
-        @config , @output_io, = config, output_io
-        @output_io.sync = true if @output_io.respond_to?(:sync=)
-      end
-
-      def view
-        self
-      end
-
-      def is_tty?
-        !!@output_io.isatty
-      end
-
-      def ansi_styled_msg(msg, result_or_sym)
-        return msg if !self.is_tty? || !self.styled
-        code = Assert::ViewHelpers::Ansi.code_for(*self.send("#{result_or_sym.to_sym}_styles"))
-        return msg if code.empty?
-        code + msg + Assert::ViewHelpers::Ansi.code_for(:reset)
-      end
-
-      # Callbacks
-
-      # define callback handlers to output information.  handlers are
-      # instance_eval'd in the scope of the view instance.  any stdout is captured
-      # and sent to the io stream.
-
-      def fire(callback, *args)
-        self.send(callback, *args)
-      end
+    def initialize(config, output_io)
+      @config , @output_io, = config, output_io
+      @output_io.sync = true if @output_io.respond_to?(:sync=)
+    end
 
-      # available callbacks from the runner:
-      # * `before_load`:  called at the beginning, before the suite is loaded
-      # * `after_load`:   called after the suite is loaded, just before `on_start`
-      #                   functionally equivalent to `on_start`
-      # * `on_start`:     called when a loaded test suite starts running
-      # * `before_test`:  called before a test starts running
-      #                   the test is passed as an arg
-      # * `on_result`:    called when a running tests generates a result
-      #                   the result is passed as an arg
-      # * `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_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
-      def before_test(test);       end
-      def on_result(result);       end
-      def after_test(test);        end
-      def on_finish;               end
-      def on_interrupt(err);       end
-
-      # IO capture
-
-      def puts(*args); @output_io.puts(*args); end
-      def print(*args); @output_io.print(*args); end
+    def view; self; end
 
+    def is_tty?
+      !!@output_io.isatty
     end
 
+    # Callbacks
+
+    # define callback handlers to output information.  These will be called
+    # by the test runner.
+
+    # available callbacks from the runner:
+    # * `before_load`:  called at the beginning, before the suite is loaded
+    # * `after_load`:   called after the suite is loaded, just before `on_start`
+    #                   functionally equivalent to `on_start`
+    # * `on_start`:     called when a loaded test suite starts running
+    # * `before_test`:  called before a test starts running
+    #                   the test is passed as an arg
+    # * `on_result`:    called when a running tests generates a result
+    #                   the result is passed as an arg
+    # * `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_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
+    def before_test(test);       end
+    def on_result(result);       end
+    def after_test(test);        end
+    def on_finish;               end
+    def on_interrupt(err);       end
+
+    # IO capture
+
+    def puts(*args); @output_io.puts(*args); end
+    def print(*args); @output_io.print(*args); end
+
   end
 
 end

data/lib/assert/view_helpers.rb

@@ -38,43 +38,6 @@ module Assert
         format % test.result_rate
       end
 
-      # get all the result details for a set of tests
-      def result_details_for(tests, result_order = :normal)
-        test_index = 0
-        tests.collect do |test|
-          test_index += 1
-
-          details = test.results.collect do |result|
-            ResultDetails.new(result, test, test_index)
-          end
-          details.reverse! if result_order == :reversed
-          details
-        end.compact.flatten
-      end
-
-      # get all the result details for a set of tests matching a file or context
-      def matched_result_details_for(match, tests, result_order = :normal)
-        context_match = match.kind_of?(Class) && match.ancestors.include?(Assert::Context)
-        file_match = match.kind_of?(String)
-
-        matching_tests = if context_match
-          tests.select {|test| test.context_info.klass == match}
-        elsif file_match
-          tests.select {|test| test.context_info.file == match}
-        else
-          tests
-        end
-
-        result_details_for(matching_tests, result_order)
-      end
-
-      # only show result details for failed or errored results
-      # show result details if a skip or passed result was issues w/ a message
-      def show_result_details?(result)
-        [:fail, :error].include?(result.to_sym) ||
-        !!([:skip, :ignore].include?(result.to_sym) && result.message)
-      end
-
       # show any captured output
       def captured_output(output)
         "--- stdout ---\n"\
@@ -82,6 +45,11 @@ module Assert
         "--------------"
       end
 
+      # show any captured output
+      def re_run_test_cmd(test_id)
+        "assert -t #{test_id.gsub(Dir.pwd, '.')}"
+      end
+
       def test_count_statement
         "#{self.count(:tests)} test#{'s' if self.count(:tests) != 1}"
       end
@@ -218,17 +186,11 @@ module Assert
         style_names.map{ |n| "\e[#{CODES[n]}m" if CODES.key?(n) }.compact.join('')
       end
 
-    end
-
-    class ResultDetails
-
-      attr_reader :result, :test_index, :test, :output
-
-      def initialize(result, test, test_index)
-        @result     = result
-        @test       = test
-        @test_index = test_index
-        @output     = test.output
+      def ansi_styled_msg(msg, result_or_sym)
+        return msg if !self.is_tty? || !self.styled
+        code = Assert::ViewHelpers::Ansi.code_for(*self.send("#{result_or_sym.to_sym}_styles"))
+        return msg if code.empty?
+        code + msg + Assert::ViewHelpers::Ansi.code_for(:reset)
       end
 
     end

data/test/helper.rb

@@ -8,3 +8,12 @@ $LOAD_PATH.unshift(ROOT_PATH)
 # require pry for debugging (`binding.pry`)
 require 'pry'
 require 'test/support/factory'
+
+# 1.8.7 backfills
+
+# Array#sample
+if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
+  class Array
+    alias_method :sample, :choice
+  end
+end

data/test/support/factory.rb

@@ -1,18 +1,18 @@
 require 'assert/config'
+require 'assert/default_suite'
 require 'assert/factory'
 require 'assert/result'
-require 'assert/suite'
 require 'assert/test'
 
 module Factory
   extend Assert::Factory
 
   def self.context_info_called_from
-    "#{Factory.path}_tests.rb:#{Factory.integer}"
+    File.expand_path("#{Factory.path}_tests.rb:#{Factory.integer}", Dir.pwd)
   end
 
   def self.context_info(context_klass = nil)
-    Assert::Suite::ContextInfo.new(context_klass || self.context_class, context_info_called_from)
+    Assert::ContextInfo.new(context_klass || self.context_class, context_info_called_from)
   end
 
   # Generate an anonymous `Context` inherited from `Assert::Context` by default.
@@ -34,7 +34,7 @@ module Factory
   def self.test(*args, &block)
     config, context_info, name = [
       args.last.kind_of?(Assert::Config) ? args.pop : self.modes_off_config,
-      args.last.kind_of?(Assert::Suite::ContextInfo) ? args.pop : self.context_info,
+      args.last.kind_of?(Assert::ContextInfo) ? args.pop : self.context_info,
       args.last.kind_of?(::String) ? args.pop : 'a test'
     ]
     Assert::Test.for_block(name, context_info, config, &block)
@@ -75,7 +75,7 @@ module Factory
   end
 
   def self.modes_off_suite
-    Assert::Suite.new(self.modes_off_config)
+    Assert::DefaultSuite.new(self.modes_off_config)
   end
 
   def self.modes_off_context_class(*args, &block)

data/test/unit/assertions/assert_raises_tests.rb

@@ -35,6 +35,26 @@ module Assert::Assertions
       messages.each_with_index{ |msg, n| assert_match /^#{exp[n]}/, msg }
     end
 
+    should "return any raised exception instance" do
+      error     = nil
+      error_msg = Factory.string
+      test = Factory.test do
+        error = assert_raises(RuntimeError){ raise(RuntimeError, error_msg) }
+      end
+      test.run
+
+      assert_not_nil error
+      assert_kind_of RuntimeError, error
+      assert_equal error_msg, error.message
+
+      test = Factory.test do
+        error = assert_raises(RuntimeError){ }
+      end
+      test.run
+
+      assert_nil error
+    end
+
   end
 
   class AssertNothingRaisedTests < Assert::Context

data/test/unit/config_helpers_tests.rb

@@ -14,26 +14,46 @@ module Assert::ConfigHelpers
         def config
           # use the assert config since it has tests, contexts, etc
           # also maybe use a fresh config that is empty
-          @config ||= [Assert.config, Assert::Config.new].choice
+          @config ||= [Assert.config, Assert::Config.new].sample
         end
       end
       @helpers = @helpers_class.new
     end
     subject{ @helpers }
 
-    should have_imeths :runner_seed, :count, :tests?, :all_pass?
-    should have_imeths :run_time, :test_rate, :result_rate
-    should have_imeths :suite_contexts, :ordered_suite_contexts
-    should have_imeths :suite_files, :ordered_suite_files
+    should have_imeths :runner, :suite, :view
+    should have_imeths :runner_seed, :single_test?, :single_test_file_line
+    should have_imeths :count, :tests?, :all_pass?
+    should have_imeths :formatted_run_time
+    should have_imeths :formatted_test_rate, :formatted_result_rate
     should have_imeths :show_test_profile_info?, :show_test_verbose_info?
     should have_imeths :ocurring_result_types
 
+    should "know the config's runner, suite and view" do
+      assert_equal subject.config.runner, subject.runner
+      assert_equal subject.config.suite,  subject.suite
+      assert_equal subject.config.view,   subject.view
+    end
+
     should "know its runner seed" do
       assert_equal subject.config.runner_seed, subject.runner_seed
     end
 
+    should "know if it is in single test mode" do
+      Assert.stub(subject.config, :single_test?){ true }
+      assert_true subject.single_test?
+
+      Assert.stub(subject.config, :single_test?){ false }
+      assert_false subject.single_test?
+    end
+
+    should "know its single test file line" do
+      exp = subject.config.single_test_file_line
+      assert_equal exp, subject.single_test_file_line
+    end
+
     should "know how to count things on the suite" do
-      thing = [:pass, :fail, :results, :tests].choice
+      thing = [:pass, :fail, :results, :tests].sample
       assert_equal subject.config.suite.count(thing), subject.count(thing)
     end
 
@@ -46,33 +66,13 @@ module Assert::ConfigHelpers
       format = '%.6f'
 
       exp = format % subject.config.suite.run_time
-      assert_equal exp, subject.run_time(format)
+      assert_equal exp, subject.formatted_run_time(format)
 
       exp = format % subject.config.suite.test_rate
-      assert_equal exp, subject.test_rate(format)
+      assert_equal exp, subject.formatted_test_rate(format)
 
       exp = format % subject.config.suite.result_rate
-      assert_equal exp, subject.result_rate(format)
-    end
-
-    should "know its suite contexts and ordered suite contexts" do
-      exp = subject.config.suite.tests.inject([]) do |contexts, test|
-        contexts << test.context_info.klass
-      end.uniq
-      assert_equal exp, subject.suite_contexts
-
-      exp = subject.suite_contexts.sort{ |a,b| a.to_s <=> b.to_s }
-      assert_equal exp, subject.ordered_suite_contexts
-    end
-
-    should "know its suite files and ordered suite files" do
-      exp = subject.config.suite.tests.inject([]) do |files, test|
-        files << test.context_info.file
-      end.uniq
-      assert_equal exp, subject.suite_files
-
-      exp = subject.suite_files.sort{ |a,b| a.to_s <=> b.to_s }
-      assert_equal exp, subject.ordered_suite_files
+      assert_equal exp, subject.formatted_result_rate(format)
     end
 
     should "know whether to show test profile info" do

data/test/unit/config_tests.rb

@@ -1,9 +1,11 @@
 require 'assert'
 require 'assert/config'
 
+require 'assert/default_runner'
+require 'assert/default_suite'
 require 'assert/default_view'
+require 'assert/file_line'
 require 'assert/runner'
-require 'assert/suite'
 
 class Assert::Config
 
@@ -14,22 +16,24 @@ class Assert::Config
     end
     subject{ @config }
 
-    should have_imeths :suite, :view, :runner
+    should have_imeths :view, :suite, :runner
     should have_imeths :test_dir, :test_helper, :test_file_suffixes
     should have_imeths :changed_proc, :pp_proc, :use_diff_proc, :run_diff_proc
-    should have_imeths :runner_seed, :changed_only, :changed_ref, :pp_objects
-    should have_imeths :capture_output, :halt_on_fail, :profile, :verbose, :list
-    should have_imeths :debug, :apply
+    should have_imeths :runner_seed, :changed_only, :changed_ref, :single_test
+    should have_imeths :pp_objects, :capture_output, :halt_on_fail, :profile
+    should have_imeths :verbose, :list, :debug
+    should have_imeths :apply, :single_test?
+    should have_imeths :single_test_file_line, :single_test_file_path
 
     should "default the view, suite, and runner" do
-      assert_kind_of Assert::DefaultView, subject.view
-      assert_kind_of Assert::Suite,  subject.suite
-      assert_kind_of Assert::Runner, subject.runner
+      assert_kind_of Assert::DefaultView,   subject.view
+      assert_kind_of Assert::DefaultSuite,  subject.suite
+      assert_kind_of Assert::DefaultRunner, subject.runner
     end
 
     should "default the test dir/helper/suffixes" do
-      assert_equal 'test', subject.test_dir
-      assert_equal 'helper.rb', subject.test_helper
+      assert_equal 'test',                    subject.test_dir
+      assert_equal 'helper.rb',               subject.test_helper
       assert_equal ['_tests.rb', "_test.rb"], subject.test_file_suffixes
     end
 
@@ -44,6 +48,7 @@ class Assert::Config
       assert_not_nil subject.runner_seed
       assert_not     subject.changed_only
       assert_empty   subject.changed_ref
+      assert_empty   subject.single_test
       assert_not     subject.pp_objects
       assert_not     subject.capture_output
       assert         subject.halt_on_fail
@@ -62,6 +67,34 @@ class Assert::Config
       assert_not Assert::Config.new(:halt_on_fail => false).halt_on_fail
     end
 
+    should "know if it is in single test mode" do
+      assert_false subject.single_test?
+
+      subject.apply(:single_test => Factory.string)
+      assert_true subject.single_test?
+    end
+
+    should "know its single test file line" do
+      exp = Assert::FileLine.parse(File.expand_path('', Dir.pwd))
+      assert_equal exp, subject.single_test_file_line
+
+      file_line_path = "#{Factory.path}_tests.rb:#{Factory.integer}"
+      subject.apply(:single_test => file_line_path)
+
+      exp = Assert::FileLine.parse(File.expand_path(file_line_path, Dir.pwd))
+      assert_equal exp, subject.single_test_file_line
+    end
+
+    should "know its single test file path" do
+      exp = Assert::FileLine.parse(File.expand_path('', Dir.pwd)).file
+      assert_equal exp, subject.single_test_file_path
+
+      path = "#{Factory.path}_tests.rb"
+      file_line_path = "#{path}:#{Factory.integer}"
+      subject.apply(:single_test => file_line_path)
+      assert_equal File.expand_path(path, Dir.pwd), subject.single_test_file_path
+    end
+
   end
 
 end