mocktail 1.2.3 → 3.0.0

data/src/mocktail/raises_neato_no_method_error.rb

@@ -0,0 +1,93 @@
+# typed: strict
+
+require_relative "share/stringifies_call"
+require_relative "share/stringifies_method_name"
+require_relative "share/creates_identifier"
+
+module Mocktail
+  class RaisesNeatoNoMethodError
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @stringifies_call = T.let(StringifiesCall.new, StringifiesCall)
+      @stringifies_method_name = T.let(StringifiesMethodName.new, StringifiesMethodName)
+      @creates_identifier = T.let(CreatesIdentifier.new, CreatesIdentifier)
+    end
+
+    sig { params(call: Call).void }
+    def call(call)
+      raise NoMethodError, <<~MSG, caller[1..]
+        No method `#{@stringifies_method_name.stringify(call)}' exists for call:
+
+          #{@stringifies_call.stringify(call, anonymous_blocks: true, always_parens: true)}
+
+        Need to define the method? Here's a sample definition:
+
+          def #{"self." if call.singleton}#{call.method}#{params(call)}
+          end
+        #{corrections(call)}
+      MSG
+    end
+
+    private
+
+    sig { params(call: Call).returns(T.nilable(String)) }
+    def params(call)
+      return if (params_lists = [
+        params_list(call.args),
+        kwparams_list(call.kwargs),
+        block_param(call.block)
+      ].compact).empty?
+
+      "(#{params_lists.join(", ")})"
+    end
+
+    sig { params(args: T::Array[T.anything]).returns(T.nilable(String)) }
+    def params_list(args)
+      return if args.empty?
+
+      count_repeats(args.map { |arg|
+        @creates_identifier.create(arg, default: "arg")
+      }).join(", ")
+    end
+
+    sig { params(kwargs: T::Hash[Symbol, T.anything]).returns(T.nilable(String)) }
+    def kwparams_list(kwargs)
+      return if kwargs.empty?
+
+      kwargs.keys.map { |key| "#{key}:" }.join(", ")
+    end
+
+    sig { params(block: T.nilable(Proc)).returns(T.nilable(String)) }
+    def block_param(block)
+      return if block.nil?
+
+      "&blk"
+    end
+
+    sig { params(identifiers: T::Array[String]).returns(T::Array[String]) }
+    def count_repeats(identifiers)
+      identifiers.map.with_index { |id, i|
+        if (preceding_matches = T.must(identifiers[0...i]).count { |other_id| id == other_id }) > 0
+          "#{id}#{preceding_matches + 1}"
+        else
+          id
+        end
+      }
+    end
+
+    sig { params(call: Call).returns(T.nilable(String)) }
+    def corrections(call)
+      return if (corrections = DidYouMean::SpellChecker.new(dictionary: T.must(call.original_type).instance_methods).correct(T.must(call.method))).empty?
+
+      <<~MSG
+
+        There #{(corrections.size == 1) ? "is" : "are"} also #{corrections.size} similar method#{"s" if corrections.size != 1} on #{T.must(call.original_type).name}.
+
+        Did you mean?
+        #{corrections.map { |c| "  #{c}" }.join("\n")}
+      MSG
+    end
+  end
+end

data/src/mocktail/records_demonstration.rb

@@ -0,0 +1,43 @@
+# typed: strict
+
+module Mocktail
+  class RecordsDemonstration
+    extend T::Sig
+
+    sig {
+      type_parameters(:T)
+        .params(
+          demonstration: T.proc.params(matchers: Mocktail::MatcherPresentation).returns(T.type_parameter(:T)),
+          demo_config: DemoConfig
+        ).returns(Call)
+    }
+    def record(demonstration, demo_config)
+      cabinet = Mocktail.cabinet
+      prior_call_count = Mocktail.cabinet.calls.dup.size
+
+      begin
+        cabinet.demonstration_in_progress = true
+        ValidatesArguments.optional(demo_config.ignore_arity) do
+          demonstration.call(Mocktail.matchers)
+        end
+      ensure
+        cabinet.demonstration_in_progress = false
+      end
+
+      if prior_call_count + 1 == cabinet.calls.size
+        T.must(cabinet.calls.pop)
+      elsif prior_call_count == cabinet.calls.size
+        raise MissingDemonstrationError.new <<~MSG.tr("\n", " ")
+          `stubs` & `verify` expect an invocation of a mocked method by a passed
+          block, but no invocation occurred.
+        MSG
+      else
+        raise AmbiguousDemonstrationError.new <<~MSG.tr("\n", " ")
+          `stubs` & `verify` expect exactly one invocation of a mocked method,
+          but #{cabinet.calls.size - prior_call_count} were detected. As a
+          result, Mocktail doesn't know which invocation to stub or verify.
+        MSG
+      end
+    end
+  end
+end

data/src/mocktail/registers_matcher.rb

@@ -0,0 +1,65 @@
+# typed: strict
+
+module Mocktail
+  class RegistersMatcher
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @grabs_original_method_parameters = T.let(GrabsOriginalMethodParameters.new, GrabsOriginalMethodParameters)
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).void }
+    def register(matcher_type)
+      if invalid_type?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          Matchers must be Ruby classes
+        MSG
+      elsif invalid_name?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}.matcher_name must return a valid method name
+        MSG
+      elsif invalid_match?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}#match? must be defined as a one-argument method
+        MSG
+      elsif invalid_flag?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}#is_mocktail_matcher? must be defined
+        MSG
+      else
+        MatcherRegistry.instance.add(matcher_type)
+      end
+    end
+
+    private
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).returns(T::Boolean) }
+    def invalid_type?(matcher_type)
+      !matcher_type.is_a?(Class)
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).returns(T::Boolean) }
+    def invalid_name?(matcher_type)
+      return true unless matcher_type.respond_to?(:matcher_name)
+      name = matcher_type.matcher_name
+
+      !name.respond_to?(:to_sym) || name.to_sym.inspect.start_with?(":\"")
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).returns(T::Boolean) }
+    def invalid_match?(matcher_type)
+      params = @grabs_original_method_parameters.grab(matcher_type.instance_method(:match?))
+      params.size > 1 || ![:req, :opt].include?(T.unsafe(params).first[0])
+    rescue NameError
+      true
+    end
+
+    sig { params(matcher_type: T.class_of(Matchers::Base)).returns(T::Boolean) }
+    def invalid_flag?(matcher_type)
+      !matcher_type.instance_method(:is_mocktail_matcher?)
+    rescue NameError
+      true
+    end
+  end
+end

data/src/mocktail/registers_stubbing.rb

@@ -0,0 +1,31 @@
+# typed: strict
+
+require_relative "records_demonstration"
+
+module Mocktail
+  class RegistersStubbing
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @records_demonstration = T.let(RecordsDemonstration.new, RecordsDemonstration)
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(
+          demonstration: T.proc.params(matchers: Mocktail::MatcherPresentation).returns(T.type_parameter(:T)),
+          demo_config: DemoConfig
+        ).returns(Mocktail::Stubbing[T.type_parameter(:T)])
+    }
+    def register(demonstration, demo_config)
+      Stubbing.new(
+        demonstration: demonstration,
+        demo_config: demo_config,
+        recording: @records_demonstration.record(demonstration, demo_config)
+      ).tap do |stubbing|
+        Mocktail.cabinet.store_stubbing(stubbing)
+      end
+    end
+  end
+end

data/src/mocktail/replaces_next.rb

@@ -0,0 +1,55 @@
+# typed: strict
+
+module Mocktail
+  class ReplacesNext
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @top_shelf = T.let(TopShelf.instance, TopShelf)
+      @redefines_new = T.let(RedefinesNew.new, RedefinesNew)
+      @imitates_type = T.let(ImitatesType.new, ImitatesType)
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(type: T::Class[T.all(T.type_parameter(:T), Object)])
+        .returns(T.type_parameter(:T))
+    }
+    def replace_once(type)
+      replace(type, 1).fetch(0)
+    end
+
+    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 replace(type, count)
+      raise UnsupportedMocktail.new("Mocktail.of_next() only supports classes") unless T.unsafe(type).is_a?(Class)
+
+      mocktails = count.times.map { @imitates_type.imitate(type) }
+
+      @top_shelf.register_of_next_replacement!(type)
+      @redefines_new.redefine(type)
+      mocktails.reverse_each do |mocktail|
+        Mocktail.stubs(
+          ignore_extra_args: true,
+          ignore_block: true,
+          ignore_arity: true,
+          times: 1
+        ) {
+          type.new
+        }.with {
+          if mocktail == mocktails.last
+            @top_shelf.unregister_of_next_replacement!(type)
+          end
+
+          mocktail
+        }
+      end
+
+      mocktails
+    end
+  end
+end

data/src/mocktail/replaces_type/redefines_new.rb

@@ -0,0 +1,32 @@
+# typed: strict
+
+module Mocktail
+  class RedefinesNew
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @handles_dry_new_call = T.let(HandlesDryNewCall.new, HandlesDryNewCall)
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def redefine(type)
+      type_replacement = TopShelf.instance.type_replacement_for(type)
+
+      if type_replacement.replacement_new.nil?
+        type_replacement.original_new = type.method(:new)
+        type.singleton_class.send(:undef_method, :new)
+        handles_dry_new_call = @handles_dry_new_call
+        type.define_singleton_method :new, ->(*args, **kwargs, &block) {
+          if TopShelf.instance.new_replaced?(type) ||
+              (type.is_a?(Class) && TopShelf.instance.of_next_registered?(type))
+            handles_dry_new_call.handle(T.cast(type, T::Class[T.all(T, Object)]), args, kwargs, block)
+          else
+            type_replacement.original_new.call(*args, **kwargs, &block)
+          end
+        }
+        type_replacement.replacement_new = type.singleton_method(:new)
+      end
+    end
+  end
+end

data/src/mocktail/replaces_type/redefines_singleton_methods.rb

@@ -0,0 +1,80 @@
+# typed: strict
+
+module Mocktail
+  class RedefinesSingletonMethods
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @handles_dry_call = T.let(HandlesDryCall.new, HandlesDryCall)
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def redefine(type)
+      type_replacement = TopShelf.instance.type_replacement_for(type)
+      return unless type_replacement.replacement_methods.nil?
+
+      type_replacement.original_methods = type.singleton_methods.map { |name|
+        type.method(name)
+      }.reject { |method| sorbet_method_hook?(method) } - [type_replacement.replacement_new]
+
+      declare_singleton_method_missing_errors!(type)
+      handles_dry_call = @handles_dry_call
+      type_replacement.replacement_methods = type_replacement.original_methods&.map { |original_method|
+        type.singleton_class.send(:undef_method, original_method.name)
+        type.define_singleton_method original_method.name, ->(*args, **kwargs, &block) {
+          if TopShelf.instance.singleton_methods_replaced?(type)
+            handles_dry_call.handle(Call.new(
+              singleton: true,
+              double: type,
+              original_type: type,
+              dry_type: type,
+              method: original_method.name,
+              original_method: original_method,
+              args: args,
+              kwargs: kwargs,
+              block: block
+            ))
+          else
+            original_method.call(*args, **kwargs, &block)
+          end
+        }
+        type.singleton_method(original_method.name)
+      }
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def declare_singleton_method_missing_errors!(type)
+      return if type.singleton_methods.include?(:method_missing)
+
+      raises_neato_no_method_error = RaisesNeatoNoMethodError.new
+      type.define_singleton_method :method_missing,
+        ->(name, *args, **kwargs, &block) {
+          raises_neato_no_method_error.call(
+            Call.new(
+              singleton: true,
+              double: self,
+              original_type: type,
+              dry_type: self.class,
+              method: name,
+              original_method: nil,
+              args: args,
+              kwargs: kwargs,
+              block: block
+            )
+          )
+        }
+    end
+
+    private
+
+    sig { params(method: Method).returns(T::Boolean) }
+    def sorbet_method_hook?(method)
+      [
+        T::Sig,
+        T::Private::Methods::MethodHooks,
+        T::Private::Methods::SingletonMethodHooks
+      ].include?(method.owner)
+    end
+  end
+end

data/src/mocktail/replaces_type/runs_sorbet_sig_blocks_before_replacement.rb

@@ -0,0 +1,39 @@
+# typed: strict
+
+module Mocktail
+  class RunsSorbetSigBlocksBeforeReplacement
+    extend T::Sig
+
+    # This is necessary because when Sorbet runs a sig block of a singleton
+    # method, it has the net effect of unwrapping/redefining the method. If
+    # we try to use Mocktail.replace(Foo) and Foo.bar has a Sorbet sig block,
+    # then we'll end up with three "versions" of the same method and no way
+    # to keep straight which one == which:
+    #
+    #  A - Foo.bar, as defined in the original class
+    #  B - Foo.bar, as redefined by RedefinesSingletonMethods
+    #  C - Foo.bar, as wrapped by sorbet-runtime
+    #
+    # Initially, Foo.method(:bar) would == C, but after the type
+    # replacement, it would == B (with a reference back to C as the original),
+    # but after handling a single dry call, our invocation of
+    # GrabsOriginalMethodParameters.grab(Foo.method(:bar)) would invoke the
+    # Sorbet `sig` block, which has the net effect of redefining the method back
+    # to A.
+    #
+    # It's very fun and confusing and a great time.
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def run(type)
+      return unless defined?(T::Private::Methods)
+
+      type.singleton_methods.each do |method_name|
+        method = type.method(method_name)
+
+        # Again: calling this for the side effect of running the sig block
+        #
+        # https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/private/methods/_methods.rb#L111
+        T::Private::Methods.signature_for_method(method)
+      end
+    end
+  end
+end

data/src/mocktail/replaces_type.rb

@@ -0,0 +1,36 @@
+# typed: strict
+
+require_relative "replaces_type/redefines_new"
+require_relative "replaces_type/redefines_singleton_methods"
+require_relative "replaces_type/runs_sorbet_sig_blocks_before_replacement"
+
+module Mocktail
+  class ReplacesType
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @top_shelf = T.let(TopShelf.instance, TopShelf)
+      @runs_sorbet_sig_blocks_before_replacement = T.let(RunsSorbetSigBlocksBeforeReplacement.new, RunsSorbetSigBlocksBeforeReplacement)
+      @redefines_new = T.let(RedefinesNew.new, RedefinesNew)
+      @redefines_singleton_methods = T.let(RedefinesSingletonMethods.new, RedefinesSingletonMethods)
+    end
+
+    sig { params(type: T.any(T::Class[T.anything], Module)).void }
+    def replace(type)
+      unless T.unsafe(type).is_a?(Class) || T.unsafe(type).is_a?(Module)
+        raise UnsupportedMocktail.new("Mocktail.replace() only supports classes and modules")
+      end
+
+      @runs_sorbet_sig_blocks_before_replacement.run(type)
+
+      if type.is_a?(Class)
+        @top_shelf.register_new_replacement!(type)
+        @redefines_new.redefine(type)
+      end
+
+      @top_shelf.register_singleton_method_replacement!(type)
+      @redefines_singleton_methods.redefine(type)
+    end
+  end
+end

data/src/mocktail/resets_state.rb

@@ -0,0 +1,14 @@
+# typed: strict
+
+module Mocktail
+  class ResetsState
+    extend T::Sig
+
+    sig { void }
+    def reset
+      TopShelf.instance.reset_current_thread!
+      Mocktail.cabinet.reset!
+      ValidatesArguments.enable!
+    end
+  end
+end

data/src/mocktail/share/bind.rb

@@ -0,0 +1,18 @@
+# typed: true
+
+module Mocktail
+  module Bind
+    # sig intentionally omitted, because the wrapper will cause infinite recursion if certain methods are mocked
+    def self.call(mock, method_name, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      if Mocktail.cabinet.double_for_instance(mock)
+        T.unsafe(Object.instance_method(method_name)).bind_call(mock, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      elsif (mock.is_a?(Module) || mock.is_a?(Class)) &&
+          (type_replacement = TopShelf.instance.type_replacement_if_exists_for(mock)) &&
+          (og_method = type_replacement.original_methods&.find { |m| m.name == method_name })
+        T.unsafe(og_method).call(*args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      else
+        T.unsafe(mock).__send__(method_name, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
+      end
+    end
+  end
+end

data/src/mocktail/share/cleans_backtrace.rb

@@ -0,0 +1,22 @@
+# typed: strict
+
+module Mocktail
+  class CleansBacktrace
+    extend T::Sig
+
+    sig {
+      type_parameters(:T)
+        .params(error: T.all(T.type_parameter(:T), StandardError))
+        .returns(T.type_parameter(:T))
+    }
+    def clean(error)
+      raise error
+    rescue error.class => e
+      T.cast(e, T.all(T.type_parameter(:T), StandardError)).tap do |e|
+        e.set_backtrace(e.backtrace.drop_while { |frame|
+          frame.start_with?(BASE_PATH, BASE_PATH) || frame.match?(/[\\|\/]sorbet-runtime.*[\\|\/]lib[\\|\/]types[\\|\/]private/)
+        })
+      end
+    end
+  end
+end

data/src/mocktail/share/creates_identifier.rb

@@ -0,0 +1,39 @@
+# typed: strict
+
+module Mocktail
+  class CreatesIdentifier
+    extend T::Sig
+
+    KEYWORDS = T.let(%w[__FILE__ __LINE__ alias and begin BEGIN break case class def defined? do else elsif end END ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield], T::Array[String])
+
+    sig { params(s: T.anything, default: String, max_length: Integer).returns(String) }
+    def create(s, default: "identifier", max_length: 24)
+      case s
+      when Kernel
+        id = (s.to_s.downcase
+          .gsub(/:0x[0-9a-f]+/, "") # Lazy attempt to wipe any Object:0x802beef identifiers
+          .gsub(/[^\w\s]/, "")
+          .gsub(/^\d+/, "")[0...max_length] || "")
+          .strip
+          .gsub(/\s+/, "_") # snake_case
+
+        if id.empty?
+          default
+        else
+          unreserved(id, default)
+        end
+      else
+        default
+      end
+    end
+
+    private
+
+    sig { params(id: String, default: String).returns(String) }
+    def unreserved(id, default)
+      return id unless KEYWORDS.include?(id)
+
+      "#{id}_#{default}"
+    end
+  end
+end

data/src/mocktail/share/determines_matching_calls.rb

@@ -0,0 +1,72 @@
+# typed: strict
+
+require_relative "bind"
+
+module Mocktail
+  class DeterminesMatchingCalls
+    extend T::Sig
+
+    sig { params(real_call: Call, demo_call: Call, demo_config: DemoConfig).returns(T::Boolean) }
+    def determine(real_call, demo_call, demo_config)
+      T.cast(Bind.call(real_call.double, :==, demo_call.double), T::Boolean) &&
+        real_call.method == demo_call.method &&
+
+        # Matcher implementation will replace this:
+        args_match?(real_call.args, demo_call.args, demo_config.ignore_extra_args) &&
+        kwargs_match?(real_call.kwargs, demo_call.kwargs, demo_config.ignore_extra_args) &&
+        blocks_match?(real_call.block, demo_call.block, demo_config.ignore_block)
+    end
+
+    private
+
+    sig { params(real_args: T::Array[T.untyped], demo_args: T::Array[T.untyped], ignore_extra_args: T::Boolean).returns(T::Boolean) }
+    def args_match?(real_args, demo_args, ignore_extra_args)
+      # Guard clause for performance:
+      return true if ignore_extra_args && demo_args.empty?
+
+      (
+        real_args.size == demo_args.size ||
+        (ignore_extra_args && real_args.size >= demo_args.size)
+      ) &&
+        demo_args.each.with_index.all? { |demo_arg, i|
+          match?(real_args[i], demo_arg)
+        }
+    end
+
+    sig { params(real_kwargs: T::Hash[Symbol, T.untyped], demo_kwargs: T::Hash[Symbol, T.untyped], ignore_extra_args: T::Boolean).returns(T::Boolean) }
+    def kwargs_match?(real_kwargs, demo_kwargs, ignore_extra_args)
+      return true if ignore_extra_args && demo_kwargs.empty?
+
+      (
+        real_kwargs.size == demo_kwargs.size ||
+        (ignore_extra_args && real_kwargs.size >= demo_kwargs.size)
+      ) &&
+        demo_kwargs.all? { |key, demo_val|
+          real_kwargs.key?(key) && match?(real_kwargs[key], demo_val)
+        }
+    end
+
+    sig { params(real_block: T.nilable(Proc), demo_block: T.nilable(Proc), ignore_block: T::Boolean).returns(T::Boolean) }
+    def blocks_match?(real_block, demo_block, ignore_block)
+      !!(ignore_block ||
+        (real_block.nil? && demo_block.nil?) ||
+        (
+          real_block && demo_block &&
+          (
+            demo_block == real_block ||
+            demo_block.call(real_block)
+          )
+        ))
+    end
+
+    sig { params(real_arg: T.untyped, demo_arg: T.untyped).returns(T::Boolean) }
+    def match?(real_arg, demo_arg)
+      if Bind.call(demo_arg, :respond_to?, :is_mocktail_matcher?) &&
+          demo_arg.is_mocktail_matcher?
+        demo_arg.match?(real_arg)
+      else
+        Bind.call(demo_arg, :==, real_arg)
+      end
+    end
+  end
+end