assert 2.15.2 → 2.16.0

data/test/unit/assertions/assert_true_false_tests.rb

@@ -6,6 +6,8 @@ require 'assert/utils'
 module Assert::Assertions
 
   class AssertTrueTests < Assert::Context
+    include Assert::Test::TestHelpers
+
     desc "`assert_true`"
     setup do
       desc = @desc = "assert true fail desc"
@@ -15,24 +17,26 @@ module Assert::Assertions
         assert_true(*args) # fail
       end
       @c = @test.config
-      @test.run
+      @test.run(&test_run_callback)
     end
     subject{ @test }
 
     should "produce results as expected" do
-      assert_equal 2, subject.result_count
-      assert_equal 1, subject.result_count(:pass)
-      assert_equal 1, subject.result_count(:fail)
+      assert_equal 2, test_run_result_count
+      assert_equal 1, test_run_result_count(:pass)
+      assert_equal 1, test_run_result_count(:fail)
     end
 
     should "have a fail message with custom and generic explanations" do
       exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to be true."
-      assert_equal exp, subject.fail_results.first.message
+      assert_equal exp, test_run_results(:fail).first.message
     end
 
   end
 
   class AssertNotTrueTests < Assert::Context
+    include Assert::Test::TestHelpers
+
     desc "`assert_not_true`"
     setup do
       desc = @desc = "assert not true fail desc"
@@ -42,24 +46,26 @@ module Assert::Assertions
         assert_not_true(*args) # fail
       end
       @c = @test.config
-      @test.run
+      @test.run(&test_run_callback)
     end
     subject{ @test }
 
     should "produce results as expected" do
-      assert_equal 2, subject.result_count
-      assert_equal 1, subject.result_count(:pass)
-      assert_equal 1, subject.result_count(:fail)
+      assert_equal 2, test_run_result_count
+      assert_equal 1, test_run_result_count(:pass)
+      assert_equal 1, test_run_result_count(:fail)
     end
 
     should "have a fail message with custom and generic explanations" do
       exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to not be true."
-      assert_equal exp, subject.fail_results.first.message
+      assert_equal exp, test_run_results(:fail).first.message
     end
 
   end
 
   class AssertFalseTests < Assert::Context
+    include Assert::Test::TestHelpers
+
     desc "`assert_false`"
     setup do
       desc = @desc = "assert false fail desc"
@@ -69,24 +75,26 @@ module Assert::Assertions
         assert_false(*args) # fail
       end
       @c = @test.config
-      @test.run
+      @test.run(&test_run_callback)
     end
     subject{ @test }
 
     should "produce results as expected" do
-      assert_equal 2, subject.result_count
-      assert_equal 1, subject.result_count(:pass)
-      assert_equal 1, subject.result_count(:fail)
+      assert_equal 2, test_run_result_count
+      assert_equal 1, test_run_result_count(:pass)
+      assert_equal 1, test_run_result_count(:fail)
     end
 
     should "have a fail message with custom and generic explanations" do
       exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to be false."
-      assert_equal exp, subject.fail_results.first.message
+      assert_equal exp, test_run_results(:fail).first.message
     end
 
   end
 
   class AssertNotFalseTests < Assert::Context
+    include Assert::Test::TestHelpers
+
     desc "`assert_not_false`"
     setup do
       desc = @desc = "assert not false fail desc"
@@ -96,19 +104,19 @@ module Assert::Assertions
         assert_not_false(*args) # fail
       end
       @c = @test.config
-      @test.run
+      @test.run(&test_run_callback)
     end
     subject{ @test }
 
     should "produce results as expected" do
-      assert_equal 2, subject.result_count
-      assert_equal 1, subject.result_count(:pass)
-      assert_equal 1, subject.result_count(:fail)
+      assert_equal 2, test_run_result_count
+      assert_equal 1, test_run_result_count(:pass)
+      assert_equal 1, test_run_result_count(:fail)
     end
 
     should "have a fail message with custom and generic explanations" do
       exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to not be false."
-      assert_equal exp, subject.fail_results.first.message
+      assert_equal exp, test_run_results(:fail).first.message
     end
 
   end

data/test/unit/assertions_tests.rb

