assert 2.18.0 → 2.19.0

data/test/unit/assertions/assert_same_tests.rb

@@ -8,32 +8,35 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_same`"
-    setup do
-      klass = Class.new; object = klass.new
-      desc = @desc = "assert same fail desc"
-      args = @args = [object, klass.new, desc]
-      @test = Factory.test do
+    subject {
+      args   = args1
+      object = object1
+      Factory.test do
         assert_same(object, object) # pass
         assert_same(*args)          # fail
       end
-      @c = @test.config
-      @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
+    let(:class1) { Class.new }
+    let(:object1) { class1.new }
+    let(:desc1) { "assert same fail desc" }
+    let(:args1) { [object1, class1.new, desc1] }
+    let(:config1) { subject.config }
 
-    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}:#{"0x0%x" % (@args[1].object_id << 1)}>)"\
-            " to be the same as #{Assert::U.show(@args[0], @c)}"\
-            " (#<#{@args[0].class}:#{"0x0%x" % (@args[0].object_id << 1)}>)."
-      assert_equal exp, test_run_results(:fail).first.message
+    should "produce results as expected" do
+      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)
+
+      exp =
+        "#{args1[2]}\n"\
+        "Expected #{Assert::U.show(args1[1], config1)}"\
+        " (#<#{args1[1].class}:#{"0x0%x" % (args1[1].object_id << 1)}>)"\
+        " to be the same as #{Assert::U.show(args1[0], config1)}"\
+        " (#<#{args1[0].class}:#{"0x0%x" % (args1[0].object_id << 1)}>)."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -41,32 +44,36 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_same`"
-    setup do
-      klass = Class.new; object = klass.new
-      desc = @desc = "assert not same fail desc"
-      args = @args = [object, object, desc]
-      @test = Factory.test do
+    subject {
+      args   = args1
+      object = object1
+      klass  = class1
+      Factory.test do
         assert_not_same(*args)             # fail
         assert_not_same(object, klass.new) # pass
       end
-      @c = @test.config
-      @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
+    let(:class1) { Class.new }
+    let(:object1) { class1.new }
+    let(:desc1) { "assert not same fail desc" }
+    let(:args1) { [object1, object1, desc1] }
+    let(:config1) { subject.config }
 
-    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}:#{"0x0%x" % (@args[1].object_id << 1)}>)"\
-            " to not be the same as #{Assert::U.show(@args[0], @c)}"\
-            " (#<#{@args[0].class}:#{"0x0%x" % (@args[0].object_id << 1)}>)."
-      assert_equal exp, test_run_results(:fail).first.message
+    should "produce results as expected" do
+      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)
+
+      exp =
+        "#{args1[2]}\n"\
+        "Expected #{Assert::U.show(args1[1], config1)}"\
+        " (#<#{args1[1].class}:#{"0x0%x" % (args1[1].object_id << 1)}>)"\
+        " to not be the same as #{Assert::U.show(args1[0], config1)}"\
+        " (#<#{args1[0].class}:#{"0x0%x" % (args1[0].object_id << 1)}>)."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -74,62 +81,60 @@ 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 AssertSameDiffTests < DiffTests
     desc "`assert_same`"
