assert 2.18.4 → 2.19.4

data/test/unit/assert_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 
 require "assert/config"
@@ -7,9 +9,9 @@ require "much-stub"
 module Assert
   class UnitTests < Assert::Context
     desc "Assert"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert }
+    let(:unit_class){ Assert }
 
     should have_imeths :config, :configure, :view, :suite, :runner
     should have_imeths :stubs, :stub, :unstub, :unstub!, :stub_send
@@ -19,9 +21,9 @@ module Assert
     end
 
     should "map its view, suite and runner to its config" do
-      assert_that(subject.view).is_the_same_as(subject.config.view)
-      assert_that(subject.suite).is_the_same_as(subject.config.suite)
-      assert_that(subject.runner).is_the_same_as(subject.config.runner)
+      assert_that(subject.view).is(subject.config.view)
+      assert_that(subject.suite).is(subject.config.suite)
+      assert_that(subject.runner).is(subject.config.runner)
     end
 
     # Note: don't really need to explicitly test the configure method as
@@ -29,27 +31,20 @@ module Assert
   end
 
   class StubTests < UnitTests
-    # setup do
-    #   orig_value1 = Factory.string
-    #   stub_value1 = Factory.string
-
-    #   @myclass =
-    #   Class.new do
-    #     def initialize(value); @value = value; end
-    #     def mymeth; @value; end
-    #   end
-    #   object1 = @myclass.new(orig_value1)
-    # end
-
-    let(:class1) {
+    let(:class1) do
       Class.new do
-        def initialize(value); @value = value; end
-        def mymeth; @value; end
+        def initialize(value)
+          @value = value
+        end
+
+        def mymeth
+          @value
+        end
       end
-    }
-    let(:object1) { class1.new(orig_value1) }
-    let(:orig_value1) { Factory.string }
-    let(:stub_value1) { Factory.string }
+    end
+    let(:object1){ class1.new(orig_value1) }
+    let(:orig_value1){ Factory.string }
+    let(:stub_value1){ Factory.string }
 
     should "build a stub" do
       stub1 = Assert.stub(object1, :mymeth)
@@ -59,9 +54,9 @@ module Assert
     should "build a stub with an on_call block" do
       my_meth_called_with = nil
       stub1 =
-        Assert.stub_on_call(object1, :mymeth) { |call|
+        Assert.stub_on_call(object1, :mymeth) do |call|
           my_meth_called_with = call
-        }
+        end
 
       object1.mymeth
       assert_kind_of MuchStub::Stub, stub1
@@ -71,12 +66,12 @@ module Assert
     should "lookup stubs that have been called before" do
       stub1 = Assert.stub(object1, :mymeth)
       stub2 = Assert.stub(object1, :mymeth)
-      assert_that(stub2).is_the_same_as(stub1)
+      assert_that(stub2).is(stub1)
     end
 
     should "set the stub's do block if given a block" do
       Assert.stub(object1, :mymeth)
-      assert_that(-> { object1.mymeth }).raises(MuchStub::NotStubbedError)
+      assert_that{ object1.mymeth }.raises(MuchStub::NotStubbedError)
       Assert.stub(object1, :mymeth){ stub_value1 }
       assert_that(object1.mymeth).equals(stub_value1)
     end
@@ -108,7 +103,7 @@ module Assert
     should "auto-unstub any stubs on teardown" do
       context_class = ::Factory.modes_off_context_class do
         setup do
-          Assert.stub("1", :to_s){ "one" }
+          Assert.stub(+"1", :to_s){ "one" }
         end
       end
 
@@ -121,8 +116,9 @@ module Assert
 
     should "be able to call a stub's original method" do
       err =
-        assert_that(-> { Assert.stub_send(object1, :mymeth) }).
-          raises(MuchStub::NotStubbedError)
+        assert_that{
+          Assert.stub_send(object1, :mymeth)
+        }.raises(MuchStub::NotStubbedError)
       assert_that(err.message).includes("not stubbed.")
       assert_that(err.backtrace.first).includes("test/unit/assert_tests.rb")
 
@@ -134,9 +130,9 @@ module Assert
 
     should "be able to add a stub tap" do
       my_meth_called_with = nil
-      Assert.stub_tap(object1, :mymeth){ |value, *args, &block|
+      Assert.stub_tap(object1, :mymeth) do |_value, *args|
         my_meth_called_with = args
-      }
+      end
 
       assert_that(object1.mymeth).equals(orig_value1)
       assert_that(my_meth_called_with).equals([])
