assert 2.19.1 → 2.19.6

data/test/unit/context/setup_dsl_tests.rb

@@ -6,9 +6,9 @@ require "assert/context/setup_dsl"
 module Assert::Context::SetupDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SetupDSL"
-    subject { Factory.modes_off_context_class }
+    subject{ Factory.modes_off_context_class }
 
-    let(:block1) { ::Proc.new {} }
+    let(:block1){ ::Proc.new{} }
   end
 
   class SetupTeardownOnceMethodsTests < UnitTests
@@ -38,7 +38,7 @@ module Assert::Context::SetupDSL
   class SetupTeardownWithMethodNameTests < UnitTests
     desc "methods given a method name"
 
-    let(:method_name1) { :something_amazing }
+    let(:method_name1){ :something_amazing }
 
     should "add the method name to the context" do
       subject.setup(method_name1)
@@ -50,20 +50,28 @@ module Assert::Context::SetupDSL
   end
 
   class ParentContextClassTests < UnitTests
-    subject { Factory.modes_off_context_class(parent_class1) }
+    subject{ Factory.modes_off_context_class(parent_class1) }
 
-    let(:parent_class1)  { Factory.modes_off_context_class }
+    let(:parent_class1){ Factory.modes_off_context_class }
   end
 
   class SetupTeardownMultipleTests < ParentContextClassTests
     desc "with multiple calls"
 
-    let(:parent_setup_block1)     { ::Proc.new { self.setup_status     = "the setup"     } }
-    let(:parent_teardown_block1)  { ::Proc.new { self.teardown_status += "the teardown"  } }
-    let(:context_setup_block1)    { ::Proc.new { self.setup_status    += " has been run" } }
-    let(:context_teardown_block1) { ::Proc.new { self.teardown_status += "has been run " } }
+    let(:parent_setup_block1) do
+      ::Proc.new{ self.setup_status = "the setup" }
+    end
+    let(:parent_teardown_block1) do
+      ::Proc.new{ self.teardown_status += "the teardown" }
+    end
+    let(:context_setup_block1) do
+      ::Proc.new{ self.setup_status += " has been run" }
+    end
+    let(:context_teardown_block1) do
+      ::Proc.new{ self.teardown_status += "has been run " }
+    end
 
-    let(:test_status_class) {
+    let(:test_status_class) do
       Class.new do
         attr_accessor :setup_status, :teardown_status
         define_method(:setup_something) do
@@ -73,7 +81,7 @@ module Assert::Context::SetupDSL
           self.teardown_status = "with something "
         end
       end
-    }
+    end
 
     should "run its parent and its own blocks in the correct order" do
       parent_class1.setup(&parent_setup_block1)
@@ -84,17 +92,19 @@ module Assert::Context::SetupDSL
       subject.teardown(&context_teardown_block1)
 
       subject.send("run_setups", obj = test_status_class.new)
-      assert_that(obj.setup_status).equals("the setup has been run with something")
+      assert_that(obj.setup_status)
+        .equals("the setup has been run with something")
 
       subject.send("run_teardowns", obj = test_status_class.new)
-      assert_that(obj.teardown_status).equals("with something has been run the teardown")
+      assert_that(obj.teardown_status)
+        .equals("with something has been run the teardown")
     end
   end
 
   class AroundMethodTests < ParentContextClassTests
     desc "with multiple `around` calls"
 
-    let(:test_status_class) { Class.new { attr_accessor :out_status } }
+    let(:test_status_class){ Class.new{ attr_accessor :out_status } }
 
     should "run its parent and its own blocks in the correct order" do
       parent_class1.around do |block|

data/test/unit/context/subject_dsl_tests.rb

@@ -6,10 +6,10 @@ require "assert/context/subject_dsl"
 module Assert::Context::SubjectDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SubjectDSL"
-    subject { Factory.modes_off_context_class(parent_class1) }
+    subject{ Factory.modes_off_context_class(parent_class1) }
 
-    let(:parent_class1)  { Factory.modes_off_context_class }
-    let(:subject_block1) { Proc.new {} }
+    let(:parent_class1){ Factory.modes_off_context_class }
+    let(:subject_block1){ Proc.new{} }
   end
 
   class DescriptionTests < UnitTests

data/test/unit/context/suite_dsl_tests.rb

@@ -8,10 +8,10 @@ require "assert/suite"
 module Assert::Context::SuiteDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SuiteDSL"
-    subject { Factory.context_class(parent_class1) }
+    subject{ Factory.context_class(parent_class1) }
 
