mocktail 1.2.3 → 3.0.0

data/lib/mocktail/sorbet/mocktail/handles_dry_call/fulfills_stubbing.rb

@@ -0,0 +1,45 @@
+# typed: strict
+
+require_relative "fulfills_stubbing/finds_satisfaction"
+require_relative "fulfills_stubbing/describes_unsatisfied_stubbing"
+
+module Mocktail
+  class FulfillsStubbing
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @finds_satisfaction = T.let(FindsSatisfaction.new, Mocktail::FindsSatisfaction)
+      @describes_unsatisfied_stubbing = T.let(DescribesUnsatisfiedStubbing.new, Mocktail::DescribesUnsatisfiedStubbing)
+    end
+
+    sig { params(dry_call: Call).returns(T.anything) }
+    def fulfill(dry_call)
+      if (stubbing = satisfaction(dry_call))
+        stubbing.satisfied!
+        stubbing.effect&.call(dry_call)
+      else
+        store_unsatisfying_call!(dry_call)
+        nil
+      end
+    end
+
+    sig { params(dry_call: Call).returns(T.nilable(Stubbing[T.anything])) }
+    def satisfaction(dry_call)
+      return if Mocktail.cabinet.demonstration_in_progress?
+
+      @finds_satisfaction.find(dry_call)
+    end
+
+    private
+
+    sig { params(dry_call: Call).void }
+    def store_unsatisfying_call!(dry_call)
+      return if Mocktail.cabinet.demonstration_in_progress?
+
+      Mocktail.cabinet.store_unsatisfying_call(
+        @describes_unsatisfied_stubbing.describe(dry_call)
+      )
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/handles_dry_call/logs_call.rb

@@ -0,0 +1,12 @@
+# typed: strict
+
+module Mocktail
+  class LogsCall
+    extend T::Sig
+
+    sig { params(dry_call: Call).void }
+    def log(dry_call)
+      Mocktail.cabinet.store_call(dry_call)
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/handles_dry_call/validates_arguments.rb

@@ -0,0 +1,45 @@
+# typed: strict
+
+module Mocktail
+  class ValidatesArguments
+    extend T::Sig
+    sig { void }
+    def self.disable!
+      Thread.current[:mocktail_arity_validation_disabled] = true
+    end
+
+    sig { void }
+    def self.enable!
+      Thread.current[:mocktail_arity_validation_disabled] = false
+    end
+
+    sig { returns(T::Boolean) }
+    def self.disabled?
+      !!Thread.current[:mocktail_arity_validation_disabled]
+    end
+
+    sig { params(disable: T.nilable(T::Boolean), blk: T.proc.returns(T.anything)).void }
+    def self.optional(disable, &blk)
+      return blk.call unless disable
+
+      disable!
+      ret = blk.call
+      enable!
+      ret
+    end
+
+    sig { void }
+    def initialize
+      @simulates_argument_error = T.let(SimulatesArgumentError.new, Mocktail::SimulatesArgumentError)
+    end
+
+    sig { params(dry_call: Call).returns(NilClass) }
+    def validate(dry_call)
+      return if self.class.disabled?
+
+      if (error = @simulates_argument_error.simulate(dry_call))
+        raise error
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/handles_dry_call.rb

@@ -0,0 +1,25 @@
+# typed: strict
+
+require_relative "handles_dry_call/fulfills_stubbing"
+require_relative "handles_dry_call/logs_call"
+require_relative "handles_dry_call/validates_arguments"
+
+module Mocktail
+  class HandlesDryCall
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @validates_arguments = T.let(ValidatesArguments.new, ValidatesArguments)
+      @logs_call = T.let(LogsCall.new, LogsCall)
+      @fulfills_stubbing = T.let(FulfillsStubbing.new, FulfillsStubbing)
+    end
+
+    sig { params(dry_call: Call).returns(T.anything) }
+    def handle(dry_call)
+      @validates_arguments.validate(dry_call)
+      @logs_call.log(dry_call)
+      @fulfills_stubbing.fulfill(dry_call)
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/handles_dry_new_call.rb

