mocktail 1.2.3 → 3.0.0

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

data/lib/mocktail/value/stubbing.rb

@@ -1,16 +1,14 @@
 module Mocktail
-  Stubbing = Struct.new(
-    :demonstration,
-    :demo_config,
-    :satisfaction_count,
-    :recording,
-    :effect,
-    keyword_init: true
-  ) do
-    def initialize(**kwargs)
-      super
-      self.satisfaction_count ||= 0
-    end
+  class Stubbing < T::Struct
+    extend T::Sig
+    extend T::Generic
+    MethodReturnType = type_member
+
+    const :demonstration
+    const :demo_config
+    prop :satisfaction_count, default: 0
+    const :recording
+    prop :effect
 
     def satisfied!
       self.satisfaction_count += 1
@@ -18,6 +16,7 @@ module Mocktail
 
     def with(&block)
       self.effect = block
+      nil
     end
   end
 end

data/lib/mocktail/value/top_shelf.rb

@@ -1,5 +1,10 @@
 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
+
     def self.instance
       Thread.current[:mocktail_top_shelf] ||= new
     end

data/lib/mocktail/value/type_replacement.rb

@@ -1,10 +1,9 @@
 module Mocktail
-  TypeReplacement = Struct.new(
-    :type,
-    :original_methods,
-    :replacement_methods,
-    :original_new,
-    :replacement_new,
-    keyword_init: true
-  )
+  class TypeReplacement < T::Struct
+    const :type
+    prop :original_methods
+    prop :replacement_methods
+    prop :original_new
+    prop :replacement_new
+  end
 end

data/lib/mocktail/value/type_replacement_data.rb

@@ -1,11 +1,14 @@
 module Mocktail
-  TypeReplacementData = Struct.new(
-    :type,
-    :replaced_method_names,
-    :calls,
-    :stubbings,
-    keyword_init: true
-  ) do
+  class TypeReplacementData < T::Struct
+    extend T::Sig
+
+    const :type
+    const :replaced_method_names
+    const :calls
+    const :stubbings
+
+    include ExplanationData
+
     def double
       type
     end

data/lib/mocktail/value/unsatisfying_call.rb

@@ -1,8 +1,7 @@
 module Mocktail
-  UnsatisfyingCall = Struct.new(
-    :call,
-    :other_stubbings,
-    :backtrace,
-    keyword_init: true
-  )
+  class UnsatisfyingCall < T::Struct
+    const :call
+    const :other_stubbings
+    const :backtrace
+  end
 end

data/lib/mocktail/value/unsatisfying_call_explanation.rb

@@ -0,0 +1,18 @@
+module Mocktail
+  class UnsatisfyingCallExplanation
+    extend T::Sig
+
+    attr_reader :reference
+
+    attr_reader :message
+
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
+
+    def type
+      self.class
+    end
+  end
+end

data/lib/mocktail/value.rb

@@ -1,14 +1,17 @@
 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/explanation"
 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/top_shelf"
 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/verifies_call/finds_verifiable_calls.rb

@@ -2,6 +2,8 @@ require_relative "../share/determines_matching_calls"
 
 module Mocktail
   class FindsVerifiableCalls
+    extend T::Sig
+
     def initialize
       @determines_matching_calls = DeterminesMatchingCalls.new
     end

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

@@ -1,5 +1,7 @@
 module Mocktail
   class GathersCallsOfMethod
+    extend T::Sig
+
     def gather(dry_call)
       Mocktail.cabinet.calls.select { |call|
         call.double == dry_call.double &&

data/lib/mocktail/verifies_call/raises_verification_error.rb

@@ -4,6 +4,8 @@ require_relative "../share/stringifies_call"
 
 module Mocktail
   class RaisesVerificationError
+    extend T::Sig
+
     def initialize
       @gathers_calls_of_method = GathersCallsOfMethod.new
       @stringifies_method_name = StringifiesMethodName.new

data/lib/mocktail/verifies_call.rb

@@ -4,6 +4,8 @@ require_relative "verifies_call/raises_verification_error"
 
 module Mocktail
   class VerifiesCall
+    extend T::Sig
+
     def initialize
       @records_demonstration = RecordsDemonstration.new
       @finds_verifiable_calls = FindsVerifiableCalls.new
@@ -17,6 +19,7 @@ module Mocktail
       unless verification_satisfied?(verifiable_calls.size, demo_config)
         @raises_verification_error.raise(recording, verifiable_calls, demo_config)
       end
+      nil
     end
 
     private

data/lib/mocktail/version.rb

@@ -1,3 +1,10 @@
 module Mocktail
-  VERSION = "1.2.3"
+  # 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