-    let(:parent_class1)  { Factory.context_class }
-    let(:custom_suite1)  { Factory.modes_off_suite }
+    let(:parent_class1){ Factory.context_class }
+    let(:custom_suite1){ Factory.modes_off_suite }
 
     should "use `Assert.suite` by default" do
       assert_that(subject.suite).equals(Assert.suite)
@@ -30,7 +30,7 @@ module Assert::Context::SuiteDSL
       parent_class1.suite(custom_suite1)
     end
 
-    let(:custom_suite2) { Factory.modes_off_suite }
+    let(:custom_suite2){ Factory.modes_off_suite }
 
     should "default to its parent's suite" do
       assert_that(subject.suite).equals(custom_suite1)

data/test/unit/context/test_dsl_tests.rb

@@ -7,8 +7,8 @@ module Assert::Context::TestDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::TestDSL"
 
-    let(:test_desc1)  { "be true" }
-    let(:test_block1) { Proc.new{ assert(true) } }
+    let(:test_desc1){ "be true" }
+    let(:test_block1){ Proc.new{ assert(true) } }
 
     should "build a test using `test` with a desc and code block" do
       d, b = test_desc1, test_block1
@@ -32,7 +32,8 @@ module Assert::Context::TestDSL
       assert_that(test.code).equals(test_block1)
     end
 
