minitest-mock_expectations 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bea8d6f91af92ae5f55ffb36919b36e9509e6358832b0a52dde9bd5fcd65d7ff
-  data.tar.gz: 1dce0a9264cc9c43aa074900b9a8be6dc5f816368c9cb4366a4c76f41328b953
+  metadata.gz: 01ebd3a13e010b674980be321ca63719fa38bf64d7c048d821cc4cf1347754af
+  data.tar.gz: 8519365b930a963f82593a4b3d59bff209889f69d1e2e53a59c4d4d01331ccee
 SHA512:
-  metadata.gz: 0a3fa1196dd9a91d7924dad39649eabfab8f6ca189c38065dbbf90c0b14ed1e07a55159b92d3bef9ee4fa8f2809cf36c62a81356208616e318296a97988b1003
-  data.tar.gz: 89a4de17e26c12f095c6fb5835f6142fc0ae8eb3e93153d299727de8fff5d68907a74ac74fe1841ef676d6bef9c1657d857b3d3b9cf28f518f1de2b7ea9f02c9
+  metadata.gz: 2d823714a5f198e096f308200bd902d13fe5536df4595de8e6b68ff276518b680a1bf2bf81853645f268a55398d79e780f1c1a38b6b31a6fdc5c9b0a16865c8e
+  data.tar.gz: 3ac1d6d54e1efb6442c36a2a76773f3b5e70196ab98b380501ef8312daf94644b28c4aff5d6682c4c31d1733fc7933f2c6de229fcf7c212a2e15becf9979e1ac

data/.travis.yml

@@ -1,7 +1,7 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.5.1
+  - 2.5.3
 before_install: gem install bundler
 
 matrix:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    minitest-mock_expectations (0.9.0)
