mocktail 0.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 426f5dbb08f6db2542f0a323d186df7126aaae652e848b0a0c378a602231d777
-  data.tar.gz: 898501920257accc975d441a12d9e54a034c40aef8c950be2f0fa80aeb0288c6
+  metadata.gz: 6a9c74cd3ff5167b99c38892ee6411a1ac3f1379158c062076bfbe6d8479c7b7
+  data.tar.gz: 81dd2b80a78c162a9c4030fa8bc9be42741c3a8c053fa33c319dc13c404234a8
 SHA512:
-  metadata.gz: 6eea3625f3851c035e00c1593e91ae7d97c76b499510a71bd8b68fb0cfb27c4cac9116f9224f30853a97cfb6826385338506e33bf2ea6d43160f12093e8a591c
-  data.tar.gz: 1e6041f4ea59a42c40b6ef42bf99f106f43eb18d3ec452580784072046f099af26753e61e79704679fba7973bc19b59b3b9cdf0b537fd95e20caceeb18a719ef
+  metadata.gz: bd1fbc482135e89dea00de9249d63b5e851d64ecb2f4afc898b4bb77abf5afc96303cfed6b59665d0e51ab4b2c8dd4c438dc2a7ab93d1c69e1d12d723797cf9a
+  data.tar.gz: 3af137dd6d1488b1ef41ac0b47178a224e160f11dce0ed0cbeb24418ae4a33c86a6e4fa8e3cabb20c8421c8ac1ac8c166045051d996d4aa1dc709e4fcc97ec3a

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,4 +1,28 @@
-# unreleased
+# 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! 🎉
+* Remove support for `Mocktail.explain(nil)` because fake nil values cannot be
+made falsey. Pretty big mistake
+* Add `Mocktail.explain_nils` which will return explanation objects of every
+call that didn't satisfy a stubbing since the last reset, including the call
+site where it happened and the backtrace to try to tease out which one you're
+looking for
+
+# 0.0.6
+
+* Require pathname, which I missed because `bundle exec` loads it. Wups!
+
+# 0.0.5
+
+* Fix concurrency [#6](https://github.com/testdouble/mocktail/pull/6)
+
+# 0.0.4
 
 * Introduce Mocktail.explain(), which will return a message & reference object
   for any of:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mocktail (0.0.4)
+    mocktail (1.1.0)
 
 GEM
   remote: https://rubygems.org/
@@ -10,29 +10,29 @@ GEM
     coderay (1.1.3)
     docile (1.4.0)
     method_source (1.0.0)
-    minitest (5.14.4)
+    minitest (5.15.0)
     parallel (1.21.0)
-    parser (3.0.2.0)
+    parser (3.1.0.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.1.1)
+    regexp_parser (2.2.0)
     rexml (3.2.5)
-    rubocop (1.20.0)
+    rubocop (1.25.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.9.1, < 2.0)
+      rubocop-ast (>= 1.15.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.11.0)
+    rubocop-ast (1.15.1)
       parser (>= 3.0.1.1)
-    rubocop-performance (1.11.5)
+    rubocop-performance (1.13.2)
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     ruby-progressbar (1.11.0)
@@ -42,9 +42,9 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
-    standard (1.3.0)
-      rubocop (= 1.20.0)
-      rubocop-performance (= 1.11.5)
+    standard (1.7.0)
+      rubocop (= 1.25.0)
+      rubocop-performance (= 1.13.2)
     unicode-display_width (2.1.0)
 
 PLATFORMS
@@ -60,4 +60,4 @@ DEPENDENCIES
   standard
 
 BUNDLED WITH
-   2.2.15
+   2.3.6

data/README.md

@@ -553,92 +553,42 @@ 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.
 
-#### 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:
-
-```ruby
-class IceTray
-end
-
-ice_tray = Mocktail.of(IceTray)
-
-ice_tray.fill(:water_type, 30)
-# => No method `IceTray#fill' exists for call: (NoMethodError)
-#
-#      fill(:water_type, 30)
-#
-#    Need to define the method? Here's a sample definition:
-#
-#      def fill(water_type, arg)
-#      end
-```
-
-From there, you can just copy-paste the provided method stub as a starting point
-for your new method.
+#### Fake instances created by Mocktail
 
-#### `nil` values returned by faked methods
+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 you go ahead and implement the `fill` method above and configure a
-stubbing:
+Suppose these interactions have occurred:
 
 ```ruby
 ice_tray = Mocktail.of(IceTray)
 
-stubs { ice_tray.fill(:tap_water, 30) }.with { :normal_ice }
-```
-
-But then you find that your subject under test is just getting `nil` back and
-you don't understand why:
+Mocktail.stubs { ice_tray.fill(:tap_water, 30) }.with { :some_ice }
 
-```ruby
-def prep
-  ice = ice_tray.fill(:tap_water, 50) # => nil
-  glass.add(ice)
-end
+ice_tray.fill(:tap_water, 50)
 ```
 
-You can pass that `nil` value to `Mocktail.explain` and get an
-`UnsatisfiedStubExplanation` that will include both a `reference` object to explore
- as well a summary message:
+You can interrogate what's going on with the fake instance by passing it to
+`explain`:
 
 ```ruby
-def prep
-  ice = ice_tray.fill(:tap_water, 50).tap do |wat|
-    puts Mocktail.explain(wat).message
-  end
-  glass.add(ice)
-end
-```
-
-Which will print:
-
-```
-This `nil' was returned by a mocked `IceTray#fill' method
-because none of its configured stubbings were satisfied.
-
-The actual call:
+explanation = Mocktail.explain(ice_tray)
 
-  fill(:tap_water, 50)
-
-Stubbings configured prior to this call but not satisfied by it:
-
-  fill(:tap_water, 30)
+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
 ```
 
-#### Fake instances created by Mocktail
-
-Any instances created by `Mocktail.of` or `Mocktail.of_next` can also 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:
+Calling `explanation.message` will return:
 
 ```
 This is a fake `IceTray' instance.
@@ -653,6 +603,7 @@ It has these mocked methods:
 `IceTray#fill' calls:
 
   fill(:tap_water, 50)
+
 ```
 
 #### Modules and classes with singleton methods replaced
@@ -662,6 +613,8 @@ 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)
 
@@ -671,10 +624,15 @@ Shop.open!(42)
 
 Shop.close!(42)
 
-puts Mocktail.explain(Shop).message
+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
 ```
 
-Will print:
+And `explanation.message` will return:
 
 ```ruby
 `Shop' is a class that has had its singleton methods faked.
@@ -689,15 +647,161 @@ It has these mocked methods:
 
   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
+
+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
+end
+
+ice_tray = Mocktail.of(IceTray)
+
+ice_tray.fill(:water_type, 30)
+# => No method `IceTray#fill' exists for call: (NoMethodError)
+#
+#      fill(:water_type, 30)
+#
+#    Need to define the method? Here's a sample definition:
+#
+#      def fill(water_type, arg)
+#      end
+```
+
+From there, you can just copy-paste the provided method stub as a starting point
+for your new method:
+
+```ruby
+class IceTray
+  def fill(water_type, amount)
+  end
+end
+```
+
+### Mocktail.explain_nils
+
+Is a faked method returning `nil` and you don't understand why?
+
+By default, methods faked by Mocktail will return `nil` when no stubbing is
+satisfied. A frequent frustration, therefore, is when the way `stubs {}.with {}`
+is configured does not satisfy a call the way you expected. To try to make
+debugging this a little bit easier, the gem provides a top-level
+`Mocktail.explain_nils` method that will return an array of summaries of every
+call to a faked method that failed to satisfy any stubbings.
+
+For example, suppose you stub this `fill` method like so:
+
+```ruby
+ice_tray = Mocktail.of(IceTray)
+
+stubs { ice_tray.fill(:tap_water, 30) }.with { :normal_ice }
+```
+
+But then you find that your subject under test is just getting `nil` back and
+you don't understand why:
+
+```ruby
+def prep
+  ice = ice_tray.fill(:tap_water, 50)
+  glass.add(ice) # => why is `ice` nil?!
+end
+```
+
+Whenever you're confused by a nil, you can call `Mocktail.explain_nils` for an
+array containing `UnsatisfyingCallExplanation` objects (one for each call to
+a faked method that did not satisfy any configured stubbings).
+
+The returned explanation objects will include both a `reference` object to
+explore as well a summary `message`:
+
+```ruby
+def prep
+  ice = ice_tray.fill(:tap_water, 50)
+  puts Mocktail.explain_nils.first.message
+  glass.add(ice)
+end
 ```
 
+Which will print:
+
+```
+This `nil' was returned by a mocked `IceTray#fill' method
+because none of its configured stubbings were satisfied.
+
+The actual call:
+
+  fill(:tap_water, 50)
+
+The call site:
+
+  /path/to/your/code.rb:42:in `prep'
+
+Stubbings configured prior to this call but not satisfied by it:
+
+  fill(:tap_water, 30)
+```
+
+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.
+
 ### Mocktail.reset
 
 This one's simple: you probably want to call `Mocktail.reset` after each test,
@@ -705,6 +809,10 @@ but you _definitely_ want to call it if you're using `Mocktail.replace` or
 `Mocktail.of_next` anywhere, since those will affect state that is shared across
 tests.
 
+Calling reset in a `teardown` or `after(:each)` hook will also improve the
+usefulness of messages returned by `Mocktail.explain` and
+`Mocktail.explain_nils`.
+
 ## Acknowledgements
 
 Mocktail is created & maintained by the software agency [Test
@@ -731,3 +839,4 @@ 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/explains_nils.rb

@@ -0,0 +1,35 @@
+require_relative "share/stringifies_method_name"
+require_relative "share/stringifies_call"
+
+module Mocktail
+  class ExplainsNils
+    def initialize
+      @stringifies_method_name = StringifiesMethodName.new
+      @stringifies_call = StringifiesCall.new
+    end
+
+    def explain
+      Mocktail.cabinet.unsatisfying_calls.map { |unsatisfying_call|
+        dry_call = unsatisfying_call.call
+        other_stubbings = unsatisfying_call.other_stubbings
+
+        UnsatisfyingCallExplanation.new(unsatisfying_call, <<~MSG)
+          `nil' was returned by a mocked `#{@stringifies_method_name.stringify(dry_call)}' method
+          because none of its configured stubbings were satisfied.
+
+          The actual call:
+
+            #{@stringifies_call.stringify(dry_call, always_parens: true)}
+
+          The call site:
+
+            #{unsatisfying_call.backtrace.first}
+
+          #{@stringifies_call.stringify_multiple(other_stubbings.map(&:recording),
+            nonzero_message: "Stubbings configured prior to this call but not satisfied by it",
+            zero_message: "No stubbings were configured on this method")}
+        MSG
+      }
+    end
+  end
+end