@@ -144,9 +140,9 @@ module Assert
 
     should "be able to add a stub tap with an on_call block" do
       my_meth_called_with = nil
-      Assert.stub_tap_on_call(object1, :mymeth){ |value, call|
+      Assert.stub_tap_on_call(object1, :mymeth) do |_value, call|
         my_meth_called_with = call
-      }
+      end
 
       assert_that(object1.mymeth).equals(orig_value1)
       assert_that(my_meth_called_with.args).equals([])
@@ -154,10 +150,21 @@ module Assert
 
     should "be able to add a stubbed spy" do
       myclass = Class.new do
-        def one; self; end
-        def two(val); self; end
-        def three; self; end
-        def ready?; false; end
+        def one
+          self
+        end
+
+        def two(_val)
+          self
+        end
+
+        def three
+          self
+        end
+
+        def ready?
+          false
+        end
       end
       myobj = myclass.new
 
@@ -167,7 +174,8 @@ module Assert
           :one,
           :two,
           :three,
-          ready?: true)
+          ready?: true,
+        )
 
       assert_that(myobj.one).equals(spy)
       assert_that(myobj.two("a")).equals(spy)

data/test/unit/assertions/assert_block_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/assertions"
 
@@ -6,15 +8,15 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_block`"
-    subject {
+    subject do
       desc = desc1
       Factory.test do
-        assert_block { true }        # pass
-        assert_block(desc) { false } # fail
+        assert_block{ true }        # pass
+        assert_block(desc){ false } # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert block fail desc" }
+    let(:desc1){ "assert block fail desc" }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -32,15 +34,15 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_block`"
-    subject {
+    subject do
       desc = desc1
       Factory.test do
-        assert_not_block(desc) { true } # fail
-        assert_not_block { false }      # pass
+        assert_not_block(desc){ true } # fail
+        assert_not_block{ false }      # pass
       end
-    }
+    end
 
-    let(:desc1) { "assert not block fail desc" }
+    let(:desc1){ "assert not block fail desc" }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)