@@ -0,0 +1,42 @@
+# typed: strict
+
+module Mocktail
+  class HandlesDryNewCall
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @validates_arguments = T.let(ValidatesArguments.new, ValidatesArguments)
+      @logs_call = T.let(LogsCall.new, LogsCall)
+      @fulfills_stubbing = T.let(FulfillsStubbing.new, FulfillsStubbing)
+      @imitates_type = T.let(ImitatesType.new, ImitatesType)
+    end
+
+    sig { params(type: T::Class[T.all(T, Object)], args: T::Array[T.anything], kwargs: T::Hash[Symbol, T.anything], block: T.nilable(Proc)).returns(T.anything) }
+    def handle(type, args, kwargs, block)
+      @validates_arguments.validate(Call.new(
+        original_method: type.instance_method(:initialize),
+        args: args,
+        kwargs: kwargs,
+        block: block
+      ))
+
+      new_call = Call.new(
+        singleton: true,
+        double: type,
+        original_type: type,
+        dry_type: type,
+        method: :new,
+        args: args,
+        kwargs: kwargs,
+        block: block
+      )
+      @logs_call.log(new_call)
+      if @fulfills_stubbing.satisfaction(new_call)
+        @fulfills_stubbing.fulfill(new_call)
+      else
+        @imitates_type.imitate(type)
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/imitates_type/ensures_imitation_support.rb

@@ -0,0 +1,16 @@
+# typed: strict
+
+module Mocktail
+  class EnsuresImitationSupport
+    extend T::Sig
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def ensure(type)
+      unless type.is_a?(Class) || type.is_a?(Module)
+        raise UnsupportedMocktail.new <<~MSG.tr("\n", " ")
+          Mocktail.of() can only mix mocktail instances of modules and classes.
+        MSG
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/imitates_type/makes_double/declares_dry_class/reconstructs_call.rb

@@ -0,0 +1,73 @@
+# typed: strict
+
+module Mocktail
+  class ReconstructsCall
+    extend T::Sig
+
+    sig {
+      params(
+        double: Object,
+        call_binding: Binding,
+        default_args: T.nilable(T::Hash[Symbol, T.anything]),
+        dry_class: T::Class[Object],
+        type: T.any(Module, T::Class[T.anything]),
+        method: Symbol,
+        original_method: T.any(UnboundMethod, Method),
+        signature: Signature
+      ).returns(Call)
+    }
+    def reconstruct(double:, call_binding:, default_args:, dry_class:, type:, method:, original_method:, signature:)
+      Call.new(
+        singleton: false,
+        double: double,
+        original_type: type,
+        dry_type: dry_class,
+        method: method,
+        original_method: original_method,
+        args: args_for(signature, call_binding, default_args),
+        kwargs: kwargs_for(signature, call_binding, default_args),
+        block: call_binding.local_variable_get(signature.block_param || ::Mocktail::Signature::DEFAULT_BLOCK_PARAM)
+      )
+    end
+
+    private
+
+    sig {
+      params(signature: Signature, call_binding: Binding, default_args: T.nilable(T::Hash[Symbol, T.anything]))
+        .returns(T::Array[T.anything])
+    }
+    def args_for(signature, call_binding, default_args)
+      arg_names, rest_name = non_default_args(signature.positional_params, default_args)
+
+      arg_values = arg_names.map { |p| call_binding.local_variable_get(p) }
+      rest_value = call_binding.local_variable_get(rest_name) if rest_name
+
+      arg_values + (rest_value || [])
+    end
+
+    sig {
+      params(signature: Signature, call_binding: Binding, default_args: T.nilable(T::Hash[Symbol, T.anything]))
+        .returns(T::Hash[Symbol, T.anything])
+    }
+    def kwargs_for(signature, call_binding, default_args)
+      kwarg_names, kwrest_name = non_default_args(signature.keyword_params, default_args)
+
+      kwarg_values = kwarg_names.to_h { |p| [p, call_binding.local_variable_get(p)] }
+      kwrest_value = call_binding.local_variable_get(kwrest_name) if kwrest_name
+
+      kwarg_values.merge(kwrest_value || {})
+    end
+
+    sig { params(params: Params, default_args: T.nilable(T::Hash[Symbol, T.anything])).returns([T::Array[Symbol], T.nilable(Symbol)]) }
+    def non_default_args(params, default_args)
+      named_args = params.allowed
+        .reject { |p| default_args&.key?(p) }
+      rest_param = params.rest
+      rest_arg = if rest_param && !default_args&.key?(rest_param)
+        params.rest
+      end
+
+      [named_args, rest_arg]
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/imitates_type/makes_double/declares_dry_class.rb