data/lib/mocktail/explains_thing.rb

@@ -9,12 +9,12 @@ module Mocktail
     end
 
     def explain(thing)
-      if is_stub_returned_nil?(thing)
-        unsatisfied_stub_explanation(thing)
-      elsif (double = Mocktail.cabinet.double_for_instance(thing))
+      if (double = Mocktail.cabinet.double_for_instance(thing))
         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
@@ -22,51 +22,50 @@ module Mocktail
 
     private
 
-    # Our fake nil doesn't even implement respond_to?, instead quacking like nil
-    def is_stub_returned_nil?(thing)
-      thing.was_returned_by_unsatisfied_stub?
-    rescue NoMethodError
-    end
-
-    def unsatisfied_stub_explanation(stub_returned_nil)
-      unsatisfied_stubbing = stub_returned_nil.unsatisfied_stubbing
-      dry_call = unsatisfied_stubbing.call
-      other_stubbings = unsatisfied_stubbing.other_stubbings
-
-      UnsatisfiedStubExplanation.new(unsatisfied_stubbing, <<~MSG)
-        This `nil' was returned by a mocked `#{@stringifies_method_name.stringify(dry_call)}' method
-        because none of its configured stubbings were satisfied.
+    def fake_method_explanation_for(thing)
+      return unless thing.is_a?(Method)
+      method = thing
+      receiver = thing.receiver
 
