assert 2.18.3 → 2.19.3

data/test/unit/runner_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/runner"
 
@@ -10,7 +12,9 @@ require "assert/view"
 class Assert::Runner
   class UnitTests < Assert::Context
     desc "Assert::Runner"
-    subject { Assert::Runner }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::Runner }
 
     should "include the config helpers" do
       assert_that(subject).includes(Assert::ConfigHelpers)
@@ -19,15 +23,14 @@ class Assert::Runner
 
   class InitTests < UnitTests
     desc "when init"
-    subject { runner1 }
+    subject{ unit_class.new(config1) }
 
     setup do
       config1.suite Assert::DefaultSuite.new(config1)
-      config1.view  Assert::View.new(config1, StringIO.new("", "w+"))
+      config1.view  Assert::View.new(config1, StringIO.new(+"", "w+"))
     end
 
-    let(:config1) { Factory.modes_off_config }
-    let(:runner1) { Assert::Runner.new(config1) }
+    let(:config1){ Factory.modes_off_config }
 
     should have_readers :config
     should have_imeths :runner, :run
@@ -46,9 +49,10 @@ class Assert::Runner
 
   class RunTests < InitTests
     desc "and run"
+    subject{ runner_class1.new(config1) }
 
     setup do
-      @view_output = ""
+      @view_output = +""
 
       suite_class = Class.new(Assert::DefaultSuite){ include CallbackMixin }
       view_class  = Class.new(Assert::View){ include CallbackMixin }
@@ -57,33 +61,36 @@ class Assert::Runner
       config1.view  view_class.new(config1, StringIO.new(@view_output, "w+"))
       config1.suite.on_test(test1)
 
-      @result = subject.run
+      @result_count = subject.run
     end
 
-    let(:runner_class1) { Class.new(Assert::Runner) { include CallbackMixin } }
-    let(:ci1) { Factory.context_info(Factory.modes_off_context_class) }
-    let(:test1) { Factory.test("should pass", ci1){ assert(1==1) } }
-    let(:runner1) { runner_class1.new(config1) }
+    let(:runner_class1) do
+      Class.new(unit_class){ include CallbackMixin }
+    end
+    let(:ci1){ Factory.context_info(Factory.modes_off_context_class) }
+    # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+    let(:test1){ Factory.test("should pass", ci1){ assert(1 == 1) } }
+    # rubocop:enable Lint/BinaryOperatorWithIdenticalOperands
 
     should "return the fail+error result count as an integer exit code" do
-      assert_that(@result).equals(0)
+      assert_that(@result_count).equals(0)
 
       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(test1, :run){ } # no-op
-      result = runner1.run
+      Assert.stub(test1, :run){} # no-op
+      result_count = subject.run
 
-      exp = fail_count + error_count
-      assert_that(result).equals(exp)
+      assert_that(result_count).equals(fail_count + error_count)
     end
 
     should "run all callbacks on itself, the suite and the view" do
       # itself
       assert_that(subject.on_start_called).is_true
       assert_that(subject.before_test_called).equals([test1])
