assert 2.19.0 → 2.19.5

data/test/unit/assertions/assert_raises_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/assertions"
 
@@ -6,18 +8,18 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_raises`"
-    subject {
+    subject do
       desc = desc1
       Factory.test do
-        assert_raises(StandardError, RuntimeError) { raise(StandardError) }    # pass
-        assert_raises(StandardError, RuntimeError, desc) { raise(Exception) }  # fail
-        assert_raises(RuntimeError, desc) { raise(StandardError) }             # fail
-        assert_raises(RuntimeError, desc) { true }                             # fail
-        assert_raises(desc) { true }                                           # fail
+        assert_raises(StandardError, RuntimeError){ raise(StandardError) }
+        assert_raises(StandardError, RuntimeError, desc){ raise(Exception) }
+        assert_raises(RuntimeError, desc){ raise(StandardError) }
+        assert_raises(RuntimeError, desc){ true }
+        assert_raises(desc){ true }
       end
-    }
+    end
 
-    let(:desc1) { "assert raises fail desc" }
+    let(:desc1){ "assert raises fail desc" }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -34,7 +36,9 @@ module Assert::Assertions
           "#{desc1}\nAn exception expected but nothing raised.",
         ]
       messages = test_run_results(:fail).map(&:message)
-      messages.each_with_index{ |msg, n| assert_that(msg).matches(/^#{exp[n]}/) }
+      messages.each_with_index do |msg, n|
+        assert_that(msg).matches(/^#{exp[n]}/)
+      end
     end
 
     should "return any raised exception instance" do
@@ -43,7 +47,7 @@ module Assert::Assertions
 
       test =
         Factory.test do
-          error = assert_raises(RuntimeError) { raise(RuntimeError, error_msg) }
+          error = assert_raises(RuntimeError){ raise(error_msg) }
         end
       test.run
 
@@ -51,7 +55,7 @@ module Assert::Assertions
       assert_that(error).is_kind_of(RuntimeError)
       assert_that(error.message).equals(error_msg)
 
-      test = Factory.test { error = assert_raises(RuntimeError) {} }
+      test = Factory.test{ error = assert_raises(RuntimeError){} }
       test.run
 
       assert_that(error).is_nil
@@ -62,17 +66,19 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_nothing_raised`"
-    subject {
+    subject do
       desc = desc1
       Factory.test do
-        assert_nothing_raised(StandardError, RuntimeError, desc) { raise(StandardError) } # fail
-        assert_nothing_raised(RuntimeError) { raise(StandardError) }                      # pass
-        assert_nothing_raised(desc) { raise(RuntimeError) }                               # fail
-        assert_nothing_raised { true }                                                    # pass
+        assert_nothing_raised(StandardError, RuntimeError, desc) do
+          raise(StandardError)
+        end
+        assert_nothing_raised(RuntimeError){ raise(StandardError) }
+        assert_nothing_raised(desc){ raise(RuntimeError) }
+        assert_nothing_raised{ true }
       end
-    }
+    end
 
-    let(:desc1) { "assert nothing raised fail desc" }
+    let(:desc1){ "assert nothing raised fail desc" }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -83,11 +89,14 @@ module Assert::Assertions
 
       exp =
         [
-          "#{desc1}\nStandardError or RuntimeError exception not expected, but raised:",
+          "#{desc1}\nStandardError or RuntimeError exception not expected, "\
+          "but raised:",
           "#{desc1}\nAn exception not expected, but raised:",
         ]
       messages = test_run_results(:fail).map(&:message)