-        The actual call:
-
-          #{@stringifies_call.stringify(dry_call, always_parens: true)}
+      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
 
-        #{describe_multiple_calls(other_stubbings.map(&:recording),
-          "Stubbings configured prior to this call but not satisfied by it",
-          "No stubbings were configured on this method")}
-      MSG
+      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 double_explanation(double)
-      double_data = DoubleData.new(
+    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.
 
         It has these mocked methods:
-        #{double.dry_methods.map { |method| "  - #{method}" }.join("\n")}
+        #{double.dry_methods.sort.map { |method| "  - #{method}" }.join("\n")}
 
-        #{double.dry_methods.map { |method| describe_dry_method(double_data, method) }.join("\n")}
+        #{double.dry_methods.sort.map { |method| describe_dry_method(double_data, method) }.join("\n")}
       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|
@@ -76,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.
@@ -95,35 +98,23 @@ module Mocktail
       ))
 
       [
-        describe_multiple_calls(
+        @stringifies_call.stringify_multiple(
           double_data.stubbings.map(&:recording).select { |call|
             call.method == method
           },
-          "`#{method_name}' stubbings",
-          "`#{method_name}' has no stubbings"
+          nonzero_message: "`#{method_name}' stubbings",
+          zero_message: "`#{method_name}' has no stubbings"
         ),
-        describe_multiple_calls(
+        @stringifies_call.stringify_multiple(
           double_data.calls.select { |call|
             call.method == method
           },
-          "`#{method_name}' calls",
-          "`#{method_name}' has no calls"
+          nonzero_message: "`#{method_name}' calls",
+          zero_message: "`#{method_name}' has no calls"
         )
       ].join("\n")
     end
 
-    def describe_multiple_calls(calls, nonzero_message, zero_message)
-      if calls.empty?
-        "#{zero_message}.\n"
-      else
-        <<~MSG
-          #{nonzero_message}:
-
-          #{calls.map { |call| "  " + @stringifies_call.stringify(call) }.join("\n\n")}
-        MSG
-      end
-    end
-
     def no_explanation(thing)
       NoExplanation.new(thing,
         "Unfortunately, Mocktail doesn't know what this thing is: #{thing.inspect}")

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

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

data/lib/mocktail/handles_dry_call/fulfills_stubbing.rb

@@ -13,13 +13,25 @@ module Mocktail
         stubbing.satisfied!
         stubbing.effect&.call(dry_call)
       else
-        StubReturnedNil.new(@describes_unsatisfied_stubbing.describe(dry_call))
+        store_unsatisfying_call!(dry_call)
+        nil
       end
     end
 
     def satisfaction(dry_call)
       return if Mocktail.cabinet.demonstration_in_progress?
+
       @finds_satisfaction.find(dry_call)
     end
+
+    private
+
+    def store_unsatisfying_call!(dry_call)
+      return if Mocktail.cabinet.demonstration_in_progress?
+
+      Mocktail.cabinet.store_unsatisfying_call(
+        @describes_unsatisfied_stubbing.describe(dry_call)
+      )
+    end
   end
 end

data/lib/mocktail/matchers/captor.rb

@@ -34,6 +34,10 @@ module Mocktail::Matchers
       def captured?
         @captured
       end
+
+      def inspect
+        "capture"
+      end
     end
 
     attr_reader :capture

data/lib/mocktail/matchers/that.rb

@@ -6,7 +6,7 @@ module Mocktail::Matchers
 
     def initialize(&blk)
       if blk.nil?
-        raise "The `that` matcher must be passed a block (e.g. `that { |arg| … }`)"
+        raise ArgumentError.new("The `that` matcher must be passed a block (e.g. `that { |arg| … }`)")
       end
       @blk = blk
     end

data/lib/mocktail/raises_neato_no_method_error.rb

@@ -11,7 +11,7 @@ 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)}

