assert 2.18.0 → 2.19.0

data/test/unit/assertions/assert_kind_of_tests.rb

@@ -8,28 +8,29 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_kind_of`"
-    setup do
-      desc = @desc = "assert kind of fail desc"
-      args = @args = [Array, "object", desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_kind_of(String, "object") # pass
         assert_kind_of(*args)            # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert kind of fail desc" }
+    let(:args1) { [Array, "object", desc1] }
+    let(:config1) { subject.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[2]}\nExpected #{Assert::U.show(@args[1], @c)} (#{@args[1].class})"\
-            " to be a kind of #{@args[0]}."
-      assert_equal exp, test_run_results(:fail).first.message
+      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 kind of #{args1[0]}."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -37,29 +38,29 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_kind_of`"
-    setup do
-      desc = @desc = "assert not kind of fail desc"
-      args = @args = [String, "object", desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_not_kind_of(*args)           # fail
         assert_not_kind_of(Array, "object") # pass
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert not kind of fail desc" }
+    let(:args1) { [String, "object", desc1] }
+    let(:config1) { subject.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[2]}\nExpected #{Assert::U.show(@args[1], @c)} (#{@args[1].class})"\
-            " to not be a kind of #{@args[0]}."
-      assert_equal exp, test_run_results(:fail).first.message
+      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 kind of #{args1[0]}."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 end
-

data/test/unit/assertions/assert_match_tests.rb

@@ -8,28 +8,29 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_match`"
-    setup do
-      desc = @desc = "assert match fail desc"
-      args = @args = ["not", "a string", desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_match(/a/, "a string") # pass
         assert_match(*args)           # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert match fail desc" }
+    let(:args1) { ["not", "a string", desc1] }
+    let(:config1) { subject.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[2]}\nExpected #{Assert::U.show(@args[1], @c)}"\
-            " to match #{Assert::U.show(@args[0], @c)}."
-      assert_equal exp, test_run_results(:fail).first.message
+      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)}"\
+        " to match #{Assert::U.show(args1[0], config1)}."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -37,29 +38,29 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_match`"
-    setup do
-      desc = @desc = "assert not match fail desc"
-      args = @args = [/a/, "a string", desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_not_match(*args)             # fail
         assert_not_match("not", "a string") # pass
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert not match fail desc" }
+    let(:args1) { [/a/, "a string", desc1] }
+    let(:config1) { subject.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[2]}\nExpected #{Assert::U.show(@args[1], @c)}"\
-            " to not match #{Assert::U.show(@args[0], @c)}."
-      assert_equal exp, test_run_results(:fail).first.message
+      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)}"\
+        " to not match #{Assert::U.show(args1[0], config1)}."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 end
-

data/test/unit/assertions/assert_nil_tests.rb

