assert 2.16.5 → 2.18.3

data/test/unit/actual_value_tests.rb

@@ -0,0 +1,335 @@
+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 :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 :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_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_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_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

data/test/unit/assert_tests.rb

@@ -1,11 +1,10 @@
-require 'assert'
+require "assert"
 
-require 'assert/config'
-require 'assert/stub'
-require 'much-stub'
+require "assert/config"
+require "assert/stub"
+require "much-stub"
 
 module Assert
-
   class UnitTests < Assert::Context
     desc "Assert"
     subject { Assert }
@@ -14,99 +13,173 @@ 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
     # nothing runs if it isn't working
-
   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
       context_class = ::Factory.modes_off_context_class do
         setup do
-          Assert.stub('1', :to_s){ 'one' }
+          Assert.stub("1", :to_s){ "one" }
         end
       end
 
-      context_class.run_setups('scope')
-      assert_equal 1, Assert.stubs.size
+      context_class.run_setups("scope")
+      assert_that(Assert.stubs.size).equals(1)
 
-      context_class.run_teardowns('scope')
-      assert_empty Assert.stubs
+      context_class.run_teardowns("scope")
+      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
 
-  end
+    should "be able to add a stub tap" do
+      my_meth_called_with = nil
+      Assert.stub_tap(object1, :mymeth){ |value, *args, &block|
+        my_meth_called_with = args
+      }
 
+      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(object1, :mymeth){ |value, call|
+        my_meth_called_with = call
+      }
+
+      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
+      myclass = Class.new do
+        def one; self; end
+        def two(val); self; end
+        def three; self; end
+        def ready?; false; end
+      end
+      myobj = myclass.new
+
+      spy =
+        Assert.stub_spy(
+          myobj,
+          :one,
+          :two,
+          :three,
+          ready?: true)
+
+      assert_that(myobj.one).equals(spy)
+      assert_that(myobj.two("a")).equals(spy)
+      assert_that(myobj.three).equals(spy)
+
+      assert_that(myobj.one.two("b").three.ready?).is_true
+
+      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