mock-suey 0.0.1 → 0.1.0

data/lib/mock_suey/ext/rspec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MockSuey
+  module Ext
+    module RSpec
+      # Provide unified interface to access target class
+      # for different double/proxy types
+      refine ::RSpec::Mocks::TestDoubleProxy do
+        def target_class = nil
+      end
+
+      refine ::RSpec::Mocks::PartialDoubleProxy do
+        def target_class = object.class
+      end
+
+      refine ::RSpec::Mocks::VerifyingPartialDoubleProxy do
+        def target_class = object.class
+      end
+
+      refine ::RSpec::Mocks::PartialClassDoubleProxy do
+        def target_class = object.singleton_class
+      end
+
+      refine ::RSpec::Mocks::VerifyingPartialClassDoubleProxy do
+        def target_class = object.singleton_class
+      end
+
+      refine ::RSpec::Mocks::VerifyingProxy do
+        def target_class = @doubled_module.target
+      end
+
+      refine ::RSpec::Mocks::Proxy do
+        attr_reader :method_doubles
+      end
+    end
+  end
+end

data/lib/mock_suey/logging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Copied from Test Prof
+module MockSuey
+  # Helper for output printing
+  module Logging
+    COLORS = {
+      INFO: "\e[34m", # blue
+      WARN: "\e[33m", # yellow
+      ERROR: "\e[31m" # red
+    }.freeze
+
+    class Formatter
+      def call(severity, _time, progname, msg)
+        colorize(severity.to_sym, "[MOCK SUEY #{severity}] #{msg}") + "\n"
+      end
+
+      private
+
+      def colorize(level, msg)
+        return msg unless MockSuey.config.color?
+
+        return msg unless COLORS.key?(level)
+
+        "#{COLORS[level]}#{msg}\e[0m"
+      end
+    end
+  end
+end

data/lib/mock_suey/method_call.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "mock_suey/ext/instance_class"
+
+module MockSuey
+  using Ext::InstanceClass
+
+  class MethodCall < Struct.new(
+    :receiver_class,
+    :method_name,
+    :arguments,
+    :return_value,
+    :has_kwargs,
+    :metadata,
+    keyword_init: true
+  )
+    def initialize(**)
+      super
+      self.metadata = {} unless metadata
+    end
+
+    def pos_args
+      return arguments unless has_kwargs
+      *positional, _kwarg = arguments
+      positional
+    end
+
+    def kwargs
+      return {} unless has_kwargs
+      arguments.last
+    end
+
+    def has_kwargs
+      super.then do |val|
+        # Flag hasn't been set explicitly,
+        # so we need to derive it from the method data
+        return val unless val.nil?
+
+        kwarg_params = keyword_parameters
+        return self.has_kwargs = false if kwarg_params.empty?
+
+        last_arg = arguments.last
+
+        unless last_arg.is_a?(::Hash) && last_arg.keys.all? { ::Symbol === _1 }
+          return self.has_kwargs = false
+        end
+
+        self.has_kwargs = true
+      end
+    end
+
+    def method_desc
+      delimeter = receiver_class.singleton_class? ? "." : "#"
+
+      "#{receiver_class.instance_class_name}#{delimeter}#{method_name}"
+    end
+
+    def inspect
+      "#{method_desc}(#{arguments.map(&:inspect).join(", ")}) -> #{return_value.inspect}"
+    end
+
+    private
+
+    def keyword_parameters
+      arg_types = receiver_class.instance_method(method_name).parameters
+      return [] if arg_types.any? { _1[0] == :nokey }
+
+      arg_types.select { _1[0].start_with?("key") }
+    end
+  end
+end