-    should "build a test that skips with no msg when `test_eventually` called" do
+    should "build a test that skips with no msg when `test_eventually` "\
+           "called" do
       d, b = test_desc1, test_block1
       context, test = build_eval_context{ test_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
@@ -44,7 +45,8 @@ module Assert::Context::TestDSL
       assert_that(err.backtrace.size).equals(1)
     end
 
-    should "build a test that skips with no msg  when `should_eventually` called" do
+    should "build a test that skips with no msg  when `should_eventually` "\
+           "called" do
       d, b = test_desc1, test_block1
       context, test = build_eval_context{ should_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
@@ -58,7 +60,7 @@ module Assert::Context::TestDSL
 
     should "skip with the msg \"TODO\" when `test` called with no block" do
       d = test_desc1
-      context, test = 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(&test.code)
       end
@@ -70,7 +72,7 @@ module Assert::Context::TestDSL
 
     should "skip with the msg \"TODO\" when `should` called with no block" do
       d = test_desc1
-      context, test = 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(&test.code)
       end
@@ -80,7 +82,8 @@ module Assert::Context::TestDSL
       assert_that(err.backtrace.size).equals(1)
     end
 
-    should "skip with the msg \"TODO\" when `test_eventually` called with no block" do
+    should "skip with the msg \"TODO\" when `test_eventually` called with "\
+           "no block" do
       d = test_desc1
       context, test = build_eval_context{ test_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
@@ -92,9 +95,10 @@ module Assert::Context::TestDSL
       assert_that(err.backtrace.size).equals(1)
     end
 
-    should "skip with the msg \"TODO\" when `should_eventually` called with no block" do
+    should "skip with the msg \"TODO\" when `should_eventually` called with "\
+           "no block" do
       d = test_desc1
-      context, test = build_eval_context{ should_eventually(d) } # no block given
+      context, test = build_eval_context{ should_eventually(d) }
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
@@ -106,7 +110,11 @@ module Assert::Context::TestDSL
 
     should "build a test from a macro using `test`" do
       d, b = test_desc1, test_block1
-      m = Assert::Macro.new{ test(d, &b); test(d, &b) }
+      m =
+        Assert::Macro.new do
+          test(d, &b)
+          test(d, &b)
+        end
       context_class = Factory.modes_off_context_class{ test(m) }
 
       assert_that(context_class.suite.tests_to_run_count).equals(2)
@@ -114,7 +122,11 @@ module Assert::Context::TestDSL
 
     should "build a test from a macro using `should`" do
       d, b = test_desc1, test_block1
-      m = Assert::Macro.new{ should(d, &b); should(d, &b) }
+      m =
+        Assert::Macro.new do
+          should(d, &b)
+          should(d, &b)
+        end
       context_class = Factory.modes_off_context_class{ should(m) }
 
       assert_that(context_class.suite.tests_to_run_count).equals(2)
@@ -122,22 +134,30 @@ module Assert::Context::TestDSL
 
     should "build a test that skips from a macro using `test_eventually`" do
       d, b = test_desc1, test_block1
-      m = Assert::Macro.new{ test(d, &b); test(d, &b) }
+      m =
+        Assert::Macro.new do
+          test(d, &b)
+          test(d, &b)
+        end
       context, test = build_eval_context{ test_eventually(m) }
 
       assert_that(context.class.suite.tests_to_run_count).equals(1)
-      assert_that {
+      assert_that{
         context.instance_eval(&test.code)
       }.raises(Assert::Result::TestSkipped)
     end
 
     should "build a test that skips from a macro using `should_eventually`" do
       d, b = test_desc1, test_block1
-      m = Assert::Macro.new{ should(d, &b); should(d, &b) }
+      m =
+        Assert::Macro.new do
+          should(d, &b)
+          should(d, &b)
+        end
       context, test = build_eval_context{ should_eventually(m) }
 
       assert_that(context.class.suite.tests_to_run_count).equals(1)
-      assert_that {
+      assert_that{
         context.instance_eval(&test.code)
       }.raises(Assert::Result::TestSkipped)
     end
@@ -153,8 +173,8 @@ module Assert::Context::TestDSL
     def capture_err(err_class, &block)
       begin
         block.call
-      rescue err_class => e
-        e
+      rescue err_class => ex
+        ex
       end
     end
   end

data/test/unit/context_info_tests.rb

@@ -8,20 +8,20 @@ require "assert/context"
 class Assert::ContextInfo
   class UnitTests < Assert::Context
     desc "Assert::ContextInfo"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::ContextInfo }
+    let(:unit_class){ Assert::ContextInfo }
   end
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new(context1, nil, @caller.first) }
+    subject{ unit_class.new(context1, nil, @caller.first) }
 
     setup do
       @caller = caller
     end
 
-    let(:context1) { Assert::Context }
+    let(:context1){ Assert::Context }
 
     should have_readers :called_from, :klass, :file
     should have_imeths :test_name

data/test/unit/context_tests.rb

@@ -10,9 +10,9 @@ require "assert/utils"
 class Assert::Context
   class UnitTests < Assert::Context
     desc "Assert::Context"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Context }
+    let(:unit_class){ Assert::Context }
 
     # DSL methods
     should have_imeths :description, :desc, :describe, :subject, :suite, :let
@@ -27,20 +27,23 @@ class Assert::Context
 
   class InitTests < UnitTests
     desc "when init"
-    subject { context_class1.new(test1, test1.config, result_callback1) }
+    subject{ context_class1.new(test1, test1.config, result_callback1) }
 
     setup do
       @callback_result = nil
     end
 
-    let(:test1)            { Factory.test }
-    let(:context_class1)   { test1.context_class }
-    let(:test_results1)    { [] }
-    let(:result_callback1) {
-      proc { |result| @callback_result = result; test_results1 << result }
-    }
-    let(:halt_config1) { Assert::Config.new(:halt_on_fail => true) }
-    let(:msg1) { Factory.string }
+    let(:test1){ Factory.test }
+    let(:context_class1){ test1.context_class }
+    let(:test_results1){ [] }
+    let(:result_callback1) do
+      proc do |result|
+        @callback_result = result
+        test_results1 << result
+      end
+    end
+    let(:halt_config1){ Assert::Config.new(halt_on_fail: true) }
+    let(:msg1){ Factory.string }
 
     should have_imeths :assert, :assert_not, :refute, :assert_that
     should have_imeths :pass, :ignore, :fail, :flunk, :skip
@@ -48,7 +51,8 @@ class Assert::Context
 
     should "collect context info" do
       test = @__assert_running_test__
-      assert_that(test.context_info.file).matches(/test\/unit\/context_tests.rb$/)
+      assert_that(test.context_info.file)
+        .matches(%r{test/unit/context_tests.rb$})
       assert_that(test.context_info.klass).equals(self.class)
     end
 
@@ -60,7 +64,9 @@ class Assert::Context
       with_backtrace(caller) do
         assert_that(result.with_bt_set?).is_true
 
-        exp = Assert::Result::Backtrace.to_s(exp_with_bt+[(result.backtrace.filtered.first)])
+        exp =
+          Assert::Result::Backtrace.to_s(exp_with_bt +
+          [(result.backtrace.filtered.first)])
         assert_that(result.trace).equals(exp)
         assert_that(result.src_line).equals(exp_with_bt.first)
       end
@@ -71,7 +77,8 @@ class Assert::Context
         assert_that(result.with_bt_set?).is_false
 
         assert_that(result.trace).equals(result.src_line)
-        assert_that(result.src_line).equals(result.backtrace.filtered.first.to_s)
+        assert_that(result.src_line)
+          .equals(result.backtrace.filtered.first.to_s)
       end
     end
   end
@@ -80,7 +87,12 @@ class Assert::Context
     desc "skip method"
 
     setup do
-      begin; subject.skip(msg1); rescue StandardError => @exception; end
+      @exception =
+        begin
+          subject.skip(msg1)
+        rescue => ex
+          ex
+        end
       @result = Factory.skip_result(@exception)
     end
 
@@ -98,7 +110,12 @@ class Assert::Context
       assert_that(@exception.backtrace.size).does_not_equal(1)
 
       called_from = Factory.string
-      begin; subject.skip(msg1, called_from); rescue StandardError => exception; end
+      exception =
+        begin
+          subject.skip(msg1, called_from)
+        rescue => ex
+          ex
+        end
       assert_that(exception.backtrace.size).equals(1)
       assert_that(exception.backtrace.first).equals(called_from)
     end
@@ -180,14 +197,20 @@ class Assert::Context
 
   class HaltOnFailTests < InitTests
     desc "failing when halting on fails"
-    subject { context_class1.new(test1, halt_config1, result_callback1) }
+    subject{ context_class1.new(test1, halt_config1, result_callback1) }
 
     should "raise an exception with the failure's message" do
-      begin; subject.fail(msg1); rescue StandardError => err; end
-      assert_that(err).is_kind_of(Assert::Result::TestFailure)
-      assert_that(err.message).equals(msg1)
-
-      result = Assert::Result::Fail.for_test(Factory.test("something"), err)
+      exception =
+        begin
+          subject.fail(msg1)
+        rescue => ex
+          ex
+        end
+      assert_that(exception).is_kind_of(Assert::Result::TestFailure)
+      assert_that(exception.message).equals(msg1)
+
+      result =
+        Assert::Result::Fail.for_test(Factory.test("something"), exception)
       assert_that(result.message).equals(msg1)
     end
 
@@ -199,7 +222,7 @@ class Assert::Context
   class AssertTests < InitTests
     desc "assert method"
 
-    let(:what_failed) { Factory.string }
+    let(:what_failed){ Factory.string }
 
     should "return a pass result given a `true` assertion" do
       result = subject.assert(true, msg1){ what_failed }
@@ -213,7 +236,8 @@ class Assert::Context
     end
 
     should "pp the assertion value in the fail message by default" do
-      exp_def_what = "Failed assert: assertion was `#{Assert::U.show(false, test1.config)}`."
+      exp_def_what =
+        "Failed assert: assertion was `#{Assert::U.show(false, test1.config)}`."
       result = subject.assert(false, msg1)
 
       assert_that(result.message).equals([msg1, exp_def_what].join("\n"))
@@ -248,7 +272,9 @@ class Assert::Context
     end
 
     should "pp the assertion value in the fail message by default" do
-      exp_def_what = "Failed assert_not: assertion was `#{Assert::U.show(true, test1.config)}`."
+      exp_def_what =
+        "Failed assert_not: "\
+        "assertion was `#{Assert::U.show(true, test1.config)}`."
       result = subject.assert_not(true, msg1)
 
       assert_that(result.message).equals([msg1, exp_def_what].join("\n"))
@@ -267,32 +293,32 @@ class Assert::Context
     desc "`assert_that` method"
 
     setup do
-      Assert.stub_tap_on_call(Assert::ActualValue, :new) { |_, call|
+      Assert.stub_tap_on_call(Assert::ActualValue, :new) do |_, call|
         @actual_value_new_call = call
-      }
+      end
     end
 
-    let(:actual_value) { Factory.string }
+    let(:actual_value){ Factory.string }
 
     should "build an Assert::ActualValue" do
       assert_instance_of Assert::ActualValue, subject.assert_that(actual_value)
       assert_equal [actual_value], @actual_value_new_call.pargs
-      assert_equal({ context: subject },  @actual_value_new_call.kargs)
+      assert_equal({ context: subject }, @actual_value_new_call.kargs)
     end
   end
 
   class SubjectTests < InitTests
     desc "subject method"
-    subject { context_class1.new(test1, test1.config, proc{ |result| }) }
+    subject{ context_class1.new(test1, test1.config, proc{ |result| }) }
 
     setup do
       expected = expected1
-      context_class1.subject { @something = expected }
+      context_class1.subject{ @something = expected }
       @subject = subject.subject
     end
 
-    let(:context_class1) { Factory.modes_off_context_class }
-    let(:expected1) { Factory.string }
+    let(:context_class1){ Factory.modes_off_context_class }
+    let(:expected1){ Factory.string }
 
     should "instance evaluate the block set with the class setup method" do
       assert_that(@subject).equals(expected1)
@@ -302,8 +328,17 @@ class Assert::Context
   class PendingTests < InitTests
     desc "`pending` method"
 
-    let(:block2) { proc { fail; pass; } }
-    let(:block1) { block = block2; proc { pending(&block) } } # test nesting
+    let(:block2) do
+      proc do
+        fail # rubocop:disable Style/SignalException
+        pass # rubocop:disable Lint/UnreachableCode
+      end
+    end
+    # test nesting
+    let(:block1) do
+      block = block2
+      proc{ pending(&block) }
+    end
 
     should "make fails skips and make passes fails" do
       subject.fail "not affected"
@@ -326,29 +361,42 @@ class Assert::Context
 
   class PendingWithHaltOnFailTests < PendingTests
     desc "when halting on fails"
-    subject { context_class1.new(test1, halt_config1, result_callback1) }
+    subject{ context_class1.new(test1, halt_config1, result_callback1) }
 
     should "make fails skips and stop the test" do
-      begin; subject.pending(&block1); rescue StandardError => err; end
-      assert_that(err).is_kind_of(Assert::Result::TestSkipped)
-      assert_that(err.message).includes("Pending fail")
-
-      assert_that(test_results1.size).equals(0) # it halted before the pending pass
+      exception =
+        begin
+          subject.pending(&block1)
+        rescue => ex
+          ex
+        end
+      assert_that(exception).is_kind_of(Assert::Result::TestSkipped)
+      assert_that(exception.message).includes("Pending fail")
+
+      # it halted before the pending pass
+      assert_that(test_results1.size).equals(0)
     end
   end
 
   class WithBacktraceTests < InitTests
     desc "`with_backtrace` method"
 
-    let(:from_bt1)    { ["called_from_here", Factory.string] }
-    let(:from_block1) { proc { ignore; fail; pass; skip "todo"; } }
+    let(:from_bt1){ ["called_from_here", Factory.string] }
+    let(:from_block1) do
+      proc do
+        ignore
+        fail # rubocop:disable Style/SignalException
+        pass # rubocop:disable Lint/UnreachableCode
+        skip "todo"
+      end
+    end
 
     should "alter non-error block results' bt with given bt's first line" do
       subject.fail "not affected"
       begin
         subject.with_backtrace(from_bt1, &from_block1)
-      rescue Assert::Result::TestSkipped => e
-        test_results1 << Assert::Result::Skip.for_test(test1, e)
+      rescue Assert::Result::TestSkipped => ex
+        test_results1 << Assert::Result::Skip.for_test(test1, ex)
       end
 
       assert_that(test_results1.size).equals(5)
@@ -367,21 +415,29 @@ class Assert::Context
   class WithNestedBacktraceTests < InitTests
     desc "`with_backtrace` method nested"
 
-    let(:from_bt1)    { ["called_from_here 1", Factory.string] }
-    let(:from_bt2)    { ["called_from_here 2", Factory.string] }
-    let(:from_block2) { proc { ignore; fail; pass; skip "todo"; } }
-    let(:from_block1) {
+    let(:from_bt1){ ["called_from_here 1", Factory.string] }
+    let(:from_bt2){ ["called_from_here 2", Factory.string] }
+    let(:from_block2) do
+      proc do
+        ignore
+        fail # rubocop:disable Style/SignalException
+        pass # rubocop:disable Lint/UnreachableCode
+        skip "todo"
+      end
+    end
+    let(:from_block1) do
       from_bt    = from_bt2
       from_block = from_block2
-      proc { with_backtrace(from_bt, &from_block) }
-    }
+      proc{ with_backtrace(from_bt, &from_block) }
+    end
 
-    should "alter non-error block results' bt with nested wbt accrued first lines" do
+    should "alter non-error block results' bt with nested wbt accrued "\
+           "first lines" do
       subject.fail "not affected"
       begin
         subject.with_backtrace(from_bt1, &from_block1)
-      rescue Assert::Result::TestSkipped => e
-        test_results1 << Assert::Result::Skip.for_test(test1, e)
+      rescue Assert::Result::TestSkipped => ex
+        test_results1 << Assert::Result::Skip.for_test(test1, ex)
       end
 
       assert_that(test_results1.size).equals(5)