assert 2.15.2 → 2.16.0

data/test/unit/context_tests.rb

@@ -12,7 +12,11 @@ class Assert::Context
       @test = Factory.test
       @context_class = @test.context_class
       @callback_result = nil
-      @result_callback = proc{ |result| @callback_result = result }
+      @test_results = []
+      @result_callback = proc do |result|
+        @callback_result = result
+        @test_results << result
+      end
       @context = @context_class.new(@test, @test.config, @result_callback)
     end
     subject{ @context }
@@ -32,9 +36,9 @@ class Assert::Context
     should have_imeths :with_backtrace, :subject
 
     def test_should_collect_context_info
-      this = @__running_test__
-      assert_match /test\/unit\/context_tests.rb$/, this.context_info.file
-      assert_equal self.class, this.context_info.klass
+      test = @__assert_running_test__
+      assert_match /test\/unit\/context_tests.rb$/, test.context_info.file
+      assert_equal self.class, test.context_info.klass
     end
 
   end
@@ -275,7 +279,7 @@ class Assert::Context
     desc "with_backtrace method"
     setup do
       @from_bt = ['called_from_here']
-      @from_block = proc { ignore; fail; pass; skip 'todo' }
+      @from_block = proc { ignore; fail; pass; skip 'todo'; }
     end
 
     should "replace the fail results from the block with the given backtrace" do
@@ -283,11 +287,11 @@ class Assert::Context
       begin
         @context.with_backtrace(@from_bt, &@from_block)
       rescue Assert::Result::TestSkipped => e
-        @test.results << Assert::Result::Skip.for_test(@test, e)
+        @test_results << Assert::Result::Skip.for_test(@test, e)
       end
 
-      assert_equal 5, @test.results.size
-      norm_fail, with_ignore, with_fail, with_pass, with_skip = @test.results
+      assert_equal 5, @test_results.size
+      norm_fail, with_ignore, with_fail, with_pass, with_skip = @test_results
 
       assert_not_equal @from_bt, norm_fail.backtrace
       assert_equal @from_bt, with_ignore.backtrace

data/test/unit/default_suite_tests.rb

@@ -8,18 +8,11 @@ class Assert::DefaultSuite
   class UnitTests < Assert::Context
     desc "Assert::DefaultSuite"
     setup do
+      ci = Factory.context_info(Factory.modes_off_context_class)
+      @test = Factory.test(Factory.string, ci){ }
+
       @config = Factory.modes_off_config
       @suite  = Assert::DefaultSuite.new(@config)
-
-      ci = Factory.context_info(Factory.modes_off_context_class)
-      [ Factory.test("should nothing", ci){ },
-        Factory.test("should pass",    ci){ assert(1==1); refute(1==0) },
-        Factory.test("should fail",    ci){ ignore; assert(1==0); refute(1==1) },
-        Factory.test("should ignored", ci){ ignore },
-        Factory.test("should skip",    ci){ skip; ignore; assert(1==1) },
-        Factory.test("should error",   ci){ raise Exception; ignore; assert(1==1) }
-      ].each{ |test| @suite.tests << test }
-      @suite.tests.each(&:run)
     end
     subject{ @suite }
 
@@ -27,46 +20,76 @@ class Assert::DefaultSuite
       assert_kind_of Assert::Suite, subject
     end
 
-    should "know its test and result attrs" do
-      assert_equal 6, subject.tests.size
-      assert_kind_of Assert::Test, subject.tests.first
-
-      assert_equal subject.tests.size, subject.test_count
-      assert_equal subject.tests,      subject.ordered_tests
-
-      exp = subject.ordered_tests.sort{ |a, b| a.run_time <=> b.run_time }
-      assert_equal exp, subject.ordered_tests_by_run_time
-
-      assert_equal 8, subject.result_count
-
-      exp = subject.ordered_tests.inject([]){ |results, t| results += t.results }
-      assert_equal exp, subject.ordered_results
-
-      assert_equal 2, subject.result_count(:pass)
-      assert_equal 2, subject.result_count(:fail)
-      assert_equal 2, subject.result_count(:ignore)
-      assert_equal 1, subject.result_count(:skip)
-      assert_equal 1, subject.result_count(:error)
+    should "default its test/result counts" do
+      assert_equal 0, subject.test_count
+      assert_equal 0, subject.result_count
+      assert_equal 0, subject.pass_result_count
+      assert_equal 0, subject.fail_result_count
+      assert_equal 0, subject.error_result_count
+      assert_equal 0, subject.skip_result_count
+      assert_equal 0, subject.ignore_result_count
     end
 
