minitest-mock_expectations 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bea8d6f91af92ae5f55ffb36919b36e9509e6358832b0a52dde9bd5fcd65d7ff
+  data.tar.gz: 1dce0a9264cc9c43aa074900b9a8be6dc5f816368c9cb4366a4c76f41328b953
+SHA512:
+  metadata.gz: 0a3fa1196dd9a91d7924dad39649eabfab8f6ca189c38065dbbf90c0b14ed1e07a55159b92d3bef9ee4fa8f2809cf36c62a81356208616e318296a97988b1003
+  data.tar.gz: 89a4de17e26c12f095c6fb5835f6142fc0ae8eb3e93153d299727de8fff5d68907a74ac74fe1841ef676d6bef9c1657d857b3d3b9cf28f518f1de2b7ea9f02c9

data/.travis.yml

@@ -0,0 +1,9 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+before_install: gem install bundler
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    minitest-mock_expectations (0.9.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  minitest (~> 5.0)
+  minitest-mock_expectations!
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 bogdanvlviv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,207 @@
+# minitest-mock_expectations
+
+Provides method call assertions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'minitest-mock_expectations'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install minitest-mock_expectations
+```
+
+## Usage
+
+```ruby
+require "minitest/mock_expectations"
+```
+
+Imagine we have model `Post`:
+
+```ruby
+class Post
+  attr_accessor :title, :body
+  attr_reader :comments
+
+  def initialize(title: "", body: "", comments: [])
+    @title = title
+    @body = body
+    @comments = comments
+  end
+
+  def add_comment(comment)
+    @comments << comment
+
+    "Thank you!"
+  end
+end
+```
+
+and variable `@post` that reffers to instance of `Post`:
+
+```ruby
+def setup
+  @post = Post.new(
+    title: "What is new in Rails 6.0",
+    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."
+    ]
+  )
+end
+```
+
+### assert_called
+
+Asserts that the method will be called once on the object in the block:
+
+```ruby
+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:
+
+```ruby
+assert_called(@post, :title, times: 2) do
+  @post.title
+  @post.title
+end
+```
+
+You can stub the return value of the method in the block via `:returns` option:
+
+```ruby
+assert_called(@post, :title, returns: "What is new in Rails 5.2") do
+  assert_equal "What is new in Rails 5.2", @object.title
+end
+
+assert_equal "What is new in Rails 6.0", @object.title
+```
+
+### assert_not_called
+
+Asserts that the method will not be called on the object in the block:
+
+```ruby
+assert_not_called(@post, :title) do
+  @post.body
+end
+```
+
+### assert_called_with
+
+Asserts that the method will be called with the arguments once on the object in the block:
+
+```ruby
+assert_called_with(@post, :add_comment, ["Thanks for sharing this."]) do
+  @post.add_comment("Thanks for sharing this.")
+end
+```
+
+You can stub the return value of the method in the block via `:returns` option:
+
+```ruby
+assert_called_with(@post, :add_comment, ["Thanks for sharing this."], returns: "Thanks!") do
+  assert_equal "Thanks!", @post.add_comment("Thanks for sharing this.")
+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:
+
+```ruby
+assert_called_with(@post, :add_comment, [["Thanks for sharing this."], ["Thanks!"]]) do
+  @post.add_comment("Thanks for sharing this.")
+  @post.add_comment("Thanks!")
+end
+```
+
+### assert_called_on_instance_of
+
+Asserts that the method will be called once on an instance of the klass in the block:
+
+```ruby
+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:
+
+```ruby
+assert_called_on_instance_of(Post, :title, times: 2) do
+  @post.title
+  @post.title
+end
+```
+
+You can stub the return value of the method in the block via `:returns` option:
+
+```ruby
+assert_called_on_instance_of(Post, :title, returns: "What is new in Rails 5.2") do
+  assert_equal "What is new in Rails 5.2", @post.title
+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:
+
+```ruby
+assert_called_on_instance_of(Post, :title, times: 3) do
+  assert_called_on_instance_of(Post, :body, times: 2) do
+    @post.title
+    @post.body
+    @post.title
+    @post.body
+    @post.title
+  end
+end
+```
+
+### assert_not_called_on_instance_of
+
+Asserts that the method will not be called once on an instance of the klass in the block:
+
+```ruby
+assert_not_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:
+
+```ruby
+assert_not_called_on_instance_of(Post, :title) do
+  assert_not_called_on_instance_of(Post, :body) do
+  end
+end
+```
+
+## 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.
+
+## Code Status
+
+[![travis-ci](https://api.travis-ci.org/bogdanvlviv/minitest-mock_expectations.svg?branch=master)](https://travis-ci.org/bogdanvlviv/minitest-mock_expectations)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/lib/minitest/mock_expectations.rb

@@ -0,0 +1,7 @@
+require "minitest/mock_expectations/version"
+require "minitest/mock_expectations/assertions"
+
+module Minitest
+  module MockExpectations
+  end
+end

data/lib/minitest/mock_expectations/assertions.rb

@@ -0,0 +1,185 @@
+require "minitest"
+require "minitest/assertions"
+require "minitest/mock"
+
+module Minitest
+  # Provides method call assertions
+  #
+  # Imagine we have model +Post+:
+  #
+  #   class Post
+  #     attr_accessor :title, :body
+  #     attr_reader :comments
+  #
+  #     def initialize(title: "", body: "", comments: [])
+  #       @title = title
+  #       @body = body
+  #       @comments = comments
+  #     end
+  #
+  #     def add_comment(comment)
+  #       @comments << comment
+  #
+  #       "Thank you!"
+  #     end
+  #   end
+  #
+  # and variable +@post+ that reffers to instance of +Post+:
+  #
+  #   def setup
+  #     @post = Post.new(
+  #       title: "What is new in Rails 6.0",
+  #       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."
+  #       ]
+  #     )
+  #   end
+  module Assertions
+    # Asserts that the method will be called once on the object in the block:
+    #
+    #   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:
+    #
+    #   assert_called(@post, :title, times: 2) do
+    #     @post.title
+    #     @post.title
+    #   end
+    #
+    # You can stub the return value of the method in the block via +:returns+ option:
+    #
+    #   assert_called(@post, :title, returns: "What is new in Rails 5.2") do
+    #     assert_equal "What is new in Rails 5.2", @object.title
+    #   end
+    #
+    #   assert_equal "What is new in Rails 6.0", @object.title
+    def assert_called(object, method_name, message = nil, times: 1, returns: nil)
+      times_called = 0
+
+      object.stub(method_name, proc { times_called += 1; returns }) { yield }
+
+      error = "Expected #{method_name} to be called #{times} times, but was called #{times_called} times"
+      error = "#{message}.\n#{error}" if message
+      assert_equal times, times_called, error
+    end
+
+    # Asserts that the method will not be called on the object in the block:
+    #
+    #   assert_not_called(@post, :title) do
+    #     @post.body
+    #   end
+    def assert_not_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:
+    #
+    #   assert_called_with(@post, :add_comment, ["Thanks for sharing this."]) do
+    #     @post.add_comment("Thanks for sharing this.")
+    #   end
+    #
+    # You can stub the return value of the method in the block via +:returns+ option:
+    #
+    #   assert_called_with(@post, :add_comment, ["Thanks for sharing this."], returns: "Thanks!") do
+    #     assert_equal "Thanks!", @post.add_comment("Thanks for sharing this.")
+    #   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:
+    #
+    #   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)
+      mock = Minitest::Mock.new
+
+      if args.all? { |arg| arg.is_a?(Array) }
+        args.each { |arg| mock.expect(:call, returns, arg) }
+      else
+        mock.expect(:call, returns, args)
+      end
+
+      object.stub(method_name, mock) { yield }
+
+      mock.verify
+    end
+
+    # Asserts that the method will be called once on an instance of the klass in the block:
+    #
+    #   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:
+    #
+    #   assert_called_on_instance_of(Post, :title, times: 2) do
+    #     @post.title
+    #     @post.title
+    #   end
+    #
+    # You can stub the return value of the method in the block via +:returns+ option:
+    #
+    #   assert_called_on_instance_of(Post, :title, returns: "What is new in Rails 5.2") do
+    #     assert_equal "What is new in Rails 5.2", @post.title
+    #   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:
+    #
+    #   assert_called_on_instance_of(Post, :title, times: 3) do
+    #     assert_called_on_instance_of(Post, :body, times: 2) do
+    #       @post.title
+    #       @post.body
+    #       @post.title
+    #       @post.body
+    #       @post.title
+    #     end
+    #   end
+    def assert_called_on_instance_of(klass, method_name, message = nil, times: 1, returns: nil)
+      times_called = 0
+
+      klass.send(:define_method, "stubbed_#{method_name}") do |*|
+        times_called += 1
+
+        returns
+      end
+
+      klass.send(:alias_method, "original_#{method_name}", method_name)
+      klass.send(:alias_method, method_name, "stubbed_#{method_name}")
+
+      yield
+
+      error = "Expected #{method_name} to be called #{times} times, but was called #{times_called} times"
+      error = "#{message}.\n#{error}" if message
+
+      assert_equal times, times_called, error
+    ensure
+      klass.send(:alias_method, method_name, "original_#{method_name}")
+      klass.send(:undef_method, "original_#{method_name}")
+      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:
+    #
+    #   assert_not_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:
+    #
+    #   assert_not_called_on_instance_of(Post, :title) do
+    #     assert_not_called_on_instance_of(Post, :body) do
+    #     end
+    #   end
+    def assert_not_called_on_instance_of(klass, method_name, message = nil, &block)
+      assert_called_on_instance_of(klass, method_name, message, times: 0, &block)
+    end
+  end
+end

data/lib/minitest/mock_expectations/version.rb

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

data/minitest-mock_expectations.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "minitest/mock_expectations/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "minitest-mock_expectations"
+  spec.version       = Minitest::MockExpectations::VERSION
+  spec.authors       = ["bogdanvlviv"]
+  spec.email         = ["bogdanvlviv@gmail.com"]
+
+  spec.summary       = "Provides method call assertions"
+  spec.description   = ""
+  spec.homepage      = "https://github.com/bogdanvlviv/minitest-mock_expectations"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/test/minitest/mock_expectations/assertions_test.rb

@@ -0,0 +1,201 @@
+require "test_helper"
+
+class Minitest::MockExpectations::AssertionsTest < Minitest::Test
+  class Post
+    attr_accessor :title, :body
+    attr_reader :comments
+
+    def initialize(title: "", body: "", comments: [])
+      @title = title
+      @body = body
+      @comments = comments
+    end
+
+    def add_comment(comment)
+      @comments << comment
+
+      "Thank you!"
+    end
+  end
+
+  def setup
+    @post = Post.new(
+      title: "What is new in Rails 6.0",
+      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."
+      ]
+    )
+  end
+
+  def test_assert_called_with_defaults_to_expect_once
+    assert_called @post, :title do
+      @post.title
+    end
+  end
+
+  def test_assert_called_more_than_once
+    assert_called(@post, :title, times: 2) do
+      @post.title
+      @post.title
+    end
+  end
+
+  def test_assert_called_method_with_arguments
+    assert_called(@post, :add_comment) do
+      @post.add_comment("Thanks for sharing this.")
+    end
+  end
+
+  def test_assert_called_returns
+    assert_called(@post, :title, returns: "What is new in Rails 5.2") do
+      assert_equal "What is new in Rails 5.2", @post.title
+    end
+
+    assert_equal "What is new in Rails 6.0", @post.title
+  end
+
+  def test_assert_called_failure
+    error = assert_raises(Minitest::Assertion) do
+      assert_called(@post, :title) do
+      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
+      @post.body
+    end
+  end
+
+  def test_assert_not_called_failure
+    error = assert_raises(Minitest::Assertion) do
+      assert_not_called(@post, :title) 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
+  end
+
+  def test_assert_called_with_message
+    error = assert_raises(Minitest::Assertion) do
+      assert_called(@post, :title, "Message") do
+      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_assert_called_with_arguments
+    assert_called_with(@post, :add_comment, ["Thanks for sharing this."]) do
+      @post.add_comment("Thanks for sharing this.")
+    end
+  end
+
+  def test_assert_called_with_arguments_and_returns
+    assert_called_with(@post, :add_comment, ["Thanks for sharing this."], returns: "Thanks!") do
+      assert_equal "Thanks!", @post.add_comment("Thanks for sharing this.")
+    end
+
+    assert_equal "Thank you!", @post.add_comment("Thanks for sharing this.")
+  end
+
+  def test_assert_called_with_failure
+    assert_raises(MockExpectationError) do
+      assert_called_with(@post, :add_comment, ["Thanks for sharing this."]) do
+        @post.add_comment("Thanks")
+      end
+    end
+  end
+
+  def test_assert_called_with_multiple_expected_arguments
+    assert_called_with(@post, :add_comment, [["Thanks for sharing this."], ["Thanks!"]]) do
+      @post.add_comment("Thanks for sharing this.")
+      @post.add_comment("Thanks!")
+    end
+  end
+
+  def test_assert_called_on_instance_of_with_defaults_to_expect_once
+    assert_called_on_instance_of Post, :title do
+      @post.title
+    end
+  end
+
+  def test_assert_called_on_instance_of_more_than_once
+    assert_called_on_instance_of(Post, :title, times: 2) do
+      @post.title
+      @post.title
+    end
+  end
+
+  def test_assert_called_on_instance_of_with_arguments
+    assert_called_on_instance_of(Post, :add_comment) do
+      @post.add_comment("Thanks for sharing this.")
+    end
+  end
+
+  def test_assert_called_on_instance_of_returns
+    assert_called_on_instance_of(Post, :title, returns: "What is new in Rails 5.2") do
+      assert_equal "What is new in Rails 5.2", @post.title
+    end
+
+    assert_equal "What is new in Rails 6.0", @post.title
+  end
+
+  def test_assert_called_on_instance_of_failure
+    error = assert_raises(Minitest::Assertion) do
+      assert_called_on_instance_of(Post, :title) do
+      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_called_on_instance_of_with_message
+    error = assert_raises(Minitest::Assertion) do
+      assert_called_on_instance_of(Post, :title, "Message") do
+      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_assert_called_on_instance_of_nesting
+    assert_called_on_instance_of(Post, :title, times: 3) do
+      assert_called_on_instance_of(Post, :body, times: 2) do
+        @post.title
+        @post.body
+        @post.title
+        @post.body
+        @post.title
+      end
+    end
+  end
+
+  def test_assert_not_called_on_instance_of
+    assert_not_called_on_instance_of(Post, :title) do
+      @post.body
+    end
+  end
+
+  def test_assert_not_called_on_instance_of_failure
+    error = assert_raises(Minitest::Assertion) do
+      assert_not_called_on_instance_of(Post, :title) 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
+  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
+      end
+    end
+  end
+end

data/test/minitest/mock_expectations_test.rb

@@ -0,0 +1,7 @@
+require "test_helper"
+
+class Minitest::MockExpectationsTest < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::Minitest::MockExpectations::VERSION
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "minitest/mock_expectations"
+
+require "minitest/autorun"

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: minitest-mock_expectations
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- bogdanvlviv
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: ''
+email:
+- bogdanvlviv@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/minitest/mock_expectations.rb
+- lib/minitest/mock_expectations/assertions.rb
+- lib/minitest/mock_expectations/version.rb
+- minitest-mock_expectations.gemspec
+- test/minitest/mock_expectations/assertions_test.rb
+- test/minitest/mock_expectations_test.rb
+- test/test_helper.rb
+homepage: https://github.com/bogdanvlviv/minitest-mock_expectations
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Provides method call assertions
+test_files: []