+    minitest-mock_expectations (1.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -19,4 +19,4 @@ DEPENDENCIES
   rake (~> 10.0)
 
 BUNDLED WITH
-   1.16.2
+   1.16.6

data/README.md

@@ -1,13 +1,13 @@
 # minitest-mock_expectations
 
-Provides method call assertions.
+Provides method call assertions for minitest
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'minitest-mock_expectations'
+gem "minitest-mock_expectations"
 ```
 
 And then execute:
@@ -58,23 +58,23 @@ def setup
     body: "https://bogdanvlviv.com/posts/ruby/rails/what-is-new-in-rails-6_0.html",
     comments: [
       "Looking really good.",
-      "I'm really like this post."
+      "I really like this post."
     ]
   )
 end
 ```
 
-### assert_called
+### assert_called(object, method_name, message = nil, times: 1, returns: nil)
 
-Asserts that the method will be called once on the object in the block:
+Asserts that the method will be called on the `object` in the block
 
 ```ruby
-assert_called @post, :title do
+assert_called(@post, :title) do
   @post.title
 end
 ```
 
-In order to assert that the method will be called multiple times on the object in the block set `:times` option:
+In order to assert that the method will be called multiple times on the `object` in the block set `:times` option:
 
 ```ruby
 assert_called(@post, :title, times: 2) do
@@ -93,19 +93,23 @@ end
 assert_equal "What is new in Rails 6.0", @object.title
 ```
 
-### assert_not_called
+### refute_called(object, method_name, message = nil, &block)
 
-Asserts that the method will not be called on the object in the block:
+Asserts that the method will not be called on the `object` in the block
 
 ```ruby
-assert_not_called(@post, :title) do
+refute_called(@post, :title) do
   @post.body
 end
 ```
 
-### assert_called_with
+### assert_not_called
+
+Alias for `refute_called`.
+
+### assert_called_with(object, method_name, arguments, returns: nil)
 
-Asserts that the method will be called with the arguments once on the object in the block:
+Asserts that the method will be called with the `arguments` on the `object` in the block
 
 ```ruby
 assert_called_with(@post, :add_comment, ["Thanks for sharing this."]) do
@@ -123,7 +127,7 @@ end
 assert_equal "Thank you!", @post.add_comment("Thanks for sharing this.")
 ```
 
-You can also assert that the method will be called with different arguments once on the object in the block:
+You can also assert that the method will be called with different `arguments` on the `object` in the block:
 
 ```ruby
 assert_called_with(@post, :add_comment, [["Thanks for sharing this."], ["Thanks!"]]) do
@@ -132,17 +136,17 @@ assert_called_with(@post, :add_comment, [["Thanks for sharing this."], ["Thanks!
 end
 ```
 
-### assert_called_on_instance_of
+### assert_called_on_instance_of(klass, method_name, message = nil, times: 1, returns: nil)
 
-Asserts that the method will be called once on an instance of the klass in the block:
+Asserts that the method will be called on an instance of the `klass` in the block
 
 ```ruby
-assert_called_on_instance_of Post, :title do
+assert_called_on_instance_of(Post, :title) do
   @post.title
 end
 ```
 
-In order to assert that the method will be called multiple times on an instance of the klass in the block set `:times` option:
+In order to assert that the method will be called multiple times on an instance of the `klass` in the block set `:times` option:
 
 ```ruby
 assert_called_on_instance_of(Post, :title, times: 2) do
@@ -161,7 +165,7 @@ end
 assert_equal "What is new in Rails 6.0", @post.title
 ```
 
-Use nesting of the blocks in order assert that the several methods will be called on an instance of the klass in the block:
+Use nesting of the blocks in order assert that the several methods will be called on an instance of the `klass` in the block:
 
 ```ruby
 assert_called_on_instance_of(Post, :title, times: 3) do
@@ -175,25 +179,29 @@ assert_called_on_instance_of(Post, :title, times: 3) do
 end
 ```
 
-### assert_not_called_on_instance_of
+### refute_called_on_instance_of(klass, method_name, message = nil, &block)
 
-Asserts that the method will not be called once on an instance of the klass in the block:
+Asserts that the method will not be called on an instance of the `klass` in the block
 
 ```ruby
-assert_not_called(@post, :title) do
+refute_called(@post, :title) do
   @post.body
 end
 ```
 
-Use nesting of the blocks in order assert that the several methods will not be called on an instance of the klass in the block:
+Use nesting of the blocks in order assert that the several methods will not be called on an instance of the `klass` in the block:
 
 ```ruby
-assert_not_called_on_instance_of(Post, :title) do
-  assert_not_called_on_instance_of(Post, :body) do
+refute_called_on_instance_of(Post, :title) do
+  refute_called_on_instance_of(Post, :body) do
   end
 end
 ```
 
+### assert_not_called_on_instance_of
+
+Alias for `refute_called_on_instance_of`.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/bogdanvlviv/minitest-mock_expectations. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](https://contributor-covenant.org) code of conduct.

data/lib/minitest/mock_expectations/assertions.rb

@@ -3,7 +3,7 @@ require "minitest/assertions"
 require "minitest/mock"
 
 module Minitest
-  # Provides method call assertions
+  # Provides method call assertions for minitest
   #
   # Imagine we have model +Post+:
   #
@@ -32,18 +32,18 @@ module Minitest
   #       body: "https://bogdanvlviv.com/posts/ruby/rails/what-is-new-in-rails-6_0.html",
   #       comments: [
   #         "Looking really good.",
-  #         "I'm really like this post."
+  #         "I really like this post."
   #       ]
   #     )
   #   end
   module Assertions
-    # Asserts that the method will be called once on the object in the block:
+    # Asserts that the method will be called on the +object+ in the block
     #
-    #   assert_called @post, :title do
+    #   assert_called(@post, :title) do
     #     @post.title
     #   end
     #
-    # In order to assert that the method will be called multiple times on the object in the block set +:times+ option:
+    # In order to assert that the method will be called multiple times on the +object+ in the block set +:times+ option:
     #
     #   assert_called(@post, :title, times: 2) do
     #     @post.title
@@ -67,16 +67,18 @@ module Minitest
       assert_equal times, times_called, error
     end
 
-    # Asserts that the method will not be called on the object in the block:
+    # Asserts that the method will not be called on the +object+ in the block
     #
-    #   assert_not_called(@post, :title) do
+    #   refute_called(@post, :title) do
     #     @post.body
     #   end
-    def assert_not_called(object, method_name, message = nil, &block)
+    def refute_called(object, method_name, message = nil, &block)
       assert_called(object, method_name, message, times: 0, &block)
     end
 
-    # Asserts that the method will be called with the arguments once on the object in the block:
+    alias assert_not_called refute_called
+
+    # Asserts that the method will be called with the +arguments+ on the +object+ in the block
     #
     #   assert_called_with(@post, :add_comment, ["Thanks for sharing this."]) do
     #     @post.add_comment("Thanks for sharing this.")
@@ -90,19 +92,19 @@ module Minitest
     #
     #   assert_equal "Thank you!", @post.add_comment("Thanks for sharing this.")
     #
-    # You can also assert that the method will be called with different arguments once on the object in the block:
+    # You can also assert that the method will be called with different +arguments+ on the +object+ in the block:
     #
     #   assert_called_with(@post, :add_comment, [["Thanks for sharing this."], ["Thanks!"]]) do
     #     @post.add_comment("Thanks for sharing this.")
     #     @post.add_comment("Thanks!")
     #   end
-    def assert_called_with(object, method_name, args, returns: nil)
+    def assert_called_with(object, method_name, arguments, returns: nil)
       mock = Minitest::Mock.new
 
-      if args.all? { |arg| arg.is_a?(Array) }
-        args.each { |arg| mock.expect(:call, returns, arg) }
+      if arguments.all? { |argument| argument.is_a?(Array) }
+        arguments.each { |argument| mock.expect(:call, returns, argument) }
       else
-        mock.expect(:call, returns, args)
+        mock.expect(:call, returns, arguments)
       end
 
       object.stub(method_name, mock) { yield }
@@ -110,13 +112,13 @@ module Minitest
       mock.verify
     end
 
-    # Asserts that the method will be called once on an instance of the klass in the block:
+    # Asserts that the method will be called on an instance of the +klass+ in the block
     #
-    #   assert_called_on_instance_of Post, :title do
+    #   assert_called_on_instance_of(Post, :title) do
     #     @post.title
     #   end
     #
-    # In order to assert that the method will be called multiple times on an instance of the klass in the block set +:times+ option:
+    # In order to assert that the method will be called multiple times on an instance of the +klass+ in the block set +:times+ option:
     #
     #   assert_called_on_instance_of(Post, :title, times: 2) do
     #     @post.title
@@ -131,7 +133,7 @@ module Minitest
     #
     #   assert_equal "What is new in Rails 6.0", @post.title
     #
-    # Use nesting of the blocks in order assert that the several methods will be called on an instance of the klass in the block:
+    # Use nesting of the blocks in order assert that the several methods will be called on an instance of the +klass+ in the block:
     #
     #   assert_called_on_instance_of(Post, :title, times: 3) do
     #     assert_called_on_instance_of(Post, :body, times: 2) do
@@ -166,20 +168,23 @@ module Minitest
       klass.send(:undef_method, "stubbed_#{method_name}")
     end
 
-    # Asserts that the method will not be called once on an instance of the klass in the block:
+    # Asserts that the method will not be called on an instance of the +klass+ in the block
     #
-    #   assert_not_called(@post, :title) do
+    #   refute_called_on_instance_of(Post, :title) do
     #     @post.body
     #   end
     #
-    # Use nesting of the blocks in order assert that the several methods will not be called on an instance of the klass in the block:
+    # Use nesting of the blocks in order assert that the several methods will not be called on an instance of the +klass+ in the block:
     #
-    #   assert_not_called_on_instance_of(Post, :title) do
-    #     assert_not_called_on_instance_of(Post, :body) do
+    #   refute_called_on_instance_of(Post, :title) do
+    #     refute_called_on_instance_of(Post, :body) do
+    #       @post.add_comment("Thanks for sharing this.")
     #     end
     #   end
-    def assert_not_called_on_instance_of(klass, method_name, message = nil, &block)
+    def refute_called_on_instance_of(klass, method_name, message = nil, &block)
       assert_called_on_instance_of(klass, method_name, message, times: 0, &block)
     end
+
+    alias assert_not_called_on_instance_of refute_called_on_instance_of
   end
 end

data/lib/minitest/mock_expectations/version.rb

@@ -1,5 +1,5 @@
 module Minitest
   module MockExpectations
-    VERSION = "0.9.0"
+    VERSION = "1.0.0"
   end
 end

data/minitest-mock_expectations.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["bogdanvlviv"]
   spec.email         = ["bogdanvlviv@gmail.com"]
 
-  spec.summary       = "Provides method call assertions"
+  spec.summary       = "Provides method call assertions for minitest"
   spec.description   = ""
   spec.homepage      = "https://github.com/bogdanvlviv/minitest-mock_expectations"
   spec.license       = "MIT"

data/test/minitest/mock_expectations/assertions_test.rb

@@ -24,13 +24,13 @@ class Minitest::MockExpectations::AssertionsTest < Minitest::Test
       body: "https://bogdanvlviv.com/posts/ruby/rails/what-is-new-in-rails-6_0.html",
       comments: [
         "Looking really good.",
-        "I'm really like this post."
+        "I really like this post."
       ]
     )
   end
 
   def test_assert_called_with_defaults_to_expect_once