-      assert_that(subject.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(subject.on_result_called.last)
+        .is_instance_of(Assert::Result::Pass)
       assert_that(subject.after_test_called).equals([test1])
       assert_that(subject.on_finish_called).is_true
 
@@ -91,7 +98,8 @@ class Assert::Runner
       suite = config1.suite
       assert_that(suite.on_start_called).is_true
       assert_that(suite.before_test_called).equals([test1])
-      assert_that(suite.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(suite.on_result_called.last)
+        .is_instance_of(Assert::Result::Pass)
       assert_that(suite.after_test_called).equals([test1])
       assert_that(suite.on_finish_called).is_true
 
@@ -99,7 +107,8 @@ class Assert::Runner
       view = config1.view
       assert_that(view.on_start_called).is_true
       assert_that(view.before_test_called).equals([test1])
-      assert_that(view.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(view.on_result_called.last)
+        .is_instance_of(Assert::Result::Pass)
       assert_that(view.after_test_called).equals([test1])
       assert_that(view.on_finish_called).is_true
     end
@@ -116,7 +125,9 @@ class Assert::Runner
     end
 
     should "run only a single test if a single test is configured" do
-      test = Factory.test("should pass", ci1){ assert(1==1) }
+      # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+      test = Factory.test("should pass", ci1){ assert(1 == 1) }
+      # rubocop:enable Lint/BinaryOperatorWithIdenticalOperands
       config1.suite.clear_tests_to_run
       config1.suite.on_test(test)
       config1.single_test test.file_line.to_s
@@ -125,8 +136,11 @@ class Assert::Runner
       assert_that(runner.before_test_called).equals([test])
     end
 
-    should "not run any tests if a single test is configured but can't be found" do
-      test = Factory.test("should pass", ci1){ assert(1==1) }
+    should "not run any tests if a single test is configured but "\
+           "can't be found" do
+      # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+      test = Factory.test("should pass", ci1){ assert(1 == 1) }
+      # rubocop:enable Lint/BinaryOperatorWithIdenticalOperands
       config1.suite.clear_tests_to_run
       config1.suite.on_test(test)
       config1.single_test Factory.string
@@ -135,7 +149,8 @@ class Assert::Runner
       assert_that(runner.before_test_called).is_nil
     end
 
-    should "describe 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
       config1.suite.clear_tests_to_run
       config1.suite.on_test(test1)
       config1.single_test test1.file_line.to_s

data/test/unit/suite_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/suite"
 
@@ -6,29 +8,24 @@ require "assert/test"
 require "test/support/inherited_stuff"
 
 class Assert::Suite
-
   class UnitTests < Assert::Context
     desc "Assert::Suite"
-    subject { Assert::Suite }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::Suite }
 
     should "include the config helpers" do
       assert_that(subject).includes(Assert::ConfigHelpers)
     end
-
-    should "know its test method regex" do
-      assert_that(subject::TEST_METHOD_REGEX).matches("test#{Factory.string}")
-      assert_that(subject::TEST_METHOD_REGEX).does_not_match("#{Factory.string}test")
-    end
   end
 
   class InitTests < UnitTests
     desc "when init"
-    subject { suite1 }
+    subject{ unit_class.new(config1) }
 
-    let(:config1) { Factory.modes_off_config }
-    let(:suite1)  { Assert::Suite.new(config1) }
+    let(:config1){ Factory.modes_off_config }
 
-    should have_readers :config, :test_methods, :setups, :teardowns
+    should have_readers :config, :setups, :teardowns
     should have_accessors :start_time, :end_time
     should have_imeths :suite, :setup, :startup, :teardown, :shutdown
     should have_imeths :tests_to_run?, :tests_to_run_count, :clear_tests_to_run
@@ -46,7 +43,6 @@ class Assert::Suite
     end
 
     should "default its attrs" do
-      assert_that(subject.test_methods).equals([])
       assert_that(subject.setups).equals([])
       assert_that(subject.teardowns).equals([])
 
@@ -78,14 +74,16 @@ class Assert::Suite
       Assert.stub(subject, :result_count){ count }
 
       assert_that(subject.run_time).equals(time)
-      assert_that(subject.test_rate).equals((subject.test_count / subject.run_time))
-      assert_that(subject.result_rate).equals((subject.result_count / subject.run_time))
+      assert_that(subject.test_rate)
+        .equals((subject.test_count / subject.run_time))
+      assert_that(subject.result_rate)
+        .equals((subject.result_count / subject.run_time))
     end
 
     should "add setup procs" do
       status = nil
-      suite1.setup{ status = "setups" }
-      suite1.startup{ status += " have been run" }
+      subject.setup{ status = "setups" }
+      subject.startup{ status += " have been run" }
 
       assert_that(subject.setups.count).equals(2)
       subject.setups.each(&:call)
@@ -94,8 +92,8 @@ class Assert::Suite
 
     should "add teardown procs" do
       status = nil
-      suite1.teardown{ status = "teardowns" }
-      suite1.shutdown{ status += " have been run" }
+      subject.teardown{ status = "teardowns" }
+      subject.shutdown{ status += " have been run" }
 
       assert_that(subject.teardowns.count).equals(2)
       subject.teardowns.each(&:call)
@@ -107,20 +105,40 @@ class Assert::Suite
     desc "with tests loaded"
 
     setup do
-      tests1.each{ |test| suite1.on_test(test) }
+      tests1.each{ |test| subject.on_test(test) }
     end
 
-    let(:ci1) { proc{ Factory.context_info(Factory.modes_off_context_class) } }
-    let(:tests1) {
+    let(:ci1){ proc{ Factory.context_info(Factory.modes_off_context_class) } }
+    let(:tests1) do
+      # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
       [
-        Factory.test("should nothing", ci1.call){ },
-        Factory.test("should pass",    ci1.call){ assert(1==1); refute(1==0) },
-        Factory.test("should fail",    ci1.call){ ignore; assert(1==0); refute(1==1) },
-        Factory.test("should ignore",  ci1.call){ ignore },
-        Factory.test("should skip",    ci1.call){ skip; ignore; assert(1==1) },
-        Factory.test("should error",   ci1.call){ raise Exception; ignore; assert(1==1) }
+        Factory.test("should nothing", ci1.call) do
+        end,
+        Factory.test("should pass", ci1.call) do
+          assert(1 == 1)
+          refute(1 == 0)
+        end,
+        Factory.test("should fail", ci1.call) do
+          ignore
+          assert(1 == 0)
+          refute(1 == 1)
+        end,
+        Factory.test("should ignore", ci1.call) do
+          ignore
+        end,
+        Factory.test("should skip", ci1.call) do
+          skip
+          ignore
+          assert(1 == 1)
+        end,
+        Factory.test("should error", ci1.call) do
+          raise Exception
+          ignore # rubocop:disable Lint/UnreachableCode
+          assert(1 == 1)
+        end,
       ]
-    }
+      # rubocop:enable Lint/BinaryOperatorWithIdenticalOperands
+    end
 
     should "know its tests-to-run attrs" do
       assert_that(subject.tests_to_run_count).equals(tests1.size)
@@ -134,14 +152,14 @@ class Assert::Suite
 
     should "find a test to run given a file line" do
       test = tests1.sample
-      assert_that(subject.find_test_to_run(test.file_line)).is_the_same_as(test)
+      assert_that(subject.find_test_to_run(test.file_line)).is(test)
     end
 
     should "know its sorted tests to run" do
       sorted_tests = subject.sorted_tests_to_run{ 1 }
       assert_that(sorted_tests.size).equals(tests1.size)
       assert_that(sorted_tests.first).is_kind_of(Assert::Test)
-      assert_that(subject.sorted_tests_to_run{ 1 }.first).is_the_same_as(sorted_tests.first)
+      assert_that(subject.sorted_tests_to_run{ 1 }.first).is(sorted_tests.first)
     end
   end
 end

data/test/unit/test_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/test"
 
@@ -8,14 +10,18 @@ require "assert/result"
 class Assert::Test
   class UnitTests < Assert::Context
     desc "Assert::Test"
-    subject { Assert::Test }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::Test }
 
-    let(:context_class1) { Factory.modes_off_context_class { desc "context class" } }
-    let(:context_info1)  { Factory.context_info(context_class1) }
-    let(:config1)        { Factory.modes_off_config }
-    let(:test_code1)     { proc { assert(true) } }
+    let(:context_class1) do
+      Factory.modes_off_context_class{ desc "context class" }
+    end
+    let(:context_info1){ Factory.context_info(context_class1) }
+    let(:config1){ Factory.modes_off_config }
+    let(:test_code1){ proc{ assert(true) } }
 
-    should have_imeths :name_file_line_context_data, :for_block, :for_method
+    should have_imeths :name_file_line_context_data, :for_block
 
     should "know how to build the name and file line given context" do
       test_name = Factory.string
@@ -42,51 +48,30 @@ class Assert::Test
       assert_that(test.config).equals(config1)
       assert_that(test.code).equals(test_code1)
     end
-
-    should "build tests for a method" do
-      meth = "a_test_method"
-      test = subject.for_method(meth, context_info1, config1)
-
-      exp = Assert::FileLine.parse(context_info1.called_from)
-      assert_that(test.file_line).equals(exp)
-
-      exp = context_info1.test_name(meth)
-      assert_that(test.name).equals(exp)
-
-      assert_that(test.context_info).equals(context_info1)
-      assert_that(test.config).equals(config1)
-
-      assert_that(test.code).is_kind_of(Proc)
-      self.instance_eval(&test.code)
-      assert_that(@a_test_method_called).is_true
-    end
-
-    def a_test_method
-      @a_test_method_called = true
-    end
   end
 
   class InitWithDataTests < UnitTests
     desc "when init with data"
-    subject { test1 }
+    subject{ unit_class.new(meta_data1.merge(run_data1)) }
 
-    let(:file_line1) { Assert::FileLine.new(Factory.string, Factory.integer.to_s) }
-    let(:meta_data1) {
+    let(:file_line1) do
+      Assert::FileLine.new(Factory.string, Factory.integer.to_s)
+    end
+    let(:meta_data1) do
       {
-        :file_line => file_line1.to_s,
-        :name      => Factory.string,
-        :output    => Factory.string,
-        :run_time  => Factory.float(1.0),
+        file_line: file_line1.to_s,
+        name: Factory.string,
+        output: Factory.string,
+        run_time: Factory.float(1.0),
       }
-    }
-    let(:run_data1) {
+    end
+    let(:run_data1) do
       {
-        :context_info => context_info1,
-        :config       => config1,
-        :code         => test_code1
+        context_info: context_info1,
+        config: config1,
+        code: test_code1,
       }
-    }
-    let(:test1) { Assert::Test.new(meta_data1.merge(run_data1)) }
+    end
 
     should have_imeths :file_line, :file_name, :line_num
     should have_imeths :name, :output, :run_time
@@ -104,7 +89,7 @@ class Assert::Test
     end
 
     should "default its attrs" do
-      test = Assert::Test.new
+      test = unit_class.new
 
       assert_that(test.file_line).equals(Assert::FileLine.parse(""))
       assert_that(test.name).equals("")
@@ -126,9 +111,12 @@ class Assert::Test
     end
 
     should "have a custom inspect that only shows limited attributes" do
-      attrs = [:name, :context_info].collect do |method|
-        "@#{method}=#{subject.send(method).inspect}"
-      end.join(" ")
+      attrs =
+        [:name, :context_info]
+          .map{ |method|
+            "@#{method}=#{subject.send(method).inspect}"
+          }
+          .join(" ")
       exp = "#<#{subject.class}:#{"0x0%x" % (subject.object_id << 1)} #{attrs}>"
       assert_that(subject.inspect).equals(exp)
     end
@@ -137,7 +125,13 @@ class Assert::Test
   class PassFailIgnoreHandlingTests < UnitTests
     include Assert::Test::TestHelpers
 
-    subject { test1 }
+    subject do
+      Factory.test("pass fail ignore test", context_info1) do
+        ignore("something")
+        assert(true)
+        assert(false)
+      end
+    end
 
     setup do
       subject.context_class.setup do
@@ -153,14 +147,6 @@ class Assert::Test
       subject.run(&test_run_callback)
     end
 
-    let(:test1) {
-      Factory.test("pass fail ignore test", context_info1) do
-        ignore("something")
-        assert(true)
-        assert(false)
-      end
-    }
-
     should "capture results in the test and any setups/teardowns" do
       assert_that(test_run_results.size).equals(9)
       test_run_results.each do |result|
@@ -205,7 +191,7 @@ class Assert::Test
     end
 
     should "capture fails in the context setup" do
-      test = Factory.test("setup halt-on-fail test", context_info1){ }
+      test = Factory.test("setup halt-on-fail test", context_info1){}
       test.context_class.setup{ raise Assert::Result::TestFailure }
       test.run(&test_run_callback)
 
@@ -213,7 +199,7 @@ class Assert::Test
     end
 
     should "capture fails in the context teardown" do
-      test = Factory.test("teardown halt-on-fail test", context_info1){ }
+      test = Factory.test("teardown halt-on-fail test", context_info1){}
       test.context_class.teardown{ raise Assert::Result::TestFailure }
       test.run(&test_run_callback)
 
@@ -222,11 +208,13 @@ class Assert::Test
 
     private
 
-    def assert_failed(test)
+    def assert_failed(_test)
       with_backtrace(caller) do
-        assert_that(test_run_result_count).equals(1, "too many/few fail results")
+        assert_that(test_run_result_count)
+          .equals(1, "too many/few fail results")
         test_run_results.each do |result|
-          assert_that(result).is_kind_of(Assert::Result::Fail, "not a fail result")
+          assert_that(result)
+            .is_kind_of(Assert::Result::Fail, "not a fail result")
         end
       end
     end
@@ -243,7 +231,7 @@ class Assert::Test
     end
 
     should "capture skips in the context setup" do
-      test = Factory.test("setup skip test", context_info1){ }
+      test = Factory.test("setup skip test", context_info1){}
       test.context_class.setup{ skip }
       test.run(&test_run_callback)
 
@@ -251,7 +239,7 @@ class Assert::Test
     end
 
     should "capture skips in the context teardown" do
-      test = Factory.test("teardown skip test", context_info1){ }
+      test = Factory.test("teardown skip test", context_info1){}
       test.context_class.teardown{ skip }
       test.run(&test_run_callback)
 
@@ -260,11 +248,13 @@ class Assert::Test
 
     private
 
-    def assert_skipped(test)
+    def assert_skipped(_test)
       with_backtrace(caller) do
-        assert_that(test_run_result_count).equals(1, "too many/few skip results")
+        assert_that(test_run_result_count)
+          .equals(1, "too many/few skip results")
         test_run_results.each do |result|
-          assert_that(result).is_kind_of(Assert::Result::Skip, "not a skip result")
+          assert_that(result)
+            .is_kind_of(Assert::Result::Skip, "not a skip result")
         end
       end
     end
@@ -283,7 +273,7 @@ class Assert::Test
     end
 
     should "capture errors in the context setup" do
-      test = Factory.test("setup error test", context_info1){ }
+      test = Factory.test("setup error test", context_info1){}
       test.context_class.setup{ raise "an error" }
       test.run(&test_run_callback)
 
@@ -291,7 +281,7 @@ class Assert::Test
     end
 
     should "capture errors in the context teardown" do
-      test = Factory.test("teardown error test", context_info1){ }
+      test = Factory.test("teardown error test", context_info1){}
       test.context_class.teardown{ raise "an error" }
       test.run(&test_run_callback)
 
@@ -300,11 +290,13 @@ class Assert::Test
 
     private
 
-    def assert_errored(test)
+    def assert_errored(_test)
       with_backtrace(caller) do
-        assert_that(test_run_result_count).equals(1, "too many/few error results")
+        assert_that(test_run_result_count)
+          .equals(1, "too many/few error results")
         test_run_results.each do |result|
-          assert_that(result).is_kind_of(Assert::Result::Error, "not an error result")
+          assert_that(result)
+            .is_kind_of(Assert::Result::Error, "not an error result")
         end
       end
     end
@@ -316,90 +308,84 @@ class Assert::Test
         raise SignalException, "USR1"
       end
 
-      assert_that(-> { test.run }).raises(SignalException)
+      assert_that{ test.run }.raises(SignalException)
     end
 
     should "raises signal exceptions in the context setup" do
-      test = Factory.test("setup signal test", context_info1){ }
+      test = Factory.test("setup signal test", context_info1){}
       test.context_class.setup{ raise SignalException, "INT" }
 
-      assert_that(-> { test.run }).raises(SignalException)
+      assert_that{ test.run }.raises(SignalException)
     end
 
     should "raises signal exceptions in the context teardown" do
-      test = Factory.test("teardown signal test", context_info1){ }
+      test = Factory.test("teardown signal test", context_info1){}
       test.context_class.teardown{ raise SignalException, "TERM" }
 
-      assert_that(-> { test.run }).raises(SignalException)
+      assert_that{ test.run }.raises(SignalException)
     end
   end
 
   class ComparingTests < UnitTests
     desc "<=> another test"
-    subject { test1 }
-
-    let(:test1) { Factory.test("mmm") }
+    subject{ Factory.test("mmm") }
 
     should "return 1 with a test named 'aaa' (greater than it)" do
-      result = test1 <=> Factory.test("aaa")
-      assert_that(result).equals(1)
+      assert_that(subject <=> Factory.test("aaa")).equals(1)
     end
 
     should "return 0 with a test named the same" do
-      result = test1 <=> Factory.test(test1.name)
-      assert_that(result).equals(0)
+      assert_that(subject <=> Factory.test(subject.name)).equals(0)
     end
 
     should "return -1 with a test named 'zzz' (less than it)" do
-      result = test1 <=> Factory.test("zzz")
-      assert_that(result).equals(-1)
+      assert_that(subject <=> Factory.test("zzz")).equals(-1)
     end
   end
 
   class CaptureOutTests < UnitTests
     desc "when capturing std out"
-
-    let(:capture_config1) { Assert::Config.new(:capture_output => true) }
-    let(:test1) {
+    subject do
       Factory.test("stdout", capture_config1) do
         puts "std out from the test"
         assert true
       end
-    }
+    end
+
+    let(:capture_config1){ Assert::Config.new(capture_output: true) }
 
     should "capture any io from the test" do
-      test1.run
-      assert_that(test1.output).equals("std out from the test\n")
+      subject.run
+      assert_that(subject.output).equals("std out from the test\n")
     end
   end
 
   class FullCaptureOutTests < CaptureOutTests
     desc "across setup, teardown, and meth calls"
+    subject do
+      Factory.test("fullstdouttest", capture_config1) do
+        puts "std out from the test"
+        assert a_method_an_assert_calls
+      end
+    end
 
     setup do
-      test1.context_class.setup{ puts "std out from the setup" }
-      test1.context_class.teardown{ puts "std out from the teardown" }
-      test1.context_class.send(:define_method, "a_method_an_assert_calls") do
+      subject.context_class.setup{ puts "std out from the setup" }
+      subject.context_class.teardown{ puts "std out from the teardown" }
+      subject.context_class.send(:define_method, "a_method_an_assert_calls") do
         puts "std out from a method an assert called"
       end
     end
 
-    let(:test1) {
-      Factory.test("fullstdouttest", capture_config1) do
-        puts "std out from the test"
-        assert a_method_an_assert_calls
-      end
-    }
-
     should "collect all stdout in the output accessor" do
-      test1.run
+      subject.run
 
       exp_out =
         "std out from the setup\n"\
         "std out from the test\n"\
         "std out from a method an assert called\n"\
         "std out from the teardown\n"
-      assert_that(test1.output).equals(exp_out)
+      assert_that(subject.output).equals(exp_out)
     end
   end
 end