-    setup do
-      exp_obj, act_obj = @exp_obj, @act_obj
-      @test = Factory.test(@c) do
+    subject {
+      exp_obj, act_obj = exp_obj1, act_obj1
+      Factory.test(config1) do
         assert_same(exp_obj, act_obj)
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
 
     should "include diff output in the fail messages" do
-      exp = "Expected #<#{@act_obj.class}:#{"0x0%x" % (@act_obj.object_id << 1)}>"\
-            " to be the same as"\
-            " #<#{@exp_obj.class}:#{"0x0%x" % (@exp_obj.object_id << 1)}>"\
-            ", 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 #<#{act_obj1.class}:#{"0x0%x" % (act_obj1.object_id << 1)}>"\
+        " to be the same as"\
+        " #<#{exp_obj1.class}:#{"0x0%x" % (exp_obj1.object_id << 1)}>"\
+        ", 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 AssertNotSameDiffTests < DiffTests
     desc "`assert_not_same`"
-    setup do
-      @exp_obj = @act_obj
-      @exp_obj_show = @act_obj_show
-
-      exp_obj, act_obj = @exp_obj, @act_obj
-      @test = Factory.test(@c) do
-        assert_not_same(exp_obj, exp_obj)
+    subject {
+      act_obj = act_obj1
+      Factory.test(config1) do
+        assert_not_same(act_obj, act_obj)
       end
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
 
     should "include diff output in the fail messages" do
-      exp = "Expected #<#{@act_obj.class}:#{"0x0%x" % (@act_obj.object_id << 1)}>"\
-            " to not be the same as"\
-            " #<#{@exp_obj.class}:#{"0x0%x" % (@exp_obj.object_id << 1)}>"\
-            ", 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 #<#{act_obj1.class}:#{"0x0%x" % (act_obj1.object_id << 1)}>"\
+        " to not be the same as"\
+        " #<#{act_obj1.class}:#{"0x0%x" % (act_obj1.object_id << 1)}>"\
+        ", diff:\n"\
+        "#{Assert::U.syscmd_diff_proc.call(act_obj_show1, act_obj_show1)}"
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 end
-

data/test/unit/assertions/assert_true_false_tests.rb

@@ -8,27 +8,27 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_true`"
-    setup do
-      desc = @desc = "assert true fail desc"
-      args = @args = ["whatever", desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_true(true)  # pass
         assert_true(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert true fail desc" }
+    let(:args1) { ["whatever", 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 be true."
-      assert_equal exp, test_run_results(:fail).first.message
+      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be true."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -36,27 +36,27 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_true`"
-    setup do
-      desc = @desc = "assert not true fail desc"
-      args = @args = [true, desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_not_true(false) # pass
         assert_not_true(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert not true fail desc" }
+    let(:args1) { [true, 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 true."
-      assert_equal exp, test_run_results(:fail).first.message
+      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be true."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -64,27 +64,27 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_false`"
-    setup do
-      desc = @desc = "assert false fail desc"
-      args = @args = ["whatever", desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_false(false) # pass
         assert_false(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert false fail desc" }
+    let(:args1) { ["whatever", 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 be false."
-      assert_equal exp, test_run_results(:fail).first.message
+      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be false."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 
@@ -92,27 +92,27 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_false`"
-    setup do
-      desc = @desc = "assert not false fail desc"
-      args = @args = [false, desc]
-      @test = Factory.test do
+    subject {
+      args = args1
+      Factory.test do
         assert_not_false(true)  # pass
         assert_not_false(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+
+    let(:desc1) { "assert not false fail desc" }
+    let(:args1) { [false, 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 false."
-      assert_equal exp, test_run_results(:fail).first.message
+      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be false."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
 end

data/test/unit/assertions_tests.rb

@@ -6,52 +6,54 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "Assert::Context"
-    setup do
-      @context_class = Factory.modes_off_context_class
-      @test = Factory.test
-      @context = @context_class.new(@test, @test.config, proc{ |r| })
-    end
-    subject{ @context }
+    subject { context_class1.new(test1, test1.config, proc { |r| }) }
+
+    let(:context_class1) { Factory.modes_off_context_class }
+    let(:test1) { Factory.test }
 
     should have_imeths :assert_block, :assert_not_block, :refute_block
-    should have_imeths :assert_raises, :assert_not_raises
-    should have_imeths :assert_raise, :assert_not_raise, :assert_nothing_raised
-    should have_imeths :assert_kind_of, :assert_not_kind_of, :refute_kind_of
-    should have_imeths :assert_instance_of, :assert_not_instance_of, :refute_instance_of
-    should have_imeths :assert_respond_to, :assert_responds_to
-    should have_imeths :assert_not_respond_to, :assert_not_responds_to
-    should have_imeths :refute_respond_to, :refute_responds_to
-    should have_imeths :assert_same, :assert_not_same, :refute_same
-    should have_imeths :assert_equal, :assert_not_equal, :refute_equal
-    should have_imeths :assert_match, :assert_not_match, :assert_no_match, :refute_match
     should have_imeths :assert_empty, :assert_not_empty, :refute_empty
+    should have_imeths :assert_equal, :assert_not_equal, :refute_equal
+    should have_imeths :assert_file_exists, :assert_not_file_exists, :refute_file_exists
     should have_imeths :assert_includes, :assert_not_includes
     should have_imeths :assert_included, :assert_not_included
     should have_imeths :refute_includes, :refute_included
+    should have_imeths :assert_instance_of, :assert_not_instance_of, :refute_instance_of
+    should have_imeths :assert_kind_of, :assert_not_kind_of, :refute_kind_of
+    should have_imeths :assert_match, :assert_not_match, :assert_no_match, :refute_match
     should have_imeths :assert_nil, :assert_not_nil, :refute_nil
     should have_imeths :assert_true, :assert_not_true, :refute_true
     should have_imeths :assert_false, :assert_not_false, :refute_false
-    should have_imeths :assert_file_exists, :assert_not_file_exists, :refute_file_exists
+    should have_imeths :assert_raises, :assert_not_raises
+    should have_imeths :assert_raise, :assert_not_raise, :assert_nothing_raised
+    should have_imeths :assert_changes, :assert_not_changes, :refute_changes
+    should have_imeths :assert_respond_to, :assert_responds_to
+    should have_imeths :assert_not_respond_to, :assert_not_responds_to
+    should have_imeths :refute_respond_to, :refute_responds_to
+    should have_imeths :assert_same, :assert_not_same, :refute_same
   end
 
   class IgnoredTests < UnitTests
     desc "ignored assertions helpers"
     setup do
-      @tests = Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
-        context_info = Factory.context_info(@context_class)
+      tests.each{ |test| test.run(&test_run_callback) }
+    end
+
+    let(:tests) {
+      context_info = Factory.context_info(context_class1)
+      Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
         Factory.test("ignored assertion helper #{helper}", context_info) do
           self.send(helper, "doesn't matter")
         end
       end
-      @tests.each{ |test| test.run(&test_run_callback) }
-    end
+    }
 
     should "have an ignored result for each helper in the constant" do
       exp = Assert::Assertions::IGNORED_ASSERTION_HELPERS.size
-      assert_equal exp, test_run_result_count
+      assert_that(test_run_result_count).equals(exp)
 
       test_run_results.each do |result|
-        assert_kind_of Assert::Result::Ignore, result
+        assert_that(result).is_kind_of(Assert::Result::Ignore)
       end
     end
 
@@ -60,7 +62,7 @@ module Assert::Assertions
         "The assertion `#{helper}` is not supported."\
         " Please use another assertion or the basic `assert`."
       end
-      assert_equal exp, test_run_results.collect(&:message)
+      assert_that(test_run_results.collect(&:message)).equals(exp)
     end
   end
 end