@@ -0,0 +1,136 @@
+# typed: strict
+
+require_relative "declares_dry_class/reconstructs_call"
+
+module Mocktail
+  class DeclaresDryClass
+    extend T::Sig
+
+    DEFAULT_ANCESTORS = T.let(T.must(Class.new(Object).ancestors[1..]), T::Array[T.any(T::Class[T.anything], Module)])
+
+    sig { void }
+    def initialize
+      @raises_neato_no_method_error = T.let(RaisesNeatoNoMethodError.new, RaisesNeatoNoMethodError)
+      @transforms_params = T.let(TransformsParams.new, TransformsParams)
+      @stringifies_method_signature = T.let(StringifiesMethodSignature.new, StringifiesMethodSignature)
+      @grabs_original_method_parameters = T.let(GrabsOriginalMethodParameters.new, GrabsOriginalMethodParameters)
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(type: T.all(T.type_parameter(:T), T::Class[Object]), instance_methods: T::Array[Symbol]).returns(T.type_parameter(:T))
+    }
+    def declare(type, instance_methods)
+      dry_class = Class.new(Object) {
+        include type if T.unsafe(type).is_a?(Module) && !T.unsafe(type).is_a?(Class)
+
+        define_method :initialize do |*args, **kwargs, &blk|
+        end
+
+        [:is_a?, :kind_of?].each do |method_name|
+          define_method method_name, ->(thing) {
+            # Mocktails extend from Object, so share the same ancestors, plus the passed type
+            [type, *DEFAULT_ANCESTORS].include?(thing)
+          }
+        end
+
+        if T.unsafe(type).is_a?(Class)
+          define_method :instance_of?, ->(thing) {
+            type == thing
+          }
+        end
+      }
+
+      add_more_methods!(dry_class, type, instance_methods)
+
+      T.unsafe(dry_class) # This is all fake! That's the whole point—it's not a real Foo, it's just some new class that quacks like a Foo
+    end
+
+    private
+
+    # These have special implementations, but if the user defines
+    # any of them on the object itself, then they'll be replaced with normal
+    # mocked methods. YMMV
+    sig { params(dry_class: T::Class[Object], type: T.any(T::Class[T.anything], Module), instance_methods: T::Array[Symbol]).void }
+    def add_more_methods!(dry_class, type, instance_methods)
+      add_stringify_methods!(dry_class, :to_s, type, instance_methods)
+      add_stringify_methods!(dry_class, :inspect, type, instance_methods)
+      define_method_missing_errors!(dry_class, type, instance_methods)
+
+      define_double_methods!(dry_class, type, instance_methods)
+    end
+
+    sig { params(dry_class: T::Class[Object], type: T.any(T::Class[T.anything], Module), instance_methods: T::Array[Symbol]).void }
+    def define_double_methods!(dry_class, type, instance_methods)
+      instance_methods.each do |method_name|
+        dry_class.undef_method(method_name) if dry_class.method_defined?(method_name)
+        parameters = @grabs_original_method_parameters.grab(type.instance_method(method_name))
+        signature = @transforms_params.transform(Call.new, params: parameters)
+        method_signature = @stringifies_method_signature.stringify(signature)
+        __mocktail_closure = {
+          dry_class: dry_class,
+          type: type,
+          method: method_name,
+          original_method: type.instance_method(method_name),
+          signature: signature
+        }
+
+        dry_class.define_method method_name,
+          eval(<<-RUBBY, binding, __FILE__, __LINE__ + 1) # standard:disable Security/Eval
+            ->#{method_signature} do
+              ::Mocktail::Debug.guard_against_mocktail_accidentally_calling_mocks_if_debugging!
+              ::Mocktail::HandlesDryCall.new.handle(::Mocktail::ReconstructsCall.new.reconstruct(
+                double: self,
+                call_binding: __send__(:binding),
+                default_args: (__send__(:binding).local_variable_defined?(:__mocktail_default_args) ? __send__(:binding).local_variable_get(:__mocktail_default_args) : {}),
+                **__mocktail_closure
+              ))
+            end
+          RUBBY
+      end
+    end
+
+    sig { params(dry_class: T::Class[Object], method_name: Symbol, type: T.any(T::Class[T.anything], Module), instance_methods: T::Array[Symbol]).void }
+    def add_stringify_methods!(dry_class, method_name, type, instance_methods)
+      dry_class.define_singleton_method method_name, -> {
+        if (id_matches = super().match(/:([0-9a-fx]+)>$/))
+          "#<Class #{"including module " if type.instance_of?(Module)}for mocktail of #{type.name}:#{id_matches[1]}>"
+        else
+          super()
+        end
+      }
+
+      unless instance_methods.include?(method_name)
+        dry_class.define_method method_name, -> {
+          if (id_matches = super().match(/:([0-9a-fx]+)>$/))
+            "#<Mocktail of #{type.name}:#{id_matches[1]}>"
+          else
+            super()
+          end
+        }
+      end
+    end
+
+    sig { params(dry_class: T::Class[Object], type: T.any(T::Class[T.anything], Module), instance_methods: T::Array[Symbol]).void }
+    def define_method_missing_errors!(dry_class, type, instance_methods)
+      return if instance_methods.include?(:method_missing)
+
+      raises_neato_no_method_error = @raises_neato_no_method_error
+      dry_class.define_method :method_missing, ->(name, *args, **kwargs, &block) {
+        raises_neato_no_method_error.call(
+          Call.new(
+            singleton: false,
+            double: self,
+            original_type: type,
+            dry_type: self.class,
+            method: name,
+            original_method: nil,
+            args: args,
+            kwargs: kwargs,
+            block: block
+          )
+        )
+      }
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/imitates_type/makes_double/gathers_fakeable_instance_methods.rb