@@ -4,6 +4,8 @@ require 'assert/assertions'
 module Assert::Assertions
 
   class UnitTests < Assert::Context
+    include Assert::Test::TestHelpers
+
     desc "Assert::Context"
     setup do
       @context_class = Factory.modes_off_context_class
@@ -43,23 +45,24 @@ module Assert::Assertions
           self.send(helper, "doesn't matter")
         end
       end
-      @expected_messages = Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
-        "The assertion `#{helper}` is not supported."\
-        " Please use another assertion or the basic `assert`."
-      end
-      @results = @tests.map(&:run).flatten
+      @tests.each{ |test| test.run(&test_run_callback) }
     end
-    subject{ @results }
 
     should "have an ignored result for each helper in the constant" do
-      subject.each do |result|
+      exp = Assert::Assertions::IGNORED_ASSERTION_HELPERS.size
+      assert_equal exp, test_run_result_count
+
+      test_run_results.each do |result|
         assert_kind_of Assert::Result::Ignore, result
       end
-      assert_equal(Assert::Assertions::IGNORED_ASSERTION_HELPERS.size, subject.size)
     end
 
     should "have a custom ignore message for each helper in the constant" do
-      assert_equal(@expected_messages, subject.collect(&:message))
+      exp = Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
+        "The assertion `#{helper}` is not supported."\
+        " Please use another assertion or the basic `assert`."
+      end
+      assert_equal exp, test_run_results.collect(&:message)
     end
 
   end

data/test/unit/config_helpers_tests.rb

@@ -23,9 +23,14 @@ module Assert::ConfigHelpers
 
     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 :tests_to_run?, :tests_to_run_count
+    should have_imeths :test_count, :result_count, :pass_result_count
+    should have_imeths :fail_result_count, :error_result_count
+    should have_imeths :skip_result_count, :ignore_result_count
+    should have_imeths :all_pass?, :formatted_run_time
     should have_imeths :formatted_test_rate, :formatted_result_rate
+    should have_imeths :formatted_suite_run_time
+    should have_imeths :formatted_suite_test_rate, :formatted_suite_result_rate
     should have_imeths :show_test_profile_info?, :show_test_verbose_info?
     should have_imeths :ocurring_result_types
 
@@ -52,27 +57,77 @@ module Assert::ConfigHelpers
       assert_equal exp, subject.single_test_file_line
     end
 
-    should "know how to count things on the suite" do
-      thing = [:pass, :fail, :results, :tests].sample
-      assert_equal subject.config.suite.count(thing), subject.count(thing)
+    should "know its tests-to-run attrs" do
+      exp = subject.config.suite.tests_to_run?
+      assert_equal exp, subject.tests_to_run?
+
+      exp = subject.config.suite.tests_to_run_count
+      assert_equal exp, subject.tests_to_run_count
     end
 
-    should "know if it has tests or not" do
-      exp = subject.count(:tests) > 0
-      assert_equal exp, subject.tests?
+    should "know its test/result counts" do
+      exp = subject.config.suite.test_count
+      assert_equal exp, subject.test_count
+
+      exp = subject.config.suite.result_count
+      assert_equal exp, subject.result_count
+
+      exp = subject.config.suite.pass_result_count
+      assert_equal exp, subject.pass_result_count
+
+      exp = subject.config.suite.fail_result_count
+      assert_equal exp, subject.fail_result_count
+
+      exp = subject.config.suite.error_result_count
+      assert_equal exp, subject.error_result_count
+
+      exp = subject.config.suite.skip_result_count
+      assert_equal exp, subject.skip_result_count
+
+      exp = subject.config.suite.ignore_result_count
+      assert_equal exp, subject.ignore_result_count
+    end
+
+    should "know if all tests are passing or not" do
+      result_count = Factory.integer
+      Assert.stub(subject, :result_count){ result_count }
+      Assert.stub(subject, :pass_result_count){ result_count }
+      assert_true subject.all_pass?
+
+      Assert.stub(subject, :pass_result_count){ Factory.integer }
+      assert_false subject.all_pass?
     end
 
     should "know its formatted run time, test rate and result rate" do
       format = '%.6f'
 
