mocktail 1.2.3 → 3.0.0

data/lib/mocktail/resets_state.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class ResetsState
+    extend T::Sig
+
     def reset
       TopShelf.instance.reset_current_thread!
       Mocktail.cabinet.reset!

data/lib/mocktail/share/bind.rb

@@ -1,13 +1,15 @@
 module Mocktail
   module Bind
-    def self.call(mock, method_name, *args, **kwargs, &blk)
+    # sig intentionally omitted, because the wrapper will cause infinite recursion if certain methods are mocked
+    def self.call(mock, method_name, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
       if Mocktail.cabinet.double_for_instance(mock)
-        Object.instance_method(method_name).bind_call(mock, *args, **kwargs, &blk)
-      elsif (type_replacement = TopShelf.instance.type_replacement_if_exists_for(mock)) &&
+        Object.instance_method(method_name).bind_call(mock, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      elsif (mock.is_a?(Module) || mock.is_a?(Class)) &&
+          (type_replacement = TopShelf.instance.type_replacement_if_exists_for(mock)) &&
           (og_method = type_replacement.original_methods&.find { |m| m.name == method_name })
-        og_method.call(*args, **kwargs, &blk)
+        og_method.call(*args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
       else
-        mock.__send__(method_name, *args, **kwargs, &blk)
+        mock.__send__(method_name, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
       end
     end
   end

data/lib/mocktail/share/cleans_backtrace.rb

@@ -1,15 +1,13 @@
-require "pathname"
-
 module Mocktail
   class CleansBacktrace
-    BASE_PATH = (Pathname.new(__FILE__) + "../../..").to_s
+    extend T::Sig
 
     def clean(error)
       raise error
-    rescue => e
+    rescue error.class => e
       e.tap do |e|
         e.set_backtrace(e.backtrace.drop_while { |frame|
-          frame.start_with?(BASE_PATH)
+          frame.start_with?(BASE_PATH, BASE_PATH) || frame.match?(/[\\|\/]sorbet-runtime.*[\\|\/]lib[\\|\/]types[\\|\/]private/)
         })
       end
     end

data/lib/mocktail/share/creates_identifier.rb

@@ -1,19 +1,26 @@
 module Mocktail
   class CreatesIdentifier
+    extend T::Sig
+
     KEYWORDS = %w[__FILE__ __LINE__ alias and begin BEGIN break case class def defined? do else elsif end END ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield]
 
     def create(s, default: "identifier", max_length: 24)
-      id = s.to_s.downcase
-        .gsub(/:0x[0-9a-f]+/, "") # Lazy attempt to wipe any Object:0x802beef identifiers
-        .gsub(/[^\w\s]/, "")
-        .gsub(/^\d+/, "")[0...max_length]
-        .strip
-        .gsub(/\s+/, "_") # snake_case
+      case s
+      when Kernel
+        id = (s.to_s.downcase
+          .gsub(/:0x[0-9a-f]+/, "") # Lazy attempt to wipe any Object:0x802beef identifiers
+          .gsub(/[^\w\s]/, "")
+          .gsub(/^\d+/, "")[0...max_length] || "")
+          .strip
+          .gsub(/\s+/, "_") # snake_case
 
-      if id.empty?
-        default
+        if id.empty?
+          default
+        else
+          unreserved(id, default)
+        end
       else
-        unreserved(id, default)
+        default
       end
     end
 

data/lib/mocktail/share/determines_matching_calls.rb

@@ -2,6 +2,8 @@ require_relative "bind"
 
 module Mocktail
   class DeterminesMatchingCalls
+    extend T::Sig
+
     def determine(real_call, demo_call, demo_config)
       Bind.call(real_call.double, :==, demo_call.double) &&
         real_call.method == demo_call.method &&
@@ -40,7 +42,7 @@ module Mocktail
     end
 
     def blocks_match?(real_block, demo_block, ignore_block)
-      ignore_block ||
+      !!(ignore_block ||
         (real_block.nil? && demo_block.nil?) ||
         (
           real_block && demo_block &&
@@ -48,7 +50,7 @@ module Mocktail
             demo_block == real_block ||
             demo_block.call(real_block)
           )
-        )
+        ))
     end
 
     def match?(real_arg, demo_arg)

data/lib/mocktail/share/stringifies_call.rb

@@ -1,12 +1,13 @@
 module Mocktail
   class StringifiesCall
+    extend T::Sig
+
     def stringify(call, anonymous_blocks: false, always_parens: false)
       "#{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
@@ -31,16 +32,18 @@ module Mocktail
         "(#{args_lists.join(", ")})"
       elsif parens
         "()"
+      else
+        ""
       end
     end
 
     def argify(args)
-      return unless args && !args.empty?
+      return unless !args.empty?
       args.map(&:inspect).join(", ")
     end
 
     def kwargify(kwargs)
-      return unless kwargs && !kwargs.empty?
+      return unless !kwargs.empty?
       kwargs.map { |key, val| "#{key}: #{val.inspect}" }.join(", ")
     end
 

data/lib/mocktail/share/stringifies_method_name.rb

@@ -1,8 +1,10 @@
 module Mocktail
   class StringifiesMethodName
+    extend T::Sig
+
     def stringify(call)
       [
-        call.original_type.name,
+        call.original_type&.name,
         call.singleton ? "." : "#",
         call.method
       ].join

data/lib/mocktail/simulates_argument_error/reconciles_args_with_params.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class ReconcilesArgsWithParams
+    extend T::Sig
+
     def reconcile(signature)
       args_match?(signature.positional_params, signature.positional_args) &&
         kwargs_match?(signature.keyword_params, signature.keyword_args)

data/lib/mocktail/simulates_argument_error/recreates_message.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class RecreatesMessage
+    extend T::Sig
+
     def recreate(signature)
       req_args = signature.positional_params.required.size
       allowed_args = signature.positional_params.allowed.size

data/lib/mocktail/simulates_argument_error/transforms_params.rb

@@ -2,26 +2,33 @@ require_relative "../share/bind"
 
 module Mocktail
   class TransformsParams
-    def transform(dry_call, params: dry_call.original_method.parameters)
+    extend T::Sig
+
+    def initialize
+      @grabs_original_method_parameters = GrabsOriginalMethodParameters.new
+    end
+
+    def transform(dry_call, params: nil)
+      params ||= @grabs_original_method_parameters.grab(dry_call.original_method)
       params = name_unnamed_params(params)
 
       Signature.new(
         positional_params: Params.new(
           all: params.select { |t, _|
             [:req, :opt, :rest].any? { |param_type| Bind.call(t, :==, param_type) }
-          }.map { |_, name| name },
-          required: params.select { |t, _| Bind.call(t, :==, :req) }.map { |_, n| n },
-          optional: params.select { |t, _| Bind.call(t, :==, :opt) }.map { |_, n| n },
+          }.map { |pair| pair.fetch(1) },
+          required: params.select { |t, _| Bind.call(t, :==, :req) }.map { |pair| pair.fetch(1) },
+          optional: params.select { |t, _| Bind.call(t, :==, :opt) }.map { |pair| pair.fetch(1) },
           rest: params.find { |t, _| Bind.call(t, :==, :rest) }&.last
         ),
         positional_args: dry_call.args,
 
         keyword_params: Params.new(
-          all: params.select { |type, _|
+          all: params.select { |type, _| # standard:disable Style/HashSlice
             [:keyreq, :key, :keyrest].include?(type)
-          }.map { |_, name| name },
-          required: params.select { |t, _| Bind.call(t, :==, :keyreq) }.map { |_, n| n },
-          optional: params.select { |t, _| Bind.call(t, :==, :key) }.map { |_, n| n },
+          }.map { |pair| pair.fetch(1) },
+          required: params.select { |t, _| Bind.call(t, :==, :keyreq) }.map { |pair| pair.fetch(1) },
+          optional: params.select { |t, _| Bind.call(t, :==, :key) }.map { |pair| pair.fetch(1) },
           rest: params.find { |t, _| Bind.call(t, :==, :keyrest) }&.last
         ),
         keyword_args: dry_call.kwargs,
@@ -36,7 +43,7 @@ module Mocktail
     def name_unnamed_params(params)
       params.map.with_index { |param, i|
         if param.size == 1
-          param + ["unnamed_arg_#{i + 1}"]
+          param + [:"unnamed_arg_#{i + 1}"]
         else
           param
         end

data/lib/mocktail/simulates_argument_error.rb

@@ -6,6 +6,8 @@ require_relative "share/stringifies_call"
 
 module Mocktail
   class SimulatesArgumentError
+    extend T::Sig
+
     def initialize
       @transforms_params = TransformsParams.new
       @reconciles_args_with_params = ReconcilesArgsWithParams.new

data/lib/mocktail/sorbet/mocktail/collects_calls.rb

@@ -0,0 +1,18 @@
+# typed: strict
+
+module Mocktail
+  class CollectsCalls
+    extend T::Sig
+
+    sig { params(double: Object, method_name: T.nilable(Symbol)).returns(T::Array[Call]) }
+    def collect(double, method_name)
+      calls = ExplainsThing.new.explain(double).reference.calls
+
+      if method_name.nil?
+        calls
+      else
+        calls.select { |call| call.method.to_s == method_name.to_s }
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/debug.rb

@@ -0,0 +1,55 @@
+# typed: strict
+
+module Mocktail
+  module Debug
+    extend T::Sig
+
+    # 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
+    sig { void }
+    def self.guard_against_mocktail_accidentally_calling_mocks_if_debugging!
+      return unless ENV["MOCKTAIL_DEBUG_ACCIDENTAL_INTERNAL_MOCK_CALLS"]
+      raise Mocktail::Error
+    rescue Mocktail::Error => 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"/"in 'block" (Ruby 3.4+ uses a single quote instead of a
+        # backtick) 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.match?(/in [`']block/)
+      }&.reject { |call_site| call_site.match?(/in [`']block/) } || []
+
+      approved_call_sites = [
+        /fulfills_stubbing.rb:(16|20)/,
+        /validates_arguments.rb:(18|23)/,
+        /validates_arguments.rb:(21|26)/
+      ]
+      if internal_call_sites.any? && approved_call_sites.none? { |approved_call_site|
+        internal_call_sites.first&.match?(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/sorbet/mocktail/dsl.rb

@@ -0,0 +1,46 @@
+# typed: strict
+
+module Mocktail
+  module DSL
+    extend T::Sig
+
+    sig {
+      type_parameters(:T)
+        .params(
+          ignore_block: T::Boolean,
+          ignore_extra_args: T::Boolean,
+          ignore_arity: T::Boolean,
+          times: T.nilable(Integer),
+          demo: T.proc.params(matchers: Mocktail::MatcherPresentation).returns(T.type_parameter(:T))
+        )
+        .returns(Mocktail::Stubbing[T.type_parameter(:T)])
+    }
+    def stubs(ignore_block: false, ignore_extra_args: false, ignore_arity: false, times: nil, &demo)
+      RegistersStubbing.new.register(demo, DemoConfig.new(
+        ignore_block: ignore_block,
+        ignore_extra_args: ignore_extra_args,
+        ignore_arity: ignore_arity,
+        times: times
+      ))
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(
+          ignore_block: T::Boolean,
+          ignore_extra_args: T::Boolean,
+          ignore_arity: T::Boolean,
+          times: T.nilable(Integer),
+          demo: T.proc.params(matchers: Mocktail::MatcherPresentation).void
+        ).void
+    }
+    def verify(ignore_block: false, ignore_extra_args: false, ignore_arity: false, times: nil, &demo)
+      VerifiesCall.new.verify(demo, DemoConfig.new(
+        ignore_block: ignore_block,
+        ignore_extra_args: ignore_extra_args,
+        ignore_arity: ignore_arity,
+        times: times
+      ))
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/errors.rb

@@ -0,0 +1,19 @@
+# typed: strict
+
+module Mocktail
+  class Error < StandardError; end
+
+  class UnexpectedError < Error; end
+
+  class UnsupportedMocktail < Error; end
+
+  class MissingDemonstrationError < Error; end
+
+  class AmbiguousDemonstrationError < Error; end
+
+  class InvalidMatcherError < Error; end
+
+  class VerificationError < Error; end
+
+  class TypeCheckingError < Error; end
+end

data/lib/mocktail/sorbet/mocktail/explains_nils.rb

@@ -0,0 +1,41 @@
+# typed: strict
+
+require_relative "share/stringifies_method_name"
+require_relative "share/stringifies_call"
+
+module Mocktail
+  class ExplainsNils
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @stringifies_method_name = T.let(StringifiesMethodName.new, StringifiesMethodName)
+      @stringifies_call = T.let(StringifiesCall.new, StringifiesCall)
+    end
+
+    sig { returns(T::Array[UnsatisfyingCallExplanation]) }
+    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/sorbet/mocktail/explains_thing.rb

@@ -0,0 +1,137 @@
+# typed: strict
+
+require_relative "share/stringifies_method_name"
+require_relative "share/stringifies_call"
+
+module Mocktail
+  class ExplainsThing
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @stringifies_method_name = T.let(StringifiesMethodName.new, StringifiesMethodName)
+      @stringifies_call = T.let(StringifiesCall.new, StringifiesCall)
+    end
+
+    sig { params(thing: Object).returns(Explanation) }
+    def explain(thing)
+      if (double = Mocktail.cabinet.double_for_instance(thing))
+        double_explanation(double)
+      elsif (thing.is_a?(Module) || thing.is_a?(Class)) &&
+          (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
+    end
+
+    private
+
+    sig { params(thing: Object).returns(T.nilable(FakeMethodExplanation)) }
+    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
+
+    sig { params(double: Double).returns(DoubleData) }
+    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
+
+    sig { params(double: Double).returns(DoubleExplanation) }
+    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.sort.map { |method| "  - #{method}" }.join("\n")}
+
+        #{double.dry_methods.sort.map { |method| describe_dry_method(double_data, method) }.join("\n")}
+      MSG
+    end
+
+    sig { params(type_replacement: TypeReplacement).returns(TypeReplacementData) }
+    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|
+          call.double == type_replacement.type
+        },
+        stubbings: Mocktail.cabinet.stubbings.select { |stubbing|
+          stubbing.recording.double == type_replacement.type
+        }
+      )
+    end
+
+    sig { params(type_replacement: TypeReplacement).returns(ReplacedTypeExplanation) }
+    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 methods faked.
+
+        It has these mocked methods:
+        #{type_replacement_data.replaced_method_names.map { |method| "  - #{method}" }.join("\n")}
+
+        #{type_replacement_data.replaced_method_names.map { |method| describe_dry_method(type_replacement_data, method) }.join("\n")}
+      MSG
+    end
+
+    sig { params(double_data: T.any(DoubleData, TypeReplacementData), method: Symbol).returns(String) }
+    def describe_dry_method(double_data, method)
+      method_name = @stringifies_method_name.stringify(Call.new(
+        original_type: double_data.type,
+        singleton: double_data.type == double_data.double,
+        method: method
+      ))
+
+      [
+        @stringifies_call.stringify_multiple(
+          double_data.stubbings.map(&:recording).select { |call|
+            call.method == method
+          },
+          nonzero_message: "`#{method_name}' stubbings",
+          zero_message: "`#{method_name}' has no stubbings"
+        ),
+        @stringifies_call.stringify_multiple(
+          double_data.calls.select { |call|
+            call.method == method
+          },
+          nonzero_message: "`#{method_name}' calls",
+          zero_message: "`#{method_name}' has no calls"
+        )
+      ].join("\n")
+    end
+
+    sig { params(thing: Object).returns(NoExplanation) }
+    def no_explanation(thing)
+      NoExplanation.new(NoExplanationData.new(thing: thing),
+        "Unfortunately, Mocktail doesn't know what this thing is: #{thing.inspect}")
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/grabs_original_method_parameters.rb

@@ -0,0 +1,33 @@
+# typed: strict
+
+module Mocktail
+  class GrabsOriginalMethodParameters
+    extend T::Sig
+
+    # Sorbet wraps the original method in a sig wrapper, so we need to unwrap it.
+    # The value returned from `owner.instance_method(method_name)` does not have
+    # the real parameters values available, as they'll have been erased
+    #
+    # If the method isn't wrapped by Sorbet, this will return the #instance_method,
+    # per usual
+    sig { params(method: T.nilable(T.any(UnboundMethod, Method))).returns(T::Array[T::Array[Symbol]]) }
+    def grab(method)
+      return [] unless method
+
+      if (wrapped_method = sorbet_wrapped_method(method))
+        wrapped_method.parameters
+      else
+        method.parameters
+      end
+    end
+
+    private
+
+    sig { params(method: T.any(UnboundMethod, Method)).returns(T.nilable(T::Private::Methods::Signature)) }
+    def sorbet_wrapped_method(method)
+      return unless defined?(::T::Private::Methods)
+
+      T::Private::Methods.signature_for_method(method)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# typed: strict
+
+require_relative "../../share/cleans_backtrace"
+require_relative "../../share/bind"
+
+module Mocktail
+  class DescribesUnsatisfiedStubbing
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @cleans_backtrace = T.let(CleansBacktrace.new, Mocktail::CleansBacktrace)
+    end
+
+    sig { params(dry_call: Mocktail::Call).returns(Mocktail::UnsatisfyingCall) }
+    def describe(dry_call)
+      UnsatisfyingCall.new(
+        call: dry_call,
+        other_stubbings: Mocktail.cabinet.stubbings.select { |stubbing|
+          Bind.call(dry_call.double, :==, stubbing.recording.double) &&
+            dry_call.method == stubbing.recording.method
+        },
+        backtrace: @cleans_backtrace.clean(Error.new).backtrace || []
+      )
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/handles_dry_call/fulfills_stubbing/finds_satisfaction.rb

@@ -0,0 +1,24 @@
+# typed: strict
+
+require_relative "../../share/determines_matching_calls"
+
+module Mocktail
+  class FindsSatisfaction
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @determines_matching_calls = T.let(DeterminesMatchingCalls.new, Mocktail::DeterminesMatchingCalls)
+    end
+
+    sig { params(dry_call: Call).returns(T.nilable(Stubbing[T.anything])) }
+    def find(dry_call)
+      Mocktail.cabinet.stubbings.reverse.find { |stubbing|
+        demo_config_times = stubbing.demo_config.times
+
+        @determines_matching_calls.determine(dry_call, stubbing.recording, stubbing.demo_config) &&
+          (demo_config_times.nil? || demo_config_times > stubbing.satisfaction_count)
+      }
+    end
+  end
+end