-    should "count its tests and results" do
-      assert_equal subject.test_count,   subject.count(:tests)
-      assert_equal subject.result_count, subject.count(:results)
+    should "increment its test count on `before_test`" do
+      subject.before_test(@test)
+      assert_equal 1, subject.test_count
+    end
 
-      assert_equal subject.result_count(:pass), subject.count(:passed)
-      assert_equal subject.result_count(:pass), subject.count(:pass)
+    should "increment its result counts on `on_result`" do
+      subject.on_result(Factory.pass_result)
+      assert_equal 1, subject.result_count
+      assert_equal 1, subject.pass_result_count
+      assert_equal 0, subject.fail_result_count
+      assert_equal 0, subject.error_result_count
+      assert_equal 0, subject.skip_result_count
+      assert_equal 0, subject.ignore_result_count
+
+      subject.on_result(Factory.fail_result)
+      assert_equal 2, subject.result_count
+      assert_equal 1, subject.pass_result_count
+      assert_equal 1, subject.fail_result_count
+      assert_equal 0, subject.error_result_count
+      assert_equal 0, subject.skip_result_count
+      assert_equal 0, subject.ignore_result_count
+
+      subject.on_result(Factory.error_result)
+      assert_equal 3, subject.result_count
+      assert_equal 1, subject.pass_result_count
+      assert_equal 1, subject.fail_result_count
+      assert_equal 1, subject.error_result_count
+      assert_equal 0, subject.skip_result_count
+      assert_equal 0, subject.ignore_result_count
+
+      subject.on_result(Factory.skip_result)
+      assert_equal 4, subject.result_count
+      assert_equal 1, subject.pass_result_count
+      assert_equal 1, subject.fail_result_count
+      assert_equal 1, subject.error_result_count
+      assert_equal 1, subject.skip_result_count
+      assert_equal 0, subject.ignore_result_count
+
+      subject.on_result(Factory.ignore_result)
+      assert_equal 5, subject.result_count
+      assert_equal 1, subject.pass_result_count
+      assert_equal 1, subject.fail_result_count
+      assert_equal 1, subject.error_result_count
+      assert_equal 1, subject.skip_result_count
+      assert_equal 1, subject.ignore_result_count
+    end
 
-      assert_equal subject.result_count(:fail), subject.count(:failed)
-      assert_equal subject.result_count(:fail), subject.count(:fail)
+    should "clear the run data on `on_start`" do
+      subject.before_test(@test)
+      subject.on_result(Factory.pass_result)
 
-      assert_equal subject.result_count(:ignore), subject.count(:ignored)
-      assert_equal subject.result_count(:ignore), subject.count(:ignore)
+      assert_equal 1, subject.test_count
+      assert_equal 1, subject.result_count
+      assert_equal 1, subject.pass_result_count
 
-      assert_equal subject.result_count(:skip), subject.count(:skipped)
-      assert_equal subject.result_count(:skip), subject.count(:skip)
+      subject.on_start
 
-      assert_equal subject.result_count(:error), subject.count(:errored)
-      assert_equal subject.result_count(:error), subject.count(:error)
+      assert_equal 0, subject.test_count
+      assert_equal 0, subject.result_count
+      assert_equal 0, subject.pass_result_count
     end
 
   end

data/test/unit/file_line_tests.rb

@@ -14,7 +14,10 @@ class Assert::FileLine
     should have_imeths :parse
 
     should "know how to parse and init from a file line path string" do
-      file_line_path = "#{@file}:#{@line}"
+      file_line_path = [
+        "#{@file}:#{@line}",
+        "#{@file}:#{@line} #{Factory.string}"
+      ].sample
       file_line = subject.parse(file_line_path)
 
       assert_equal @file, file_line.file

data/test/unit/result_tests.rb

@@ -1,6 +1,8 @@
 require 'assert'
 require 'assert/result'
 
+require 'assert/file_line'
+
 module Assert::Result
 
   class UnitTests < Assert::Context
@@ -38,24 +40,26 @@ module Assert::Result
     desc "Base"
     setup do
       @given_data = {
-        :type      => Factory.string,
-        :name      => Factory.string,
-        :test_name => Factory.string,
-        :test_id   => Factory.string,
-        :message   => Factory.string,
-        :output    => Factory.text,
-        :backtrace => Backtrace.new(caller),
-        :trace     => Factory.string
+        :type           => Factory.string,
+        :name           => Factory.string,
+        :test_name      => Factory.string,
+        :test_file_line => Assert::FileLine.new(Factory.string, Factory.integer),
+        :message        => Factory.string,
+        :output         => Factory.text,
+        :backtrace      => Backtrace.new(caller),
+        :trace          => Factory.string
       }
       @result = Base.new(@given_data)
     end
     subject{ @result }
 
     should have_cmeths :type, :name, :for_test