@@ -0,0 +1,28 @@
+# typed: strict
+
+module Mocktail
+  class GathersFakeableInstanceMethods
+    extend T::Sig
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).returns(T::Array[Symbol]) }
+    def gather(type)
+      methods = type.instance_methods + [
+        (:respond_to_missing? if type.private_method_defined?(:respond_to_missing?))
+      ].compact
+
+      methods.reject { |m|
+        ignore?(type, m)
+      }
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module), method_name: Symbol).returns(T::Boolean) }
+    def ignore?(type, method_name)
+      ignored_ancestors.include?(type.instance_method(method_name).owner)
+    end
+
+    sig { returns(T::Array[Module]) }
+    def ignored_ancestors
+      Object.ancestors
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/imitates_type/makes_double.rb

@@ -0,0 +1,29 @@
+# typed: strict
+
+require_relative "makes_double/declares_dry_class"
+require_relative "makes_double/gathers_fakeable_instance_methods"
+
+module Mocktail
+  class MakesDouble
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @declares_dry_class = T.let(DeclaresDryClass.new, DeclaresDryClass)
+      @gathers_fakeable_instance_methods = T.let(GathersFakeableInstanceMethods.new, GathersFakeableInstanceMethods)
+    end
+
+    sig { params(type: T::Class[Object]).returns(Double) }
+    def make(type)
+      dry_methods = @gathers_fakeable_instance_methods.gather(type)
+      dry_type = @declares_dry_class.declare(type, dry_methods)
+
+      Double.new(
+        original_type: type,
+        dry_type: dry_type,
+        dry_instance: dry_type.new,
+        dry_methods: dry_methods
+      )
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/imitates_type.rb

@@ -0,0 +1,29 @@
+# typed: strict
+
+require_relative "imitates_type/ensures_imitation_support"
+require_relative "imitates_type/makes_double"
+
+module Mocktail
+  class ImitatesType
+    extend T::Sig
+    extend T::Generic
+
+    sig { void }
+    def initialize
+      @ensures_imitation_support = T.let(EnsuresImitationSupport.new, EnsuresImitationSupport)
+      @makes_double = T.let(MakesDouble.new, MakesDouble)
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(type: T::Class[T.all(T.type_parameter(:T), Object)])
+        .returns(T.all(T.type_parameter(:T), Object))
+    }
+    def imitate(type)
+      @ensures_imitation_support.ensure(type)
+      T.cast(@makes_double.make(type).tap do |double|
+        Mocktail.cabinet.store_double(double)
+      end.dry_instance, T.all(T.type_parameter(:T), Object))
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/initialize_based_on_type_system_mode_switching.rb

