mocktail 1.0.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05ec28e8027b6d73ee5b3f513ce4d5e23a60ea0266643e344e20e8f995410ce2
-  data.tar.gz: 7baf1cff682de031f3f25cebad265e59e598c4f4103968ea2dda61b6c7605c9c
+  metadata.gz: 7eb64f90875e53a9bfd5b4d995f8526eb6695dd9bd8a88c850b02eed851cb96d
+  data.tar.gz: ae2b4443a3740c375c70e7e490cbe3463d9672f17665ae47930b6ee614e9891d
 SHA512:
-  metadata.gz: 4c5eef4fe5c68abd7d1e506bc59db58daa931fb484118e0ee4d6d286944d2834d0bb3107183102ac65110e12f32992b73fadbfcc26ed750bff060535e4eba5a2
-  data.tar.gz: cff11562ac6bc79475719f17f912ffc2fe8af6315ab90dbdc838143c237542ad788cba2d6c05ee15417799b2f597634244edf3c9f50dac5121adbac551602bdb
+  metadata.gz: de8d47071e93c4d406391a1155dea9b6a1a9ac89f56422ae29e6dda5f134c9e5e724ec8006aba833b5ff19d9d2dff4550384bc349506f5ab9cefe3fd2185af1d
+  data.tar.gz: 5bf88d0aadc08fe9a9380312cf491146439e72e335091e2e79849196b74e93aba20b0fac2d122152a4661008ee243b5b3b39cb6408fc776b2cc2567ffca0924f

data/.github/workflows/main.yml

