assert 2.18.2 → 2.18.3

data/test/unit/assert_tests.rb

@@ -13,13 +13,13 @@ module Assert
     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_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)
     end
 
     # Note: don't really need to explicitly test the configure method as
@@ -27,57 +27,80 @@ module Assert
   end
 
   class StubTests < UnitTests
-    setup do
-      @orig_value = Factory.string
-      @stub_value = Factory.string
-
-      @myclass = Class.new do
+    # 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) {
+      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_the_same_as(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
@@ -88,41 +111,43 @@ module Assert
       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 +167,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

@@ -6,25 +6,26 @@ 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 { test1 }
+
+    let(:desc1) { "assert block fail desc" }
+    let(:test1) {
+      desc = desc1
+      Factory.test do
+        assert_block { true }        # pass
+        assert_block(desc) { false } # fail
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
 
     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 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 return a true value."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -32,26 +33,26 @@ 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 { test1 }
+
+    let(:desc1) { "assert not block fail desc" }
+    let(:test1) {
+      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 }
+    }
 
     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 not return a true value."
-      assert_equal exp, test_run_results(:fail).first.message
+      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_empty_tests.rb

@@ -8,56 +8,59 @@ 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 { test1 }
+
+    let(:desc1) { "assert empty fail desc" }
+    let(:args1) { [[1], desc1] }
+    let(:test1) {
+      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(:config1) { test1.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 { test1 }
+
+    let(:desc1) { "assert not empty fail desc" }
+    let(:args1) { [[], desc1] }
+    let(:test1) {
+      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(:config1) { test1.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

data/test/unit/assertions/assert_equal_tests.rb

@@ -8,28 +8,30 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_equal`"
-    setup do
-      desc = @desc = "assert equal fail desc"
-      a = @a = ["1", "2", desc]
-      @test = Factory.test do
-        assert_equal(1, 1) # pass
-        assert_equal(*a)   # fail
+    subject { test1 }
+
+    let(:desc1) { "assert equal fail desc" }
+    let(:args1) { ["1", "2", desc1] }
+    let(:test1) {
+      args = args1
+      Factory.test do
+        assert_equal(1, 1)  # pass
+        assert_equal(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+    let(:config1) { test1.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 = "#{@a[2]}\nExpected #{Assert::U.show(@a[1], @c)}"\
-            " to be equal to #{Assert::U.show(@a[0], @c)}."
-      assert_equal exp, test_run_results(:fail).first.message
+      exp =
+        "#{args1[2]}\nExpected #{Assert::U.show(args1[1], config1)}"\
+        " to be equal to #{Assert::U.show(args1[0], config1)}."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -37,28 +39,30 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_equal`"
-    setup do
-      desc = @desc = "assert not equal fail desc"
-      a = @a = ["1", "1", desc]
-      @test = Factory.test do
-        assert_not_equal(*a)   # fail
-        assert_not_equal(1, 2) # pass
+    subject { test1 }
+
+    let(:desc1) { "assert not equal fail desc" }
+    let(:args1) { ["1", "1", desc1] }
+    let(:test1) {
+      args = args1
+      Factory.test do
+        assert_not_equal(*args) # fail
+        assert_not_equal(1, 2)  # pass
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+    let(:config1) { test1.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 = "#{@a[2]}\nExpected #{Assert::U.show(@a[1], @c)}"\
-            " to not be equal to #{Assert::U.show(@a[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 be equal to #{Assert::U.show(args1[0], config1)}."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -66,21 +70,16 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "with objects that define custom equality operators"
-    setup do
-      is_class = Class.new do
-        def ==(other); true; end
-      end
-      @is = is_class.new
 
-      is_not_class = Class.new do
-        def ==(other); false; end
-      end
-      @is_not = is_not_class.new
-    end
+    let(:is_class)     { Class.new do; def ==(other); true;  end; end }
+    let(:is_not_class) { Class.new do; def ==(other); false; end; end }
+
+    let(:is1) { is_class.new }
+    let(:is_not1) { is_not_class.new }
 
     should "use the equality operator of the exp value" do
-      assert_equal @is, @is_not
-      assert_not_equal @is_not, @is
+      assert_that(is1).equals(is_not1)
+      assert_that(is_not1).does_not_equal(is1)
     end
   end
 
@@ -88,52 +87,59 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "with objects that should use diff when showing"
-    setup do
-      @exp_obj = "I'm a\nstring"
-      @act_obj = "I am a \nstring"
 
-      @c = Factory.modes_off_config
-      @c.use_diff_proc(Assert::U.default_use_diff_proc)
-      @c.run_diff_proc(Assert::U.syscmd_diff_proc)
+    let(:config1) {
+      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
+    }
 
-      @exp_obj_show = Assert::U.show_for_diff(@exp_obj, @c)
-      @act_obj_show = Assert::U.show_for_diff(@act_obj, @c)
-    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) }
   end
 
   class AssertEqualDiffTests < DiffTests
     desc "`assert_equal`"
-    setup do
-      exp_obj, act_obj = @exp_obj, @act_obj
-      @test = Factory.test(@c) do
+    subject { test1 }
+
+    let(:test1) {
+      exp_obj, act_obj = exp_obj1, act_obj1
+      Factory.test(config1) do
         assert_equal(exp_obj, act_obj)
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
 
     should "include diff output in the fail messages" do
-      exp = "Expected does not equal actual, diff:\n"\
-            "#{Assert::U.syscmd_diff_proc.call(@exp_obj_show, @act_obj_show)}"
-      assert_equal exp, test_run_results(:fail).first.message
+      subject.run(&test_run_callback)
+
+      exp =
+        "Expected does not equal actual, diff:\n"\
+        "#{Assert::U.syscmd_diff_proc.call(exp_obj_show1, act_obj_show1)}"
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
   class AssertNotEqualDiffTests < DiffTests
     desc "`assert_not_equal`"
-    setup do
-      exp_obj, act_obj = @exp_obj, @act_obj
-      @test = Factory.test(@c) do
+    subject { test1 }
+
+    let(:test1) {
+      exp_obj = exp_obj1
+      Factory.test(config1) do
         assert_not_equal(exp_obj, exp_obj)
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
 
     should "include diff output in the fail messages" do
-      exp = "Expected equals actual, diff:\n"\
-            "#{Assert::U.syscmd_diff_proc.call(@exp_obj_show, @exp_obj_show)}"
-      assert_equal exp, test_run_results(:fail).first.message
+      subject.run(&test_run_callback)
+
+      exp =
+        "Expected equals actual, diff:\n"\
+        "#{Assert::U.syscmd_diff_proc.call(exp_obj_show1, exp_obj_show1)}"
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 end