mocktail 0.0.1

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "standard/rake"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: [:test, "standard:fix"]

data/bin/console

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "mocktail"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+class Negroni
+  def self.ingredients
+    [:gin, :campari, :sweet_vermouth]
+  end
+
+  def shake!(shaker)
+    shaker.mix(self.class.ingredients)
+  end
+
+  def sip(amount)
+    raise "unimplemented"
+  end
+end
+
+include Mocktail::DSL
+class UserRepository
+  def find(id); end
+
+  def transaction(&blk); end
+end
+
+class Auditor
+  def record!(message, user:, action: nil); end
+end
+
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mocktail/dsl.rb

@@ -0,0 +1,21 @@
+module Mocktail
+  module DSL
+    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
+
+    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/errors.rb

@@ -0,0 +1,15 @@
+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
+end

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

@@ -0,0 +1,16 @@
+require_relative "../../share/determines_matching_calls"
+
+module Mocktail
+  class FindsSatisfaction
+    def initialize
+      @determines_matching_calls = DeterminesMatchingCalls.new
+    end
+
+    def find(dry_call)
+      Mocktail.cabinet.stubbings.reverse.find { |stubbing|
+        @determines_matching_calls.determine(dry_call, stubbing.recording, stubbing.demo_config) &&
+          (stubbing.demo_config.times.nil? || stubbing.demo_config.times > stubbing.satisfaction_count)
+      }
+    end
+  end
+end

data/lib/mocktail/handles_dry_call/fulfills_stubbing.rb

@@ -0,0 +1,21 @@
+require_relative "fulfills_stubbing/finds_satisfaction"
+
+module Mocktail
+  class FulfillsStubbing
+    def initialize
+      @finds_satisfaction = FindsSatisfaction.new
+    end
+
+    def fulfill(dry_call)
+      if (stubbing = satisfaction(dry_call))
+        stubbing.satisfied!
+        stubbing.effect&.call(dry_call)
+      end
+    end
+
+    def satisfaction(dry_call)
+      return if Mocktail.cabinet.demonstration_in_progress?
+      @finds_satisfaction.find(dry_call)
+    end
+  end
+end

data/lib/mocktail/handles_dry_call/logs_call.rb

@@ -0,0 +1,7 @@
+module Mocktail
+  class LogsCall
+    def log(dry_call)
+      Mocktail.cabinet.store_call(dry_call)
+    end
+  end
+end

data/lib/mocktail/handles_dry_call/validates_arguments.rb

@@ -0,0 +1,57 @@
+require_relative "../share/simulates_argument_error"
+
+module Mocktail
+  class ValidatesArguments
+    def self.disable!
+      Thread.current[:mocktail_arity_validation_disabled] = true
+    end
+
+    def self.enable!
+      Thread.current[:mocktail_arity_validation_disabled] = false
+    end
+
+    def self.disabled?
+      Thread.current[:mocktail_arity_validation_disabled]
+    end
+
+    def self.optional(disable, &blk)
+      return blk.call unless disable
+
+      disable!
+      blk.call.tap do
+        enable!
+      end
+    end
+
+    def initialize
+      @simulates_argument_error = SimulatesArgumentError.new
+    end
+
+    def validate(dry_call)
+      return if self.class.disabled?
+
+      arg_params, kwarg_params = dry_call.original_method.parameters.reject { |type, _|
+        type == :block
+      }.partition { |type, _|
+        [:req, :opt, :rest].include?(type)
+      }
+
+      unless args_match?(arg_params, dry_call.args) &&
+          kwargs_match?(kwarg_params, dry_call.kwargs)
+        raise @simulates_argument_error.simulate(arg_params, dry_call.args, kwarg_params, dry_call.kwargs)
+      end
+    end
+
+    private
+
+    def args_match?(arg_params, args)
+      args.size >= arg_params.count { |type, _| type == :req } &&
+        (arg_params.any? { |type, _| type == :rest } || args.size <= arg_params.size)
+    end
+
+    def kwargs_match?(kwarg_params, kwargs)
+      kwarg_params.select { |type, _| type == :keyreq }.all? { |_, name| kwargs.key?(name) } &&
+        (kwarg_params.any? { |type, _| type == :keyrest } || kwargs.keys.all? { |name| kwarg_params.any? { |_, key| name == key } })
+    end
+  end
+end

data/lib/mocktail/handles_dry_call.rb

@@ -0,0 +1,19 @@
+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
+    def initialize
+      @validates_arguments = ValidatesArguments.new
+      @logs_call = LogsCall.new
+      @fulfills_stubbing = FulfillsStubbing.new
+    end
+
+    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/handles_dry_new_call.rb

@@ -0,0 +1,36 @@
+module Mocktail
+  class HandlesDryNewCall
+    def initialize
+      @validates_arguments = ValidatesArguments.new
+      @logs_call = LogsCall.new
+      @fulfills_stubbing = FulfillsStubbing.new
+      @imitates_type = ImitatesType.new
+    end
+
+    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/imitates_type/ensures_imitation_support.rb

