mocktail 2.0.0 → 3.0.0

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

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