mocktail 1.2.3 → 2.0.0

data/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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/lib/mocktail/sorbet/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 = "2.0.0"
+end

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

@@ -0,0 +1 @@
+require_relative "sorbet/mocktail"

data/lib/mocktail/stringifies_method_signature.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class StringifiesMethodSignature
+    extend T::Sig
+
     def stringify(signature)
       positional_params = positional(signature)
       keyword_params = keyword(signature)

data/lib/mocktail/typed.rb

@@ -0,0 +1,3 @@
+module Mocktail
+  TYPED = false
+end

data/lib/mocktail/value/cabinet.rb

@@ -4,8 +4,15 @@ require_relative "../share/bind"
 # is guaranteed by Mocktail to be local to the currently-running thread
 module Mocktail
   class Cabinet
+    extend T::Sig
+
     attr_writer :demonstration_in_progress
-    attr_reader :calls, :stubbings, :unsatisfying_calls
+
+    attr_reader :calls
+
+    attr_reader :stubbings
+
+    attr_reader :unsatisfying_calls
 
     def initialize
       @doubles = []

data/lib/mocktail/value/call.rb

@@ -1,14 +1,46 @@
 module Mocktail
-  Call = Struct.new(
-    :singleton,
-    :double,
-    :original_type,
-    :dry_type,
-    :method,
-    :original_method,
-    :args,
-    :kwargs,
-    :block,
-    keyword_init: true
-  )
+  class Call < T::Struct
+    extend T::Sig
+
+    const :singleton
+    const :double, default: nil
+    const :original_type
+    const :dry_type
+    const :method, without_accessors: true
+    const :original_method
+    const :args, default: []
+    const :kwargs, 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
+
+    attr_reader :method
+
+    # Because T::Struct compares with referential equality, we need
+    # to redefine the equality methods to compare the values of the attributes.
+
+    def ==(other)
+      eql?(other)
+    end
+
+    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
+
+    def hash
+      [@singleton, @double, @original_type, @dry_type, @method, @original_method, @args, @kwargs, @block].hash
+    end
+  end
 end

data/lib/mocktail/value/demo_config.rb

@@ -1,9 +1,8 @@
 module Mocktail
-  DemoConfig = Struct.new(
-    :ignore_block,
-    :ignore_extra_args,
-    :ignore_arity,
-    :times,
-    keyword_init: true
-  )
+  class DemoConfig < T::Struct
+    const :ignore_block, default: false
+    const :ignore_extra_args, default: false
+    const :ignore_arity, default: false
+    const :times, default: nil
+  end
 end

data/lib/mocktail/value/double.rb

@@ -1,9 +1,8 @@
 module Mocktail
-  Double = Struct.new(
-    :original_type,
-    :dry_type,
-    :dry_instance,
-    :dry_methods,
-    keyword_init: true
-  )
+  class Double < T::Struct
+    const :original_type
+    const :dry_type
+    const :dry_instance
+    const :dry_methods
+  end
 end

data/lib/mocktail/value/double_data.rb

@@ -1,9 +1,13 @@
+require_relative "call"
+require_relative "stubbing"
+
 module Mocktail
-  DoubleData = Struct.new(
-    :type,
-    :double,
-    :calls,
-    :stubbings,
-    keyword_init: true
-  )
+  class DoubleData < T::Struct
+    include ExplanationData
+
+    const :type
+    const :double
+    const :calls
+    const :stubbings
+  end
 end

data/lib/mocktail/value/explanation.rb

@@ -1,6 +1,10 @@
 module Mocktail
   class Explanation
-    attr_reader :reference, :message
+    extend T::Sig
+
+    attr_reader :reference
+
+    attr_reader :message
 
     def initialize(reference, message)
       @reference = reference
@@ -13,17 +17,38 @@ module Mocktail
   end
 
   class NoExplanation < Explanation
-  end
+    attr_reader :reference
 
-  class UnsatisfyingCallExplanation < Explanation
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
   end
 
   class DoubleExplanation < Explanation
+    attr_reader :reference
+
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
   end
 
   class ReplacedTypeExplanation < Explanation
+    attr_reader :reference
+
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
   end
 
   class FakeMethodExplanation < Explanation
+    attr_reader :reference
+
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
   end
 end

data/lib/mocktail/value/explanation_data.rb

@@ -0,0 +1,14 @@
+module Mocktail
+  module ExplanationData
+    extend T::Helpers
+    extend T::Sig
+
+    include Kernel
+
+    def calls
+    end
+
+    def stubbings
+    end
+  end
+end

data/lib/mocktail/value/fake_method_data.rb

@@ -1,8 +1,9 @@
 module Mocktail
-  FakeMethodData = Struct.new(
-    :receiver,
-    :calls,
-    :stubbings,
-    keyword_init: true
-  )
+  class FakeMethodData < T::Struct
+    include ExplanationData
+
+    const :receiver
+    const :calls
+    const :stubbings
+  end
 end

data/lib/mocktail/value/matcher_registry.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class MatcherRegistry
+    extend T::Sig
+
     def self.instance
       @matcher_registry ||= new
     end

data/lib/mocktail/value/no_explanation_data.rb

@@ -0,0 +1,16 @@
+module Mocktail
+  class NoExplanationData < T::Struct
+    extend T::Sig
+    include ExplanationData
+
+    const :thing
+
+    def calls
+      raise Error.new("No calls have been recorded for #{thing.inspect}, because Mocktail doesn't know what it is.")
+    end
+
+    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/value/signature.rb

@@ -1,32 +1,11 @@
 module Mocktail
-  Signature = Struct.new(
-    :positional_params,
-    :positional_args,
-    :keyword_params,
-    :keyword_args,
-    :block_param,
-    :block_arg,
-    keyword_init: true
-  )
-  class Signature
-    DEFAULT_REST_ARGS = "args"
-    DEFAULT_REST_KWARGS = "kwargs"
-    DEFAULT_BLOCK_PARAM = "blk"
-  end
+  class Params < T::Struct
+    extend T::Sig
 
-  Params = Struct.new(
-    :all,
-    :required,
-    :optional,
-    :rest,
-    keyword_init: true
-  ) do
-    def initialize(**params)
-      super
-      self.all ||= []
-      self.required ||= []
-      self.optional ||= []
-    end
+    prop :all, default: []
+    prop :required, default: []
+    prop :optional, default: []
+    prop :rest
 
     def allowed
       all.select { |name| required.include?(name) || optional.include?(name) }
@@ -36,4 +15,17 @@ module Mocktail
       !!rest
     end
   end
+
+  class Signature < T::Struct
+    const :positional_params
+    const :positional_args
+    const :keyword_params
+    const :keyword_args
+    const :block_param
+    const :block_arg, default: nil
+
+    DEFAULT_REST_ARGS = "args"
+    DEFAULT_REST_KWARGS = "kwargs"
+    DEFAULT_BLOCK_PARAM = "blk"
+  end
 end