data/lib/mocktail/{simulates_argument_error → share}/cleans_backtrace.rb

@@ -1,3 +1,5 @@
+require "pathname"
+
 module Mocktail
   class CleansBacktrace
     BASE_PATH = (Pathname.new(__FILE__) + "../../..").to_s

data/lib/mocktail/share/stringifies_call.rb

@@ -4,6 +4,20 @@ module Mocktail
       "#{call.method}#{args_to_s(call, parens: always_parens)}#{blockify(call.block, anonymous: anonymous_blocks)}"
     end
 
+    def stringify_multiple(calls, nonzero_message:, zero_message:,
+      anonymous_blocks: false, always_parens: false)
+
+      if calls.empty?
+        "#{zero_message}.\n"
+      else
+        <<~MSG
+          #{nonzero_message}:
+
+          #{calls.map { |call| "  " + stringify(call) }.join("\n\n")}
+        MSG
+      end
+    end
+
     private
 
     def args_to_s(call, parens: true)

data/lib/mocktail/simulates_argument_error.rb

@@ -1,7 +1,7 @@
 require_relative "simulates_argument_error/transforms_params"
 require_relative "simulates_argument_error/reconciles_args_with_params"
 require_relative "simulates_argument_error/recreates_message"
-require_relative "simulates_argument_error/cleans_backtrace"
+require_relative "share/cleans_backtrace"
 require_relative "share/stringifies_call"
 
 module Mocktail

data/lib/mocktail/value/cabinet.rb

@@ -3,18 +3,20 @@
 module Mocktail
   class Cabinet
     attr_writer :demonstration_in_progress