+      run_time = Factory.float
+      exp = format % run_time
+      assert_equal exp, subject.formatted_run_time(run_time, format)
+      assert_equal exp, subject.formatted_run_time(run_time)
+
+      test_rate = Factory.float
+      exp = format % test_rate
+      assert_equal exp, subject.formatted_result_rate(test_rate, format)
+      assert_equal exp, subject.formatted_result_rate(test_rate)
+
+      result_rate = Factory.float
+      exp = format % result_rate
+      assert_equal exp, subject.formatted_result_rate(result_rate, format)
+      assert_equal exp, subject.formatted_result_rate(result_rate)
+    end
+
+    should "know its formatted suite run time, test rate and result rate" do
+      format = '%.6f'
+
       exp = format % subject.config.suite.run_time
-      assert_equal exp, subject.formatted_run_time(format)
+      assert_equal exp, subject.formatted_suite_run_time(format)
 
       exp = format % subject.config.suite.test_rate
-      assert_equal exp, subject.formatted_test_rate(format)
+      assert_equal exp, subject.formatted_suite_test_rate(format)
 
       exp = format % subject.config.suite.result_rate
-      assert_equal exp, subject.formatted_result_rate(format)
+      assert_equal exp, subject.formatted_suite_result_rate(format)
     end
 
     should "know whether to show test profile info" do
@@ -84,8 +139,12 @@ module Assert::ConfigHelpers
     end
 
     should "know what result types occur in a suite's results" do
-      exp = [:pass, :fail, :ignore, :skip, :error].select do |result_sym|
-        subject.count(result_sym) > 0
+      result_types = [:pass, :fail, :ignore, :skip, :error]
+      result_count = Factory.integer
+      Assert.stub(subject, "#{result_types.sample}_result_count"){ result_count }
+
+      exp = result_types.select do |type_sym|
+        subject.send("#{type_sym}_result_count") > 0
       end
       assert_equal exp, subject.ocurring_result_types
     end

data/test/unit/context/test_dsl_tests.rb

@@ -12,100 +12,94 @@ module Assert::Context::TestDSL
 
     should "build a test using `test` with a desc and code block" do
       d, b = @test_desc, @test_block
-      context_class = Factory.modes_off_context_class{ test(d, &b) }
+      context, test = build_eval_context{ test(d, &b) }
 
-      assert_equal 1, context_class.suite.tests.size
+      assert_equal 1, context.class.suite.tests_to_run_count
 
-      exp_test_name = @test_desc
-      built_test    = context_class.suite.tests.first
-
-      assert_kind_of Assert::Test, built_test
-      assert_equal exp_test_name, built_test.name
-      assert_equal @test_block,   built_test.code
+      assert_kind_of Assert::Test, test
+      assert_equal @test_desc,  test.name
+      assert_equal @test_block, test.code
     end
 
     should "build a test using `should` with a desc and code block" do
       d, b = @test_desc, @test_block
-      context_class = Factory.modes_off_context_class{ should(d, &b) }
-
-      assert_equal 1, context_class.suite.tests.size
+      context, test = build_eval_context{ should(d, &b) }
 
-      exp_test_name = "should #{@test_desc}"
-      built_test    = context_class.suite.tests.last
+      assert_equal 1, context.class.suite.tests_to_run_count
 
-      assert_kind_of Assert::Test, built_test
-      assert_equal exp_test_name, built_test.name
-      assert_equal @test_block,   built_test.code
+      assert_kind_of Assert::Test, test
+      assert_equal "should #{@test_desc}", test.name
+      assert_equal @test_block, test.code
     end
 
     should "build a test that skips with no msg when `test_eventually` called" do
       d, b = @test_desc, @test_block
-      context = build_eval_context{ test_eventually(d, &b) }
+      context, test = build_eval_context{ test_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&context.class.suite.tests.last.code)
+        context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 1,      context.class.suite.tests_to_run_count
       assert_equal 'TODO', err.message
       assert_equal 1,      err.backtrace.size
     end
 
     should "build a test that skips with no msg  when `should_eventually` called" do
       d, b = @test_desc, @test_block