data/test/unit/assertions/assert_changes_tests.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "assert"
+require "assert/assertions"
+
+module Assert::Assertions
+  class AssertChangesTests < Assert::Context
+    include Assert::Test::TestHelpers
+
+    desc "`assert_changes`"
+    subject do
+      desc = desc1
+      Factory.test do
+        @my_var = 1
+        assert_changes("@my_var", from: 1, to: 2){ @my_var = 2 } # pass
+        @my_var = 1
+        assert_changes("@my_var", from: 1){ @my_var = 2 }        # pass
+        @my_var = 1
+        assert_changes("@my_var", to: 2){ @my_var = 2 }          # pass
+        @my_var = 1
+        assert_changes("@my_var", desc: desc){ @my_var = 2 }     # pass
+
+        @my_var = 1
+        assert_changes("@my_var", from: 2, to: 1){ @my_var = 2 } # fail
+        @my_var = 1
+        assert_changes("@my_var", from: 2){ @my_var = 2 }        # fail
+        @my_var = 1
+        assert_changes("@my_var", to: 1){ @my_var = 2 }          # fail
+        @my_var = 1
+        assert_changes("@my_var", desc: desc){ @my_var = 1 }     # fail
+      end
+    end
+
+    let(:desc1){ "assert changes fail desc" }
+
+    should "produce results as expected" do
+      subject.run(&test_run_callback)
+
+      assert_that(test_run_result_count).equals(10)
+      assert_that(test_run_result_count(:pass)).equals(5)
+      assert_that(test_run_result_count(:fail)).equals(5)
+
+      exp =
+        [
+          "Expected `@my_var` to change from `2`",
+          "Expected `@my_var` to change to `1`",
+          "Expected `@my_var` to change from `2`",
+          "Expected `@my_var` to change to `1`",
+          "#{desc1}\nExpected `@my_var` to change; "\
+          "it was `1` and didn't change",
+        ]
+      messages = test_run_results(:fail).map(&:message)
+      messages.each_with_index do |msg, n|
+        assert_that(msg).matches(/^#{exp[n]}/)
+      end
+    end
+  end
+
+  class AssertNotChangesTests < Assert::Context
+    include Assert::Test::TestHelpers
+
+    desc "`assert_changes`"
+    subject do
+      desc = desc1
+      Factory.test do
+        @my_var = 1
+        assert_not_changes("@my_var", from: 1){ @my_var = 1 }    # pass
+        @my_var = 1
+        assert_not_changes("@my_var", desc: desc){ @my_var = 1 } # pass
+
+        @my_var = 1
+        assert_not_changes("@my_var", from: 2){ @my_var = 1 }    # fail
+        @my_var = 1
+        assert_not_changes("@my_var", from: 1){ @my_var = 2 }    # fail
+        @my_var = 1
+        assert_not_changes("@my_var", desc: desc){ @my_var = 2 } # fail
+      end
+    end
+
+    let(:desc1){ "assert not changes fail desc" }
+
+    should "produce results as expected" do
+      subject.run(&test_run_callback)
+
+      assert_that(test_run_result_count).equals(8)
+      assert_that(test_run_result_count(:pass)).equals(5)
+      assert_that(test_run_result_count(:fail)).equals(3)
+
+      exp =
+        [
+          "Expected `@my_var` to not change from `2`",
+          "Expected `@my_var` to not change; "\
+          "it was `1` and changed to `2`",
+          "#{desc1}\nExpected `@my_var` to not change; "\
+          "it was `1` and changed to `2`",
+        ]
+      messages = test_run_results(:fail).map(&:message)
+      messages.each_with_index do |msg, n|
+        assert_that(msg).matches(/^#{exp[n]}/)
+      end
+    end
+  end
+end

data/test/unit/assertions/assert_empty_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_empty`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_empty([])    # pass
         assert_empty(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert empty fail desc" }
-    let(:args1) { [[1], desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert empty fail desc" }
+    let(:args1){ [[1], desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -28,7 +30,8 @@ module Assert::Assertions
       assert_that(test_run_result_count(:fail)).equals(1)
 
       exp =
-        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be empty."
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be "\
+        "empty."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -37,17 +40,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_empty`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_empty([1])   # pass
         assert_not_empty(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert not empty fail desc" }
-    let(:args1) { [[], desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not empty fail desc" }
+    let(:args1){ [[], desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -57,7 +60,8 @@ module Assert::Assertions
       assert_that(test_run_result_count(:fail)).equals(1)
 
       exp =
-        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be empty."
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not "\
+        "be empty."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end

data/test/unit/assertions/assert_equal_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_equal`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_equal(1, 1)  # pass
         assert_equal(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert equal fail desc" }
-    let(:args1) { ["1", "2", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert equal fail desc" }
+    let(:args1){ ["1", "2", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -38,17 +40,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_equal`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_equal(*args) # fail
         assert_not_equal(1, 2)  # pass
       end
-    }
+    end
 
-    let(:desc1) { "assert not equal fail desc" }
-    let(:args1) { ["1", "1", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not equal fail desc" }
+    let(:args1){ ["1", "1", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -69,11 +71,31 @@ module Assert::Assertions
 
     desc "with objects that define custom equality operators"
 
-    let(:is_class)     { Class.new do; def ==(other); true;  end; end }
-    let(:is_not_class) { Class.new do; def ==(other); false; end; end }
+    let(:is_class) do
+      Class.new do
+        def ==(other)
+          if other.is_a?(Assert::ActualValue.not_given.class)
+            super
+          else
+            true
+          end
+        end
+      end
+    end
+    let(:is_not_class) do
+      Class.new do
+        def ==(other)
+          if other.is_a?(Assert::ActualValue.not_given.class)
+            super
+          else
+            false
+          end
+        end
+      end
+    end
 
-    let(:is1) { is_class.new }
-    let(:is_not1) { is_not_class.new }
+    let(:is1){ is_class.new }
+    let(:is_not1){ is_not_class.new }
 
     should "use the equality operator of the exp value" do
       assert_that(is1).equals(is_not1)
@@ -86,27 +108,27 @@ module Assert::Assertions
 
     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 AssertEqualDiffTests < DiffTests
     desc "`assert_equal`"
-    subject {
+    subject do
       exp_obj, act_obj = exp_obj1, act_obj1
       Factory.test(config1) do
         assert_equal(exp_obj, act_obj)
       end
-    }
+    end
 
     should "include diff output in the fail messages" do
       subject.run(&test_run_callback)
@@ -120,12 +142,12 @@ module Assert::Assertions
 
   class AssertNotEqualDiffTests < DiffTests
     desc "`assert_not_equal`"
-    subject {
+    subject do
       exp_obj = exp_obj1
       Factory.test(config1) do
         assert_not_equal(exp_obj, exp_obj)
       end
-    }
+    end
 
     should "include diff output in the fail messages" do
       subject.run(&test_run_callback)