assert 2.16.5 → 2.18.3

data/test/unit/assertions/assert_block_tests.rb

@@ -1,61 +1,58 @@
-require 'assert'
-require 'assert/assertions'
+require "assert"
+require "assert/assertions"
 
 module Assert::Assertions
-
   class AssertBlockTests < Assert::Context
     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
-    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 = "#{desc1}\nExpected block to return a true value."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
 
   class AssertNotBlockTests < Assert::Context
     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)
 
-    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
-    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 = "#{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

@@ -1,66 +1,66 @@
-require 'assert'
-require 'assert/assertions'
+require "assert"
+require "assert/assertions"
 
-require 'assert/utils'
+require "assert/utils"
 
 module Assert::Assertions
-
   class AssertEmptyTests < Assert::Context
     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)
 
-    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
-    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 not be empty."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
-
 end

data/test/unit/assertions/assert_equal_tests.rb

@@ -1,147 +1,145 @@
-require 'assert'
-require 'assert/assertions'
+require "assert"
+require "assert/assertions"
 
-require 'assert/utils'
+require "assert/utils"
 
 module Assert::Assertions
-
   class AssertEqualTests < Assert::Context
     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)
 
-    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
-    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[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
 
   class AssertNotEqualTests < Assert::Context
     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
-    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[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
 
   class EqualOrderTests < Assert::Context
     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
 
   class DiffTests < Assert::Context
     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)
 
-      @exp_obj_show = Assert::U.show_for_diff(@exp_obj, @c)
-      @act_obj_show = Assert::U.show_for_diff(@act_obj, @c)
-    end
+    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
+    }
 
+    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
-    end
+      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
-    end
+      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

data/test/unit/assertions/assert_file_exists_tests.rb

@@ -1,7 +1,7 @@
-require 'assert'
-require 'assert/assertions'
+require "assert"
+require "assert/assertions"
 
-require 'assert/utils'
+require "assert/utils"
 
 module Assert::Assertions
 
@@ -9,59 +9,57 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_file_exists`"
-    setup do
-      desc = @desc = "assert file exists empty fail desc"
-      args = @args = [ '/a/path/to/some/file/that/no/exists', desc ]
-      @test = Factory.test do
+    subject { test1 }
+
+    let(:desc1) { "assert file exists fail desc" }
+    let(:args1) { ["/a/path/to/some/file/that/no/exists", desc1] }
+    let(:test1) {
+      args = args1
+      Factory.test do
         assert_file_exists(__FILE__) # pass
         assert_file_exists(*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 exist."
-      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 exist."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
 
   class AssertNotFileExistsTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "`assert_not_file_exists`"
-    setup do
-      desc = @desc = "assert not file exists empty fail desc"
-      args = @args = [ __FILE__, desc ]
-      @test = Factory.test do
-        assert_not_file_exists('/a/path/to/some/file/that/no/exists') # pass
-        assert_not_file_exists(*args) # fail
+    subject { test1 }
+
+    let(:desc1) { "assert not file exists fail desc" }
+    let(:args1) { [__FILE__, desc1] }
+    let(:test1) {
+      args = args1
+      Factory.test do
+        assert_not_file_exists("/file/path") # pass
+        assert_not_file_exists(*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 not exist."
-      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 not exist."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
-
 end
-