mocktail 1.2.3 → 3.0.0

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

data/src/mocktail/value/call.rb

@@ -0,0 +1,51 @@
+# typed: strict
+
+module Mocktail
+  class Call < T::Struct
+    extend T::Sig
+
+    const :singleton, T.nilable(T::Boolean)
+    const :double, Object, default: nil
+    const :original_type, T.nilable(T.any(T::Class[T.anything], Module))
+    const :dry_type, T.nilable(T.any(T::Class[T.anything], Module))
+    const :method, T.nilable(Symbol), without_accessors: true
+    const :original_method, T.nilable(T.any(UnboundMethod, Method))
+    const :args, T::Array[T.untyped], default: []
+    const :kwargs, T::Hash[Symbol, T.untyped], default: {}
+    # At present, there's no way to type optional/variadic params in blocks
+    #   (i.e. `T.proc.params(*T.untyped).returns(T.untyped)` doesn't work)
+    #
+    # See: https://github.com/sorbet/sorbet/issues/1142#issuecomment-1586195730
+    const :block, T.nilable(Proc)
+
+    sig { returns(T.nilable(Symbol)) }
+    attr_reader :method
+
+    # Because T::Struct compares with referential equality, we need
+    # to redefine the equality methods to compare the values of the attributes.
+    sig { params(other: T.nilable(T.anything)).returns(T::Boolean) }
+    def ==(other)
+      eql?(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def eql?(other)
+      case other
+      when Call
+        [
+          :singleton, :double, :original_type, :dry_type,
+          :method, :original_method, :args, :kwargs, :block
+        ].all? { |attr|
+          instance_variable_get(:"@#{attr}") == other.send(attr)
+        }
+      else
+        false
+      end
+    end
+
+    sig { returns(Integer) }
+    def hash
+      [@singleton, @double, @original_type, @dry_type, @method, @original_method, @args, @kwargs, @block].hash
+    end
+  end
+end

data/src/mocktail/value/demo_config.rb

@@ -0,0 +1,10 @@
+# typed: strict
+
+module Mocktail
+  class DemoConfig < T::Struct
+    const :ignore_block, T::Boolean, default: false
+    const :ignore_extra_args, T::Boolean, default: false
+    const :ignore_arity, T::Boolean, default: false
+    const :times, T.nilable(Integer), default: nil
+  end
+end

data/src/mocktail/value/double.rb

@@ -0,0 +1,10 @@
+# typed: strict
+
+module Mocktail
+  class Double < T::Struct
+    const :original_type, T.any(T::Class[T.anything], Module)
+    const :dry_type, T::Class[T.anything]
+    const :dry_instance, Object
+    const :dry_methods, T::Array[Symbol]
+  end
+end

data/src/mocktail/value/double_data.rb

@@ -0,0 +1,15 @@
+# typed: strict
+
+require_relative "call"
+require_relative "stubbing"
+
+module Mocktail
+  class DoubleData < T::Struct
+    include ExplanationData
+
+    const :type, T.any(T::Class[T.anything], Module)
+    const :double, Object
+    const :calls, T::Array[Call]
+    const :stubbings, T::Array[Stubbing[T.anything]]
+  end
+end

data/src/mocktail/value/explanation.rb

@@ -0,0 +1,68 @@
+# typed: strict
+
+module Mocktail
+  class Explanation
+    extend T::Sig
+
+    sig { returns(Mocktail::ExplanationData) }
+    attr_reader :reference
+
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { params(reference: Mocktail::ExplanationData, message: String).void }
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
+
+    sig { returns(T.class_of(Explanation)) }
+    def type
+      self.class
+    end
+  end
+
+  class NoExplanation < Explanation
+    sig { override.returns(NoExplanationData) }
+    attr_reader :reference
+
+    sig { params(reference: NoExplanationData, message: String).void }
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
+  end
+
+  class DoubleExplanation < Explanation
+    sig { override.returns(DoubleData) }
+    attr_reader :reference
+
+    sig { params(reference: DoubleData, message: String).void }
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
+  end
+
+  class ReplacedTypeExplanation < Explanation
+    sig { override.returns(TypeReplacementData) }
+    attr_reader :reference
+
+    sig { params(reference: TypeReplacementData, message: String).void }
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
+  end
+
+  class FakeMethodExplanation < Explanation
+    sig { override.returns(FakeMethodData) }
+    attr_reader :reference
+
+    sig { params(reference: FakeMethodData, message: String).void }
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
+  end
+end

data/src/mocktail/value/explanation_data.rb

@@ -0,0 +1,19 @@
+# typed: strict
+
+module Mocktail
+  module ExplanationData
+    extend T::Helpers
+    extend T::Sig
+
+    interface!
+    include Kernel
+
+    sig { abstract.returns T::Array[Mocktail::Call] }
+    def calls
+    end
+
+    sig { abstract.returns T::Array[Mocktail::Stubbing[T.anything]] }
+    def stubbings
+    end
+  end
+end

data/src/mocktail/value/fake_method_data.rb

@@ -0,0 +1,11 @@
+# typed: strict
+
+module Mocktail
+  class FakeMethodData < T::Struct
+    include ExplanationData
+
+    const :receiver, T.anything
+    const :calls, T::Array[Call]
+    const :stubbings, T::Array[Stubbing[T.anything]]
+  end
+end

data/src/mocktail/value/matcher_registry.rb

@@ -0,0 +1,27 @@
+# typed: strict
+
+module Mocktail
+  class MatcherRegistry
+    extend T::Sig
+
+    sig { returns(MatcherRegistry) }
+    def self.instance
+      @matcher_registry ||= T.let(new, T.nilable(T.attached_class))
+    end
+
+    sig { void }
+    def initialize
+      @matchers = T.let({}, T::Hash[Symbol, T.class_of(Matchers::Base)])
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).void }
+    def add(matcher_type)
+      @matchers[matcher_type.matcher_name] = matcher_type
+    end
+
+    sig { params(name: Symbol).returns(T.nilable(T.class_of(Matchers::Base))) }
+    def get(name)
+      @matchers[name]
+    end
+  end
+end

data/src/mocktail/value/no_explanation_data.rb

@@ -0,0 +1,20 @@
+# typed: strict
+
+module Mocktail
+  class NoExplanationData < T::Struct
+    extend T::Sig
+    include ExplanationData
+
+    const :thing, Object
+
+    sig { override.returns(T::Array[Mocktail::Call]) }
+    def calls
+      raise Error.new("No calls have been recorded for #{thing.inspect}, because Mocktail doesn't know what it is.")
+    end
+
+    sig { override.returns T::Array[Mocktail::Stubbing[T.anything]] }
+    def stubbings
+      raise Error.new("No stubbings exist on #{thing.inspect}, because Mocktail doesn't know what it is.")
+    end
+  end
+end