data/lib/mock_suey/mock_contract.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "mock_suey/ext/instance_class"
+
+module MockSuey
+  class MockContract
+    using Ext::InstanceClass
+
+    class Error < StandardError
+      attr_reader :contract
+
+      def initialize(contract, msg)
+        @contract = contract
+        super(msg)
+      end
+
+      private
+
+      def captured_calls_message(calls)
+        calls.map do |call|
+          contract.args_pattern.map.with_index do |arg, i|
+            (ANYTHING == arg) ? "_" : call.arguments[i].inspect
+          end.join(", ").then do |args_desc|
+            "    (#{args_desc}) -> #{call.return_value.class}"
+          end
+        end.uniq.join("\n")
+      end
+    end
+
+    class NoMethodCalls < Error
+      def initialize(contract)
+        super(
+          contract,
+          "Mock contract verification failed:\n" \
+          "  No method calls captured for #{contract.method_desc}"
+        )
+      end
+    end
+
+    class NoMatchingMethodCalls < Error
+      def initialize(contract, real_calls)
+        @contract = contract
+        super(
+          contract,
+          "Mock contract verification failed:\n" \
+          "  No matching calls captured for #{contract.inspect}.\n" \
+          "  Captured call patterns:\n" \
+          "#{captured_calls_message(real_calls)}"
+        )
+      end
+    end
+
+    class NoMatchingReturnType < Error
+      def initialize(contract, real_calls)
+        @contract = contract
+        super(
+          contract,
+          "Mock contract verification failed:\n" \
+          "  No calls with the expected return type captured for #{contract.inspect}.\n" \
+          "  Captured call patterns:\n" \
+          "#{captured_calls_message(real_calls)}"
+        )
+      end
+    end
+
+    ANYTHING = Object.new.freeze
+
+    def self.from_stub(call_obj)
+      call_obj => {receiver_class:, method_name:, return_value:}
+
+      args_pattern = call_obj.arguments.map do
+        contractable_arg?(_1) ? _1 : ANYTHING
+      end
+
+      new(
+        receiver_class:,
+        method_name:,
+        args_pattern:,
+        return_type: return_value.class
+      )
+    end
+
+    def self.contractable_arg?(val)
+      case val
+      when TrueClass, FalseClass, Numeric, String, Regexp, NilClass
+        true
+      when Array
+        val.all? { |v| contractable_arg?(v) }
+      when Hash
+        contractable_arg?(val.values)
+      else
+        false
+      end
+    end
+
+    attr_reader :receiver_class, :method_name,
+      :args_pattern, :return_type
+
+    def initialize(receiver_class:, method_name:, args_pattern:, return_type:)
+      @receiver_class = receiver_class
+      @method_name = method_name
+      @args_pattern = args_pattern
+      @return_type = return_type
+    end
+
+    def verify!(calls)
+      return if noop?
+
+      raise NoMethodCalls.new(self) if calls.nil? || calls.empty?
+
+      matching_input_calls = calls.select { matching_args?(_1) }
+      raise NoMatchingMethodCalls.new(self, calls) if matching_input_calls.empty?
+
+      matching_input_calls.each do
+        return if _1.return_value.class <= return_type
+      end
+
+      raise NoMatchingReturnType.new(self, matching_input_calls)
+    end
+
+    def noop? = args_pattern.all? { _1 == ANYTHING }
+
+    def method_desc
+      delimeter = receiver_class.singleton_class? ? "." : "#"
+
+      "#{receiver_class.instance_class_name}#{delimeter}#{method_name}"
+    end
+
+    def inspect
+      args_pattern.map do
+        (_1 == ANYTHING) ? "_" : _1.inspect
+      end.join(", ").then do |args_desc|
+        "#{method_desc}: (#{args_desc}) -> #{return_type}"
+      end
+    end
+
+    private
+
+    def matching_args?(call)
+      args_pattern.each.with_index do |arg, i|
+        next if arg == ANYTHING
+        # Use case-eq here to make it possible to use composed
+        # matchers in the future
+        return false unless arg === call.arguments[i]
+      end
+
+      true
+    end
+  end
+end