-    attr_reader :calls, :stubbings
+    attr_reader :calls, :stubbings, :unsatisfying_calls
 
     def initialize
       @doubles = []
       @calls = []
       @stubbings = []
+      @unsatisfying_calls = []
       @demonstration_in_progress = false
     end
 
     def reset!
       @calls = []
       @stubbings = []
+      @unsatisfying_calls = []
       # Could cause an exception or prevent pollution—you decide!
       @demonstration_in_progress = false
       # note we don't reset doubles as they don't carry any
@@ -34,6 +36,10 @@ module Mocktail
       @stubbings << stubbing
     end
 
+    def store_unsatisfying_call(unsatisfying_call)
+      @unsatisfying_calls << unsatisfying_call
+    end
+
     def demonstration_in_progress?
       @demonstration_in_progress
     end

data/lib/mocktail/value/explanation.rb

@@ -15,7 +15,7 @@ module Mocktail
   class NoExplanation < Explanation
   end
 
-  class UnsatisfiedStubExplanation < Explanation
+  class UnsatisfyingCallExplanation < Explanation
   end
 
   class DoubleExplanation < Explanation
@@ -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/top_shelf.rb

@@ -1,65 +1,60 @@
-# The top shelf stores all cross-thread & thread-aware state, so anything that
-# goes here is on its own when it comes to ensuring thread safety.
 module Mocktail
   class TopShelf
     def self.instance
-      @self ||= new
+      Thread.current[:mocktail_top_shelf] ||= new
     end
 
+    @@type_replacements = {}
+    @@type_replacements_mutex = Mutex.new
+
     def initialize
-      @type_replacements = {}
-      @new_registrations = {}
-      @of_next_registrations = {}
-      @singleton_method_registrations = {}
+      @new_registrations = []
+      @of_next_registrations = []
+      @singleton_method_registrations = []
     end
 
     def type_replacement_for(type)
-      @type_replacements[type] ||= TypeReplacement.new(type: type)
+      @@type_replacements_mutex.synchronize {
+        @@type_replacements[type] ||= TypeReplacement.new(type: type)
+      }
     end
 
     def type_replacement_if_exists_for(type)
-      @type_replacements[type]
+      @@type_replacements_mutex.synchronize {
+        @@type_replacements[type]
+      }
     end
 
     def reset_current_thread!
-      @new_registrations[Thread.current] = []
-      @of_next_registrations[Thread.current] = []
-      @singleton_method_registrations[Thread.current] = []
+      Thread.current[:mocktail_top_shelf] = self.class.new
     end
 
     def register_new_replacement!(type)
-      @new_registrations[Thread.current] ||= []
-      @new_registrations[Thread.current] |= [type]
+      @new_registrations |= [type]
     end
 
     def new_replaced?(type)
-      @new_registrations[Thread.current] ||= []
-      @new_registrations[Thread.current].include?(type)
+      @new_registrations.include?(type)
     end
 
     def register_of_next_replacement!(type)
-      @of_next_registrations[Thread.current] ||= []
-      @of_next_registrations[Thread.current] |= [type]
+      @of_next_registrations |= [type]
     end
 
     def of_next_registered?(type)
-      @of_next_registrations[Thread.current] ||= []
-      @of_next_registrations[Thread.current].include?(type)
+      @of_next_registrations.include?(type)
     end
 
     def unregister_of_next_replacement!(type)
-      @of_next_registrations[Thread.current] ||= []
-      @of_next_registrations[Thread.current] -= [type]
+      @of_next_registrations -= [type]
     end
 
     def register_singleton_method_replacement!(type)
-      @singleton_method_registrations[Thread.current] ||= []
-      @singleton_method_registrations[Thread.current] |= [type]
+      @singleton_method_registrations |= [type]
     end
 
     def singleton_methods_replaced?(type)
-      @singleton_method_registrations[Thread.current] ||= []
-      @singleton_method_registrations[Thread.current].include?(type)
+      @singleton_method_registrations.include?(type)
     end
   end
 end

data/lib/mocktail/value/{unsatisfied_stubbing.rb → unsatisfying_call.rb}

@@ -1,7 +1,8 @@
 module Mocktail
