mocktail 1.2.3 → 2.0.0

data/lib/mocktail/sorbet/mocktail/registers_matcher.rb

@@ -0,0 +1,65 @@
+# typed: strict
+
+module Mocktail
+  class RegistersMatcher
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @grabs_original_method_parameters = T.let(GrabsOriginalMethodParameters.new, GrabsOriginalMethodParameters)
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).void }
+    def register(matcher_type)
+      if invalid_type?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          Matchers must be Ruby classes
+        MSG
+      elsif invalid_name?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}.matcher_name must return a valid method name
+        MSG
+      elsif invalid_match?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}#match? must be defined as a one-argument method
+        MSG
+      elsif invalid_flag?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}#is_mocktail_matcher? must be defined
+        MSG
+      else
+        MatcherRegistry.instance.add(matcher_type)
+      end
+    end
+
+    private
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).returns(T::Boolean) }
+    def invalid_type?(matcher_type)
+      !matcher_type.is_a?(Class)
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).returns(T::Boolean) }
+    def invalid_name?(matcher_type)
+      return true unless matcher_type.respond_to?(:matcher_name)
+      name = matcher_type.matcher_name
+
+      !name.respond_to?(:to_sym) || name.to_sym.inspect.start_with?(":\"")
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).returns(T::Boolean) }
+    def invalid_match?(matcher_type)
+      params = @grabs_original_method_parameters.grab(matcher_type.instance_method(:match?))
+      params.size > 1 || ![:req, :opt].include?(T.unsafe(params).first[0])
+    rescue NameError
+      true
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).returns(T::Boolean) }
+    def invalid_flag?(matcher_type)
+      !matcher_type.instance_method(:is_mocktail_matcher?)
+    rescue NameError
+      true
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/registers_stubbing.rb

@@ -0,0 +1,31 @@
+# typed: strict
+
+require_relative "records_demonstration"
+
+module Mocktail
+  class RegistersStubbing
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @records_demonstration = T.let(RecordsDemonstration.new, RecordsDemonstration)
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(
+          demonstration: T.proc.params(matchers: Mocktail::MatcherPresentation).returns(T.type_parameter(:T)),
+          demo_config: DemoConfig
+        ).returns(Mocktail::Stubbing[T.type_parameter(:T)])
+    }
+    def register(demonstration, demo_config)
+      Stubbing.new(
+        demonstration: demonstration,
+        demo_config: demo_config,
+        recording: @records_demonstration.record(demonstration, demo_config)
+      ).tap do |stubbing|
+        Mocktail.cabinet.store_stubbing(stubbing)
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/replaces_next.rb

@@ -0,0 +1,55 @@
+# typed: strict
+
+module Mocktail
+  class ReplacesNext
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @top_shelf = T.let(TopShelf.instance, TopShelf)
+      @redefines_new = T.let(RedefinesNew.new, RedefinesNew)
+      @imitates_type = T.let(ImitatesType.new, ImitatesType)
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(type: T::Class[T.all(T.type_parameter(:T), Object)])
+        .returns(T.type_parameter(:T))
+    }
+    def replace_once(type)
+      replace(type, 1).fetch(0)
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(type: T::Class[T.all(T.type_parameter(:T), Object)], count: Integer)
+        .returns(T::Array[T.type_parameter(:T)])
+    }
+    def replace(type, count)
+      raise UnsupportedMocktail.new("Mocktail.of_next() only supports classes") unless T.unsafe(type).is_a?(Class)
+
+      mocktails = count.times.map { @imitates_type.imitate(type) }
+
+      @top_shelf.register_of_next_replacement!(type)
+      @redefines_new.redefine(type)
+      mocktails.reverse_each do |mocktail|
+        Mocktail.stubs(
+          ignore_extra_args: true,
+          ignore_block: true,
+          ignore_arity: true,
+          times: 1
+        ) {
+          type.new
+        }.with {
+          if mocktail == mocktails.last
+            @top_shelf.unregister_of_next_replacement!(type)
+          end
+
+          mocktail
+        }
+      end
+
+      mocktails
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/replaces_type/redefines_new.rb