data/lib/mock_suey/rspec/mock_context.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "mock_suey/ext/rspec"
+require "mock_suey/ext/instance_class"
+
+module MockSuey
+  module RSpec
+    # Special type of shared context for mocks.
+    # The main difference is that it can track mocked classes and methods.
+    module MockContext
+      NAMESPACE = "mock::"
+
+      class << self
+        attr_writer :context_namespace
+
+        def context_namespace = @context_namespace || NAMESPACE
+
+        def collector = @collector ||= MocksCollector.new
+
+        def registry = collector.registry
+      end
+
+      class MocksCollector
+        using Ext::RSpec
+        using Ext::InstanceClass
+
+        # Registry contains all identified mocks/stubs in a form:
+        #   Hash[Class: Hash[Symbol method_name, Array[MethodCall]]
+        attr_reader :registry
+
+        def initialize
+          @registry = Hash.new { |h, k| h[k] = {} }
+          @mocks = {}
+        end
+
+        def watch(context_id)
+          return if mocks.key?(context_id)
+
+          mocks[context_id] = true
+
+          evaluate_context!(context_id)
+        end
+
+        private
+
+        attr_reader :mocks
+
+        def evaluate_context!(context_id)
+          store = registry
+
+          Class.new(::RSpec::Core::ExampleGroup) do
+            def self.metadata = {}
+
+            def self.filtered_examples = examples
+
+            ::RSpec::Core::MemoizedHelpers.define_helpers_on(self)
+
+            include_context(context_id)
+
+            specify("true") { expect(true).to be(true) }
+
+            after do
+              ::RSpec::Mocks.space.proxies.values.each do |proxy|
+                proxy.method_doubles.values.each do |double|
+                  method_name = double.method_name
+                  receiver_class = proxy.target_class
+
+                  # Simple doubles don't have targets
+                  next unless receiver_class
+
+                  # TODO: Make conversion customizable (see proxy_method_invoked)
+                  if method_name == :new && receiver_class.singleton_class?
+                    receiver_class, method_name = receiver_class.instance_class, :initialize
+                  end
+
+                  expected_calls = store[receiver_class][method_name] = []
+
+                  double.stubs.each do |stub|
+                    arguments =
+                      if stub.expected_args in [::RSpec::Mocks::ArgumentMatchers::NoArgsMatcher]
+                        []
+                      else
+                        stub.expected_args
+                      end
+
+                    return_value = stub.implementation.terminal_action.call
+
+                    expected_calls << MethodCall.new(
+                      receiver_class:,
+                      method_name:,
+                      arguments:,
+                      return_value:
+                    )
+                  end
+                end
+              end
+            end
+          end.run
+        end
+      end
+
+      module DSL
+        def mock_context(name, **opts, &block)
+          ::RSpec.shared_context("#{MockContext.context_namespace}#{name}", **opts, &block)
+        end
+      end
+
+      module ExampleGroup
+        def include_mock_context(name)
+          context_id = "#{MockContext.context_namespace}#{name}"
+
+          MockContext.collector.watch(context_id)
+          include_context(context_id)
+        end
+      end
+    end
+  end
+end
+
+# Extending RSpec
+RSpec.extend(MockSuey::RSpec::MockContext::DSL)
+
+if RSpec.configuration.expose_dsl_globally?
+  Object.include(MockSuey::RSpec::MockContext::DSL)
+  Module.extend(MockSuey::RSpec::MockContext::DSL)
+end
+
+RSpec::Core::ExampleGroup.extend(MockSuey::RSpec::MockContext::ExampleGroup)
+RSpec::Core::ExampleGroup.extend(MockSuey::RSpec::MockContext::DSL)

data/lib/mock_suey/rspec/proxy_method_invoked.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+begin
+  RSpec::Mocks::VerifyingMethodDouble
+rescue LoadError
+  warn "Couldn't find VerifyingMethodDouble class from rspec-mocks"
+  return
+end
+
+require "mock_suey/ext/rspec"
+require "mock_suey/ext/instance_class"
+
+module MockSuey
+  module RSpec
+    using Ext::RSpec
+    using Ext::InstanceClass
+
+    module ProxyMethodInvokedHook
+      def proxy_method_invoked(obj, *args, &block)
+        return super if obj.is_a?(::RSpec::Mocks::TestDouble) && !obj.is_a?(::RSpec::Mocks::VerifyingDouble)
+
+        receiver_class = @proxy.target_class
+        method_name = @method_name
+
+        # TODO: Make conversion customizable to support .perform_later -> #perform
+        # and other similar use-cases
+        if method_name == :new && receiver_class.singleton_class?
+          receiver_class, method_name = receiver_class.instance_class, :initialize
+        end
+
+        method_call = MockSuey::MethodCall.new(
+          receiver_class:,
+          method_name:,
+          arguments: args,
+          metadata: {example: ::RSpec.current_example}
+        )
+
+        super.tap do |ret|
+          method_call.return_value = ret
+          MockSuey.handle_mocked_call(method_call)
+        end
+      end
+    end
+  end
+end
+
+RSpec::Mocks::MethodDouble.prepend(MockSuey::RSpec::ProxyMethodInvokedHook)

data/lib/mock_suey/rspec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "set"
+
+module MockSuey
+  module RSpec
+    module_function
+
+    def register_example_failure(example, err)
+      example.execution_result.status = :failed
+      example.execution_result.exception = err
+      example.set_aggregate_failures_exception(err)
+    end
+
+    def report_non_example_failure(err, location = nil)
+      err.set_backtrace([location]) if err.backtrace.nil? && location
+
+      ::RSpec.configuration.reporter.notify_non_example_exception(
+        err,
+        "An error occurred after suite run."
+      )
+    end
+  end
+end
+
+require "mock_suey/rspec/proxy_method_invoked"
+require "mock_suey/rspec/mock_context"
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    MockSuey.cook
+  end
+
+  config.after(:suite) do
+    leftovers = MockSuey.eat
+
+    next if leftovers.empty?
+
+    failed_examples = Set.new
+
+    leftovers.each do |call_obj|
+      err = call_obj.metadata[:error]
+      example = call_obj.metadata[:example]
+
+      if example
+        failed_examples << example
+        MockSuey::RSpec.register_example_failure(example, err)
+      else
+        location = call_obj.metadata[:location]
+        MockSuey::RSpec.report_non_example_failure(err, location)
+      end
+    end
+
+    failed_examples.each do
+      ::RSpec.configuration.reporter.example_failed(_1)
+    end
+
+    exit(RSpec.configuration.failure_exit_code)
+  end
+end

