mocktail 2.0.0 → 3.0.0

data/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/mocktail/share/stringifies_call.rb

@@ -0,0 +1,84 @@
+# 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/src/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/src/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/src/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

data/src/mocktail/simulates_argument_error/transforms_params.rb

@@ -0,0 +1,58 @@
+# typed: strict
+
+require_relative "../share/bind"
+
+module Mocktail
+  class TransformsParams
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @grabs_original_method_parameters = T.let(GrabsOriginalMethodParameters.new, GrabsOriginalMethodParameters)
+    end
+
+    sig { params(dry_call: Call, params: T.nilable(T::Array[T::Array[Symbol]])).returns(Signature) }
+    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 { |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, _| # standard:disable Style/HashSlice
+            [:keyreq, :key, :keyrest].include?(type)
+          }.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,
+
+        block_param: params.find { |t, _| Bind.call(t, :==, :block) }&.last,
+        block_arg: dry_call.block
+      )
+    end
+
+    private
+
+    sig { params(params: T::Array[T::Array[Symbol]]).returns(T::Array[T::Array[Symbol]]) }
+    def name_unnamed_params(params)
+      params.map.with_index { |param, i|
+        if param.size == 1
+          param + [:"unnamed_arg_#{i + 1}"]
+        else
+          param
+        end
+      }
+    end
+  end
+end

data/src/mocktail/simulates_argument_error.rb

@@ -0,0 +1,36 @@
+# typed: strict
+
+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 "share/cleans_backtrace"
+require_relative "share/stringifies_call"
+
+module Mocktail
+  class SimulatesArgumentError
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @transforms_params = T.let(TransformsParams.new, TransformsParams)
+      @reconciles_args_with_params = T.let(ReconcilesArgsWithParams.new, ReconcilesArgsWithParams)
+      @recreates_message = T.let(RecreatesMessage.new, RecreatesMessage)
+      @cleans_backtrace = T.let(CleansBacktrace.new, CleansBacktrace)
+      @stringifies_call = T.let(StringifiesCall.new, StringifiesCall)
+    end
+
+    sig { params(dry_call: Call).returns(T.nilable(ArgumentError)) }
+    def simulate(dry_call)
+      signature = @transforms_params.transform(dry_call)
+
+      unless @reconciles_args_with_params.reconcile(signature)
+        @cleans_backtrace.clean(
+          ArgumentError.new([
+            @recreates_message.recreate(signature),
+            "[Mocktail call: `#{@stringifies_call.stringify(dry_call)}']"
+          ].join(" "))
+        )
+      end
+    end
+  end
+end

data/src/mocktail/sorbet.rb

@@ -0,0 +1,3 @@
+# typed: strict
+
+require_relative "sorbet/mocktail"

data/src/mocktail/stringifies_method_signature.rb

@@ -0,0 +1,53 @@
+# typed: strict
+
+module Mocktail
+  class StringifiesMethodSignature
+    extend T::Sig
+
+    sig { params(signature: Signature).returns(String) }
+    def stringify(signature)
+      positional_params = positional(signature)
+      keyword_params = keyword(signature)
+      block_param = block(signature)
+
+      "(#{[positional_params, keyword_params, block_param].compact.join(", ")})"
+    end
+
+    private
+
+    sig { params(signature: Signature).returns(T.nilable(String)) }
+    def positional(signature)
+      params = signature.positional_params.all.map do |name|
+        if signature.positional_params.allowed.include?(name)
+          "#{name} = ((__mocktail_default_args ||= {})[:#{name}] = nil)"
+        elsif signature.positional_params.rest == name
+          "*#{(name == :*) ? Signature::DEFAULT_REST_ARGS : name}"
+        end
+      end.compact
+
+      params.join(", ") if params.any?
+    end
+
+    sig { params(signature: Signature).returns(T.nilable(String)) }
+    def keyword(signature)
+      params = signature.keyword_params.all.map do |name|
+        if signature.keyword_params.allowed.include?(name)
+          "#{name}: ((__mocktail_default_args ||= {})[:#{name}] = nil)"
+        elsif signature.keyword_params.rest == name
+          "**#{(name == :**) ? Signature::DEFAULT_REST_KWARGS : name}"
+        end
+      end.compact
+
+      params.join(", ") if params.any?
+    end
+
+    sig { params(signature: Signature).returns(String) }
+    def block(signature)
+      if signature.block_param && signature.block_param != :&
+        "&#{signature.block_param}"
+      else
+        "&#{Signature::DEFAULT_BLOCK_PARAM}"
+      end
+    end
+  end
+end

data/src/mocktail/typed.rb

@@ -0,0 +1,5 @@
+# typed: strict
+
+module Mocktail
+  TYPED = true
+end

data/src/mocktail/value/cabinet.rb

@@ -0,0 +1,91 @@
+# typed: strict
+
+require_relative "../share/bind"
+
+# 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
+  class Cabinet
+    extend T::Sig
+
+    sig { params(demonstration_in_progress: T::Boolean).void }
+    attr_writer :demonstration_in_progress
+
+    sig { returns(T::Array[Call]) }
+    attr_reader :calls
+
+    sig { returns(T::Array[Stubbing[T.anything]]) }
+    attr_reader :stubbings
+
+    sig { returns(T::Array[UnsatisfyingCall]) }
+    attr_reader :unsatisfying_calls
+
+    sig { void }
+    def initialize
+      @doubles = T.let([], T::Array[Double])
+      @calls = T.let([], T::Array[Call])
+      @stubbings = T.let([], T::Array[Stubbing[T.anything]])
+      @unsatisfying_calls = T.let([], T::Array[UnsatisfyingCall])
+      @demonstration_in_progress = T.let(false, T::Boolean)
+    end
+
+    sig { void }
+    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
+      # user-meaningful state on them, and clearing them on reset could result
+      # in valid mocks being broken and stop working
+    end
+
+    sig { params(double: Double).void }
+    def store_double(double)
+      @doubles << double
+    end
+
+    sig { params(call: Call).void }
+    def store_call(call)
+      @calls << call
+    end
+
+    sig { params(stubbing: Stubbing[T.anything]).void }
+    def store_stubbing(stubbing)
+      @stubbings << stubbing
+    end
+
+    sig { params(unsatisfying_call: UnsatisfyingCall).void }
+    def store_unsatisfying_call(unsatisfying_call)
+      @unsatisfying_calls << unsatisfying_call
+    end
+
+    sig { returns(T::Boolean) }
+    def demonstration_in_progress?
+      @demonstration_in_progress
+    end
+
+    sig { params(thing: T.anything).returns(T.nilable(Double)) }
+    def double_for_instance(thing)
+      @doubles.find { |double|
+        # Intentionally calling directly to avoid an infinite recursion in Bind.call
+        Object.instance_method(:==).bind_call(double.dry_instance, thing)
+      }
+    end
+
+    sig { params(double: Double).returns(T::Array[Stubbing[T.anything]]) }
+    def stubbings_for_double(double)
+      @stubbings.select { |stubbing|
+        Bind.call(stubbing.recording.double, :==, double.dry_instance)
+      }
+    end
+
+    sig { params(double: Double).returns(T::Array[Call]) }
+    def calls_for_double(double)
+      @calls.select { |call|
+        Bind.call(call.double, :==, double.dry_instance)
+      }
+    end
+  end
+end