assert 2.18.3 → 2.19.3

data/test/system/test_tests.rb

@@ -1,22 +1,21 @@
+# frozen_string_literal: true
+
 require "assert"
 
 class Assert::Test
-
   class SystemTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "Assert::Test"
-    subject { test1 }
 
     setup do
-      test1.run(&test_run_callback)
+      subject.run(&test_run_callback)
     end
   end
 
   class NoResultsTests < SystemTests
     desc "when producing no results"
-
-    let(:test1) { Factory.test }
+    subject{ Factory.test }
 
     should "generate 0 results" do
       assert_that(test_run_result_count).equals(0)
@@ -25,8 +24,13 @@ class Assert::Test
 
   class PassTests < SystemTests
     desc "when passing a single assertion"
-
-    let(:test1) { Factory.test{ assert(1 == 1) } }
+    subject do
+      Factory.test do
+        assert(
+          1 == 1, # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+        )
+      end
+    end
 
     should "generate 1 result" do
       assert_that(test_run_result_count).equals(1)
@@ -39,8 +43,7 @@ class Assert::Test
 
   class FailTests < SystemTests
     desc "when failing a single assertion"
-
-    let(:test1) { Factory.test{ assert(1 == 0) } }
+    subject{ Factory.test{ assert(1 == 0) } }
 
     should "generate 1 result" do
       assert_that(test_run_result_count).equals(1)
@@ -53,8 +56,7 @@ class Assert::Test
 
   class SkipTests < SystemTests
     desc "when skipping once"
-
-    let(:test1) { Factory.test{ skip } }
+    subject{ Factory.test{ skip } }
 
     should "generate 1 result" do
       assert_that(test_run_result_count).equals(1)
@@ -67,8 +69,7 @@ class Assert::Test
 
   class ErrorTests < SystemTests
     desc "when erroring once"
-
-    let(:test1) { Factory.test{ raise("WHAT") } }
+    subject{ Factory.test{ raise("WHAT") } }
 
     should "generate 1 result" do
       assert_that(test_run_result_count).equals(1)
@@ -81,13 +82,14 @@ class Assert::Test
 
   class MixedTests < SystemTests
     desc "when passing 1 assertion and failing 1 assertion"
-
-    let(:test1) {
+    subject do
       Factory.test do
-        assert(1 == 1)
+        assert(
+          1 == 1, # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+        )
         assert(1 == 0)
       end
-    }
+    end
 
     should "generate 2 total results" do
       assert_that(test_run_result_count).equals(2)
@@ -103,15 +105,17 @@ class Assert::Test
   end
 
   class MixedSkipTests < SystemTests
-    desc "when passing 1 assertion and failing 1 assertion with a skip call in between"
-
-    let(:test1) {
+    desc "when passing 1 assertion and failing 1 assertion with a skip call "\
+         "in between"
+    subject do
       Factory.test do
-        assert(1 == 1)
+        assert(
+          1 == 1, # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+        )
         skip
         assert(1 == 0)
       end
-    }
+    end
 
     should "generate 2 total results" do
       assert_that(test_run_result_count).equals(2)
@@ -135,15 +139,17 @@ class Assert::Test
   end
 
   class MixedErrorTests < SystemTests
-    desc "when passing 1 assertion and failing 1 assertion with an exception raised in between"
-
-    let(:test1) {
+    desc "when passing 1 assertion and failing 1 assertion with an exception "\
+         "raised in between"
+    subject do
       Factory.test do
-        assert(1 == 1)
-        raise Exception, "something errored"
-        assert(1 == 0)
+        assert(
+          1 == 1, # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+        )
+        raise "something errored"
+        assert(1 == 0) # rubocop:disable Lint/UnreachableCode
       end
-    }
+    end
 
     should "generate 2 total results" do
       assert_that(test_run_result_count).equals(2)
@@ -167,15 +173,17 @@ class Assert::Test
   end
 
   class MixedPassTests < SystemTests
-    desc "when passing 1 assertion and failing 1 assertion with a pass call in between"
-
-    let(:test1) {
+    desc "when passing 1 assertion and failing 1 assertion with a pass call "\
+         "in between"
+    subject do
       Factory.test do
-        assert(1 == 1)
+        assert(
+          1 == 1, # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+        )
         pass
         assert(1 == 0)
       end
-    }
+    end
 
     should "generate 3 total results" do
       assert_that(test_run_result_count).equals(3)
@@ -195,15 +203,17 @@ class Assert::Test
   end
 
   class MixedFailTests < SystemTests
-    desc "when failing 1 assertion and passing 1 assertion with a fail call in between"
-
-    let(:test1) {
+    desc "when failing 1 assertion and passing 1 assertion with a fail call "\
+         "in between"
+    subject do
       Factory.test do
         assert(1 == 0)
-        fail
-        assert(1 == 1)
+        fail # rubocop:disable Style/SignalException
+        assert( # rubocop:disable Lint/UnreachableCode
+          1 == 1, # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+        )
       end
-    }
+    end
 
     should "generate 3 total results" do
       assert_that(test_run_result_count).equals(3)
@@ -223,15 +233,17 @@ class Assert::Test
   end
 
   class MixedFlunkTests < SystemTests
-    desc "has failing 1 assertion and passing 1 assertion with a flunk call in between"
-
-    let(:test1) {
+    desc "has failing 1 assertion and passing 1 assertion with a flunk call "\
+         "in between"
+    subject do
       Factory.test do
         assert(1 == 0)
         flunk
-        assert(1 == 1)
+        assert(
+          1 == 1, # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+        )
       end
-    }
+    end
 
     should "generate 3 total results" do
       assert_that(test_run_result_count).equals(3)
@@ -252,18 +264,20 @@ class Assert::Test
 
   class WithSetupsTests < SystemTests
     desc "that has setup logic"
+    subject do
+      Factory.test("t", Factory.context_info(context_class1)){ pass "TEST" }
+    end
 
-    let(:context_class1) {
+    let(:context_class1) do
       Factory.context_class do
         # assert style
-        setup { pass "assert style setup" }
+        setup{ pass "assert style setup" }
         # test/unit style
-        def setup; pass "test/unit style setup"; end
+        def setup
+          pass "test/unit style setup"
+        end
       end
-    }
-    let(:test1) {
-      Factory.test("t", Factory.context_info(context_class1)) { pass "TEST" }
-    }
+    end
 
     should "execute all setup logic when run" do
       assert_that(test_run_result_count(:pass)).equals(3)
@@ -275,18 +289,20 @@ class Assert::Test
 
   class WithTeardownsTests < SystemTests
     desc "that has teardown logic"
+    subject do
+      Factory.test("t", Factory.context_info(context_class1)){ pass "TEST" }
+    end
 
-    let(:context_class1) {
+    let(:context_class1) do
       Factory.context_class do
         # assert style
-        teardown { pass "assert style teardown" }
+        teardown{ pass "assert style teardown" }
         # test/unit style
-        def teardown; pass "test/unit style teardown"; end
+        def teardown
+          pass "test/unit style teardown"
+        end
       end
-    }
-    let(:test1) {
-      Factory.test("t", Factory.context_info(context_class1)) { pass "TEST" }
-    }
+    end
 
     should "execute all teardown logic when run" do
       assert_that(test_run_result_count(:pass)).equals(3)
@@ -298,39 +314,39 @@ class Assert::Test
 
   class WithAroundsTests < SystemTests
     desc "that has around logic (in addition to setups/teardowns)"
+    subject do
+      Factory.test("t", Factory.context_info(context_class1)){ pass "TEST" }
+    end
 
-    let(:parent_context_class1) {
+    let(:parent_context_class1) do
       Factory.modes_off_context_class do
         around do |block|
           pass "parent around start"
           block.call
           pass "parent around end"
         end
-        setup { pass "parent setup" }
-        teardown { pass "parent teardown" }
+        setup{ pass "parent setup" }
+        teardown{ pass "parent teardown" }
       end
-    }
-    let(:context_class1) {
+    end
+    let(:context_class1) do
       Factory.modes_off_context_class(parent_context_class1) do
-        setup { pass "child setup1" }
+        setup{ pass "child setup1" }
         around do |block|
           pass "child around1 start"
           block.call
           pass "child around1 end"
         end
-        teardown { pass "child teardown1" }
-        setup { pass "child setup2" }
+        teardown{ pass "child teardown1" }
+        setup{ pass "child setup2" }
         around do |block|
           pass "child around2 start"
           block.call
           pass "child around2 end"
         end
-        teardown { pass "child teardown2" }
+        teardown{ pass "child teardown2" }
       end
-    }
-    let(:test1) {
-      Factory.test("t", Factory.context_info(context_class1)) { pass "TEST" }
-    }
+    end
 
     should "run the arounds outside of the setups/teardowns/test" do
       assert_that(test_run_result_count(:pass)).equals(13)
@@ -339,7 +355,7 @@ class Assert::Test
         "parent around start", "child around1 start", "child around2 start",
         "parent setup", "child setup1", "child setup2", "TEST",
         "child teardown1", "child teardown2", "parent teardown",
-        "child around2 end", "child around1 end", "parent around end"
+        "child around2 end", "child around1 end", "parent around end",
       ]
       assert_that(test_run_result_messages).equals(exp)
     end

data/test/unit/actual_value_tests.rb

@@ -1,29 +1,34 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/actual_value"
 
 class Assert::ActualValue
   class UnitTests < Assert::Context
     desc "Assert::ActualValue"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::ActualValue }
+    let(:unit_class){ Assert::ActualValue }
   end
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new(actual_value1, context: context1) }
+    subject{ unit_class.new(actual_value1, context: context1) }
 
-    let(:actual_value1) { Factory.string }
-    let(:context1) { Factory.modes_off_context }
+    let(:actual_value1){ Factory.string }
+    let(:context1){ Factory.modes_off_context }
 
     should have_imeths :returns_true, :does_not_return_true
     should have_imeths :raises, :does_not_raise
+    should have_imeths :changes, :does_not_change
+    should have_imeths :is_a, :is_not_a
     should have_imeths :is_a_kind_of, :is_not_a_kind_of
     should have_imeths :is_kind_of, :is_not_kind_of
     should have_imeths :is_an_instance_of, :is_not_an_instance_of
     should have_imeths :is_instance_of, :is_not_instance_of
     should have_imeths :responds_to, :does_not_respond_to
     should have_imeths :is_the_same_as, :is_not_the_same_as
+    should have_imeths :is, :is_not
     should have_imeths :equals, :does_not_equal
     should have_imeths :is_equal_to, :is_not_equal_to
     should have_imeths :matches, :does_not_match
@@ -38,14 +43,14 @@ class Assert::ActualValue
   class MethodsTests < InitTests
     desc "methods"
 
-    let(:args1) { Factory.integer(3).times.map { Factory.string } }
-    let(:capture_last_call_block) { ->(call) { @last_call = call } }
+    let(:args1){ Factory.integer(3).times.map{ Factory.string } }
+    let(:capture_last_call_block){ ->(call){ @last_call = call } }
 
     should "call to their equivalent context methods" do
       assert_calls(
         :assert_block,
         when_calling: :returns_true,
-        on_value: -> {}
+        on_value: ->{},
       ) do |value, call|
         assert_equal args1, call.args
         assert_equal value, call.block
@@ -54,7 +59,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_block,
         when_calling: :does_not_return_true,
-        on_value: -> {}
+        on_value: ->{},
       ) do |value, call|
         assert_equal args1, call.args
         assert_equal value, call.block
@@ -63,7 +68,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_raises,
         when_calling: :raises,
-        on_value: -> {}
+        on_value: ->{},
       ) do |value, call|
         assert_equal args1, call.args
         assert_equal value, call.block
@@ -72,40 +77,74 @@ class Assert::ActualValue
       assert_calls(
         :assert_nothing_raised,
         when_calling: :does_not_raise,
-        on_value: -> {}
+        on_value: ->{},
+      ) do |value, call|
+        assert_equal args1, call.args
+        assert_equal value, call.block
+      end
+
+      assert_calls(
+        :assert_changes,
+        when_calling: :changes,
+        on_value: ->{},
+      ) do |value, call|
+        assert_equal args1, call.args
+        assert_equal value, call.block
+      end
+
+      assert_calls(
+        :assert_not_changes,
+        when_calling: :does_not_change,
+        on_value: ->{},
       ) do |value, call|
         assert_equal args1, call.args
         assert_equal value, call.block
       end
 
       assert_calls(
-        :assert_kind_of,
+        :assert_is_a,
+        when_calling: [:is_a, String],
+        on_value: actual_value1,
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_is_a,
         when_calling: [:is_a_kind_of, String],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [String, value, *args1], call.args
       end
 
       assert_calls(
-        :assert_kind_of,
+        :assert_is_a,
         when_calling: [:is_kind_of, String],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [String, value, *args1], call.args
       end
 
       assert_calls(
-        :assert_not_kind_of,
+        :assert_is_not_a,
+        when_calling: [:is_not_a, String],
+        on_value: actual_value1,
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_is_not_a,
         when_calling: [:is_not_a_kind_of, String],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [String, value, *args1], call.args
       end
 
       assert_calls(
-        :assert_not_kind_of,
+        :assert_is_not_a,
         when_calling: [:is_not_kind_of, String],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [String, value, *args1], call.args
       end
@@ -113,7 +152,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_instance_of,
         when_calling: [:is_an_instance_of, String],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [String, value, *args1], call.args
       end
@@ -121,7 +160,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_instance_of,
         when_calling: [:is_instance_of, String],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [String, value, *args1], call.args
       end
@@ -129,7 +168,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_instance_of,
         when_calling: [:is_not_an_instance_of, String],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [String, value, *args1], call.args
       end
@@ -137,7 +176,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_instance_of,
         when_calling: [:is_not_instance_of, String],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [String, value, *args1], call.args
       end
@@ -145,7 +184,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_responds_to,
         when_calling: [:responds_to, :method],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [:method, value, *args1], call.args
       end
@@ -153,7 +192,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_responds_to,
         when_calling: [:does_not_respond_to, :method],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [:method, value, *args1], call.args
       end
@@ -161,7 +200,15 @@ class Assert::ActualValue
       assert_calls(
         :assert_same,
         when_calling: [:is_the_same_as, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_same,
+        when_calling: [:is, "something"],
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -169,7 +216,15 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_same,
         when_calling: [:is_not_the_same_as, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_same,
+        when_calling: [:is_not, "something"],
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -177,7 +232,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_equal,
         when_calling: [:equals, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -185,7 +240,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_equal,
         when_calling: [:is_equal_to, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -193,7 +248,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_equal,
         when_calling: [:does_not_equal, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -201,7 +256,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_equal,
         when_calling: [:is_not_equal_to, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -209,7 +264,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_match,
         when_calling: [:matches, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -217,7 +272,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_match,
         when_calling: [:does_not_match, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -225,7 +280,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_empty,
         when_calling: :is_empty,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -233,7 +288,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_empty,
         when_calling: :is_not_empty,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -241,7 +296,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_includes,
         when_calling: [:includes, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -249,7 +304,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_includes,
         when_calling: [:does_not_include, "something"],
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal ["something", value, *args1], call.args
       end
@@ -257,7 +312,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_nil,
         when_calling: :is_nil,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -265,7 +320,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_nil,
         when_calling: :is_not_nil,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -273,7 +328,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_true,
         when_calling: :is_true,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -281,7 +336,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_true,
         when_calling: :is_not_true,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -289,7 +344,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_false,
         when_calling: :is_false,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -297,7 +352,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_false,
         when_calling: :is_not_false,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -305,7 +360,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_file_exists,
         when_calling: :is_a_file,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -313,7 +368,7 @@ class Assert::ActualValue
       assert_calls(
         :assert_not_file_exists,
         when_calling: :is_not_a_file,
-        on_value: actual_value1
+        on_value: actual_value1,
       ) do |value, call|
         assert_equal [value, *args1], call.args
       end
@@ -325,7 +380,9 @@ class Assert::ActualValue
       @last_call = nil
       Assert.stub_on_call(context1, context_method, &capture_last_call_block)
 
-      unit_class.new(on_value, context: context1).public_send(*[*when_calling, *args1])
+      unit_class
+        .new(on_value, context: context1)
+        .public_send(*when_calling, *args1)
       yield(on_value, @last_call)
 
       Assert.unstub(context1, context_method)