-      messages.each_with_index{ |msg, n| assert_that(msg).matches(/^#{exp[n]}/) }
+      messages.each_with_index do |msg, n|
+        assert_that(msg).matches(/^#{exp[n]}/)
+      end
     end
   end
 end

data/test/unit/assertions/assert_respond_to_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/assertions"
 
@@ -8,17 +10,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_respond_to`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_respond_to(:abs, 1) # pass
         assert_respond_to(*args)   # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert respond to fail desc" }
-    let(:args1) { [:abs, "1", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert respond to fail desc" }
+    let(:args1){ [:abs, "1", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -39,17 +41,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_respond_to`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_respond_to(*args)     # fail
         assert_not_respond_to(:abs, "1") # pass
       end
-    }
+    end
 
-    let(:desc1) { "assert not respond to fail desc" }
-    let(:args1) { [:abs, 1, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not respond to fail desc" }
+    let(:args1){ [:abs, 1, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)

data/test/unit/assertions/assert_same_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/assertions"
 
@@ -8,20 +10,20 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_same`"
-    subject {
+    subject do
       args   = args1
       object = object1
       Factory.test do
         assert_same(object, object) # pass
         assert_same(*args)          # fail
       end
-    }
+    end
 
-    let(:class1) { Class.new }
-    let(:object1) { class1.new }
-    let(:desc1) { "assert same fail desc" }
-    let(:args1) { [object1, class1.new, desc1] }
-    let(:config1) { subject.config }
+    let(:class1){ Class.new }
+    let(:object1){ class1.new }
+    let(:desc1){ "assert same fail desc" }
+    let(:args1){ [object1, class1.new, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -44,7 +46,7 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_same`"
-    subject {
+    subject do
       args   = args1
       object = object1
       klass  = class1
@@ -52,13 +54,13 @@ module Assert::Assertions
         assert_not_same(*args)             # fail
         assert_not_same(object, klass.new) # pass
       end
-    }
+    end
 
-    let(:class1) { Class.new }
-    let(:object1) { class1.new }
-    let(:desc1) { "assert not same fail desc" }
-    let(:args1) { [object1, object1, desc1] }
-    let(:config1) { subject.config }
+    let(:class1){ Class.new }
+    let(:object1){ class1.new }
+    let(:desc1){ "assert not same fail desc" }
+    let(:args1){ [object1, object1, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -81,27 +83,27 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "with objects that should use diff when showing"
-    let(:config1) {
+    let(:config1) do
       Factory.modes_off_config.tap do |config|
         config.use_diff_proc(Assert::U.default_use_diff_proc)
         config.run_diff_proc(Assert::U.syscmd_diff_proc)
       end
-    }
+    end
 
-    let(:exp_obj1) { "I'm a\nstring" }
-    let(:act_obj1) { "I am a \nstring" }
-    let(:exp_obj_show1) { Assert::U.show_for_diff(exp_obj1, config1) }
-    let(:act_obj_show1) { Assert::U.show_for_diff(act_obj1, config1) }
+    let(:exp_obj1){ "I'm a\nstring" }
+    let(:act_obj1){ "I am a \nstring" }
+    let(:exp_obj_show1){ Assert::U.show_for_diff(exp_obj1, config1) }
+    let(:act_obj_show1){ Assert::U.show_for_diff(act_obj1, config1) }
   end
 
   class AssertSameDiffTests < DiffTests
     desc "`assert_same`"
-    subject {
+    subject do
       exp_obj, act_obj = exp_obj1, act_obj1
       Factory.test(config1) do
         assert_same(exp_obj, act_obj)
       end
-    }
+    end
 
     should "include diff output in the fail messages" do
       subject.run(&test_run_callback)
@@ -118,12 +120,12 @@ module Assert::Assertions
 
   class AssertNotSameDiffTests < DiffTests
     desc "`assert_not_same`"
-    subject {
+    subject do
       act_obj = act_obj1
       Factory.test(config1) do
         assert_not_same(act_obj, act_obj)
       end
-    }
+    end
 
     should "include diff output in the fail messages" do
       subject.run(&test_run_callback)

data/test/unit/assertions/assert_true_false_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/assertions"
 
@@ -8,17 +10,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_true`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_true(true)  # pass
         assert_true(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert true fail desc" }
-    let(:args1) { ["whatever", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert true fail desc" }
+    let(:args1){ ["whatever", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -27,7 +29,9 @@ module Assert::Assertions
       assert_that(test_run_result_count(:pass)).equals(1)
       assert_that(test_run_result_count(:fail)).equals(1)
 
-      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be true."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "be true."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -36,17 +40,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_true`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_true(false) # pass
         assert_not_true(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert not true fail desc" }
-    let(:args1) { [true, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not true fail desc" }
+    let(:args1){ [true, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -55,7 +59,9 @@ module Assert::Assertions
       assert_that(test_run_result_count(:pass)).equals(1)
       assert_that(test_run_result_count(:fail)).equals(1)
 
-      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be true."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "not be true."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -64,17 +70,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_false`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_false(false) # pass
         assert_false(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert false fail desc" }
-    let(:args1) { ["whatever", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert false fail desc" }
+    let(:args1){ ["whatever", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -83,7 +89,9 @@ module Assert::Assertions
       assert_that(test_run_result_count(:pass)).equals(1)
       assert_that(test_run_result_count(:fail)).equals(1)
 
-      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be false."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "be false."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -92,17 +100,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_false`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_false(true)  # pass
         assert_not_false(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert not false fail desc" }
-    let(:args1) { [false, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not false fail desc" }
+    let(:args1){ [false, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -111,7 +119,9 @@ module Assert::Assertions
       assert_that(test_run_result_count(:pass)).equals(1)
       assert_that(test_run_result_count(:fail)).equals(1)
 
-      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be false."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "not be false."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end

data/test/unit/assertions_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/assertions"
 
@@ -6,21 +8,26 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "Assert::Context"
-    subject { context_class1.new(test1, test1.config, proc { |r| }) }
+    subject{ context_class1.new(test1, test1.config, proc{ |r| }) }
 
-    let(:context_class1) { Factory.modes_off_context_class }
-    let(:test1) { Factory.test }
+    let(:context_class1){ Factory.modes_off_context_class }
+    let(:test1){ Factory.test }
 
     should have_imeths :assert_block, :assert_not_block, :refute_block
     should have_imeths :assert_empty, :assert_not_empty, :refute_empty
     should have_imeths :assert_equal, :assert_not_equal, :refute_equal
-    should have_imeths :assert_file_exists, :assert_not_file_exists, :refute_file_exists
+    should have_imeths :assert_file_exists, :assert_not_file_exists
+    should have_imeths :refute_file_exists
     should have_imeths :assert_includes, :assert_not_includes
     should have_imeths :assert_included, :assert_not_included
     should have_imeths :refute_includes, :refute_included
-    should have_imeths :assert_instance_of, :assert_not_instance_of, :refute_instance_of
+    should have_imeths :assert_instance_of, :assert_not_instance_of
+    should have_imeths :refute_instance_of
+    should have_imeths :assert_is_a, :assert_is_not_a, :assert_not_a
+    should have_imeths :refute_is_a
     should have_imeths :assert_kind_of, :assert_not_kind_of, :refute_kind_of
-    should have_imeths :assert_match, :assert_not_match, :assert_no_match, :refute_match
+    should have_imeths :assert_match, :assert_not_match, :assert_no_match
+    should have_imeths :refute_match
     should have_imeths :assert_nil, :assert_not_nil, :refute_nil
     should have_imeths :assert_true, :assert_not_true, :refute_true
     should have_imeths :assert_false, :assert_not_false, :refute_false
@@ -39,14 +46,14 @@ module Assert::Assertions
       tests.each{ |test| test.run(&test_run_callback) }
     end
 
-    let(:tests) {
+    let(:tests) do
       context_info = Factory.context_info(context_class1)
       Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
         Factory.test("ignored assertion helper #{helper}", context_info) do
-          self.send(helper, "doesn't matter")
+          send(helper, "doesn't matter")
         end
       end
-    }
+    end
 
     should "have an ignored result for each helper in the constant" do
       exp = Assert::Assertions::IGNORED_ASSERTION_HELPERS.size