mock-suey 0.0.1 → 0.1.0

data/lib/.rbnext/3.1/mock_suey/core.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module MockSuey
+  class Configuration
+    # No freezing this const to allow third-party libraries
+    # to integrate with mock_suey
+    TYPE_CHECKERS = %w[ruby]
+
+    attr_accessor :debug,
+      :logger,
+      :log_level,
+      :color,
+      :store_mocked_calls,
+      :signature_load_dirs,
+      :raise_on_missing_types,
+      :raise_on_missing_auto_types,
+      :trace_real_calls,
+      :trace_real_calls_via
+
+    attr_reader :type_check, :auto_type_check, :verify_mock_contracts
+
+    def initialize
+      @debug = %w[1 y yes true t].include?(ENV["MOCK_SUEY_DEBUG"])
+      @log_level = debug ? :debug : :info
+      @color = nil
+      @store_mocked_calls = false
+      @type_check = nil
+      @signature_load_dirs = ["sig"]
+      @raise_on_missing_types = false
+      @raise_on_missing_auto_types = true
+      @trace_real_calls = false
+      @auto_type_check = false
+      @trace_real_calls_via = :prepend
+    end
+
+    def color?
+      return color unless color.nil?
+
+      logdev = logger.instance_variable_get(:@logdev)
+      return self.color = false unless logdev
+
+      output = logdev.instance_variable_get(:@dev)
+      return self.color = false unless output
+
+      self.color = output.is_a?(IO) && output.tty?
+    end
+
+    def type_check=(val)
+      if val.nil?
+        @type_check = nil
+        return
+      end
+
+      val = val.to_s
+      raise ArgumentError, "Unsupported type checker: #{val}. Supported: #{TYPE_CHECKERS.join(",")}" unless TYPE_CHECKERS.include?(val)
+
+      @type_check = val
+    end
+
+    def auto_type_check=(val)
+      if val
+        @trace_real_calls = true
+        @store_mocked_calls = true
+        @auto_type_check = true
+      else
+        @auto_type_check = val
+      end
+    end
+
+    def verify_mock_contracts=(val)
+      if val
+        @trace_real_calls = true
+        @verify_mock_contracts = true
+      else
+        @verify_mock_contracts = val
+      end
+    end
+  end
+
+  class << self
+    attr_reader :stored_mocked_calls, :tracer, :stored_real_calls
+    attr_accessor :type_checker
+
+    def config = @config ||= Configuration.new
+
+    def configure ;  yield config; end
+
+    def logger = config.logger
+
+    def on_mocked_call(&block)
+      on_mocked_callbacks << block
+    end
+
+    def handle_mocked_call(call_obj)
+      on_mocked_callbacks.each { _1.call(call_obj) }
+    end
+
+    def on_mocked_callbacks
+      @on_mocked_callbacks ||= []
+    end
+
+    # Load extensions and start tracing if required
+    def cook
+      setup_logger
+      setup_type_checker
+      setup_mocked_calls_collection if config.store_mocked_calls
+      setup_real_calls_collection if config.trace_real_calls
+    end
+
+    # Run post-suite checks
+    def eat
+      @stored_real_calls = tracer.stop if config.trace_real_calls
+
+      offenses = []
+
+      if config.store_mocked_calls
+        logger.debug { "Stored mocked calls:\n#{stored_mocked_calls.map { "  #{_1.inspect}" }.join("\n")}" }
+      end
+
+      if config.trace_real_calls
+        logger.debug { "Traced real calls:\n#{stored_real_calls.map { "  #{_1.inspect}" }.join("\n")}" }
+      end
+
+      if config.auto_type_check
+        perform_auto_type_check(offenses)
+      end
+
+      if config.verify_mock_contracts
+        perform_contracts_verification(offenses)
+      end
+
+      offenses
+    end
+
+    private
+
+    def setup_logger
+      if !config.logger || config.debug
+        config.logger = Logger.new($stdout)
+        config.logger.formatter = Logging::Formatter.new
+      end
+      config.logger.level = config.log_level
+    end
+
+    def setup_type_checker
+      return unless config.type_check
+
+      # Allow configuring type checher manually
+      unless type_checker
+        require "mock_suey/type_checks/#{config.type_check}"
+        const_name = config.type_check.split("_").map(&:capitalize).join
+
+        self.type_checker = MockSuey::TypeChecks.const_get(const_name)
+          .new(load_dirs: config.signature_load_dirs)
+
+        logger.info "Set up type checker: #{type_checker.class.name} (load_dirs: #{config.signature_load_dirs})"
+      end
+
+      raise_on_missing = config.raise_on_missing_types
+
+      on_mocked_call do |call_obj|
+        type_checker.typecheck!(call_obj, raise_on_missing: raise_on_missing)
+      end
+    end
+
+    def setup_mocked_calls_collection
+      logger.info "Collect mocked calls (MockSuey.stored_mocked_calls)"
+
+      @stored_mocked_calls = []
+
+      on_mocked_call { @stored_mocked_calls << _1 }
+    end
+
+    def setup_real_calls_collection
+      logger.info "Collect real calls via #{config.trace_real_calls_via} (MockSuey.stored_real_calls)"
+
+      @tracer = Tracer.new(via: config.trace_real_calls_via)
+
+      MockSuey::RSpec::MockContext.registry.each do |klass, methods|
+        logger.debug { "Trace #{klass} methods: #{methods.keys.join(", ")}" }
+        tracer.collect(klass, methods.keys)
+      end
+
+      tracer.start!
+    end
+
+    def perform_auto_type_check(offenses)
+      raise "No type checker configured" unless type_checker
+
+      # Generate signatures
+      type_checker.load_signatures_from_calls(stored_real_calls)
+
+      logger.info "Type-checking mocked calls against auto-generated signatures..."
+
+      was_offenses = offenses.size
+
+      # Verify stored mocked calls
+      raise_on_missing = config.raise_on_missing_auto_types
+
+      stored_mocked_calls.each do |call_obj|
+        type_checker.typecheck!(call_obj, raise_on_missing: raise_on_missing)
+      rescue RBS::Test::Tester::TypeError, TypeChecks::MissingSignature => err
+        call_obj.metadata[:error] = err
+        offenses << call_obj
+      end
+
+      failed_count = offenses.size - was_offenses
+      failed = failed_count > 0
+
+      if failed
+        logger.error "❌ Type-checking completed. Failed examples: #{failed_count}"
+      else
+        logger.info "✅ Type-checking completed. All good"
+      end
+    end
+
+    def perform_contracts_verification(offenses)
+      logger.info "Verifying mock contracts..."
+      real_calls_per_class_method = stored_real_calls.group_by(&:receiver_class).tap do |grouped|
+        grouped.transform_values! { _1.group_by(&:method_name) }
+      end
+
+      was_offenses = offenses.size
+
+      MockSuey::RSpec::MockContext.registry.each do |klass, methods|
+        methods.values.flatten.each do |stub_call|
+          contract = MockContract.from_stub(stub_call)
+          logger.debug { "Generated contract:\n  #{contract.inspect}\n    (from stub: #{stub_call.inspect})" }
+          contract.verify!(real_calls_per_class_method.dig(klass, stub_call.method_name))
+        rescue MockContract::Error => err
+          stub_call.metadata[:error] = err
+          offenses << stub_call
+        end
+      end
+
+      failed_count = offenses.size - was_offenses
+      failed = failed_count > 0
+
+      if failed
+        logger.error "❌ Verifying mock contracts completed. Failed contracts: #{failed_count}"
+      else
+        logger.info "✅ Verifying mock contracts completed. All good"
+      end
+    end
+  end
+end

data/lib/.rbnext/3.1/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: receiver_class,
+        method_name: method_name,
+        args_pattern: 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/.rbnext/3.1/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: receiver_class,
+                      method_name: method_name,
+                      arguments: arguments,
+                      return_value: 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/.rbnext/3.1/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: receiver_class,
+          method_name: 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)