mocktail 1.2.3 → 2.0.0

data/lib/mocktail/matchers/not.rb

@@ -1,5 +1,7 @@
 module Mocktail::Matchers
   class Not < Base
+    extend T::Sig
+
     def self.matcher_name
       :not
     end

data/lib/mocktail/matchers/numeric.rb

@@ -1,16 +1,17 @@
 module Mocktail::Matchers
   class Numeric < Base
+    extend T::Sig
+
     def self.matcher_name
       :numeric
     end
 
-    # Change this comment to a descriptive one once this is merged:
-    # https://github.com/rubocop/rubocop/pull/10551
-    def initialize # standard:disable Style/RedundantInitialize
+    def initialize
+      # Empty initialize is necessary b/c Base default expects an argument
     end
 
     def match?(actual)
-      [Integer, Float, (BigDecimal if defined?(BigDecimal))].include?(actual.class)
+      actual.is_a?(::Numeric)
     end
 
     def inspect

data/lib/mocktail/matchers/that.rb

@@ -1,5 +1,7 @@
 module Mocktail::Matchers
   class That < Base
+    extend T::Sig
+
     def self.matcher_name
       :that
     end

data/lib/mocktail/matchers.rb

@@ -7,6 +7,9 @@ require_relative "matchers/base"
 require_relative "matchers/any"
 require_relative "matchers/captor"
 require_relative "matchers/includes"
+require_relative "matchers/includes_string"
+require_relative "matchers/includes_hash"
+require_relative "matchers/includes_key"
 require_relative "matchers/is_a"
 require_relative "matchers/matches"
 require_relative "matchers/not"

data/lib/mocktail/raises_neato_no_method_error.rb

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

data/lib/mocktail/records_demonstration.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class RecordsDemonstration
+    extend T::Sig
+
     def record(demonstration, demo_config)
       cabinet = Mocktail.cabinet
       prior_call_count = Mocktail.cabinet.calls.dup.size

data/lib/mocktail/registers_matcher.rb

@@ -1,5 +1,11 @@
 module Mocktail
   class RegistersMatcher
+    extend T::Sig
+
+    def initialize
+      @grabs_original_method_parameters = GrabsOriginalMethodParameters.new
+    end
+
     def register(matcher_type)
       if invalid_type?(matcher_type)
         raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
@@ -32,12 +38,11 @@ module Mocktail
       return true unless matcher_type.respond_to?(:matcher_name)
       name = matcher_type.matcher_name
 
-      !(name.is_a?(String) || name.is_a?(Symbol)) ||
-        name.to_sym.inspect.start_with?(":\"")
+      !name.respond_to?(:to_sym) || name.to_sym.inspect.start_with?(":\"")
     end
 
     def invalid_match?(matcher_type)
-      params = matcher_type.instance_method(:match?).parameters
+      params = @grabs_original_method_parameters.grab(matcher_type.instance_method(:match?))
       params.size > 1 || ![:req, :opt].include?(params.first[0])
     rescue NameError
       true

data/lib/mocktail/registers_stubbing.rb

@@ -2,6 +2,8 @@ require_relative "records_demonstration"
 
 module Mocktail
   class RegistersStubbing
+    extend T::Sig
+
     def initialize
       @records_demonstration = RecordsDemonstration.new
     end

data/lib/mocktail/replaces_next.rb

@@ -1,11 +1,17 @@
 module Mocktail
   class ReplacesNext
+    extend T::Sig
+
     def initialize
       @top_shelf = TopShelf.instance
       @redefines_new = RedefinesNew.new
       @imitates_type = ImitatesType.new
     end
 
+    def replace_once(type)
+      replace(type, 1).fetch(0)
+    end
+
     def replace(type, count)
       raise UnsupportedMocktail.new("Mocktail.of_next() only supports classes") unless type.is_a?(Class)
 
@@ -30,7 +36,7 @@ module Mocktail
         }
       end
 
-      (mocktails.size == 1) ? mocktails.first : mocktails
+      mocktails
     end
   end
 end

data/lib/mocktail/replaces_type/redefines_new.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class RedefinesNew
+    extend T::Sig
+
     def initialize
       @handles_dry_new_call = HandlesDryNewCall.new
     end