-    assert_called @post, :title do
+    assert_called(@post, :title) do
       @post.title
     end
   end
@@ -59,35 +59,51 @@ class Minitest::MockExpectations::AssertionsTest < Minitest::Test
   def test_assert_called_failure
     error = assert_raises(Minitest::Assertion) do
       assert_called(@post, :title) do
+        @post.body
       end
     end
 
     assert_equal "Expected title to be called 1 times, but was called 0 times.\nExpected: 1\n  Actual: 0", error.message
   end
 
-  def test_assert_not_called
-    assert_not_called(@post, :title) do
+  def test_assert_called_with_message
+    error = assert_raises(Minitest::Assertion) do
+      assert_called(@post, :title, "Message") do
+        @post.body
+      end
+    end
+
+    assert_equal "Message.\nExpected title to be called 1 times, but was called 0 times.\nExpected: 1\n  Actual: 0", error.message
+  end
+
+  def test_refute_called
+    refute_called(@post, :title) do
       @post.body
     end
   end
 
-  def test_assert_not_called_failure
+  def test_refute_called_failure
     error = assert_raises(Minitest::Assertion) do
-      assert_not_called(@post, :title) do
-        @post.title
+      refute_called(@post, :add_comment) do
+        @post.add_comment("Thanks for sharing this.")
       end
     end
 