@@ -8,27 +8,27 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_nil`"
-    setup do
-      desc = @desc = "assert nil empty fail desc"
-      args = @args = [1, desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_nil(nil)   # pass
         assert_nil(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert nil empty fail desc" }
+    let(:args1) { [1, desc1] }
+    let(:config1) { subject.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to be nil."
-      assert_equal exp, test_run_results(:fail).first.message
+      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[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be nil."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -36,28 +36,27 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_nil`"
-    setup do
-      desc = @desc = "assert not nil empty fail desc"
-      args = @args = [nil, desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_not_nil(1)     # pass
         assert_not_nil(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert not nil empty fail desc" }
+    let(:args1) { [nil, desc1] }
+    let(:config1) { subject.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to not be nil."
-      assert_equal exp, test_run_results(:fail).first.message
+      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[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be nil."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 end
-

data/test/unit/assertions/assert_raises_tests.rb

@@ -6,54 +6,55 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_raises`"
-    setup do
-      d = @d = "assert raises fail desc"
-      @test = Factory.test do
-        assert_raises(StandardError, RuntimeError){ raise(StandardError) } # pass
-        assert_raises(StandardError, RuntimeError, d){ raise(Exception) }  # fail
-        assert_raises(RuntimeError, d){ raise(StandardError) }             # fail
-        assert_raises(RuntimeError, d){ true }                             # fail
-        assert_raises(d){ true }                                           # fail
+    subject {
+      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
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert raises fail desc" }
 
     should "produce results as expected" do
-      assert_equal 5, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 4, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = [
-        "#{@d}\nStandardError or RuntimeError exception expected, not:",
-        "#{@d}\nRuntimeError exception expected, not:",
-        "#{@d}\nRuntimeError exception expected but nothing raised.",
-        "#{@d}\nAn exception expected but nothing raised."
-      ]
+      assert_that(test_run_result_count).equals(5)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(4)
+
+      exp =
+        [
+          "#{desc1}\nStandardError or RuntimeError exception expected, not:",
+          "#{desc1}\nRuntimeError exception expected, not:",
+          "#{desc1}\nRuntimeError exception expected but nothing raised.",
+          "#{desc1}\nAn exception expected but nothing raised.",
+        ]
       messages = test_run_results(:fail).map(&:message)
-      messages.each_with_index{ |msg, n| assert_match(/^#{exp[n]}/, msg) }
+      messages.each_with_index{ |msg, n| assert_that(msg).matches(/^#{exp[n]}/) }
     end
 
     should "return any raised exception instance" do
       error     = nil
       error_msg = Factory.string
-      test = Factory.test do
-        error = assert_raises(RuntimeError){ raise(RuntimeError, error_msg) }
-      end
+
+      test =
+        Factory.test do
+          error = assert_raises(RuntimeError) { raise(RuntimeError, error_msg) }
+        end
       test.run
 
-      assert_not_nil error
-      assert_kind_of RuntimeError, error
-      assert_equal error_msg, error.message
+      assert_that(error).is_not_nil
+      assert_that(error).is_kind_of(RuntimeError)
+      assert_that(error.message).equals(error_msg)
 
-      test = Factory.test do
-        error = assert_raises(RuntimeError){ }
-      end
+      test = Factory.test { error = assert_raises(RuntimeError) {} }
       test.run
 
-      assert_nil error
+      assert_that(error).is_nil
     end
   end
 
@@ -61,33 +62,32 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_nothing_raised`"
-    setup do
-      d = @d = "assert nothing raised fail desc"
-      @test = Factory.test do
-        anr = :assert_nothing_raised
-        self.send(anr, StandardError, RuntimeError, d){ raise(StandardError) } # fail
-        self.send(anr, RuntimeError){ raise(StandardError) }                   # pass
-        self.send(anr, d){ raise(RuntimeError) }                               # fail
-        self.send(anr){ true }                                                 # pass
+    subject {
+      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
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert nothing raised fail desc" }
 
     should "produce results as expected" do
-      assert_equal 4, test_run_result_count
-      assert_equal 2, test_run_result_count(:pass)
-      assert_equal 2, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
+
+      assert_that(test_run_result_count).equals(4)
+      assert_that(test_run_result_count(:pass)).equals(2)
+      assert_that(test_run_result_count(:fail)).equals(2)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = [
-        "#{@d}\nStandardError or RuntimeError exception not expected, but raised:",
-        "#{@d}\nAn exception not expected, but raised:"
-      ]
+      exp =
+        [
+          "#{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_match(/^#{exp[n]}/, msg) }
+      messages.each_with_index{ |msg, n| assert_that(msg).matches(/^#{exp[n]}/) }
     end
   end
 end
-

data/test/unit/assertions/assert_respond_to_tests.rb

@@ -8,29 +8,30 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_respond_to`"
-    setup do
-      desc = @desc = "assert respond to fail desc"
-      args = @args = [:abs, "1", desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_respond_to(:abs, 1) # pass
         assert_respond_to(*args)   # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert respond to fail desc" }
+    let(:args1) { [:abs, "1", desc1] }
+    let(:config1) { subject.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[2]}\n"\
-            "Expected #{Assert::U.show(@args[1], @c)} (#{@args[1].class})"\
-            " to respond to `#{@args[0]}`."
-      assert_equal exp, test_run_results(:fail).first.message
+      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]}\n"\
+        "Expected #{Assert::U.show(args1[1], config1)} (#{args1[1].class})"\
+        " to respond to `#{args1[0]}`."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -38,30 +39,30 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_respond_to`"
-    setup do
-      desc = @desc = "assert not respond to fail desc"
-      args = @args = [:abs, 1, desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_not_respond_to(*args)     # fail
         assert_not_respond_to(:abs, "1") # pass
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert not respond to fail desc" }
+    let(:args1) { [:abs, 1, desc1] }
+    let(:config1) { subject.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[2]}\n"\
-            "Expected #{Assert::U.show(@args[1], @c)} (#{@args[1].class})"\
-            " to not respond to `#{@args[0]}`."
-      assert_equal exp, test_run_results(:fail).first.message
+      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]}\n"\
+        "Expected #{Assert::U.show(args1[1], config1)} (#{args1[1].class})"\
+        " to not respond to `#{args1[0]}`."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 end
-