data/lib/mock_suey/tracer.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module MockSuey
+  class Tracer
+    class PrependCollector
+      attr_reader :tracer
+
+      def initialize(tracer)
+        @tracer = tracer
+      end
+
+      def module_for(klass, methods)
+        tracer = self.tracer
+
+        Module.new do
+          define_method(:__mock_suey_tracer__) { tracer }
+
+          methods.each do |mid|
+            module_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{mid}(*args, **kwargs, &block)
+                super.tap do |return_value|
+                  arguments = args
+                  arguments << kwargs unless kwargs.empty?
+
+                  __mock_suey_tracer__ << MethodCall.new(
+                    receiver_class: self.class,
+                    method_name: __method__,
+                    arguments: arguments,
+                    has_kwargs: !kwargs.empty?,
+                    return_value: return_value,
+                    metadata: {
+                      location: method(__method__).super_method.source_location.first
+                    }
+                  )
+                end
+              end
+            RUBY
+          end
+        end
+      end
+
+      def setup(targets)
+        targets.each do |klass, methods|
+          mod = module_for(klass, methods)
+          klass.prepend(mod)
+        end
+      end
+
+      def stop
+      end
+    end
+
+    class TracePointCollector
+      attr_reader :tracer
+
+      def initialize(tracer)
+        @tracer = tracer
+      end
+
+      def setup(targets)
+        tracer = self.tracer
+        calls_stack = []
+
+        @tp = TracePoint.trace(:call, :return) do |tp|
+          methods = targets[tp.defined_class]
+          next unless methods
+          next unless methods.include?(tp.method_id)
+
+          receiver_class, method_name = tp.defined_class, tp.method_id
+
+          if tp.event == :call
+            method = tp.self.method(method_name)
+            arguments = []
+            kwargs = {}
+
+            method.parameters.each do |(type, name)|
+              next if name == :** || name == :* || name == :&
+
+              val = tp.binding.local_variable_get(name)
+
+              case type
+              when :req, :opt
+                arguments << val
+              when :keyreq, :key
+                kwargs[name] = val
+              when :rest
+                arguments.concat(val)
+              when :keyrest
+                kwargs.merge!(val)
+              end
+            end
+
+            arguments << kwargs unless kwargs.empty?
+
+            call_obj = MethodCall.new(
+              receiver_class:,
+              method_name:,
+              arguments:,
+              has_kwargs: !kwargs.empty?,
+              metadata: {
+                location: method.source_location.first
+              }
+            )
+            tracer << call_obj
+            calls_stack << call_obj
+          elsif tp.event == :return
+            call_obj = calls_stack.pop
+            call_obj.return_value = tp.return_value
+          end
+        end
+      end
+
+      def stop
+        tp.disable
+      end
+
+      private
+
+      attr_reader :tp
+    end
+
+    attr_reader :store, :targets, :collector
+
+    def initialize(via: :prepend)
+      @store = []
+      @targets = Hash.new { |h, k| h[k] = [] }
+      @collector =
+        if via == :prepend
+          PrependCollector.new(self)
+        elsif via == :trace_point
+          TracePointCollector.new(self)
+        else
+          raise ArgumentError, "Unknown tracing method: #{via}"
+        end
+    end
+
+    def collect(klass, methods)
+      targets[klass].concat(methods)
+      targets[klass].uniq!
+    end
+
+    def start!
+      collector.setup(targets)
+    end
+
+    def stop
+      collector.stop
+      total = store.size
+      filter_calls!
+      MockSuey.logger.debug "Collected #{store.size} real calls (#{total - store.size} were filtered)"
+      store
+    end
+
+    def <<(call_obj)
+      store << call_obj
+    end
+
+    private
+
+    def filter_calls!
+      store.reject! { mocked?(_1) }
+    end
+
+    def mocked?(call_obj)
+      location = call_obj.metadata[:location]
+
+      location.match?(%r{/lib/rspec/mocks/}) ||
+        call_obj.return_value.is_a?(::RSpec::Mocks::Double) ||
+        call_obj.arguments.any? { _1.is_a?(::RSpec::Mocks::Double) } ||
+        call_obj.kwargs.values.any? { _1.is_a?(::RSpec::Mocks::Double) }
+    end
+  end
+end