assert 2.18.2 → 2.19.2

data/test/system/test_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 
 class Assert::Test
@@ -6,332 +8,322 @@ class Assert::Test
     include Assert::Test::TestHelpers
 
     desc "Assert::Test"
-    subject{ @test }
+
+    setup do
+      subject.run(&test_run_callback)
+    end
   end
 
   class NoResultsTests < SystemTests
     desc "when producing no results"
-    setup do
-      @test = Factory.test
-      @test.run(&test_run_callback)
-    end
+    subject { Factory.test }
 
     should "generate 0 results" do
-      assert_equal 0, test_run_result_count
+      assert_that(test_run_result_count).equals(0)
     end
   end
 
   class PassTests < SystemTests
     desc "when passing a single assertion"
-    setup do
-      @test = Factory.test{ assert(1 == 1) }
-      @test.run(&test_run_callback)
-    end
+    subject { Factory.test{ assert(1 == 1) } }
 
     should "generate 1 result" do
-      assert_equal 1, test_run_result_count
+      assert_that(test_run_result_count).equals(1)
     end
 
     should "generate 1 pass result" do
-      assert_equal 1, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(1)
     end
   end
 
   class FailTests < SystemTests
     desc "when failing a single assertion"
-    setup do
-      @test = Factory.test{ assert(1 == 0) }
-      @test.run(&test_run_callback)
-    end
+    subject { Factory.test{ assert(1 == 0) } }
 
     should "generate 1 result" do
-      assert_equal 1, test_run_result_count
+      assert_that(test_run_result_count).equals(1)
     end
 
     should "generate 1 fail result" do
-      assert_equal 1, test_run_result_count(:fail)
+      assert_that(test_run_result_count(:fail)).equals(1)
     end
   end
 
   class SkipTests < SystemTests
     desc "when skipping once"
-    setup do
-      @test = Factory.test{ skip }
-      @test.run(&test_run_callback)
-    end
+    subject { Factory.test{ skip } }
 
     should "generate 1 result" do
-      assert_equal 1, test_run_result_count
+      assert_that(test_run_result_count).equals(1)
     end
 
     should "generate 1 skip result" do
-      assert_equal 1, test_run_result_count(:skip)
+      assert_that(test_run_result_count(:skip)).equals(1)
     end
   end
 
   class ErrorTests < SystemTests
     desc "when erroring once"
-    setup do
-      @test = Factory.test{ raise("WHAT") }
-      @test.run(&test_run_callback)
-    end
+    subject { Factory.test{ raise("WHAT") } }
 
     should "generate 1 result" do
-      assert_equal 1, test_run_result_count
+      assert_that(test_run_result_count).equals(1)
     end
 
     should "generate 1 error result" do
-      assert_equal 1, test_run_result_count(:error)
+      assert_that(test_run_result_count(:error)).equals(1)
     end
   end
 
   class MixedTests < SystemTests
     desc "when passing 1 assertion and failing 1 assertion"