@@ -0,0 +1,11 @@
+# typed: false
+
+require_relative "typed"
+
+# Constant boolean, so won't statically type-check, but `T.unsafe` can't be used
+# because we haven't required sorbet-runtime yet
+if eval("Mocktail::TYPED", binding, __FILE__, __LINE__)
+  require "sorbet-runtime"
+else
+  require "#{Gem.loaded_specs["sorbet-eraser"].gem_dir}/lib/t"
+end

data/lib/mocktail/sorbet/mocktail/initializes_mocktail.rb

@@ -0,0 +1,25 @@
+# typed: strict
+
+module Mocktail
+  class InitializesMocktail
+    extend T::Sig
+
+    sig { void }
+    def init
+      [
+        Mocktail::Matchers::Any,
+        Mocktail::Matchers::Includes,
+        Mocktail::Matchers::IncludesString,
+        Mocktail::Matchers::IncludesKey,
+        Mocktail::Matchers::IncludesHash,
+        Mocktail::Matchers::IsA,
+        Mocktail::Matchers::Matches,
+        Mocktail::Matchers::Not,
+        Mocktail::Matchers::Numeric,
+        Mocktail::Matchers::That
+      ].each do |matcher_type|
+        Mocktail.register_matcher(matcher_type)
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/matcher_presentation.rb

@@ -0,0 +1,21 @@
+# typed: strict
+
+module Mocktail
+  class MatcherPresentation
+    extend T::Sig
+
+    sig { params(name: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+    def respond_to_missing?(name, include_private = false)
+      !!MatcherRegistry.instance.get(name) || super
+    end
+
+    sig { params(name: Symbol, args: T.anything, kwargs: T.anything, blk: T.nilable(Proc)).returns(T.anything) }
+    def method_missing(name, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      if (matcher = MatcherRegistry.instance.get(name))
+        T.unsafe(matcher).new(*args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      else
+        super
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/matchers/any.rb

@@ -0,0 +1,27 @@
+# typed: strict
+
+module Mocktail::Matchers
+  class Any < Base
+    extend T::Sig
+
+    sig { returns(Symbol) }
+    def self.matcher_name
+      :any
+    end
+
+    sig { void }
+    def initialize
+      # Empty initialize is necessary b/c Base default expects an argument
+    end
+
+    sig { params(actual: T.anything).returns(T::Boolean) }
+    def match?(actual)
+      true
+    end
+
+    sig { returns(String) }
+    def inspect
+      "any"
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/matchers/base.rb

@@ -0,0 +1,39 @@
+# typed: strict
+
+module Mocktail::Matchers
+  class Base
+    extend T::Sig
+    extend T::Helpers
+
+    if T.unsafe(Mocktail::TYPED) && T::Private::RuntimeLevels.default_checked_level != :never
+      abstract!
+    end
+
+    # Custom matchers can receive any args, kwargs, or block they want. Usually
+    # single-argument, though, so that's defaulted here and in #insepct
+    sig { params(expected: BasicObject).void }
+    def initialize(expected)
+      @expected = expected
+    end
+
+    sig { returns(Symbol) }
+    def self.matcher_name
+      raise Mocktail::InvalidMatcherError.new("The `matcher_name` class method must return a valid method name")
+    end
+
+    sig { params(actual: T.untyped).returns(T::Boolean) }
+    def match?(actual)
+      raise Mocktail::InvalidMatcherError.new("Matchers must implement `match?(argument)`")
+    end
+
+    sig { returns(String) }
+    def inspect
+      "#{self.class.matcher_name}(#{T.cast(@expected, Object).inspect})"
+    end
+
+    sig { returns(TrueClass) }
+    def is_mocktail_matcher?
+      true
+    end
+  end
+end