@@ -13,7 +15,7 @@ module Mocktail
         handles_dry_new_call = @handles_dry_new_call
         type.define_singleton_method :new, ->(*args, **kwargs, &block) {
           if TopShelf.instance.new_replaced?(type) ||
-              TopShelf.instance.of_next_registered?(type)
+              (type.is_a?(Class) && TopShelf.instance.of_next_registered?(type))
             handles_dry_new_call.handle(type, args, kwargs, block)
           else
             type_replacement.original_new.call(*args, **kwargs, &block)

data/lib/mocktail/replaces_type/redefines_singleton_methods.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class RedefinesSingletonMethods
+    extend T::Sig
+
     def initialize
       @handles_dry_call = HandlesDryCall.new
     end
@@ -10,11 +12,11 @@ module Mocktail
 
       type_replacement.original_methods = type.singleton_methods.map { |name|
         type.method(name)
-      } - [type_replacement.replacement_new]
+      }.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_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)
@@ -58,5 +60,15 @@ module Mocktail
           )
         }
     end
+
+    private
+
+    def sorbet_method_hook?(method)
+      [
+        T::Sig,
+        T::Private::Methods::MethodHooks,
+        T::Private::Methods::SingletonMethodHooks
+      ].include?(method.owner)
+    end
   end
 end

data/lib/mocktail/replaces_type/runs_sorbet_sig_blocks_before_replacement.rb

@@ -0,0 +1,37 @@
+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.
+
+    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/lib/mocktail/replaces_type.rb

@@ -1,10 +1,14 @@
 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
+
     def initialize
       @top_shelf = TopShelf.instance
+      @runs_sorbet_sig_blocks_before_replacement = RunsSorbetSigBlocksBeforeReplacement.new
       @redefines_new = RedefinesNew.new
       @redefines_singleton_methods = RedefinesSingletonMethods.new
     end
@@ -14,6 +18,8 @@ module Mocktail
         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)

data/lib/mocktail/resets_state.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class ResetsState
+    extend T::Sig
+
     def reset
       TopShelf.instance.reset_current_thread!
       Mocktail.cabinet.reset!

data/lib/mocktail/share/bind.rb

@@ -1,13 +1,15 @@
 module Mocktail
   module Bind
-    def self.call(mock, method_name, *args, **kwargs, &blk)
+    # 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)
-        Object.instance_method(method_name).bind_call(mock, *args, **kwargs, &blk)
-      elsif (type_replacement = TopShelf.instance.type_replacement_if_exists_for(mock)) &&
+        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 })
-        og_method.call(*args, **kwargs, &blk)
+        og_method.call(*args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
       else
-        mock.__send__(method_name, *args, **kwargs, &blk)
+        mock.__send__(method_name, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
       end
     end
   end

data/lib/mocktail/share/cleans_backtrace.rb

@@ -1,15 +1,13 @@
-require "pathname"
-
 module Mocktail
   class CleansBacktrace
-    BASE_PATH = (Pathname.new(__FILE__) + "../../..").to_s
+    extend T::Sig
 
     def clean(error)
       raise error
-    rescue => e
+    rescue error.class => e
       e.tap do |e|
         e.set_backtrace(e.backtrace.drop_while { |frame|
-          frame.start_with?(BASE_PATH)
+          frame.start_with?(BASE_PATH, BASE_PATH) || frame.match?(/[\\|\/]sorbet-runtime.*[\\|\/]lib[\\|\/]types[\\|\/]private/)
         })
       end
     end

data/lib/mocktail/share/creates_identifier.rb

@@ -1,19 +1,26 @@
 module Mocktail
   class CreatesIdentifier
+    extend T::Sig
+
     KEYWORDS = %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]
 
     def create(s, default: "identifier", max_length: 24)
-      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
+      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
+        if id.empty?
+          default
+        else
+          unreserved(id, default)
+        end
       else
-        unreserved(id, default)
+        default
       end
     end
 

data/lib/mocktail/share/determines_matching_calls.rb

@@ -2,6 +2,8 @@ require_relative "bind"
 
 module Mocktail
   class DeterminesMatchingCalls
+    extend T::Sig
+
     def determine(real_call, demo_call, demo_config)
       Bind.call(real_call.double, :==, demo_call.double) &&
         real_call.method == demo_call.method &&
@@ -40,7 +42,7 @@ module Mocktail
     end
 
     def blocks_match?(real_block, demo_block, ignore_block)
-      ignore_block ||
+      !!(ignore_block ||
         (real_block.nil? && demo_block.nil?) ||
         (
           real_block && demo_block &&
@@ -48,7 +50,7 @@ module Mocktail
             demo_block == real_block ||
             demo_block.call(real_block)
           )
-        )
+        ))
     end
 
     def match?(real_arg, demo_arg)

data/lib/mocktail/share/stringifies_call.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class StringifiesCall
+    extend T::Sig
+
     def stringify(call, anonymous_blocks: false, always_parens: false)
       "#{call.method}#{args_to_s(call, parens: always_parens)}#{blockify(call.block, anonymous: anonymous_blocks)}"
     end