-    assert_equal "Expected title to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
+    assert_equal "Expected add_comment to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
   end
 
-  def test_assert_called_with_message
+  def test_refute_called_with_message
     error = assert_raises(Minitest::Assertion) do
-      assert_called(@post, :title, "Message") do
+      refute_called(@post, :title, "Message") do
+        @post.title
       end
     end
 
-    assert_equal "Message.\nExpected title to be called 1 times, but was called 0 times.\nExpected: 1\n  Actual: 0", error.message
+    assert_equal "Message.\nExpected title to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
+  end
+
+  def test_assert_not_called_is_alias_for_refute_called
+    assert method(:assert_not_called).eql?(method(:refute_called))
   end
 
   def test_assert_called_with_arguments
@@ -120,7 +136,7 @@ class Minitest::MockExpectations::AssertionsTest < Minitest::Test
   end
 
   def test_assert_called_on_instance_of_with_defaults_to_expect_once
-    assert_called_on_instance_of Post, :title do
+    assert_called_on_instance_of(Post, :title) do
       @post.title
     end
   end
@@ -149,6 +165,7 @@ class Minitest::MockExpectations::AssertionsTest < Minitest::Test
   def test_assert_called_on_instance_of_failure
     error = assert_raises(Minitest::Assertion) do
       assert_called_on_instance_of(Post, :title) do
+        @post.body
       end
     end
 
@@ -158,6 +175,7 @@ class Minitest::MockExpectations::AssertionsTest < Minitest::Test
   def test_assert_called_on_instance_of_with_message
     error = assert_raises(Minitest::Assertion) do
       assert_called_on_instance_of(Post, :title, "Message") do
+        @post.body
       end
     end
 
@@ -176,26 +194,41 @@ class Minitest::MockExpectations::AssertionsTest < Minitest::Test
     end
   end
 
-  def test_assert_not_called_on_instance_of
-    assert_not_called_on_instance_of(Post, :title) do
+  def test_refute_called_on_instance_of
+    refute_called_on_instance_of(Post, :title) do
       @post.body
     end
   end
 
-  def test_assert_not_called_on_instance_of_failure
+  def test_refute_called_on_instance_of_failure
+    error = assert_raises(Minitest::Assertion) do
+      refute_called_on_instance_of(Post, :add_comment) do
+        @post.add_comment("Thanks for sharing this.")
+      end
+    end
+
+    assert_equal "Expected add_comment to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
+  end
+
+  def test_refute_called_on_instance_of_with_message
     error = assert_raises(Minitest::Assertion) do
-      assert_not_called_on_instance_of(Post, :title) do
+      refute_called_on_instance_of(Post, :title, "Message") do
         @post.title
       end
     end
 
-    assert_equal "Expected title to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
+    assert_equal "Message.\nExpected title to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
   end
 
-  def test_assert_not_called_on_instance_of_nesting
-    assert_not_called_on_instance_of(Post, :title) do
-      assert_not_called_on_instance_of(Post, :body) do
+  def test_refute_called_on_instance_of_nesting
+    refute_called_on_instance_of(Post, :title) do
+      refute_called_on_instance_of(Post, :body) do
+        @post.add_comment("Thanks for sharing this.")
       end
     end
   end
+
+  def test_assert_called_on_instance_of_is_alias_for_refute_called
+    assert method(:assert_not_called_on_instance_of).eql?(method(:refute_called_on_instance_of))
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-mock_expectations
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - bogdanvlviv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-18 00:00:00.000000000 Z
+date: 2018-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -59,7 +59,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
 - ".travis.yml"
 - Gemfile
 - Gemfile.lock
@@ -96,5 +95,5 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: Provides method call assertions
+summary: Provides method call assertions for minitest
 test_files: []