@@ -7,7 +7,7 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-latest ]
-        ruby-version: [3.0.1]
+        ruby-version: ['3.0', '3.1']
 
     runs-on: ${{ matrix.os }}
 

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 1.1.1
+
+* Improve output for undefined singleton methods
+  ([#11](https://github.com/testdouble/mocktail/pull/11) by
+  [@calebhearth](https://github.com/calebhearth))
+
+# 1.1.0
+
+* Feature: add support for passing methods to `Mocktail.explain()`
+* Fix 3.1 support by bypassing highlight_error for custom NoMethodError objects
+  raised by Mocktail [error_highlight#20](https://github.com/ruby/error_highlight/issues/20)
+
 # 1.0.0
 
 * First breaking change! 🎉

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mocktail (1.0.0)
+    mocktail (1.1.2)
 
 GEM
   remote: https://rubygems.org/
@@ -11,28 +11,28 @@ GEM
     docile (1.4.0)
     method_source (1.0.0)
     minitest (5.15.0)
-    parallel (1.21.0)
-    parser (3.0.3.2)
+    parallel (1.22.1)
+    parser (3.1.2.0)
       ast (~> 2.4.1)
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    rainbow (3.0.0)
+    rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.2.0)
+    regexp_parser (2.3.0)
     rexml (3.2.5)
-    rubocop (1.23.0)
+    rubocop (1.27.0)
       parallel (~> 1.10)
-      parser (>= 3.0.0.0)
+      parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.12.0, < 2.0)
+      rubocop-ast (>= 1.16.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.15.0)
-      parser (>= 3.0.1.1)
-    rubocop-performance (1.12.0)
+    rubocop-ast (1.17.0)
+      parser (>= 3.1.1.0)
+    rubocop-performance (1.13.3)
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     ruby-progressbar (1.11.0)
@@ -41,10 +41,10 @@ GEM
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
-    simplecov_json_formatter (0.1.3)
-    standard (1.5.0)
-      rubocop (= 1.23.0)
-      rubocop-performance (= 1.12.0)
+    simplecov_json_formatter (0.1.4)
+    standard (1.10.0)
+      rubocop (= 1.27.0)
+      rubocop-performance (= 1.13.3)
     unicode-display_width (2.1.0)
 
 PLATFORMS
@@ -60,4 +60,4 @@ DEPENDENCIES
   standard
 
 BUNDLED WITH
-   2.2.30
+   2.3.6

data/README.md

@@ -10,6 +10,11 @@ library for Ruby that provides a terse and robust API for creating mocks,
 getting them in the hands of the code you're testing, stub & verify behavior,
 and even safely override class methods.
 
+If you'd prefer a voice & video introduction to Mocktail aside from this README,
+you might enjoy this ⚡️[Lightning
+Talk](https://blog.testdouble.com/talks/2022-05-18-please-mock-me?utm_source=twitter&utm_medium=organic-social&utm_campaign=conf-talk)⚡️ 
+from RailsConf 2022.
+
 ## An aperitif
 
 Before getting into the details, let's demonstrate what Mocktail's API looks
@@ -553,14 +558,160 @@ them!)]
 ### Mocktail.explain
 
 Test debugging is hard enough when there _aren't_ fake objects flying every
-which way, so Mocktail tries to make it a little easier by way of better
-messages throughout the library.
+which way, so Mocktail tries to make it a little easier on you. In addition to
+returning useful messages throughout the API, the gem also includes an
+introspection method `Mocktail.explain(thing)`, which returns a human-readable
+`message` and a `reference` object with useful attributes (that vary depending
+on the type of fake `thing` you pass in. Below are some things `explain()` can
+do.
+
+#### Fake instances created by Mocktail
+
+Any instances created by `Mocktail.of` or `Mocktail.of_next` can be passed to
+`Mocktail.explain`, and they will list out all the calls and stubbings made for
+each of their fake methods.
+
+Suppose these interactions have occurred:
+
+```ruby
+ice_tray = Mocktail.of(IceTray)
+
+Mocktail.stubs { ice_tray.fill(:tap_water, 30) }.with { :some_ice }
+
+ice_tray.fill(:tap_water, 50)
+```
+
+You can interrogate what's going on with the fake instance by passing it to
+`explain`:
+
+```ruby
+explanation = Mocktail.explain(ice_tray)
+
+explanation.reference.type      #=> IceTray
+explanation.reference.double    #=> The ice_tray instance
+explanation.reference.calls     #=> details on each invocation of each method
+explanation.reference.stubbings #=> all stubbings configured for each method
+```
+
+Calling `explanation.message` will return:
+
+```
+This is a fake `IceTray' instance.
+
+It has these mocked methods:
+  - fill
+
+`IceTray#fill' stubbings:
+
+  fill(:tap_water, 30)
+
+`IceTray#fill' calls:
+
+  fill(:tap_water, 50)
+
+```
+
+#### Modules and classes with singleton methods replaced
+
+If you've called `Mocktail.replace()` on a class or module, it can also be
+passed to `Mocktail.explain()` for a summary of all the stubbing configurations
+and calls made against its faked singleton methods for the currently running
+thread.
+
+Imagine a `Shop` class with `self.open!` and `self.close!` singleton methods:
+
+```ruby
+Mocktail.replace(Shop)
+
+stubs { |m| Shop.open!(m.numeric) }.with { :a_bar }
+
+Shop.open!(42)
+
+Shop.close!(42)
+
+explanation = Mocktail.explain(Shop)
+
+explanation.reference.type      #=> Shop
+explanation.reference.replaced_method_names #=> [:close!, :open!]
+explanation.reference.calls     #=> details on each invocation of each method
+explanation.reference.stubbings #=> all stubbings configured for each method
+```
+
+And `explanation.message` will return:
+
+```ruby
+`Shop' is a class that has had its singleton methods faked.
+
+It has these mocked methods:
+  - close!
+  - open!
+
+`Shop.close!' has no stubbings.
+
+`Shop.close!' calls:
+
+  close!(42)
+
+  close!(42)
+
+`Shop.open!' stubbings:
+
+  open!(numeric)
+
+  open!(numeric)
+
+`Shop.open!' calls:
+
+  open!(42)
+
+  open!(42)
+```
+
+#### Methods on faked instances and replaced types
+
+In addition to passing the test double, you can also pass a reference to any
+fake method created by Mocktail to `Mocktail.explain`:
+
+```ruby
+ice_tray = Mocktail.of(IceTray)
+
+ice_tray.fill(:chilled, 50)
+
+explanation = Mocktail.explain(ice_tray.method(:fill))
+
+explanation.reference.receiver  #=> a reference to the `ice_tray` instance
+explanation.reference.calls     #=> details on each invocation of the method
+explanation.reference.stubbings #=> all stubbings configured for the method
+```
+
+The above may be handy in cases where you want to assert the number of calls of
+a method outside the `Mocktail.verify` API:
+
+```ruby
+assert_equal 1, explanation.reference.calls.size
+```
+
+The explanation will also contain a `message` like this:
+
+```
+`IceTray#fill' has no stubbings.
+
+`IceTray#fill' calls:
+
+  fill(:chilled, 50)
+```
+
+Replaced singleton methods can also be passed to `explain()`, so something like
+`Mocktail.explain(Shop.method(:open!))` from the earlier example would also work
+(with `Shop` being the `receiver` on the explanation's `reference`).
 
 #### Undefined methods
 
-One message you'll see automatically if you try to call a method
-that doesn't exist is this one, which gives a sample definition of the method
-you had attempted to call:
+There's no API for this one, but Mocktail also offers explanations for methods
+that don't exist yet. You'll see this error message whenever you try to call a
+method that doesn't exist on a test double. The message is designed to
+facilitate "paint-by-numbers" TDD, by including a sample definition of the
+method you had attempted to call that can be copy-pasted into a source listing:
 
 ```ruby
 class IceTray
@@ -589,7 +740,7 @@ class IceTray
 end
 ```
 
-### Unexpected nils with Mocktail.explain_nils
+### Mocktail.explain_nils
 
 Is a faked method returning `nil` and you don't understand why?
 
@@ -656,75 +807,6 @@ The `reference` object will have details of the `call` itself, an array of
 `other_stubbings` defined on the faked method, and a `backtrace` to determine
 which call site produced the unexpected `nil` value.
 
-#### Fake instances created by Mocktail
-
-Any instances created by `Mocktail.of` or `Mocktail.of_next` can be passed to
-`Mocktail.explain`, and they will list out all the calls and stubbings made for
-each of their fake methods.
-
-Calling `Mocktail.explain(ice_tray).message` following the example above will
-yield:
-
-```
-This is a fake `IceTray' instance.
-
-It has these mocked methods:
-  - fill
-
-`IceTray#fill' stubbings:
-
-  fill(:tap_water, 30)
-
-`IceTray#fill' calls:
-
-  fill(:tap_water, 50)
-```
-
-#### Modules and classes with singleton methods replaced
-
-If you've called `Mocktail.replace()` on a class or module, it can also be
-passed to `Mocktail.explain()` for a summary of all the stubbing configurations
-and calls made against its faked singleton methods for the currently running
-thread.
-
-Imagine a `Shop` class with `self.open!` and `self.close!` singleton methods:
-
-```ruby
-Mocktail.replace(Shop)
-
-stubs { |m| Shop.open!(m.numeric) }.with { :a_bar }
-
-Shop.open!(42)
-
-Shop.close!(42)
-
-puts Mocktail.explain(Shop).message
-```
-
-Will print:
-
-```ruby
-`Shop' is a class that has had its singleton methods faked.
-
-It has these mocked methods:
-  - close!
-  - open!
-
-`Shop.close!' has no stubbings.
-
-`Shop.close!' calls:
-
-  close!(42)
-
-`Shop.open!' stubbings:
-
-  open!(numeric)
-
-`Shop.open!' calls:
-
-  open!(42)
-```
-
 ### Mocktail.reset
 
 This one's simple: you probably want to call `Mocktail.reset` after each test,
@@ -736,10 +818,35 @@ Calling reset in a `teardown` or `after(:each)` hook will also improve the
 usefulness of messages returned by `Mocktail.explain` and
 `Mocktail.explain_nils`.
 
+## References
+
+Mocktail is designed following a somewhat academic understanding of what mocking
+is and how it should be used. Below are several references on this topic.
+
+Blog Posts and Papers:
+
+- [Endo-Testing: Unit Testing with Mock
+  Objects](<https://www2.ccs.neu.edu/research/demeter/related-work/extreme-programming/MockObjectsFinal.PDF>
+  by Tim Mackinnon, Steve Freeman, and Philip Craig, the paper that introduced
+  mocking presented by the creators of mocking.
+- Michael Feathers' [The Flawed Theory Behind Unit
+  Testing](<https://michaelfeathers.typepad.com/michael_feathers_blog/2008/06/the-flawed-theo.html>)
+
+Books:
+
+- [_Growing Object-Oriented Software, Guided by
+  Tests_](<https://bookshop.org/books/growing-object-oriented-software-guided-by-tests/9780321503626>)
+  by Steve Freeman and Nat Price
+
+Talks:
+
+- [Please don’t mock me](https://www.youtube.com/watch?v=Af4M8GMoxi4) by Justin
+  Searls
+
 ## Acknowledgements
 
 Mocktail is created & maintained by the software agency [Test
-Double](https://twitter.com). If you've ever come across our eponymously-named
+Double](https://testdouble.com). If you've ever come across our eponymously-named
 [testdouble.js](https://github.com/testdouble/testdouble.js/), you might find
 Mocktail's API to be quite similar. The term "test double" was originally coined
 by Gerard Meszaros in his book [xUnit Test
@@ -762,4 +869,3 @@ including (but not limited to) one-on-one communications, public posts/comments,
 code reviews, pull requests, and GitHub issues. If violations occur, Test Double
 will take any action they deem appropriate for the infraction, up to and
 including blocking a user from the organization's repositories.
-

data/lib/mocktail/debug.rb

@@ -0,0 +1,49 @@
+module Mocktail
+  module Debug
+    # It would be easy and bad for the mocktail lib to call something like
+    #
+    #   double == other_double
+    #
+    # But if it's a double, that means anyone who stubs that method could change
+    # the internal behavior of the library in unexpected ways (as happened here:
+    # https://github.com/testdouble/mocktail/issues/7 )
+    #
+    # For that reason when we run our tests, we also want to blow up if this
+    # happens unintentionally. This works in conjunction with the test
+    # MockingMethodfulClassesTest, because it mocks every defined method on the
+    # mocked BasicObject
+    def self.guard_against_mocktail_accidentally_calling_mocks_if_debugging!
+      return unless ENV["MOCKTAIL_DEBUG_ACCIDENTAL_INTERNAL_MOCK_CALLS"]
+      raise
+    rescue => e
+      base_path = Pathname.new(__FILE__).dirname.to_s
+      backtrace_minus_this_and_whoever_called_this = e.backtrace[2..]
+      internal_call_sites = backtrace_minus_this_and_whoever_called_this.take_while { |call_site|
+        # the "in `block" is very confusing but necessary to include lines after
+        # a stubs { blah.foo }.with { … } call, since that's when most of the
+        # good stuff happens
+        call_site.start_with?(base_path) || call_site.include?("in `block")
+      }.reject { |call_site| call_site.include?("in `block") }
+
+      approved_call_sites = [
+        "fulfills_stubbing.rb:14",
+        "validates_arguments.rb:16",
+        "validates_arguments.rb:19"
+      ]
+      if internal_call_sites.any? && approved_call_sites.none? { |approved_call_site|
+        internal_call_sites.first.include?(approved_call_site)
+      }
+        raise Error.new <<~MSG
+          Unauthorized internal call of a mock internally by Mocktail itself:
+
+          #{internal_call_sites.first}
+
+          Offending call's complete stack trace:
+
+          #{backtrace_minus_this_and_whoever_called_this.join("\n")}
+          ==END OFFENDING TRACE==
+        MSG
+      end
+    end
+  end
+end

data/lib/mocktail/explains_thing.rb

@@ -13,6 +13,8 @@ module Mocktail
         double_explanation(double)
       elsif (type_replacement = TopShelf.instance.type_replacement_if_exists_for(thing))
         replaced_type_explanation(type_replacement)
+      elsif (fake_method_explanation = fake_method_explanation_for(thing))
+        fake_method_explanation
       else
         no_explanation(thing)
       end
@@ -20,13 +22,37 @@ module Mocktail
 
     private
 
-    def double_explanation(double)
-      double_data = DoubleData.new(
+    def fake_method_explanation_for(thing)
+      return unless thing.is_a?(Method)
+      method = thing
+      receiver = thing.receiver
+
+      receiver_data = if (double = Mocktail.cabinet.double_for_instance(receiver))
+        data_for_double(double)
+      elsif (type_replacement = TopShelf.instance.type_replacement_if_exists_for(receiver))
+        data_for_type_replacement(type_replacement)
+      end
+
+      if receiver_data
+        FakeMethodExplanation.new(FakeMethodData.new(
+          receiver: receiver,
+          calls: receiver_data.calls,
+          stubbings: receiver_data.stubbings
+        ), describe_dry_method(receiver_data, method.name))
+      end
+    end
+
+    def data_for_double(double)
+      DoubleData.new(
         type: double.original_type,
         double: double.dry_instance,
         calls: Mocktail.cabinet.calls_for_double(double),
         stubbings: Mocktail.cabinet.stubbings_for_double(double)
       )
+    end
+
+    def double_explanation(double)
+      double_data = data_for_double(double)
 
       DoubleExplanation.new(double_data, <<~MSG)
         This is a fake `#{double.original_type.name}' instance.
@@ -38,8 +64,8 @@ module Mocktail
       MSG
     end
 
-    def replaced_type_explanation(type_replacement)
-      type_replacement_data = TypeReplacementData.new(
+    def data_for_type_replacement(type_replacement)
+      TypeReplacementData.new(
         type: type_replacement.type,
         replaced_method_names: type_replacement.replacement_methods.map(&:name).sort,
         calls: Mocktail.cabinet.calls.select { |call|
@@ -49,6 +75,10 @@ module Mocktail
           stubbing.recording.double == type_replacement.type
         }
       )
+    end
+
+    def replaced_type_explanation(type_replacement)
+      type_replacement_data = data_for_type_replacement(type_replacement)
 
       ReplacedTypeExplanation.new(type_replacement_data, <<~MSG)
         `#{type_replacement.type}' is a #{type_replacement.type.class.to_s.downcase} that has had its singleton methods faked.

data/lib/mocktail/handles_dry_call/fulfills_stubbing/describes_unsatisfied_stubbing.rb

@@ -1,17 +1,19 @@
 require_relative "../../share/cleans_backtrace"
+require_relative "../../share/compares_safely"
 
 module Mocktail
   class DescribesUnsatisfiedStubbing
     def initialize
       @cleans_backtrace = CleansBacktrace.new
+      @compares_safely = ComparesSafely.new
     end
 
     def describe(dry_call)
       UnsatisfyingCall.new(
         call: dry_call,
         other_stubbings: Mocktail.cabinet.stubbings.select { |stubbing|
-          dry_call.double == stubbing.recording.double &&
-            dry_call.method == stubbing.recording.method
+          @compares_safely.compare(dry_call.double, stubbing.recording.double) &&
+            @compares_safely.compare(dry_call.method, stubbing.recording.method)
         },
         backtrace: @cleans_backtrace.clean(Error.new).backtrace
       )

data/lib/mocktail/imitates_type/makes_double/declares_dry_class.rb

@@ -41,7 +41,10 @@ module Mocktail
     def define_double_methods!(dry_class, type, instance_methods)
       handles_dry_call = @handles_dry_call
       instance_methods.each do |method|
+        dry_class.undef_method(method) if dry_class.method_defined?(method)
+
         dry_class.define_method method, ->(*args, **kwargs, &block) {
+          Debug.guard_against_mocktail_accidentally_calling_mocks_if_debugging!
           handles_dry_call.handle(Call.new(
             singleton: false,
             double: self,

data/lib/mocktail/matchers/any.rb

@@ -4,7 +4,9 @@ module Mocktail::Matchers
       :any
     end
 
-    def initialize
+    # Change this comment to a descriptive one once this is merged:
+    # https://github.com/rubocop/rubocop/pull/10551
+    def initialize # standard:disable Style/RedundantInitialize
     end
 
     def match?(actual)

data/lib/mocktail/matchers/numeric.rb

@@ -4,7 +4,9 @@ module Mocktail::Matchers
       :numeric
     end
 
-    def initialize
+    # Change this comment to a descriptive one once this is merged:
+    # https://github.com/rubocop/rubocop/pull/10551
+    def initialize # standard:disable Style/RedundantInitialize
     end
 
     def match?(actual)

data/lib/mocktail/raises_neato_no_method_error.rb

@@ -11,14 +11,14 @@ module Mocktail
     end
 
     def call(call)
-      raise NoMethodError.new <<~MSG
+      raise NoMethodError, <<~MSG, caller[1..]
         No method `#{@stringifies_method_name.stringify(call)}' exists for call:
 
           #{@stringifies_call.stringify(call, anonymous_blocks: true, always_parens: true)}
 
         Need to define the method? Here's a sample definition:
 
-          def #{call.method}#{params(call)}
+          def #{"self." if call.singleton}#{call.method}#{params(call)}
           end
         #{corrections(call)}
       MSG

data/lib/mocktail/replaces_type/redefines_singleton_methods.rb

@@ -12,6 +12,7 @@ module Mocktail
         type.method(name)
       } - [type_replacement.replacement_new]
 
+      declare_singleton_method_missing_errors!(type)
       handles_dry_call = @handles_dry_call
       type_replacement.replacement_methods = type_replacement.original_methods.map { |original_method|
         type.singleton_class.send(:undef_method, original_method.name)
@@ -35,5 +36,27 @@ module Mocktail
         type.singleton_method(original_method.name)
       }
     end
+
+    def declare_singleton_method_missing_errors!(type)
+      return if type.singleton_methods.include?(:method_missing)
+
+      raises_neato_no_method_error = RaisesNeatoNoMethodError.new
+      type.define_singleton_method :method_missing,
+        ->(name, *args, **kwargs, &block) {
+          raises_neato_no_method_error.call(
+            Call.new(
+              singleton: true,
+              double: self,
+              original_type: type,
+              dry_type: self.class,
+              method: name,
+              original_method: nil,
+              args: args,
+              kwargs: kwargs,
+              block: block
+            )
+          )
+        }
+    end
   end
 end

data/lib/mocktail/share/compares_safely.rb

@@ -0,0 +1,7 @@
+module Mocktail
+  class ComparesSafely
+    def compare(thing, other_thing)
+      Object.instance_method(:==).bind_call(thing, other_thing)
+    end
+  end
+end

data/lib/mocktail/share/determines_matching_calls.rb

@@ -1,8 +1,14 @@
+require_relative "compares_safely"
+
 module Mocktail
   class DeterminesMatchingCalls
+    def initialize
+      @compares_safely = ComparesSafely.new
+    end
+
     def determine(real_call, demo_call, demo_config)
-      real_call.double == demo_call.double &&
-        real_call.method == demo_call.method &&
+      @compares_safely.compare(real_call.double, demo_call.double) &&
+        @compares_safely.compare(real_call.method, demo_call.method) &&
 
         # Matcher implementation will replace this:
         args_match?(real_call.args, demo_call.args, demo_config.ignore_extra_args) &&
@@ -53,7 +59,7 @@ module Mocktail
           demo_arg.is_mocktail_matcher?
         demo_arg.match?(real_arg)
       else
-        demo_arg == real_arg
+        demo_arg == real_arg # TODO <-- test if mock object and call safe compare if so, otherwise ==
       end
     end
   end

data/lib/mocktail/simulates_argument_error/transforms_params.rb

@@ -1,16 +1,22 @@
+require_relative "../share/compares_safely"
+
 module Mocktail
   class TransformsParams
+    def initialize
+      @compares_safely = ComparesSafely.new
+    end
+
     def transform(dry_call)
       params = dry_call.original_method.parameters
 
       Signature.new(
         positional_params: Params.new(
-          all: params.select { |type, _|
-            [:req, :opt, :rest].include?(type)
+          all: params.select { |t, _|
+            [:req, :opt, :rest].any? { |param_type| @compares_safely.compare(t, param_type) }
           }.map { |_, name| name },
-          required: params.select { |t, _| t == :req }.map { |_, n| n },
-          optional: params.select { |t, _| t == :opt }.map { |_, n| n },
-          rest: params.find { |type, _| type == :rest } & [1]
+          required: params.select { |t, _| @compares_safely.compare(t, :req) }.map { |_, n| n },
+          optional: params.select { |t, _| @compares_safely.compare(t, :opt) }.map { |_, n| n },
+          rest: params.find { |t, _| @compares_safely.compare(t, :rest) } & [1]
         ),
         positional_args: dry_call.args,
 
@@ -18,13 +24,13 @@ module Mocktail
           all: params.select { |type, _|
             [:keyreq, :key, :keyrest].include?(type)
           }.map { |_, name| name },
-          required: params.select { |t, _| t == :keyreq }.map { |_, n| n },
-          optional: params.select { |t, _| t == :key }.map { |_, n| n },
-          rest: params.find { |type, _| type == :keyrest } & [1]
+          required: params.select { |t, _| @compares_safely.compare(t, :keyreq) }.map { |_, n| n },
+          optional: params.select { |t, _| @compares_safely.compare(t, :key) }.map { |_, n| n },
+          rest: params.find { |t, _| @compares_safely.compare(t, :keyrest) } & [1]
         ),
         keyword_args: dry_call.kwargs,
 
-        block_param: params.find { |type, _| type == :block } & [1],
+        block_param: params.find { |t, _| @compares_safely.compare(t, :block) } & [1],
         block_arg: dry_call.block
       )
     end

data/lib/mocktail/value/cabinet.rb

@@ -1,3 +1,5 @@
+require_relative "../share/compares_safely"
+
 # The Cabinet stores all thread-local state, so anything that goes here
 # is guaranteed by Mocktail to be local to the currently-running thread
 module Mocktail
@@ -6,6 +8,7 @@ module Mocktail
     attr_reader :calls, :stubbings, :unsatisfying_calls
 
     def initialize
+      @compares_safely = ComparesSafely.new
       @doubles = []
       @calls = []
       @stubbings = []
@@ -45,15 +48,19 @@ module Mocktail
     end
 
     def double_for_instance(thing)
-      @doubles.find { |double| double.dry_instance == thing }
+      @doubles.find { |double| @compares_safely.compare(double.dry_instance, thing) }
     end
 
     def stubbings_for_double(double)
-      @stubbings.select { |stubbing| stubbing.recording.double == double.dry_instance }
+      @stubbings.select { |stubbing|
+        @compares_safely.compare(stubbing.recording.double, double.dry_instance)
+      }
     end
 
     def calls_for_double(double)
-      @calls.select { |call| call.double == double.dry_instance }
+      @calls.select { |call|
+        @compares_safely.compare(call.double, double.dry_instance)
+      }
     end
   end
 end

data/lib/mocktail/value/explanation.rb

@@ -23,4 +23,7 @@ module Mocktail
 
   class ReplacedTypeExplanation < Explanation
   end
+
+  class FakeMethodExplanation < Explanation
+  end
 end

data/lib/mocktail/value/fake_method_data.rb

@@ -0,0 +1,9 @@
+module Mocktail
+  class FakeMethodData < Struct.new(
+    :receiver,
+    :calls,
+    :stubbings,
+    keyword_init: true
+  )
+  end
+end

data/lib/mocktail/value.rb

@@ -4,6 +4,7 @@ require_relative "value/demo_config"
 require_relative "value/double"
 require_relative "value/double_data"
 require_relative "value/explanation"
+require_relative "value/fake_method_data"
 require_relative "value/matcher_registry"
 require_relative "value/signature"
 require_relative "value/stubbing"

data/lib/mocktail/version.rb

@@ -1,3 +1,3 @@
 module Mocktail
-  VERSION = "1.0.0"
+  VERSION = "1.1.2"
 end

data/lib/mocktail.rb

@@ -1,3 +1,4 @@
+require_relative "mocktail/debug"
 require_relative "mocktail/dsl"
 require_relative "mocktail/errors"
 require_relative "mocktail/explains_thing"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mocktail
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Justin Searls
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-20 00:00:00.000000000 Z
+date: 2022-06-25 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -29,6 +29,7 @@ files:
 - bin/console
 - bin/setup
 - lib/mocktail.rb
+- lib/mocktail/debug.rb
 - lib/mocktail/dsl.rb
 - lib/mocktail/errors.rb
 - lib/mocktail/explains_nils.rb
@@ -67,6 +68,7 @@ files:
 - lib/mocktail/replaces_type/redefines_singleton_methods.rb
 - lib/mocktail/resets_state.rb
 - lib/mocktail/share/cleans_backtrace.rb
+- lib/mocktail/share/compares_safely.rb
 - lib/mocktail/share/creates_identifier.rb
 - lib/mocktail/share/determines_matching_calls.rb
 - lib/mocktail/share/stringifies_call.rb
@@ -82,6 +84,7 @@ files:
 - lib/mocktail/value/double.rb
 - lib/mocktail/value/double_data.rb
 - lib/mocktail/value/explanation.rb
+- lib/mocktail/value/fake_method_data.rb
 - lib/mocktail/value/matcher_registry.rb
 - lib/mocktail/value/signature.rb
 - lib/mocktail/value/stubbing.rb
@@ -116,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.6
 signing_key:
 specification_version: 4
 summary: Take your objects, and make them a double