assert 2.19.1 → 2.19.6

data/test/unit/assertions/assert_file_exists_tests.rb

@@ -6,22 +6,21 @@ require "assert/assertions"
 require "assert/utils"
 
 module Assert::Assertions
-
   class AssertFileExistsTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "`assert_file_exists`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_file_exists(__FILE__) # pass
         assert_file_exists(*args)    # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert file exists fail desc" }
-    let(:args1) { ["/a/path/to/some/file/that/no/exists", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert file exists fail desc" }
+    let(:args1){ ["/a/path/to/some/file/that/no/exists", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -30,7 +29,8 @@ 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 exist."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to exist."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -39,17 +39,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_file_exists`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_file_exists("/file/path") # pass
         assert_not_file_exists(*args)        # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert not file exists fail desc" }
-    let(:args1) { [__FILE__, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not file exists fail desc" }
+    let(:args1){ [__FILE__, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -58,7 +58,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 exist."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "not exist."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end

data/test/unit/assertions/assert_includes_tests.rb

@@ -10,17 +10,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_includes`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_includes(1, [1]) # pass
         assert_includes(*args)  # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert includes fail desc" }
-    let(:args1) { [2, [1], desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert includes fail desc" }
+    let(:args1){ [2, [1], desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -41,17 +41,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_included`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_included(2, [1]) # pass
         assert_not_included(*args)  # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert not included fail desc" }
-    let(:args1) { [1, [1], desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not included fail desc" }
+    let(:args1){ [1, [1], desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)

data/test/unit/assertions/assert_instance_of_tests.rb

@@ -10,17 +10,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_instance_of`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_instance_of(String, "object") # pass
         assert_instance_of(*args)            # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert instance of fail desc" }
-    let(:args1) { [Array, "object", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert instance of fail desc" }
+    let(:args1){ [Array, "object", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -30,8 +30,8 @@ module Assert::Assertions
       assert_that(test_run_result_count(:fail)).equals(1)
 
       exp =
-        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)} (#{args1[1].class})"\
-        " to be an instance of #{args1[0]}."
+        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)} "\
+        "(#{args1[1].class}) to be an instance of #{args1[0]}."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -40,17 +40,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_instance_of`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_instance_of(*args)           # fail
         assert_not_instance_of(Array, "object") # pass
       end
-    }
+    end
 
-    let(:desc1) { "assert not instance of fail desc" }
-    let(:args1) { [String, "object", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not instance of fail desc" }
+    let(:args1){ [String, "object", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -60,8 +60,8 @@ module Assert::Assertions
       assert_that(test_run_result_count(:fail)).equals(1)
 
       exp =
-        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)} (#{args1[1].class})"\
-        " to not be an instance of #{args1[0]}."
+        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)} "\
+        "(#{args1[1].class}) to not be an instance of #{args1[0]}."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end

data/test/unit/assertions/assert_is_a_tests.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "assert"
+require "assert/assertions"
+
+require "assert/utils"
+
+module Assert::Assertions
+  class AssertIsATests < Assert::Context
+    include Assert::Test::TestHelpers
+
+    desc "`assert_is_a`"
+    subject do
+      args = args1
+      Factory.test do
+        assert_is_a(String, "object") # pass
+        assert_is_a(*args)            # fail
+      end
+    end
+
+    let(:desc1){ "assert kind of fail desc" }
+    let(:args1){ [Array, "object", desc1] }
+    let(:config1){ subject.config }
+
+    should "produce results as expected" do
+      subject.run(&test_run_callback)
+
+      assert_that(test_run_result_count).equals(2)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(1)
+
+      exp =
+        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)} "\
+        "(#{args1[1].class}) to be a `#{args1[0]}`."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
+  end
+
+  class AssertIsNotATests < Assert::Context
+    include Assert::Test::TestHelpers
+
+    desc "`assert_not_kind_of`"
+    subject do
+      args = args1
+      Factory.test do
+        assert_is_not_a(*args)           # fail
+        assert_is_not_a(Array, "object") # pass
+      end
+    end
+
+    let(:desc1){ "assert not kind of fail desc" }
+    let(:args1){ [String, "object", desc1] }
+    let(:config1){ subject.config }
+
+    should "produce results as expected" do
+      subject.run(&test_run_callback)
+
+      assert_that(test_run_result_count).equals(2)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(1)
+
+      exp =
+        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)} "\
+        "(#{args1[1].class}) to not be a `#{args1[0]}`."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
+  end
+
+  class AssertKindOfTests < Assert::Context
+    include Assert::Test::TestHelpers
+
+    desc "`assert_kind_of`"
+    subject do
+      args = args1
+      Factory.test do
+        assert_kind_of(String, "object") # pass
+        assert_kind_of(*args)            # fail
+      end
+    end
+
+    let(:desc1){ "assert kind of fail desc" }
+    let(:args1){ [Array, "object", desc1] }
+    let(:config1){ subject.config }
+
+    should "produce results as expected" do
+      subject.run(&test_run_callback)
+
+      assert_that(test_run_result_count).equals(2)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(1)
+
+      exp =
+        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)} "\
+        "(#{args1[1].class}) to be a `#{args1[0]}`."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
+  end
+
+  class AssertNotKindOfTests < Assert::Context
+    include Assert::Test::TestHelpers
+
+    desc "`assert_not_kind_of`"
+    subject do
+      args = args1
+      Factory.test do
+        assert_not_kind_of(*args)           # fail
+        assert_not_kind_of(Array, "object") # pass
+      end
+    end
+
+    let(:desc1){ "assert not kind of fail desc" }
+    let(:args1){ [String, "object", desc1] }
+    let(:config1){ subject.config }
+
+    should "produce results as expected" do
+      subject.run(&test_run_callback)
+
+      assert_that(test_run_result_count).equals(2)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(1)
+
+      exp =
+        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)} "\
+        "(#{args1[1].class}) to not be a `#{args1[0]}`."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
+  end
+end

data/test/unit/assertions/assert_match_tests.rb

@@ -10,17 +10,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_match`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_match(/a/, "a string") # pass
         assert_match(*args)           # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert match fail desc" }
-    let(:args1) { ["not", "a string", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert match fail desc" }
+    let(:args1){ ["not", "a string", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -40,17 +40,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_match`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_match(*args)             # fail
         assert_not_match("not", "a string") # pass
       end
-    }
+    end
 
-    let(:desc1) { "assert not match fail desc" }
-    let(:args1) { [/a/, "a string", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not match fail desc" }
+    let(:args1){ [/a/, "a string", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)

data/test/unit/assertions/assert_nil_tests.rb

@@ -10,17 +10,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_nil`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_nil(nil)   # pass
         assert_nil(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert nil empty fail desc" }
-    let(:args1) { [1, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert nil empty fail desc" }
+    let(:args1){ [1, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -29,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 nil."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "be nil."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -38,17 +40,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_nil`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_nil(1)     # pass
         assert_not_nil(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert not nil empty fail desc" }
-    let(:args1) { [nil, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not nil empty fail desc" }
+    let(:args1){ [nil, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -57,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 nil."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "not be nil."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end

data/test/unit/assertions/assert_raises_tests.rb

@@ -8,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)
@@ -36,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
@@ -45,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
 
@@ -53,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
@@ -64,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)
@@ -85,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