-    should have_imeths :type, :name, :test_name, :test_id
+    should have_imeths :type, :name, :test_name, :test_file_line
+    should have_imeths :test_file_name, :test_line_num, :test_id
     should have_imeths :message, :output, :backtrace, :trace
+    should have_imeths :file_line, :file_name, :line_num
     should have_imeths *Assert::Result.types.keys.map{ |k| "#{k}?" }
-    should have_imeths :set_backtrace, :data, :to_sym, :to_s
+    should have_imeths :set_backtrace, :to_sym, :to_s
 
     should "know its class-level type/name" do
       assert_equal :unknown, subject.class.type
@@ -79,60 +83,78 @@ module Assert::Result
     end
 
     should "use any given attrs" do
-      assert_equal @given_data[:type].to_sym, subject.type
-      assert_equal @given_data[:name],        subject.name
-      assert_equal @given_data[:test_name],   subject.test_name
-      assert_equal @given_data[:test_id],     subject.test_id
-      assert_equal @given_data[:message],     subject.message
-      assert_equal @given_data[:output],      subject.output
-      assert_equal @given_data[:backtrace],   subject.backtrace
-      assert_equal @given_data[:trace],       subject.trace
+      assert_equal @given_data[:type].to_sym,    subject.type
+      assert_equal @given_data[:name],           subject.name
+      assert_equal @given_data[:test_name],      subject.test_name
+      assert_equal @given_data[:test_file_line], subject.test_file_line
+      assert_equal @given_data[:message],        subject.message
+      assert_equal @given_data[:output],         subject.output
+      assert_equal @given_data[:backtrace],      subject.backtrace
+      assert_equal @given_data[:trace],          subject.trace
     end
 
     should "default its attrs" do
       result = Base.new({})
 
-      assert_equal :unknown,          result.type
-      assert_equal '',                result.name
-      assert_equal '',                result.test_name
-      assert_equal '',                result.test_id
-      assert_equal '',                result.message
-      assert_equal '',                result.output
-      assert_equal Backtrace.new([]), result.backtrace
-      assert_equal '',                result.trace
+      assert_equal :unknown,                   result.type
+      assert_equal '',                         result.name
+      assert_equal '',                         result.test_name
+      assert_equal Assert::FileLine.parse(''), result.test_file_line
+      assert_equal '',                         result.message
+      assert_equal '',                         result.output
+      assert_equal Backtrace.new([]),          result.backtrace
+      assert_equal '',                         result.trace
     end
 
-    should "know if it is a certain type of result" do
-      Assert::Result.types.keys.each do |type|
-        assert_false subject.send("#{type}?")
-        Assert.stub(subject, :type){ type }
-        assert_true subject.send("#{type}?")
-      end
+    should "know its test file line attrs" do
+      exp = @given_data[:test_file_line]
+      assert_equal exp.file,      subject.test_file_name
+      assert_equal exp.line.to_i, subject.test_line_num
+      assert_equal exp.to_s,      subject.test_id
     end
 
     should "allow setting a new backtrace" do
       new_bt        = Factory.integer(3).times.map{ Factory.string }
       exp_backtrace = Backtrace.new(new_bt)
       exp_trace     = exp_backtrace.filtered.first.to_s
-
       subject.set_backtrace(new_bt)
+      assert_equal exp_backtrace, subject.backtrace
+      assert_equal exp_trace,     subject.trace
 
+      # test that the first bt line is used if filtered is empty
+      assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
+      new_bt          = Factory.integer(3).times.map{ assert_lib_path }
+      exp_backtrace   = Backtrace.new(new_bt)
+      exp_trace       = exp_backtrace.first.to_s
+      subject.set_backtrace(new_bt)
       assert_equal exp_backtrace, subject.backtrace
       assert_equal exp_trace,     subject.trace
     end
 
-    should "know its data" do
-      exp = {
-        :type      => subject.type,
-        :name      => subject.name,
-        :test_name => subject.test_name,
-        :test_id   => subject.test_id,
-        :message   => subject.message,
-        :output    => subject.output,
-        :backtrace => subject.backtrace,
-        :trace     => subject.trace,
-      }
-      assert_equal exp, subject.data
+    should "know its file line attrs" do
+      new_bt = Factory.integer(3).times.map{ Factory.string }
+      subject.set_backtrace(new_bt)
+      exp = Assert::FileLine.parse(subject.backtrace.filtered.first.to_s)
+      assert_equal exp,           subject.file_line
+      assert_equal exp.file,      subject.file_name
+      assert_equal exp.line.to_i, subject.line_num
+
+      # test that the first bt line is used if filtered is empty
+      assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
+      new_bt = Factory.integer(3).times.map{ assert_lib_path }
+      subject.set_backtrace(new_bt)
+      exp = Assert::FileLine.parse(subject.backtrace.first.to_s)
+      assert_equal exp,           subject.file_line
+      assert_equal exp.file,      subject.file_name
+      assert_equal exp.line.to_i, subject.line_num
+    end
+
+    should "know if it is a certain type of result" do
+      Assert::Result.types.keys.each do |type|
+        assert_false subject.send("#{type}?")
+        Assert.stub(subject, :type){ type }
+        assert_true subject.send("#{type}?")
+      end
     end
 
     should "know its symbol representation" do