-    setup do
-      @test = Factory.test do
+    subject {
+      Factory.test do
         assert(1 == 1)
         assert(1 == 0)
       end
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "generate 2 total results" do
-      assert_equal 2, test_run_result_count
+      assert_that(test_run_result_count).equals(2)
     end
 
     should "generate 1 pass result" do
-      assert_equal 1, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(1)
     end
 
     should "generate 1 fail result" do
-      assert_equal 1, test_run_result_count(:fail)
+      assert_that(test_run_result_count(:fail)).equals(1)
     end
   end
 
   class MixedSkipTests < SystemTests
     desc "when passing 1 assertion and failing 1 assertion with a skip call in between"
-    setup do
-      @test = Factory.test do
+    subject {
+      Factory.test do
         assert(1 == 1)
         skip
         assert(1 == 0)
       end
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "generate 2 total results" do
-      assert_equal 2, test_run_result_count
+      assert_that(test_run_result_count).equals(2)
     end
 
     should "generate a skip for its last result" do
-      assert_kind_of Assert::Result::Skip, last_test_run_result
+      assert_that(last_test_run_result).is_kind_of(Assert::Result::Skip)
     end
 
     should "generate 1 pass result" do
-      assert_equal 1, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(1)
     end
 
     should "generate 1 skip result" do
-      assert_equal 1, test_run_result_count(:skip)
+      assert_that(test_run_result_count(:skip)).equals(1)
     end
 
     should "generate 0 fail results" do
-      assert_equal 0, test_run_result_count(:fail)
+      assert_that(test_run_result_count(:fail)).equals(0)
     end
   end
 
   class MixedErrorTests < SystemTests
     desc "when passing 1 assertion and failing 1 assertion with an exception raised in between"
-    setup do
-      @test = Factory.test do
+    subject {
+      Factory.test do
         assert(1 == 1)
         raise Exception, "something errored"
         assert(1 == 0)
       end
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "generate 2 total results" do
-      assert_equal 2, test_run_result_count
+      assert_that(test_run_result_count).equals(2)
     end
 
     should "generate an error for its last result" do
-      assert_kind_of Assert::Result::Error, last_test_run_result
+      assert_that(last_test_run_result).is_kind_of(Assert::Result::Error)
     end
 
     should "generate 1 pass result" do
-      assert_equal 1, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(1)
     end
 
     should "generate 1 error result" do
-      assert_equal 1, test_run_result_count(:error)
+      assert_that(test_run_result_count(:error)).equals(1)
     end
 
     should "generate 0 fail results" do
-      assert_equal 0, test_run_result_count(:fail)
+      assert_that(test_run_result_count(:fail)).equals(0)
     end
   end
 
   class MixedPassTests < SystemTests
     desc "when passing 1 assertion and failing 1 assertion with a pass call in between"
-    setup do
-      @test = Factory.test do
+    subject {
+      Factory.test do
         assert(1 == 1)
         pass
         assert(1 == 0)
       end
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "generate 3 total results" do
-      assert_equal 3, test_run_result_count
+      assert_that(test_run_result_count).equals(3)
     end
 
     should "generate a fail for its last result" do
-      assert_kind_of Assert::Result::Fail, last_test_run_result
+      assert_that(last_test_run_result).is_kind_of(Assert::Result::Fail)
     end
 
     should "generate 2 pass results" do
-      assert_equal 2, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(2)
     end
 
     should "generate 1 fail result" do
-      assert_equal 1, test_run_result_count(:fail)
+      assert_that(test_run_result_count(:fail)).equals(1)
     end
   end
 
   class MixedFailTests < SystemTests
     desc "when failing 1 assertion and passing 1 assertion with a fail call in between"
-    setup do
-      @test = Factory.test do
+    subject {
+      Factory.test do
         assert(1 == 0)
         fail
         assert(1 == 1)
       end
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "generate 3 total results" do
-      assert_equal 3, test_run_result_count
+      assert_that(test_run_result_count).equals(3)
     end
 
     should "generate a pass for its last result" do
-      assert_kind_of Assert::Result::Pass, last_test_run_result
+      assert_that(last_test_run_result).is_kind_of(Assert::Result::Pass)
     end
 
     should "generate 1 pass result" do
-      assert_equal 1, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(1)
     end
 
     should "generate 2 fail results" do
-      assert_equal 2, test_run_result_count(:fail)
+      assert_that(test_run_result_count(:fail)).equals(2)
     end
   end
 
   class MixedFlunkTests < SystemTests
     desc "has failing 1 assertion and passing 1 assertion with a flunk call in between"
-    setup do
-      @test = Factory.test do
+    subject {
+      Factory.test do
         assert(1 == 0)
         flunk
         assert(1 == 1)
       end
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "generate 3 total results" do
-      assert_equal 3, test_run_result_count
+      assert_that(test_run_result_count).equals(3)
     end
 
     should "generate a pass for its last result" do
-      assert_kind_of Assert::Result::Pass, last_test_run_result
+      assert_that(last_test_run_result).is_kind_of(Assert::Result::Pass)
     end
 
     should "generate 1 pass results" do
-      assert_equal 1, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(1)
     end
 
     should "generate 2 fail results" do
-      assert_equal 2, test_run_result_count(:fail)
+      assert_that(test_run_result_count(:fail)).equals(2)
     end
   end
 
   class WithSetupsTests < SystemTests
     desc "that has setup logic"
-    setup do
-      @context_class = Factory.context_class do
+    subject {
+      Factory.test("t", Factory.context_info(context_class1)) { pass "TEST" }
+    }
+
+    let(:context_class1) {
+      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
       end
-      @test = Factory.test("t", Factory.context_info(@context_class)){ pass "TEST" }
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "execute all setup logic when run" do
-      assert_equal 3, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(3)
 
       exp = ["assert style setup", "test/unit style setup", "TEST"]
-      assert_equal exp, test_run_result_messages
+      assert_that(test_run_result_messages).equals(exp)
     end
   end
 
   class WithTeardownsTests < SystemTests
     desc "that has teardown logic"
-    setup do
-      @context_class = Factory.context_class do
+    subject {
+      Factory.test("t", Factory.context_info(context_class1)) { pass "TEST" }
+    }
+
+    let(:context_class1) {
+      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
       end
-      @test = Factory.test("t", Factory.context_info(@context_class)){ pass "TEST" }
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "execute all teardown logic when run" do
-      assert_equal 3, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(3)
 
       exp = ["TEST", "assert style teardown", "test/unit style teardown"]
-      assert_equal exp, test_run_result_messages
+      assert_that(test_run_result_messages).equals(exp)
     end
   end
 
   class WithAroundsTests < SystemTests
     desc "that has around logic (in addition to setups/teardowns)"
-    setup do
-      @parent_context_class = Factory.modes_off_context_class do
+    subject {
+      Factory.test("t", Factory.context_info(context_class1)) { pass "TEST" }
+    }
+
+    let(:parent_context_class1) {
+      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
-      @context_class = Factory.modes_off_context_class(@parent_context_class) do
-        setup{ pass "child setup1" }
+    }
+    let(:context_class1) {
+      Factory.modes_off_context_class(parent_context_class1) do
+        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
-      @test = Factory.test("t", Factory.context_info(@context_class)){ pass "TEST" }
-      @test.run(&test_run_callback)
-    end
+    }
 
     should "run the arounds outside of the setups/teardowns/test" do
-      assert_equal 13, test_run_result_count(:pass)
+      assert_that(test_run_result_count(:pass)).equals(13)
 
       exp = [
         "parent around start", "child around1 start", "child around2 start",
@@ -339,7 +331,7 @@ class Assert::Test
         "child teardown1", "child teardown2", "parent teardown",
         "child around2 end", "child around1 end", "parent around end"
       ]
-      assert_equal exp, test_run_result_messages
+      assert_that(test_run_result_messages).equals(exp)
     end
   end
 end

data/test/unit/actual_value_tests.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+require "assert"
+require "assert/actual_value"
+
+class Assert::ActualValue
+  class UnitTests < Assert::Context
+    desc "Assert::ActualValue"
+    subject { unit_class }
+
+    let(:unit_class) { Assert::ActualValue }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.new(actual_value1, context: context1) }
+
+    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_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
+    should have_imeths :is_empty, :is_not_empty
+    should have_imeths :includes, :does_not_include
+    should have_imeths :is_nil, :is_not_nil
+    should have_imeths :is_true, :is_not_true
+    should have_imeths :is_false, :is_not_false
+    should have_imeths :is_a_file, :is_not_a_file
+  end
+
+  class MethodsTests < InitTests
+    desc "methods"
+
+    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: -> {}
+      ) do |value, call|
+        assert_equal args1, call.args
+        assert_equal value, call.block
+      end
+
+      assert_calls(
+        :assert_not_block,
+        when_calling: :does_not_return_true,
+        on_value: -> {}
+      ) do |value, call|
+        assert_equal args1, call.args
+        assert_equal value, call.block
+      end
+
+      assert_calls(
+        :assert_raises,
+        when_calling: :raises,
+        on_value: -> {}
+      ) do |value, call|
+        assert_equal args1, call.args
+        assert_equal value, call.block
+      end
+
+      assert_calls(
+        :assert_nothing_raised,
+        when_calling: :does_not_raise,
+        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,
+        when_calling: [:is_a_kind_of, String],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_kind_of,
+        when_calling: [:is_kind_of, String],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_kind_of,
+        when_calling: [:is_not_a_kind_of, String],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_kind_of,
+        when_calling: [:is_not_kind_of, String],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_instance_of,
+        when_calling: [:is_an_instance_of, String],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_instance_of,
+        when_calling: [:is_instance_of, String],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_instance_of,
+        when_calling: [:is_not_an_instance_of, String],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_instance_of,
+        when_calling: [:is_not_instance_of, String],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [String, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_responds_to,
+        when_calling: [:responds_to, :method],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [:method, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_responds_to,
+        when_calling: [:does_not_respond_to, :method],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [:method, value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_same,
+        when_calling: [:is_the_same_as, "something"],
+        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
+
+      assert_calls(
+        :assert_not_same,
+        when_calling: [:is_not_the_same_as, "something"],
+        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
+
+      assert_calls(
+        :assert_equal,
+        when_calling: [:equals, "something"],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_equal,
+        when_calling: [:is_equal_to, "something"],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_equal,
+        when_calling: [:does_not_equal, "something"],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_equal,
+        when_calling: [:is_not_equal_to, "something"],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_match,
+        when_calling: [:matches, "something"],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_match,
+        when_calling: [:does_not_match, "something"],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_empty,
+        when_calling: :is_empty,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_empty,
+        when_calling: :is_not_empty,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_includes,
+        when_calling: [:includes, "something"],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_includes,
+        when_calling: [:does_not_include, "something"],
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal ["something", value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_nil,
+        when_calling: :is_nil,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_nil,
+        when_calling: :is_not_nil,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_true,
+        when_calling: :is_true,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_true,
+        when_calling: :is_not_true,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_false,
+        when_calling: :is_false,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_false,
+        when_calling: :is_not_false,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_file_exists,
+        when_calling: :is_a_file,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+
+      assert_calls(
+        :assert_not_file_exists,
+        when_calling: :is_not_a_file,
+        on_value: actual_value1
+      ) do |value, call|
+        assert_equal [value, *args1], call.args
+      end
+    end
+
+    private
+
+    def assert_calls(context_method, when_calling:, on_value:)
+      @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])
+      yield(on_value, @last_call)
+
+      Assert.unstub(context1, context_method)
+      @last_call = nil
+    end
+  end
+end