@@ -31,16 +33,18 @@ module Mocktail
         "(#{args_lists.join(", ")})"
       elsif parens
         "()"
+      else
+        ""
       end
     end
 
     def argify(args)
-      return unless args && !args.empty?
+      return unless !args.empty?
       args.map(&:inspect).join(", ")
     end
 
     def kwargify(kwargs)
-      return unless kwargs && !kwargs.empty?
+      return unless !kwargs.empty?
       kwargs.map { |key, val| "#{key}: #{val.inspect}" }.join(", ")
     end
 

data/lib/mocktail/share/stringifies_method_name.rb

@@ -1,8 +1,10 @@
 module Mocktail
   class StringifiesMethodName
+    extend T::Sig
+
     def stringify(call)
       [
-        call.original_type.name,
+        call.original_type&.name,
         call.singleton ? "." : "#",
         call.method
       ].join

data/lib/mocktail/simulates_argument_error/reconciles_args_with_params.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class ReconcilesArgsWithParams
+    extend T::Sig
+
     def reconcile(signature)
       args_match?(signature.positional_params, signature.positional_args) &&
         kwargs_match?(signature.keyword_params, signature.keyword_args)

data/lib/mocktail/simulates_argument_error/recreates_message.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class RecreatesMessage
+    extend T::Sig
+
     def recreate(signature)
       req_args = signature.positional_params.required.size
       allowed_args = signature.positional_params.allowed.size

data/lib/mocktail/simulates_argument_error/transforms_params.rb

@@ -2,16 +2,23 @@ require_relative "../share/bind"
 
 module Mocktail
   class TransformsParams
-    def transform(dry_call, params: dry_call.original_method.parameters)
+    extend T::Sig
+
+    def initialize
+      @grabs_original_method_parameters = GrabsOriginalMethodParameters.new
+    end
+
+    def transform(dry_call, params: nil)
+      params ||= @grabs_original_method_parameters.grab(dry_call.original_method)
       params = name_unnamed_params(params)
 
       Signature.new(
         positional_params: Params.new(
           all: params.select { |t, _|
             [:req, :opt, :rest].any? { |param_type| Bind.call(t, :==, param_type) }
-          }.map { |_, name| name },
-          required: params.select { |t, _| Bind.call(t, :==, :req) }.map { |_, n| n },
-          optional: params.select { |t, _| Bind.call(t, :==, :opt) }.map { |_, n| n },
+          }.map { |pair| pair.fetch(1) },
+          required: params.select { |t, _| Bind.call(t, :==, :req) }.map { |pair| pair.fetch(1) },
+          optional: params.select { |t, _| Bind.call(t, :==, :opt) }.map { |pair| pair.fetch(1) },
           rest: params.find { |t, _| Bind.call(t, :==, :rest) }&.last
         ),
         positional_args: dry_call.args,
@@ -19,9 +26,9 @@ module Mocktail
         keyword_params: Params.new(
           all: params.select { |type, _|
             [:keyreq, :key, :keyrest].include?(type)
-          }.map { |_, name| name },
-          required: params.select { |t, _| Bind.call(t, :==, :keyreq) }.map { |_, n| n },
-          optional: params.select { |t, _| Bind.call(t, :==, :key) }.map { |_, n| n },
+          }.map { |pair| pair.fetch(1) },
+          required: params.select { |t, _| Bind.call(t, :==, :keyreq) }.map { |pair| pair.fetch(1) },
+          optional: params.select { |t, _| Bind.call(t, :==, :key) }.map { |pair| pair.fetch(1) },
           rest: params.find { |t, _| Bind.call(t, :==, :keyrest) }&.last
         ),
         keyword_args: dry_call.kwargs,