@@ -0,0 +1,32 @@
+# typed: strict
+
+module Mocktail
+  class RedefinesNew
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @handles_dry_new_call = T.let(HandlesDryNewCall.new, HandlesDryNewCall)
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def redefine(type)
+      type_replacement = TopShelf.instance.type_replacement_for(type)
+
+      if type_replacement.replacement_new.nil?
+        type_replacement.original_new = type.method(:new)
+        type.singleton_class.send(:undef_method, :new)
+        handles_dry_new_call = @handles_dry_new_call
+        type.define_singleton_method :new, ->(*args, **kwargs, &block) {
+          if TopShelf.instance.new_replaced?(type) ||
+              (type.is_a?(Class) && TopShelf.instance.of_next_registered?(type))
+            handles_dry_new_call.handle(T.cast(type, T::Class[T.all(T, Object)]), args, kwargs, block)
+          else
+            type_replacement.original_new.call(*args, **kwargs, &block)
+          end
+        }
+        type_replacement.replacement_new = type.singleton_method(:new)
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb

@@ -0,0 +1,80 @@
+# typed: strict
+
+module Mocktail
+  class RedefinesSingletonMethods
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @handles_dry_call = T.let(HandlesDryCall.new, HandlesDryCall)
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def redefine(type)
+      type_replacement = TopShelf.instance.type_replacement_for(type)
+      return unless type_replacement.replacement_methods.nil?
+
+      type_replacement.original_methods = type.singleton_methods.map { |name|
+        type.method(name)
+      }.reject { |method| sorbet_method_hook?(method) } - [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)
+        type.define_singleton_method original_method.name, ->(*args, **kwargs, &block) {
+          if TopShelf.instance.singleton_methods_replaced?(type)
+            handles_dry_call.handle(Call.new(
+              singleton: true,
+              double: type,
+              original_type: type,
+              dry_type: type,
+              method: original_method.name,
+              original_method: original_method,
+              args: args,
+              kwargs: kwargs,
+              block: block
+            ))
+          else
+            original_method.call(*args, **kwargs, &block)
+          end
+        }
+        type.singleton_method(original_method.name)
+      }
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    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
+
+    private
+
+    sig { params(method: Method).returns(T::Boolean) }
+    def sorbet_method_hook?(method)
+      [
+        T::Sig,
+        T::Private::Methods::MethodHooks,
+        T::Private::Methods::SingletonMethodHooks
+      ].include?(method.owner)
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/replaces_type/runs_sorbet_sig_blocks_before_replacement.rb

@@ -0,0 +1,39 @@
+# typed: strict
+
+module Mocktail
+  class RunsSorbetSigBlocksBeforeReplacement
+    extend T::Sig
+
+    # This is necessary because when Sorbet runs a sig block of a singleton
+    # method, it has the net effect of unwrapping/redefining the method. If
+    # we try to use Mocktail.replace(Foo) and Foo.bar has a Sorbet sig block,
+    # then we'll end up with three "versions" of the same method and no way
+    # to keep straight which one == which:
+    #
+    #  A - Foo.bar, as defined in the original class
+    #  B - Foo.bar, as redefined by RedefinesSingletonMethods
+    #  C - Foo.bar, as wrapped by sorbet-runtime
+    #
+    # Initially, Foo.method(:bar) would == C, but after the type
+    # replacement, it would == B (with a reference back to C as the original),
+    # but after handling a single dry call, our invocation of
+    # GrabsOriginalMethodParameters.grab(Foo.method(:bar)) would invoke the
+    # Sorbet `sig` block, which has the net effect of redefining the method back
+    # to A.
+    #
+    # It's very fun and confusing and a great time.
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def run(type)
+      return unless defined?(T::Private::Methods)
+
+      type.singleton_methods.each do |method_name|
+        method = type.method(method_name)
+
+        # Again: calling this for the side effect of running the sig block
+        #
+        # https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/private/methods/_methods.rb#L111
+        T::Private::Methods.signature_for_method(method)
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/replaces_type.rb