@@ -0,0 +1,11 @@
+module Mocktail
+  class EnsuresImitationSupport
+    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/imitates_type/makes_double/declares_dry_class.rb

@@ -0,0 +1,95 @@
+module Mocktail
+  class DeclaresDryClass
+    def initialize
+      @handles_dry_call = HandlesDryCall.new
+    end
+
+    def declare(type)
+      type_type = type_of(type)
+      instance_methods = instance_methods_on(type)
+      dry_class = Class.new(Object) {
+        include type if type_type == :module
+
+        def initialize(*args, **kwargs, &blk)
+        end
+
+        define_method :is_a?, ->(thing) {
+          type.ancestors.include?(thing)
+        }
+        alias_method :kind_of?, :is_a?
+
+        if type_type == :class
+          define_method :instance_of?, ->(thing) {
+            type == thing
+          }
+        end
+      }
+
+      add_stringify_methods!(dry_class, :to_s, type, type_type, instance_methods)
+      add_stringify_methods!(dry_class, :inspect, type, type_type, instance_methods)
+
+      define_double_methods!(dry_class, type, instance_methods)
+
+      dry_class
+    end
+
+    private
+
+    def define_double_methods!(dry_class, type, instance_methods)
+      handles_dry_call = @handles_dry_call
+      instance_methods.each do |method|
+        dry_class.define_method method, ->(*args, **kwargs, &block) {
+          handles_dry_call.handle(Call.new(
+            singleton: false,
+            double: self,
+            original_type: type,
+            dry_type: self.class,
+            method: method,
+            original_method: type.instance_method(method),
+            args: args,
+            kwargs: kwargs,
+            block: block
+          ))
+        }
+      end
+    end
+
+    def add_stringify_methods!(dry_class, method_name, type, type_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
+
+    def type_of(type)
+      if type.is_a?(Class)
+        :class
+      elsif type.is_a?(Module)
+        :module
+      end
+    end
+
+    def instance_methods_on(type)
+      type.instance_methods.reject { |m|
+        ignored_ancestors.include?(type.instance_method(m).owner)
+      }
+    end
+
+    def ignored_ancestors
+      Object.ancestors
+    end
+  end
+end

data/lib/mocktail/imitates_type/makes_double.rb

@@ -0,0 +1,18 @@
+require_relative "makes_double/declares_dry_class"
+
+module Mocktail
+  class MakesDouble
+    def initialize
+      @declares_dry_class = DeclaresDryClass.new
+    end
+
+    def make(klass)
+      dry_type = @declares_dry_class.declare(klass)
+      Double.new(
+        original_type: klass,
+        dry_type: dry_type,
+        dry_instance: dry_type.new
+      )
+    end
+  end
+end

data/lib/mocktail/imitates_type.rb

@@ -0,0 +1,19 @@
+require_relative "imitates_type/ensures_imitation_support"
+require_relative "imitates_type/makes_double"
+
+module Mocktail
+  class ImitatesType
+    def initialize
+      @top_shelf = TopShelf.instance
+      @ensures_imitation_support = EnsuresImitationSupport.new
+      @makes_double = MakesDouble.new
+    end
+
+    def imitate(type)
+      @ensures_imitation_support.ensure(type)
+      @makes_double.make(type).tap do |double|
+        Mocktail.cabinet.store_double(double)
+      end.dry_instance
+    end
+  end
+end

data/lib/mocktail/initializes_mocktail.rb

@@ -0,0 +1,17 @@
+module Mocktail
+  class InitializesMocktail
+    def init
+      [
+        Mocktail::Matchers::Any,
+        Mocktail::Matchers::Includes,
+        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/matcher_presentation.rb

@@ -0,0 +1,15 @@
+module Mocktail
+  class MatcherPresentation
+    def respond_to_missing?(name, include_private = false)
+      !!MatcherRegistry.instance.get(name) || super
+    end
+
+    def method_missing(name, *args, **kwargs, &blk)
+      if (matcher = MatcherRegistry.instance.get(name))
+        matcher.new(*args, **kwargs, &blk)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/mocktail/matchers/any.rb

@@ -0,0 +1,18 @@
+module Mocktail::Matchers
+  class Any < Base
+    def self.matcher_name
+      :any
+    end
+
+    def initialize
+    end
+
+    def match?(actual)
+      true
+    end
+
+    def inspect
+      "any"
+    end
+  end
+end

data/lib/mocktail/matchers/base.rb

@@ -0,0 +1,25 @@
+module Mocktail::Matchers
+  class Base
+    # Custom matchers can receive any args, kwargs, or block they want. Usually
+    # single-argument, though, so that's defaulted here and in #insepct
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def self.matcher_name
+      raise Mocktail::Error.new("The `matcher_name` class method must return a valid method name")
+    end
+
+    def match?(actual)
+      raise Mocktail::Error.new("Matchers must implement `match?(argument)`")
+    end
+
+    def inspect
+      "#{self.class.matcher_name}(#{@expected.inspect})"
+    end
+
+    def is_mocktail_matcher?
+      true
+    end
+  end
+end

data/lib/mocktail/matchers/captor.rb

@@ -0,0 +1,52 @@
+module Mocktail::Matchers
+  # Captors are conceptually complex implementations, but with a simple usage/purpose:
+  # They are values the user can create and hold onto that will return a matcher
+  # and then "capture" the value made by the real call, for later analysis & assertion.
+  #
+  # Unlike other matchers, these don't make any useful sense for stubbing, but are
+  # very useful when asserting complication call verifications
+  #
+  # The fact the user will need the reference outside the verification call is
+  # why this is a top-level method on Mocktail, and not included in the |m| block
+  # arg to stubs/verify
+  #
+  # See Mockito, which is the earliest implementation I know of:
+  # https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Captor.html
+  class Captor
+    class Capture < Mocktail::Matchers::Base
+      def self.matcher_name
+        :capture
+      end
+
+      attr_reader :value
+
+      def initialize
+        @value = nil
+        @captured = false
+      end
+
+      def match?(actual)
+        @value = actual
+        @captured = true
+        true
+      end
+
+      def captured?
+        @captured
+      end
+    end
+
+    attr_reader :capture
+    def initialize
+      @capture = Capture.new
+    end
+
+    def captured?
+      @capture.captured?
+    end
+
+    def value
+      @capture.value
+    end
+  end
+end

data/lib/mocktail/matchers/includes.rb

@@ -0,0 +1,24 @@
+module Mocktail::Matchers
+  class Includes < Base
+    def self.matcher_name
+      :includes
+    end
+
+    def initialize(*expecteds)
+      @expecteds = expecteds
+    end
+
+    def match?(actual)
+      @expecteds.all? { |expected|
+        (actual.respond_to?(:include?) && actual.include?(expected)) ||
+          (actual.is_a?(Hash) && expected.is_a?(Hash) && expected.all? { |k, v| actual[k] == v })
+      }
+    rescue
+      false
+    end
+
+    def inspect
+      "#{self.class.matcher_name}(#{@expecteds.map(&:inspect).join(", ")})"
+    end
+  end
+end

data/lib/mocktail/matchers/is_a.rb

@@ -0,0 +1,11 @@
+module Mocktail::Matchers
+  class IsA < Base
+    def self.matcher_name
+      :is_a
+    end
+
+    def match?(actual)
+      actual.is_a?(@expected)
+    end
+  end
+end

data/lib/mocktail/matchers/matches.rb

@@ -0,0 +1,13 @@
+module Mocktail::Matchers
+  class Matches < Base
+    def self.matcher_name
+      :matches
+    end
+
+    def match?(actual)
+      actual.respond_to?(:match?) && actual.match?(@expected)
+    rescue
+      false
+    end
+  end
+end

data/lib/mocktail/matchers/not.rb

@@ -0,0 +1,11 @@
+module Mocktail::Matchers
+  class Not < Base
+    def self.matcher_name
+      :not
+    end
+
+    def match?(actual)
+      @expected != actual
+    end
+  end
+end

data/lib/mocktail/matchers/numeric.rb

@@ -0,0 +1,18 @@
+module Mocktail::Matchers
+  class Numeric < Base
+    def self.matcher_name
+      :numeric
+    end
+
+    def initialize
+    end
+
+    def match?(actual)
+      [Integer, Float, (BigDecimal if defined?(BigDecimal))].include?(actual.class)
+    end
+
+    def inspect
+      "numeric"
+    end
+  end
+end

data/lib/mocktail/matchers/that.rb

@@ -0,0 +1,24 @@
+module Mocktail::Matchers
+  class That < Base
+    def self.matcher_name
+      :that
+    end
+
+    def initialize(&blk)
+      if blk.nil?
+        raise "The `that` matcher must be passed a block (e.g. `that { |arg| … }`)"
+      end
+      @blk = blk
+    end
+
+    def match?(actual)
+      @blk.call(actual)
+    rescue
+      false
+    end
+
+    def inspect
+      "that {…}"
+    end
+  end
+end

data/lib/mocktail/matchers.rb

@@ -0,0 +1,14 @@
+module Mocktail
+  module Matchers
+  end
+end
+
+require_relative "matchers/base"
+require_relative "matchers/any"
+require_relative "matchers/captor"
+require_relative "matchers/includes"
+require_relative "matchers/is_a"
+require_relative "matchers/matches"
+require_relative "matchers/not"
+require_relative "matchers/numeric"
+require_relative "matchers/that"