@@ -36,7 +43,7 @@ module Mocktail
     def name_unnamed_params(params)
       params.map.with_index { |param, i|
         if param.size == 1
-          param + ["unnamed_arg_#{i + 1}"]
+          param + ["unnamed_arg_#{i + 1}".to_sym]
         else
           param
         end

data/lib/mocktail/simulates_argument_error.rb

@@ -6,6 +6,8 @@ require_relative "share/stringifies_call"
 
 module Mocktail
   class SimulatesArgumentError
+    extend T::Sig
+
     def initialize
       @transforms_params = TransformsParams.new
       @reconciles_args_with_params = ReconcilesArgsWithParams.new

data/lib/mocktail/sorbet/mocktail/collects_calls.rb

@@ -0,0 +1,18 @@
+# typed: strict
+
+module Mocktail
+  class CollectsCalls
+    extend T::Sig
+
+    sig { params(double: Object, method_name: T.nilable(Symbol)).returns(T::Array[Call]) }
+    def collect(double, method_name)
+      calls = ExplainsThing.new.explain(double).reference.calls
+
+      if method_name.nil?
+        calls
+      else
+        calls.select { |call| call.method.to_s == method_name.to_s }
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/debug.rb

@@ -0,0 +1,54 @@
+# typed: strict
+
+module Mocktail
+  module Debug
+    extend T::Sig
+
+    # It would be easy and bad for the mocktail lib to call something like
+    #
+    #   double == other_double
+    #
+    # But if it's a double, that means anyone who stubs that method could change
+    # the internal behavior of the library in unexpected ways (as happened here:
+    # https://github.com/testdouble/mocktail/issues/7 )
+    #
+    # For that reason when we run our tests, we also want to blow up if this
+    # happens unintentionally. This works in conjunction with the test
+    # MockingMethodfulClassesTest, because it mocks every defined method on the
+    # mocked BasicObject
+    sig { void }
+    def self.guard_against_mocktail_accidentally_calling_mocks_if_debugging!
+      return unless ENV["MOCKTAIL_DEBUG_ACCIDENTAL_INTERNAL_MOCK_CALLS"]
+      raise Mocktail::Error
+    rescue Mocktail::Error => e
+      base_path = Pathname.new(__FILE__).dirname.to_s
+      backtrace_minus_this_and_whoever_called_this = e.backtrace&.[](2..)
+      internal_call_sites = backtrace_minus_this_and_whoever_called_this&.take_while { |call_site|
+        # the "in `block" is very confusing but necessary to include lines after
+        # a stubs { blah.foo }.with { … } call, since that's when most of the
+        # good stuff happens
+        call_site.start_with?(base_path) || call_site.include?("in `block")
+      }&.reject { |call_site| call_site.include?("in `block") } || []
+
+      approved_call_sites = [
+        /fulfills_stubbing.rb:(16|20)/,
+        /validates_arguments.rb:(18|23)/,
+        /validates_arguments.rb:(21|26)/
+      ]
+      if internal_call_sites.any? && approved_call_sites.none? { |approved_call_site|
+        internal_call_sites.first&.match?(approved_call_site)
+      }
+        raise Error.new <<~MSG
+          Unauthorized internal call of a mock internally by Mocktail itself:
+
+          #{internal_call_sites.first}
+
+          Offending call's complete stack trace:
+
+          #{backtrace_minus_this_and_whoever_called_this&.join("\n")}
+          ==END OFFENDING TRACE==
+        MSG
+      end
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/dsl.rb

@@ -0,0 +1,46 @@
+# typed: strict
+
+module Mocktail
+  module DSL
+    extend T::Sig
+
+    sig {
+      type_parameters(:T)
+        .params(
+          ignore_block: T::Boolean,
+          ignore_extra_args: T::Boolean,
+          ignore_arity: T::Boolean,
+          times: T.nilable(Integer),
+          demo: T.proc.params(matchers: Mocktail::MatcherPresentation).returns(T.type_parameter(:T))
+        )
+        .returns(Mocktail::Stubbing[T.type_parameter(:T)])
+    }
+    def stubs(ignore_block: false, ignore_extra_args: false, ignore_arity: false, times: nil, &demo)
+      RegistersStubbing.new.register(demo, DemoConfig.new(
+        ignore_block: ignore_block,
+        ignore_extra_args: ignore_extra_args,
+        ignore_arity: ignore_arity,
+        times: times
+      ))
+    end
+
+    sig {
+      type_parameters(:T)
+        .params(
+          ignore_block: T::Boolean,
+          ignore_extra_args: T::Boolean,
+          ignore_arity: T::Boolean,
+          times: T.nilable(Integer),
+          demo: T.proc.params(matchers: Mocktail::MatcherPresentation).void
+        ).void
+    }
+    def verify(ignore_block: false, ignore_extra_args: false, ignore_arity: false, times: nil, &demo)
+      VerifiesCall.new.verify(demo, DemoConfig.new(
+        ignore_block: ignore_block,
+        ignore_extra_args: ignore_extra_args,
+        ignore_arity: ignore_arity,
+        times: times
+      ))
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/errors.rb

@@ -0,0 +1,19 @@
+# typed: strict
+
+module Mocktail
+  class Error < StandardError; end
+
+  class UnexpectedError < Error; end
+
+  class UnsupportedMocktail < Error; end
+
+  class MissingDemonstrationError < Error; end
+
+  class AmbiguousDemonstrationError < Error; end
+
+  class InvalidMatcherError < Error; end
+
+  class VerificationError < Error; end
+
+  class TypeCheckingError < Error; end
+end