-      context = build_eval_context{ should_eventually(d, &b) }
+      context, test = build_eval_context{ should_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&context.class.suite.tests.last.code)
+        context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 1,      context.class.suite.tests_to_run_count
       assert_equal 'TODO', err.message
       assert_equal 1,      err.backtrace.size
     end
 
     should "skip with the msg \"TODO\" when `test` called with no block" do
       d = @test_desc
-      context = build_eval_context { test(d) } # no block passed
+      context, test = build_eval_context { test(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&context.class.suite.tests.last.code)
+        context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 1,      context.class.suite.tests_to_run_count
       assert_equal 'TODO', err.message
       assert_equal 1,      err.backtrace.size
     end
 
     should "skip with the msg \"TODO\" when `should` called with no block" do
       d = @test_desc
-      context = build_eval_context { should(d) } # no block passed
+      context, test = build_eval_context { should(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&context.class.suite.tests.last.code)
+        context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 1,      context.class.suite.tests_to_run_count
       assert_equal 'TODO', err.message
       assert_equal 1,      err.backtrace.size
     end
 
     should "skip with the msg \"TODO\" when `test_eventually` called with no block" do
       d = @test_desc
-      context = build_eval_context{ test_eventually(d) } # no block given
+      context, test = build_eval_context{ test_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&context.class.suite.tests.last.code)
+        context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 1,      context.class.suite.tests_to_run_count
       assert_equal 'TODO', err.message
       assert_equal 1,      err.backtrace.size
     end
 
     should "skip with the msg \"TODO\" when `should_eventually` called with no block" do
       d = @test_desc
-      context = build_eval_context{ should_eventually(d) } # no block given
+      context, test = build_eval_context{ should_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&context.class.suite.tests.last.code)
+        context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests.size
+      assert_equal 1,      context.class.suite.tests_to_run_count
       assert_equal 'TODO', err.message
       assert_equal 1,      err.backtrace.size
     end
@@ -115,7 +109,7 @@ module Assert::Context::TestDSL
       m = Assert::Macro.new{ test(d, &b); test(d, &b) }
       context_class = Factory.modes_off_context_class{ test(m) }
 
-      assert_equal 2, context_class.suite.tests.size
+      assert_equal 2, context_class.suite.tests_to_run_count
     end
 
     should "build a test from a macro using `should`" do
@@ -123,28 +117,28 @@ module Assert::Context::TestDSL
       m = Assert::Macro.new{ should(d, &b); should(d, &b) }
       context_class = Factory.modes_off_context_class{ should(m) }
 
-      assert_equal 2, context_class.suite.tests.size
+      assert_equal 2, context_class.suite.tests_to_run_count
     end
 
     should "build a test that skips from a macro using `test_eventually`" do
       d, b = @test_desc, @test_block
       m = Assert::Macro.new{ test(d, &b); test(d, &b) }
-      context = build_eval_context{ test_eventually(m) }
+      context, test = build_eval_context{ test_eventually(m) }
 
-      assert_equal 1, context.class.suite.tests.size
+      assert_equal 1, context.class.suite.tests_to_run_count
       assert_raises(Assert::Result::TestSkipped) do
-        context.instance_eval(&context.class.suite.tests.last.code)
+        context.instance_eval(&test.code)
       end
     end
 
     should "build a test that skips from a macro using `should_eventually`" do
       d, b = @test_desc, @test_block
       m = Assert::Macro.new{ should(d, &b); should(d, &b) }
-      context = build_eval_context{ should_eventually(m) }
+      context, test = build_eval_context{ should_eventually(m) }
 
-      assert_equal 1, context.class.suite.tests.size
+      assert_equal 1, context.class.suite.tests_to_run_count
       assert_raises(Assert::Result::TestSkipped) do
-        context.instance_eval(&context.class.suite.tests.last.code)
+        context.instance_eval(&test.code)
       end
 
     end
@@ -153,9 +147,8 @@ module Assert::Context::TestDSL
 
     def build_eval_context(&build_block)
       context_class = Factory.modes_off_context_class &build_block
-      context_info  = Factory.context_info(context_class)
-      test = Factory.test("whatever", context_info)
-      context_class.new(test, test.config, proc{ |r| })
+      test = context_class.suite.sorted_tests_to_run.to_a.last
+      [context_class.new(test, test.config, proc{ |r| }), test]
     end
 
     def capture_err(err_class, &block)