mocktail 1.2.3 → 3.0.0

data/src/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/src/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/src/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/src/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/src/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/src/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

data/src/mocktail/value/unsatisfying_call_explanation.rb

@@ -0,0 +1,24 @@
+# typed: strict
+
+module Mocktail
+  class UnsatisfyingCallExplanation
+    extend T::Sig
+
+    sig { returns(UnsatisfyingCall) }
+    attr_reader :reference
+
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { params(reference: UnsatisfyingCall, message: String).void }
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
+
+    sig { returns(T.class_of(UnsatisfyingCallExplanation)) }
+    def type
+      self.class
+    end
+  end
+end

data/src/mocktail/value.rb

@@ -0,0 +1,19 @@
+# typed: strict
+
+require_relative "value/cabinet"
+require_relative "value/call"
+require_relative "value/demo_config"
+require_relative "value/explanation"
+require_relative "value/explanation_data"
+require_relative "value/double"
+require_relative "value/double_data"
+require_relative "value/fake_method_data"
+require_relative "value/matcher_registry"
+require_relative "value/no_explanation_data"
+require_relative "value/signature"
+require_relative "value/stubbing"
+require_relative "value/type_replacement"
+require_relative "value/type_replacement_data"
+require_relative "value/unsatisfying_call_explanation"
+require_relative "value/unsatisfying_call"
+require_relative "value/top_shelf"

data/src/mocktail/verifies_call/finds_verifiable_calls.rb

@@ -0,0 +1,21 @@
+# typed: strict
+
+require_relative "../share/determines_matching_calls"
+
+module Mocktail
+  class FindsVerifiableCalls
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @determines_matching_calls = T.let(DeterminesMatchingCalls.new, DeterminesMatchingCalls)
+    end
+
+    sig { params(recording: Call, demo_config: DemoConfig).returns(T::Array[Call]) }
+    def find(recording, demo_config)
+      Mocktail.cabinet.calls.select { |call|
+        @determines_matching_calls.determine(call, recording, demo_config)
+      }
+    end
+  end
+end

data/src/mocktail/verifies_call/raises_verification_error/gathers_calls_of_method.rb

@@ -0,0 +1,15 @@
+# typed: strict
+
+module Mocktail
+  class GathersCallsOfMethod
+    extend T::Sig
+
+    sig { params(dry_call: Call).returns(T::Array[Call]) }
+    def gather(dry_call)
+      Mocktail.cabinet.calls.select { |call|
+        call.double == dry_call.double &&
+          call.method == dry_call.method
+      }
+    end
+  end
+end

data/src/mocktail/verifies_call/raises_verification_error.rb

