mocktail 1.2.3 → 2.0.0

data/lib/mocktail/sorbet/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, _|
+            [: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}".to_sym]
+        else
+          param
+        end
+      }
+    end
+  end
+end

data/lib/mocktail/sorbet/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/lib/mocktail/sorbet/mocktail/sorbet.rb

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

data/lib/mocktail/sorbet/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/lib/mocktail/sorbet/mocktail/typed.rb

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

data/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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

data/lib/mocktail/sorbet/mocktail/value/signature.rb

@@ -0,0 +1,35 @@
+# typed: strict
+
+module Mocktail
+  class Params < T::Struct
+    extend T::Sig
+
+    prop :all, T::Array[Symbol], default: []
+    prop :required, T::Array[Symbol], default: []
+    prop :optional, T::Array[Symbol], default: []
+    prop :rest, T.nilable(Symbol)
+
+    sig { returns(T::Array[Symbol]) }
+    def allowed
+      all.select { |name| required.include?(name) || optional.include?(name) }
+    end
+
+    sig { returns(T::Boolean) }
+    def rest?
+      !!rest
+    end
+  end
+
+  class Signature < T::Struct
+    const :positional_params, Params
+    const :positional_args, T::Array[T.anything]
+    const :keyword_params, Params
+    const :keyword_args, T::Hash[Symbol, T.anything]
+    const :block_param, T.nilable(Symbol)
+    const :block_arg, T.nilable(Proc), default: nil
+
+    DEFAULT_REST_ARGS = "args"
+    DEFAULT_REST_KWARGS = "kwargs"
+    DEFAULT_BLOCK_PARAM = "blk"
+  end
+end

data/lib/mocktail/sorbet/mocktail/value/stubbing.rb

@@ -0,0 +1,26 @@
+# typed: strict
+
+module Mocktail
+  class Stubbing < T::Struct
+    extend T::Sig
+    extend T::Generic
+    MethodReturnType = type_member
+
+    const :demonstration, T.proc.params(matchers: Mocktail::MatcherPresentation).returns(MethodReturnType)
+    const :demo_config, DemoConfig
+    prop :satisfaction_count, Integer, default: 0
+    const :recording, Call
+    prop :effect, T.nilable(T.proc.params(call: Mocktail::Call).returns(MethodReturnType))
+
+    sig { void }
+    def satisfied!
+      self.satisfaction_count += 1
+    end
+
+    sig { params(block: T.proc.params(call: Mocktail::Call).returns(MethodReturnType)).void }
+    def with(&block)
+      self.effect = block
+      nil
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/value/top_shelf.rb

@@ -0,0 +1,79 @@
+# typed: strict
+
+module Mocktail
+  # The TopShelf is where we keep all the more global, dangerous state.
+  # In particular, this is where Mocktail manages state related to singleton
+  # method replacements carried out with Mocktail.replace(ClassOrModule)
+  class TopShelf
+    extend T::Sig
+
+    sig { returns(TopShelf) }
+    def self.instance
+      Thread.current[:mocktail_top_shelf] ||= new
+    end
+
+    @@type_replacements = T.let({}, T::Hash[T.any(Module, T::Class[T.anything]), TypeReplacement])
+    @@type_replacements_mutex = T.let(Mutex.new, Mutex)
+
+    sig { void }
+    def initialize
+      @new_registrations = T.let([], T::Array[T.any(Module, T::Class[T.anything])])
+      @of_next_registrations = T.let([], T::Array[T::Class[T.anything]])
+      @singleton_method_registrations = T.let([], T::Array[T.any(Module, T::Class[T.anything])])
+    end
+
+    sig { params(type: T.any(Module, T::Class[T.anything])).returns(TypeReplacement) }
+    def type_replacement_for(type)
+      @@type_replacements_mutex.synchronize {
+        @@type_replacements[type] ||= TypeReplacement.new(type: type)
+      }
+    end
+
+    sig { params(type: T.any(Module, T::Class[T.anything])).returns(T.nilable(TypeReplacement)) }
+    def type_replacement_if_exists_for(type)
+      @@type_replacements_mutex.synchronize {
+        @@type_replacements[type]
+      }
+    end
+
+    sig { void }
+    def reset_current_thread!
+      Thread.current[:mocktail_top_shelf] = self.class.new
+    end
+
+    sig { params(type: T.any(Module, T::Class[T.anything])).void }
+    def register_new_replacement!(type)
+      @new_registrations |= [type]
+    end
+
+    sig { params(type: T.any(Module, T::Class[T.anything])).returns(T::Boolean) }
+    def new_replaced?(type)
+      @new_registrations.include?(type)
+    end
+
+    sig { params(type: T::Class[T.anything]).void }
+    def register_of_next_replacement!(type)
+      @of_next_registrations |= [type]
+    end
+
+    sig { params(type: T::Class[T.anything]).returns(T::Boolean) }
+    def of_next_registered?(type)
+      @of_next_registrations.include?(type)
+    end
+
+    sig { params(type: T::Class[T.anything]).void }
+    def unregister_of_next_replacement!(type)
+      @of_next_registrations -= [type]
+    end
+
+    sig { params(type: T.any(Module, T::Class[T.anything])).void }
+    def register_singleton_method_replacement!(type)
+      @singleton_method_registrations |= [type]
+    end
+
+    sig { params(type: T.any(Module, T::Class[T.anything])).returns(T::Boolean) }
+    def singleton_methods_replaced?(type)
+      @singleton_method_registrations.include?(type)
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/value/type_replacement.rb

@@ -0,0 +1,11 @@
+# typed: strict
+
+module Mocktail
+  class TypeReplacement < T::Struct
+    const :type, T.any(T::Class[T.anything], Module)
+    prop :original_methods, T.nilable(T::Array[Method])
+    prop :replacement_methods, T.nilable(T::Array[Method])
+    prop :original_new, T.nilable(Method)
+    prop :replacement_new, T.nilable(Method)
+  end
+end

data/lib/mocktail/sorbet/mocktail/value/type_replacement_data.rb

@@ -0,0 +1,19 @@
+# typed: strict
+
+module Mocktail
+  class TypeReplacementData < T::Struct
+    extend T::Sig
+
+    const :type, T.any(T::Class[T.anything], Module)
+    const :replaced_method_names, T::Array[Symbol]
+    const :calls, T::Array[Call]
+    const :stubbings, T::Array[Stubbing[T.anything]]
+
+    include ExplanationData
+
+    sig { returns(T.any(T::Class[T.anything], Module)) }
+    def double
+      type
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/value/unsatisfying_call.rb

@@ -0,0 +1,9 @@
+# typed: strict
+
+module Mocktail
+  class UnsatisfyingCall < T::Struct
+    const :call, Call
+    const :other_stubbings, T::Array[Stubbing[T.anything]]
+    const :backtrace, T::Array[String]
+  end
+end