-  class UnsatisfiedStubbing < Struct.new(
+  class UnsatisfyingCall < Struct.new(
     :call,
     :other_stubbings,
+    :backtrace,
     keyword_init: true
   )
   end

data/lib/mocktail/value.rb

@@ -4,11 +4,11 @@ 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"
-require_relative "value/stub_returned_nil"
 require_relative "value/top_shelf"
 require_relative "value/type_replacement"
 require_relative "value/type_replacement_data"
-require_relative "value/unsatisfied_stubbing"
+require_relative "value/unsatisfying_call"

data/lib/mocktail/version.rb

@@ -1,3 +1,3 @@
 module Mocktail
-  VERSION = "0.0.4"
+  VERSION = "1.1.0"
 end

data/lib/mocktail.rb

@@ -1,6 +1,7 @@
 require_relative "mocktail/dsl"
 require_relative "mocktail/errors"
 require_relative "mocktail/explains_thing"
+require_relative "mocktail/explains_nils"
 require_relative "mocktail/handles_dry_call"
 require_relative "mocktail/handles_dry_new_call"
 require_relative "mocktail/imitates_type"
@@ -61,6 +62,10 @@ module Mocktail
     ExplainsThing.new.explain(thing)
   end
 
+  def self.explain_nils
+    ExplainsNils.new.explain
+  end
+
   # Stores most transactional state about calls & stubbing configurations
   # Anything returned by this is undocumented and could change at any time, so
   # don't commit code that relies on it!

data/mocktail.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.authors = ["Justin Searls"]
   spec.email = ["searls@gmail.com"]
 
-  spec.summary = "your objects, less potency"
+  spec.summary = "Take your objects, and make them a double"
   spec.homepage = "https://github.com/testdouble/mocktail"
   spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mocktail
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Justin Searls
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-07 00:00:00.000000000 Z
+date: 2022-01-27 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -31,6 +31,7 @@ files:
 - lib/mocktail.rb
 - lib/mocktail/dsl.rb
 - lib/mocktail/errors.rb
+- lib/mocktail/explains_nils.rb
 - lib/mocktail/explains_thing.rb
 - lib/mocktail/handles_dry_call.rb
 - lib/mocktail/handles_dry_call/fulfills_stubbing.rb
@@ -65,12 +66,12 @@ files:
 - lib/mocktail/replaces_type/redefines_new.rb
 - lib/mocktail/replaces_type/redefines_singleton_methods.rb
 - lib/mocktail/resets_state.rb
+- lib/mocktail/share/cleans_backtrace.rb
 - lib/mocktail/share/creates_identifier.rb
 - lib/mocktail/share/determines_matching_calls.rb
 - lib/mocktail/share/stringifies_call.rb
 - lib/mocktail/share/stringifies_method_name.rb
 - lib/mocktail/simulates_argument_error.rb
-- lib/mocktail/simulates_argument_error/cleans_backtrace.rb
 - lib/mocktail/simulates_argument_error/reconciles_args_with_params.rb
 - lib/mocktail/simulates_argument_error/recreates_message.rb
 - lib/mocktail/simulates_argument_error/transforms_params.rb
@@ -81,14 +82,14 @@ 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/stub_returned_nil.rb
 - lib/mocktail/value/stubbing.rb
 - lib/mocktail/value/top_shelf.rb
 - lib/mocktail/value/type_replacement.rb
 - lib/mocktail/value/type_replacement_data.rb
-- lib/mocktail/value/unsatisfied_stubbing.rb
+- lib/mocktail/value/unsatisfying_call.rb
 - lib/mocktail/verifies_call.rb
 - lib/mocktail/verifies_call/finds_verifiable_calls.rb
 - lib/mocktail/verifies_call/raises_verification_error.rb
@@ -116,8 +117,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.3.6
 signing_key:
 specification_version: 4
-summary: your objects, less potency
+summary: Take your objects, and make them a double
 test_files: []

data/lib/mocktail/value/stub_returned_nil.rb

@@ -1,26 +0,0 @@
-module Mocktail
-  class StubReturnedNil < BasicObject
-    attr_reader :unsatisfied_stubbing
-
-    def initialize(unsatisfied_stubbing)
-      @unsatisfied_stubbing = unsatisfied_stubbing
-    end
-
-    def was_returned_by_unsatisfied_stub?
-      true
-    end
-
-    def tap
-      yield self
-      self
-    end
-
-    def method_missing(name, *args, **kwargs, &blk)
-      nil.send(name, *args, **kwargs, &blk)
-    end
-
-    def respond_to_missing?(name, include_all = false)
-      nil.respond_to?(name, include_all)
-    end
-  end
-end