@@ -0,0 +1,36 @@
+# typed: strict
+
+require_relative "replaces_type/redefines_new"
+require_relative "replaces_type/redefines_singleton_methods"
+require_relative "replaces_type/runs_sorbet_sig_blocks_before_replacement"
+
+module Mocktail
+  class ReplacesType
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @top_shelf = T.let(TopShelf.instance, TopShelf)
+      @runs_sorbet_sig_blocks_before_replacement = T.let(RunsSorbetSigBlocksBeforeReplacement.new, RunsSorbetSigBlocksBeforeReplacement)
+      @redefines_new = T.let(RedefinesNew.new, RedefinesNew)
+      @redefines_singleton_methods = T.let(RedefinesSingletonMethods.new, RedefinesSingletonMethods)
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def replace(type)
+      unless T.unsafe(type).is_a?(Class) || T.unsafe(type).is_a?(Module)
+        raise UnsupportedMocktail.new("Mocktail.replace() only supports classes and modules")
+      end
+
+      @runs_sorbet_sig_blocks_before_replacement.run(type)
+
+      if type.is_a?(Class)
+        @top_shelf.register_new_replacement!(type)
+        @redefines_new.redefine(type)
+      end
+
+      @top_shelf.register_singleton_method_replacement!(type)
+      @redefines_singleton_methods.redefine(type)
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/resets_state.rb

@@ -0,0 +1,14 @@
+# typed: strict
+
+module Mocktail
+  class ResetsState
+    extend T::Sig
+
+    sig { void }
+    def reset
+      TopShelf.instance.reset_current_thread!
+      Mocktail.cabinet.reset!
+      ValidatesArguments.enable!
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/share/bind.rb