@@ -0,0 +1,74 @@
+# typed: strict
+
+require_relative "raises_verification_error/gathers_calls_of_method"
+require_relative "../share/stringifies_method_name"
+require_relative "../share/stringifies_call"
+
+module Mocktail
+  class RaisesVerificationError
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @gathers_calls_of_method = T.let(GathersCallsOfMethod.new, GathersCallsOfMethod)
+      @stringifies_method_name = T.let(StringifiesMethodName.new, StringifiesMethodName)
+      @stringifies_call = T.let(StringifiesCall.new, StringifiesCall)
+    end
+
+    sig { params(recording: Call, verifiable_calls: T::Array[Call], demo_config: DemoConfig).void }
+    def raise(recording, verifiable_calls, demo_config)
+      Kernel.raise VerificationError.new <<~MSG
+        Expected mocktail of `#{@stringifies_method_name.stringify(recording)}' to be called like:
+
+          #{@stringifies_call.stringify(recording)}#{[
+            (" [#{demo_config.times} #{pl("time", demo_config.times)}]" unless demo_config.times.nil?),
+            (" [ignoring extra args]" if demo_config.ignore_extra_args),
+            (" [ignoring blocks]" if demo_config.ignore_block)
+          ].compact.join(" ")}
+
+        #{[
+          describe_verifiable_times_called(demo_config, verifiable_calls.size),
+          describe_other_calls(recording, verifiable_calls, demo_config)
+        ].compact.join("\n\n")}
+      MSG
+    end
+
+    private
+
+    sig { params(demo_config: DemoConfig, count: Integer).returns(T.nilable(String)) }
+    def describe_verifiable_times_called(demo_config, count)
+      return if demo_config.times.nil?
+
+      if count == 0
+        "But it was never called this way."
+      else
+        "But it was actually called this way #{count} #{pl("time", count)}."
+      end
+    end
+
+    sig { params(recording: Call, verifiable_calls: T::Array[Call], demo_config: DemoConfig).returns(T.nilable(String)) }
+    def describe_other_calls(recording, verifiable_calls, demo_config)
+      calls_of_method = @gathers_calls_of_method.gather(recording) - verifiable_calls
+      if calls_of_method.size == 0
+        if demo_config.times.nil?
+          "But it was never called."
+        end
+      else
+        <<~MSG
+          It was called differently #{calls_of_method.size} #{pl("time", calls_of_method.size)}:
+
+          #{calls_of_method.map { |call| "  " + @stringifies_call.stringify(call) }.join("\n\n")}
+        MSG
+      end
+    end
+
+    sig { params(s: String, count: T.nilable(Integer)).returns(String) }
+    def pl(s, count)
+      if count == 1
+        s
+      else
+        s + "s"
+      end
+    end
+  end
+end

data/src/mocktail/verifies_call.rb

@@ -0,0 +1,37 @@
+# typed: strict
+
+require_relative "records_demonstration"
+require_relative "verifies_call/finds_verifiable_calls"
+require_relative "verifies_call/raises_verification_error"
+
+module Mocktail
+  class VerifiesCall
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @records_demonstration = T.let(RecordsDemonstration.new, RecordsDemonstration)
+      @finds_verifiable_calls = T.let(FindsVerifiableCalls.new, FindsVerifiableCalls)
+      @raises_verification_error = T.let(RaisesVerificationError.new, RaisesVerificationError)
+    end
+
+    sig { params(demo: T.proc.params(matchers: Mocktail::MatcherPresentation).void, demo_config: DemoConfig).void }
+    def verify(demo, demo_config)
+      recording = @records_demonstration.record(demo, demo_config)
+      verifiable_calls = @finds_verifiable_calls.find(recording, demo_config)
+
+      unless verification_satisfied?(verifiable_calls.size, demo_config)
+        @raises_verification_error.raise(recording, verifiable_calls, demo_config)
+      end
+      nil
+    end
+
+    private
+
+    sig { params(verifiable_call_count: Integer, demo_config: DemoConfig).returns(T::Boolean) }
+    def verification_satisfied?(verifiable_call_count, demo_config)
+      (demo_config.times.nil? && verifiable_call_count > 0) ||
+        (demo_config.times == verifiable_call_count)
+    end
+  end
+end

data/src/mocktail/version.rb

@@ -0,0 +1,12 @@
+# typed: strict
+
+module Mocktail
+  # The gemspec will define Module::VERSION as loaded from lib/, but if the
+  # user loads mocktail/sorbet, its version file will be effectively redefining
+  # it. Undef it first to ensure we don't spew warnings
+  if defined?(VERSION)
+    Mocktail.send(:remove_const, :VERSION)
+  end
+
+  VERSION = "3.0.0"
+end

data/src/mocktail.rb

@@ -0,0 +1,154 @@
+# typed: strict
+
+require "pathname"
+
+if defined?(Mocktail::TYPED)
+  if eval("Mocktail::TYPED", binding, __FILE__, __LINE__)
+    warn "`require \"mocktail\"' was called, but Mocktail was already required as `require \"mocktail/sorbet\"', so we're NOT going to load it to avoid constants from being redefined. If you want to use Mocktail WITHOUT sorbet runtime checks, remove whatever is requiring `mocktail/sorbet'."
+  else
+    warn "`require \"mocktail/sorbet\"' was called, but Mocktail was already required as `require \"mocktail\"', so we're NOT going to load it to avoid constants from being redefined. If you want to use Mocktail WITH sorbet runtime checks, remove whatever is requiring `mocktail'."
+  end
+  return
+end
+
+require_relative "mocktail/initialize_based_on_type_system_mode_switching"
+
+require_relative "mocktail/collects_calls"
+require_relative "mocktail/debug"
+require_relative "mocktail/dsl"
+require_relative "mocktail/errors"
+require_relative "mocktail/explains_thing"
+require_relative "mocktail/explains_nils"
+require_relative "mocktail/grabs_original_method_parameters"
+require_relative "mocktail/handles_dry_call"
+require_relative "mocktail/handles_dry_new_call"
+require_relative "mocktail/imitates_type"
+require_relative "mocktail/initializes_mocktail"
+require_relative "mocktail/matcher_presentation"
+require_relative "mocktail/matchers"
+require_relative "mocktail/raises_neato_no_method_error"
+require_relative "mocktail/registers_matcher"
+require_relative "mocktail/registers_stubbing"
+require_relative "mocktail/replaces_next"
+require_relative "mocktail/replaces_type"
+require_relative "mocktail/resets_state"
+require_relative "mocktail/simulates_argument_error"
+require_relative "mocktail/stringifies_method_signature"
+require_relative "mocktail/value"
+require_relative "mocktail/verifies_call"
+require_relative "mocktail/version"
+
+module Mocktail
+  extend T::Sig
+  extend DSL
+  BASE_PATH = T.let((Pathname.new(__FILE__) + "..").to_s, String)
+
+  # Returns an instance of `type` whose implementation is mocked out
+  sig {
+    type_parameters(:T)
+      .params(type: T::Class[T.all(T.type_parameter(:T), Object)])
+      .returns(T.all(T.type_parameter(:T), Object))
+  }
+  def self.of(type)
+    ImitatesType.new.imitate(type)
+  end
+
+  # Returns an instance of `klass` whose implementation is mocked out AND
+  # stubs its constructor to return that fake the next time klass.new is called
+  sig {
+    type_parameters(:T)
+      .params(type: T::Class[T.all(T.type_parameter(:T), Object)], count: T.nilable(Integer))
+      .returns(T.type_parameter(:T))
+  }
+  def self.of_next(type, count: 1)
+    count ||= 1
+    if count == 1
+      ReplacesNext.new.replace_once(type)
+    elsif !T.unsafe(Mocktail::TYPED) || T::Private::RuntimeLevels.default_checked_level == :never
+      T.unsafe(ReplacesNext.new).replace(type, count)
+    else
+      raise TypeCheckingError.new <<~MSG
+        Calling `Mocktail.of_next()' with a `count' value other than 1 is not supported when
+        type checking is enabled. There are two ways to fix this:
+
+        1. Use `Mocktail.of_next_with_count(type, count)' instead, which will always return
+           an array of fake objects.
+
+        2. Disable runtime type checking by setting `T::Private::RuntimeLevels.default_checked_level = :never'
+           or by setting the envronment variable `SORBET_RUNTIME_DEFAULT_CHECKED_LEVEL=never'
+      MSG
+    end
+  end
+
+  # An alias of of_next that always returns an array of fakes
+  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 self.of_next_with_count(type, count)
+    ReplacesNext.new.replace(type, count)
+  end
+
+  sig { returns(Mocktail::MatcherPresentation) }
+  def self.matchers
+    MatcherPresentation.new
+  end
+
+  sig { returns(Mocktail::Matchers::Captor) }
+  def self.captor
+    Matchers::Captor.new
+  end
+
+  sig { params(matcher: T.class_of(Mocktail::Matchers::Base)).void }
+  def self.register_matcher(matcher)
+    RegistersMatcher.new.register(matcher)
+  end
+
+  # Replaces every singleton method on `type` with a fake, and when instantiated
+  # or included will also fake instance methods
+  sig { params(type: T.any(T::Class[T.anything], Module)).void }
+  def self.replace(type)
+    ReplacesType.new.replace(type)
+    nil
+  end
+
+  sig { void }
+  def self.reset
+    ResetsState.new.reset
+  end
+
+  sig {
+    params(thing: Object)
+      .returns(Explanation)
+  }
+  def self.explain(thing)
+    ExplainsThing.new.explain(thing)
+  end
+
+  sig { returns(T::Array[Mocktail::UnsatisfyingCallExplanation]) }
+  def self.explain_nils
+    ExplainsNils.new.explain
+  end
+
+  # An alias for Mocktail.explain(double).reference.calls
+  # Takes an optional second parameter of the method name to filter only
+  # calls to that method
+  sig {
+    params(double: Object, method_name: T.nilable(T.any(String, Symbol)))
+      .returns(T::Array[Mocktail::Call])
+  }
+  def self.calls(double, method_name = nil)
+    CollectsCalls.new.collect(double, method_name&.to_sym)
+  end
+
+  # Stores most transactional state about calls & stubbing configurations
+  # Anything returned by this is undocumented and could change at any time, so
+  # don't commit code that relies on it!
+  sig { returns Cabinet }
+  def self.cabinet
+    Thread.current[:mocktail_store] ||= Cabinet.new
+  end
+end
+
+Mocktail::InitializesMocktail.new.init

data/sub_projects/rbi_generator/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "mocktail", require: false, path: "../.."
+gem "tapioca", require: false

data/sub_projects/rbi_generator/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: ../..
+  specs:
+    mocktail (3.0.0)
+      sorbet-eraser (~> 0.3.1)
+      sorbet-runtime (~> 0.5.9204)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    benchmark (0.4.0)
+    erubi (1.13.1)
+    logger (1.7.0)
+    netrc (0.11.0)
+    parallel (1.26.3)
+    prism (1.4.0)
+    rbi (0.3.1)
+      prism (~> 1.0)
+      rbs (>= 3.4.4)
+      sorbet-runtime (>= 0.5.9204)
+    rbs (3.9.2)
+      logger
+    sorbet (0.5.11971)
+      sorbet-static (= 0.5.11971)
+    sorbet-eraser (0.3.1)
+    sorbet-runtime (0.5.11971)
+    sorbet-static (0.5.11971-universal-darwin)
+    sorbet-static-and-runtime (0.5.11971)
+      sorbet (= 0.5.11971)
+      sorbet-runtime (= 0.5.11971)
+    spoom (1.6.1)
+      erubi (>= 1.10.0)
+      prism (>= 0.28.0)
+      rbi (>= 0.2.3)
+      sorbet-static-and-runtime (>= 0.5.10187)
+      thor (>= 0.19.2)
+    tapioca (0.16.11)
+      benchmark
+      bundler (>= 2.2.25)
+      netrc (>= 0.11.0)
+      parallel (>= 1.21.0)
+      rbi (~> 0.2)
+      sorbet-static-and-runtime (>= 0.5.11087)
+      spoom (>= 1.2.0)
+      thor (>= 1.2.0)
+      yard-sorbet
+    thor (1.3.2)
+    yard (0.9.45)
+    yard-sorbet (0.9.0)
+      sorbet-runtime
+      yard
+
+PLATFORMS
+  arm64-darwin-22
+  arm64-darwin-24
+  arm64-darwin-25
+
+DEPENDENCIES
+  mocktail!
+  tapioca
+
+BUNDLED WITH
+   2.4.13

data/sub_projects/rbi_generator/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true

data/sub_projects/sorbet_user/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gem "mocktail", path: "../..", require: "mocktail/sorbet"
+
+gem "standard"
+gem "standard-sorbet"
+gem "minitest", "~> 5.26" # 6.0+ requires Ruby >= 3.2, dropping support for Ruby 3.1
+gem "rake"
+gem "m"
+
+gem "sorbet"
+gem "sorbet-runtime"
+gem "tapioca"