assert 2.18.2 → 2.19.2

data/test/unit/assert_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 
 require "assert/config"
@@ -7,19 +9,21 @@ require "much-stub"
 module Assert
   class UnitTests < Assert::Context
     desc "Assert"
-    subject { Assert }
+    subject { unit_class }
+
+    let(:unit_class) { Assert }
 
     should have_imeths :config, :configure, :view, :suite, :runner
     should have_imeths :stubs, :stub, :unstub, :unstub!, :stub_send
 
     should "know its config instance" do
-      assert_kind_of Assert::Config, subject.config
+      assert_that(subject.config).is_kind_of(Assert::Config)
     end
 
     should "map its view, suite and runner to its config" do
-      assert_same subject.config.view,   subject.view
-      assert_same subject.config.suite,  subject.suite
-      assert_same subject.config.runner, subject.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
@@ -27,102 +31,116 @@ module Assert
   end
 
   class StubTests < UnitTests
-    setup do
-      @orig_value = Factory.string
-      @stub_value = Factory.string
-
-      @myclass = Class.new do
+    let(:class1) {
+      Class.new do
         def initialize(value); @value = value; end
         def mymeth; @value; end
       end
-      @myobj = @myclass.new(@orig_value)
-    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(@myobj, :mymeth)
+      stub1 = Assert.stub(object1, :mymeth)
+      assert_that(stub1).is_kind_of(MuchStub::Stub)
+    end
+
+    should "build a stub with an on_call block" do
+      my_meth_called_with = nil
+      stub1 =
+        Assert.stub_on_call(object1, :mymeth) { |call|
+          my_meth_called_with = call
+        }
+
+      object1.mymeth
       assert_kind_of MuchStub::Stub, stub1
+      assert_equal [], my_meth_called_with.args
     end
 
     should "lookup stubs that have been called before" do
-      stub1 = Assert.stub(@myobj, :mymeth)
-      stub2 = Assert.stub(@myobj, :mymeth)
-      assert_same stub1, stub2
+      stub1 = Assert.stub(object1, :mymeth)
+      stub2 = Assert.stub(object1, :mymeth)
+      assert_that(stub2).is(stub1)
     end
 
     should "set the stub's do block if given a block" do
-      Assert.stub(@myobj, :mymeth)
-      assert_raises(MuchStub::NotStubbedError){ @myobj.mymeth }
-      Assert.stub(@myobj, :mymeth){ @stub_value }
-      assert_equal @stub_value, @myobj.mymeth
+      Assert.stub(object1, :mymeth)
+      assert_that { object1.mymeth }.raises(MuchStub::NotStubbedError)
+      Assert.stub(object1, :mymeth){ stub_value1 }
+      assert_that(object1.mymeth).equals(stub_value1)
     end
 
     should "teardown stubs" do
-      assert_equal @orig_value, @myobj.mymeth
-      Assert.unstub(@myobj, :mymeth)
-      assert_equal @orig_value, @myobj.mymeth
-
-      assert_equal @orig_value, @myobj.mymeth
-      Assert.stub(@myobj, :mymeth){ @stub_value }
-      assert_equal @stub_value, @myobj.mymeth
-      Assert.unstub(@myobj, :mymeth)
-      assert_equal @orig_value, @myobj.mymeth
+      assert_that(object1.mymeth).equals(orig_value1)
+      Assert.unstub(object1, :mymeth)
+      assert_that(object1.mymeth).equals(orig_value1)
+
+      assert_that(object1.mymeth).equals(orig_value1)
+      Assert.stub(object1, :mymeth){ stub_value1 }
+      assert_that(object1.mymeth).equals(stub_value1)
+      Assert.unstub(object1, :mymeth)
+      assert_that(object1.mymeth).equals(orig_value1)
     end
 
     should "know and teardown all stubs" do
-      assert_equal @orig_value, @myobj.mymeth
+      assert_that(object1.mymeth).equals(orig_value1)
 
-      Assert.stub(@myobj, :mymeth){ @stub_value }
-      assert_equal @stub_value, @myobj.mymeth
-      assert_equal 1, Assert.stubs.size
+      Assert.stub(object1, :mymeth){ stub_value1 }
+      assert_that(object1.mymeth).equals(stub_value1)
+      assert_that(Assert.stubs.size).equals(1)
 
       Assert.unstub!
-      assert_equal @orig_value, @myobj.mymeth
-      assert_empty Assert.stubs
+      assert_that(object1.mymeth).equals(orig_value1)
+      assert_that(Assert.stubs).is_empty
     end
 
     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
 
       context_class.run_setups("scope")
-      assert_equal 1, Assert.stubs.size
+      assert_that(Assert.stubs.size).equals(1)
 
       context_class.run_teardowns("scope")
-      assert_empty Assert.stubs
+      assert_that(Assert.stubs).is_empty
     end
 
     should "be able to call a stub's original method" do
-      err = assert_raises(MuchStub::NotStubbedError){ Assert.stub_send(@myobj, :mymeth) }
-      assert_includes "not stubbed.",              err.message
-      assert_includes "test/unit/assert_tests.rb", err.backtrace.first
+      err =
+        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")
 
-      Assert.stub(@myobj, :mymeth){ @stub_value }
+      Assert.stub(object1, :mymeth){ stub_value1 }
 
-      assert_equal @stub_value, @myobj.mymeth
-      assert_equal @orig_value, Assert.stub_send(@myobj, :mymeth)
+      assert_that(object1.mymeth).equals(stub_value1)
+      assert_that(Assert.stub_send(object1, :mymeth)).equals(orig_value1)
     end
 
     should "be able to add a stub tap" do
       my_meth_called_with = nil
-      Assert.stub_tap(@myobj, :mymeth){ |value, *args, &block|
+      Assert.stub_tap(object1, :mymeth){ |value, *args, &block|
         my_meth_called_with = args
       }
 
-      assert_equal @orig_value, @myobj.mymeth
-      assert_equal [], my_meth_called_with
+      assert_that(object1.mymeth).equals(orig_value1)
+      assert_that(my_meth_called_with).equals([])
     end
 
     should "be able to add a stub tap with an on_call block" do
       my_meth_called_with = nil
-      Assert.stub_tap_on_call(@myobj, :mymeth){ |value, call|
+      Assert.stub_tap_on_call(object1, :mymeth){ |value, call|
         my_meth_called_with = call
       }
 
-      assert_equal @orig_value, @myobj.mymeth
-      assert_equal [], my_meth_called_with.args
+      assert_that(object1.mymeth).equals(orig_value1)
+      assert_that(my_meth_called_with.args).equals([])
     end
 
     should "be able to add a stubbed spy" do
@@ -142,19 +160,19 @@ module Assert
           :three,
           ready?: true)
 
-      assert_equal spy, myobj.one
-      assert_equal spy, myobj.two("a")
-      assert_equal spy, myobj.three
+      assert_that(myobj.one).equals(spy)
+      assert_that(myobj.two("a")).equals(spy)
+      assert_that(myobj.three).equals(spy)
 
-      assert_true myobj.one.two("b").three.ready?
+      assert_that(myobj.one.two("b").three.ready?).is_true
 
-      assert_kind_of MuchStub::CallSpy, spy
-      assert_equal 2, spy.one_call_count
-      assert_equal 2, spy.two_call_count
-      assert_equal 2, spy.three_call_count
-      assert_equal 1, spy.ready_predicate_call_count
-      assert_equal ["b"], spy.two_last_called_with.args
-      assert_true spy.ready_predicate_called?
+      assert_that(spy).is_kind_of(MuchStub::CallSpy)
+      assert_that(spy.one_call_count).equals(2)
+      assert_that(spy.two_call_count).equals(2)
+      assert_that(spy.three_call_count).equals(2)
+      assert_that(spy.ready_predicate_call_count).equals(1)
+      assert_that(spy.two_last_called_with.args).equals(["b"])
+      assert_that(spy.ready_predicate_called?).is_true
     end
   end
 end

data/test/unit/assertions/assert_block_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/assertions"
 
@@ -6,25 +8,25 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_block`"
-    setup do
-      desc = @desc = "assert block fail desc"
-      @test = Factory.test do
-        assert_block{ true }        # pass
-        assert_block(desc){ false } # fail
+    subject {
+      desc = desc1
+      Factory.test do
+        assert_block { true }        # pass
+        assert_block(desc) { false } # fail
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert block fail desc" }
 
     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)
+
+      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)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@desc}\nExpected block to return a true value."
-      assert_equal exp, test_run_results(:fail).first.message
+      exp = "#{desc1}\nExpected block to return a true value."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -32,26 +34,25 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_block`"
-    setup do
-      desc = @desc = "assert not block fail desc"
-      @test = Factory.test do
-        assert_not_block(desc){ true } # fail
-        assert_not_block{ false }      # pass
+    subject {
+      desc = desc1
+      Factory.test do
+        assert_not_block(desc) { true } # fail
+        assert_not_block { false }      # pass
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert not block fail desc" }
 
     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 = "#{@desc}\nExpected block to not return a true value."
-      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 = "#{desc1}\nExpected block to not return a true value."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 end
-

data/test/unit/assertions/assert_changes_tests.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "assert"
+require "assert/assertions"
+
+module Assert::Assertions
+  class AssertChangesTests < Assert::Context
+    include Assert::Test::TestHelpers
+
+    desc "`assert_changes`"
+    subject {
+      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
+    }
+
+    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{ |msg, n| assert_that(msg).matches(/^#{exp[n]}/) }
+    end
+  end
+
+  class AssertNotChangesTests < Assert::Context
+    include Assert::Test::TestHelpers
+
+    desc "`assert_changes`"
+    subject {
+      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
+    }
+
+    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{ |msg, n| assert_that(msg).matches(/^#{exp[n]}/) }
+    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,56 +10,57 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_empty`"
-    setup do
-      desc = @desc = "assert empty fail desc"
-      args = @args = [[1], desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_empty([])    # pass
         assert_empty(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert 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 empty."
-      assert_equal exp, test_run_results(:fail).first.message
-    end
+      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 empty."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
 
   class AssertNotEmptyTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "`assert_not_empty`"
-    setup do
-      desc = @desc = "assert not empty fail desc"
-      args = @args = [[], desc]
-      @test = Factory.test do
-        assert_not_empty([1]) # pass
+    subject {
+      args = args1
+      Factory.test do
+        assert_not_empty([1])   # pass
         assert_not_empty(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert not empty fail desc" }
+    let(:args1) { [[], 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)
+
+      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)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to not be empty."
-      assert_equal exp, test_run_results(:fail).first.message
+      exp =
+        "#{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
 end