@@ -0,0 +1,18 @@
+# typed: true
+
+module Mocktail
+  module Bind
+    # 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)
+        T.unsafe(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 })
+        T.unsafe(og_method).call(*args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      else
+        T.unsafe(mock).__send__(method_name, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/share/cleans_backtrace.rb

@@ -0,0 +1,22 @@
+# typed: strict
+
+module Mocktail
+  class CleansBacktrace
+    extend T::Sig
+
+    sig {
+      type_parameters(:T)
+        .params(error: T.all(T.type_parameter(:T), StandardError))
+        .returns(T.type_parameter(:T))
+    }
+    def clean(error)
+      raise error
+    rescue error.class => e
+      T.cast(e, T.all(T.type_parameter(:T), StandardError)).tap do |e|
+        e.set_backtrace(e.backtrace.drop_while { |frame|
+          frame.start_with?(BASE_PATH, BASE_PATH) || frame.match?(/[\\|\/]sorbet-runtime.*[\\|\/]lib[\\|\/]types[\\|\/]private/)
+        })
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/share/creates_identifier.rb

@@ -0,0 +1,39 @@
+# typed: strict
+
+module Mocktail
+  class CreatesIdentifier
+    extend T::Sig
+
+    KEYWORDS = T.let(%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], T::Array[String])
+
+    sig { params(s: T.anything, default: String, max_length: Integer).returns(String) }
+    def create(s, default: "identifier", max_length: 24)
+      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
+        else
+          unreserved(id, default)
+        end
+      else
+        default
+      end
+    end
+
+    private
+
+    sig { params(id: String, default: String).returns(String) }
+    def unreserved(id, default)
+      return id unless KEYWORDS.include?(id)
+
+      "#{id}_#{default}"
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/share/determines_matching_calls.rb

@@ -0,0 +1,72 @@
+# typed: strict
+
+require_relative "bind"
+
+module Mocktail
+  class DeterminesMatchingCalls
+    extend T::Sig
+
+    sig { params(real_call: Call, demo_call: Call, demo_config: DemoConfig).returns(T::Boolean) }
+    def determine(real_call, demo_call, demo_config)
+      T.cast(Bind.call(real_call.double, :==, demo_call.double), T::Boolean) &&
+        real_call.method == demo_call.method &&
+
+        # Matcher implementation will replace this:
+        args_match?(real_call.args, demo_call.args, demo_config.ignore_extra_args) &&
+        kwargs_match?(real_call.kwargs, demo_call.kwargs, demo_config.ignore_extra_args) &&
+        blocks_match?(real_call.block, demo_call.block, demo_config.ignore_block)
+    end
+
+    private
+
+    sig { params(real_args: T::Array[T.untyped], demo_args: T::Array[T.untyped], ignore_extra_args: T::Boolean).returns(T::Boolean) }
+    def args_match?(real_args, demo_args, ignore_extra_args)
+      # Guard clause for performance:
+      return true if ignore_extra_args && demo_args.empty?
+
+      (
+        real_args.size == demo_args.size ||
+        (ignore_extra_args && real_args.size >= demo_args.size)
+      ) &&
+        demo_args.each.with_index.all? { |demo_arg, i|
+          match?(real_args[i], demo_arg)
+        }
+    end
+
+    sig { params(real_kwargs: T::Hash[Symbol, T.untyped], demo_kwargs: T::Hash[Symbol, T.untyped], ignore_extra_args: T::Boolean).returns(T::Boolean) }
+    def kwargs_match?(real_kwargs, demo_kwargs, ignore_extra_args)
+      return true if ignore_extra_args && demo_kwargs.empty?
+
+      (
+        real_kwargs.size == demo_kwargs.size ||
+        (ignore_extra_args && real_kwargs.size >= demo_kwargs.size)
+      ) &&
+        demo_kwargs.all? { |key, demo_val|
+          real_kwargs.key?(key) && match?(real_kwargs[key], demo_val)
+        }
+    end
+
+    sig { params(real_block: T.nilable(Proc), demo_block: T.nilable(Proc), ignore_block: T::Boolean).returns(T::Boolean) }
+    def blocks_match?(real_block, demo_block, ignore_block)
+      !!(ignore_block ||
+        (real_block.nil? && demo_block.nil?) ||
+        (
+          real_block && demo_block &&
+          (
+            demo_block == real_block ||
+            demo_block.call(real_block)
+          )
+        ))
+    end
+
+    sig { params(real_arg: T.untyped, demo_arg: T.untyped).returns(T::Boolean) }
+    def match?(real_arg, demo_arg)
+      if Bind.call(demo_arg, :respond_to?, :is_mocktail_matcher?) &&
+          demo_arg.is_mocktail_matcher?
+        demo_arg.match?(real_arg)
+      else
+        Bind.call(demo_arg, :==, real_arg)
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/share/stringifies_call.rb

@@ -0,0 +1,85 @@
+# typed: strict
+
+module Mocktail
+  class StringifiesCall
+    extend T::Sig
+
+    sig { params(call: Call, anonymous_blocks: T::Boolean, always_parens: T::Boolean).returns(String) }
+    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
+
+    sig { params(calls: T::Array[Call], nonzero_message: String, zero_message: String, anonymous_blocks: T::Boolean, always_parens: T::Boolean).returns(String) }
+    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
+
+    sig { params(call: Call, parens: T::Boolean).returns(T.nilable(String)) }
+    def args_to_s(call, parens: true)
+      args_lists = [
+        argify(call.args),
+        kwargify(call.kwargs),
+        lambdafy(call.block)
+      ].compact
+
+      if !args_lists.empty?
+        "(#{args_lists.join(", ")})"
+      elsif parens
+        "()"
+      else
+        ""
+      end
+    end
+
+    sig { params(args: T::Array[Object]).returns(T.nilable(String)) }
+    def argify(args)
+      return unless !args.empty?
+      args.map(&:inspect).join(", ")
+    end
+
+    sig { params(kwargs: T::Hash[Symbol, Object]).returns(T.nilable(String)) }
+    def kwargify(kwargs)
+      return unless !kwargs.empty?
+      kwargs.map { |key, val| "#{key}: #{val.inspect}" }.join(", ")
+    end
+
+    sig { params(block: T.nilable(Proc)).returns(T.nilable(String)) }
+    def lambdafy(block)
+      return unless block&.lambda?
+      "&lambda[#{source_locationify(block)}]"
+    end
+
+    sig { params(block: T.nilable(Proc), anonymous: T::Boolean).returns(T.nilable(String)) }
+    def blockify(block, anonymous:)
+      return unless block && !block.lambda?
+
+      if anonymous
+        " {…}"
+      else
+        " { Proc at #{source_locationify(block)} }"
+      end
+    end
+
+    sig { params(block: Proc).returns(String) }
+    def source_locationify(block)
+      "#{strip_pwd(block.source_location[0])}:#{block.source_location[1]}"
+    end
+
+    sig { params(path: String).returns(String) }
+    def strip_pwd(path)
+      path.gsub(Dir.pwd + File::SEPARATOR, "")
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/share/stringifies_method_name.rb

@@ -0,0 +1,16 @@
+# typed: strict
+
+module Mocktail
+  class StringifiesMethodName
+    extend T::Sig
+
+    sig { params(call: Call).returns(String) }
+    def stringify(call)
+      [
+        call.original_type&.name,
+        call.singleton ? "." : "#",
+        call.method
+      ].join
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/simulates_argument_error/reconciles_args_with_params.rb

@@ -0,0 +1,27 @@
+# typed: strict
+
+module Mocktail
+  class ReconcilesArgsWithParams
+    extend T::Sig
+
+    sig { params(signature: Signature).returns(T::Boolean) }
+    def reconcile(signature)
+      args_match?(signature.positional_params, signature.positional_args) &&
+        kwargs_match?(signature.keyword_params, signature.keyword_args)
+    end
+
+    private
+
+    sig { params(arg_params: Params, args: T::Array[T.untyped]).returns(T::Boolean) }
+    def args_match?(arg_params, args)
+      args.size >= arg_params.required.size &&
+        (arg_params.rest? || args.size <= arg_params.allowed.size)
+    end
+
+    sig { params(kwarg_params: Params, kwargs: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+    def kwargs_match?(kwarg_params, kwargs)
+      kwarg_params.required.all? { |name| kwargs.key?(name) } &&
+        (kwarg_params.rest? || kwargs.keys.all? { |name| kwarg_params.allowed.include?(name) })
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/simulates_argument_error/recreates_message.rb

@@ -0,0 +1,34 @@
+# typed: strict
+
+module Mocktail
+  class RecreatesMessage
+    extend T::Sig
+
+    sig { params(signature: Signature).returns(String) }
+    def recreate(signature)
+      req_args = signature.positional_params.required.size
+      allowed_args = signature.positional_params.allowed.size
+      rest_args = signature.positional_params.rest?
+      req_kwargs = signature.keyword_params.required
+
+      if signature.positional_args.size < req_args || (!rest_args && signature.positional_args.size > allowed_args)
+        expected_desc = if rest_args
+          "#{req_args}+"
+        elsif allowed_args != req_args
+          "#{req_args}..#{allowed_args}"
+        else
+          req_args.to_s
+        end
+
+        "wrong number of arguments (given #{signature.positional_args.size}, expected #{expected_desc}#{"; required keyword#{"s" if req_kwargs.size > 1}: #{req_kwargs.join(", ")}" unless req_kwargs.empty?})"
+
+      elsif !(missing_kwargs = req_kwargs.reject { |name| signature.keyword_args.key?(name) }).empty?
+        "missing keyword#{"s" if missing_kwargs.size > 1}: #{missing_kwargs.map { |name| name.inspect }.join(", ")}"
+      elsif !(unknown_kwargs = signature.keyword_args.keys.reject { |name| signature.keyword_params.all.include?(name) }).empty?
+        "unknown keyword#{"s" if unknown_kwargs.size > 1}: #{unknown_kwargs.map { |name| name.inspect }.join(", ")}"
+      else
+        "unknown cause (this is probably a bug in Mocktail)"
+      end
+    end
+  end
+end