@@ -164,8 +186,10 @@ module Assert::Result
     end
 
     should "show only its class and message when inspected" do
-      exp = "#<#{subject.class}:#{'0x0%x' % (subject.object_id << 1)}"\
-            " @message=#{subject.message.inspect}>"
+      exp = "#<#{subject.class}:#{'0x0%x' % (subject.object_id << 1)} "\
+            "@message=#{subject.message.inspect} "\
+            "@file_line=#{subject.file_line.to_s.inspect} "\
+            "@test_file_line=#{subject.test_file_line.to_s.inspect}>"
       assert_equal exp, subject.inspect
     end
 

data/test/unit/runner_tests.rb

@@ -52,10 +52,6 @@ class Assert::Runner
       callback_mixin = Module.new
       @runner_class = Class.new(Assert::Runner) do
         include CallbackMixin
-
-        def run!(&block)
-          self.suite.tests.each(&block)
-        end
       end
       suite_class  = Class.new(Assert::DefaultSuite){ include CallbackMixin }
       view_class   = Class.new(Assert::View){ include CallbackMixin }
@@ -67,14 +63,24 @@ class Assert::Runner
 
       @ci = Factory.context_info(Factory.modes_off_context_class)
       @test = Factory.test("should pass", @ci){ assert(1==1) }
-      @config.suite.tests << @test
+      @config.suite.on_test(@test)
 
       @runner = @runner_class.new(@config)
       @result = @runner.run
     end
 
-    should "return an integer exit code" do
+    should "return the fail+error result count as an integer exit code" do
       assert_equal 0, @result
+
+      fail_count  = Factory.integer
+      error_count = Factory.integer
+      Assert.stub(subject, :fail_result_count){ fail_count }
+      Assert.stub(subject, :error_result_count){ error_count }
+      Assert.stub(@test, :run){ } # no-op
+      result = @runner.run
+
+      exp = fail_count + error_count
+      assert_equal exp, result
     end
 
     should "run all callbacks on itself, the suite and the view" do
@@ -102,34 +108,46 @@ class Assert::Runner
       assert_true view.on_finish_called
     end
 
-    should "descibe running the tests in random order if there are tests" do
+    should "describe running the tests in random order if there are tests" do
       exp = "Running tests in random order, " \
             "seeded with \"#{subject.runner_seed}\"\n"
       assert_includes exp, @view_output
 
       @view_output.gsub!(/./, '')
-      @config.suite.tests.clear
+      @config.suite.clear_tests_to_run
       subject.run
       assert_not_includes exp, @view_output
     end
 
     should "run only a single test if a single test is configured" do
-      other_test = Factory.test("should also pass", @ci){ assert(1==1) }
-      @config.suite.tests << other_test
+      test = Factory.test("should pass", @ci){ assert(1==1) }
+      @config.suite.clear_tests_to_run
+      @config.suite.on_test(test)
+      @config.single_test test.file_line.to_s
 
-      @config.single_test @test.file_line.to_s
+      runner = @runner_class.new(@config).tap(&:run)
+      assert_equal [test], runner.before_test_called
+    end
+
+    should "not run any tests if a single test is configured but can't be found" do
+      test = Factory.test("should pass", @ci){ assert(1==1) }
+      @config.suite.clear_tests_to_run
+      @config.suite.on_test(test)
+      @config.single_test Factory.string
 
-      runner = @runner_class.new(@config)
-      runner.run
-      assert_equal [@test], runner.before_test_called
+      runner = @runner_class.new(@config).tap(&:run)
+      assert_nil runner.before_test_called
     end
 
-    should "descibe running only a single test if a single test is configured" do
+    should "describe running only a single test if a single test is configured" do
+      @config.suite.clear_tests_to_run
+      @config.suite.on_test(@test)
       @config.single_test @test.file_line.to_s
       @view_output.gsub!(/./, '')
       subject.run
 
-      exp = "Running test: #{subject.single_test_file_line}\n"
+      exp = "Running test: #{subject.single_test_file_line}, " \
+            "seeded with \"#{subject.runner_seed}\"\n"
       assert_includes exp, @view_output
     end