mock-suey 0.0.1 → 0.1.0

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

data/lib/.rbnext/3.1/mock_suey/type_checks/ruby.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+gem "rbs", "~> 2.0"
+require "rbs"
+require "rbs/test"
+
+require "set"
+require "pathname"
+
+require "mock_suey/ext/instance_class"
+
+module MockSuey
+  module TypeChecks
+    using Ext::InstanceClass
+
+    class Ruby
+      class SignatureGenerator
+        attr_reader :klass, :method_calls, :constants, :singleton
+        alias_method :singleton?, :singleton
+
+        def initialize(klass, method_calls)
+          @klass = klass
+          @singleton = klass.singleton_class?
+          @method_calls = method_calls
+          @constants = Set.new
+        end
+
+        def to_rbs
+          [
+            header,
+            *method_calls.map { |name, calls| method_sig(name, calls) },
+            footer
+          ].join("\n")
+        end
+
+        private
+
+        def header
+          nesting_parts = klass.instance_class_name.split("::")
+
+          base = Kernel
+          nesting = 0
+
+          lines = []
+
+          nesting_parts.map do |const|
+            base = base.const_get(const)
+            lines << "#{"  " * nesting}#{base.is_a?(Class) ? "class" : "module"} #{const}"
+            nesting += 1
+          end
+
+          @nesting = nesting_parts.size
+
+          lines.join("\n")
+        end
+
+        def footer
+          @nesting.times.map do |n|
+            "#{"  " * (@nesting - n - 1)}end"
+          end.join("\n")
+        end
+
+        def method_sig(name, calls)
+          "#{"  " * @nesting}def #{singleton? ? "self." : ""}#{name}: (#{[args_sig(calls.map(&:pos_args)), kwargs_sig(calls.map(&:kwargs))].compact.join(", ")}) -> (#{return_sig(name, calls.map(&:return_value))})"
+        end
+
+        def args_sig(args)
+          return if args.all?(&:empty?)
+
+          args.transpose.map do |arg_values|
+            arg_values.map(&:class).uniq.map do
+              constants << _1
+              "::#{_1.name}"
+            end
+          end.join(", ")
+        end
+
+        def kwargs_sig(kwargs)
+          return if kwargs.all?(&:empty?)
+
+          key_values = kwargs.each_with_object(Hash.new { |h, k| h[k] = [] }) { |pairs, acc|
+            pairs.each { acc[_1] << _2 }
+          }
+
+          key_values.map do |key, values|
+            values_sig = values.map(&:class).uniq.map do
+              constants << _1
+              "::#{_1.name}"
+            end.join(" | ")
+
+            "?#{key}: (#{values_sig})"
+          end.join(", ")
+        end
+
+        def return_sig(name, values)
+          # Special case
+          return "self" if name == :initialize
+
+          values.map(&:class).uniq.map do
+            constants << _1
+            "::#{_1.name}"
+          end.join(" | ")
+        end
+      end
+
+      def initialize(load_dirs: [])
+        @load_dirs = Array(load_dirs)
+      end
+
+      def typecheck!(call_obj, raise_on_missing: false)
+        method_name = call_obj.method_name
+
+        method_call = RBS::Test::ArgumentsReturn.return(
+          arguments: call_obj.arguments,
+          value: call_obj.return_value
+        )
+
+        call_trace = RBS::Test::CallTrace.new(
+          method_name: method_name,
+          method_call: method_call,
+          # TODO: blocks support
+          block_calls: [],
+          block_given: false
+        )
+
+        method_type = type_for(call_obj.receiver_class, method_name)
+
+        unless method_type
+          raise MissingSignature, "No signature found for #{call_obj.method_desc}" if raise_on_missing
+          return
+        end
+
+        self_class = call_obj.receiver_class
+        instance_class = call_obj.receiver_class
+        class_class = call_obj.receiver_class.singleton_class? ? call_obj.receiver_class : call_obj.receiver_class.singleton_class
+
+        typecheck = RBS::Test::TypeCheck.new(
+          self_class: self_class,
+          builder: builder,
+          sample_size: 100, # What should be the value here?
+          unchecked_classes: [],
+          instance_class: instance_class,
+          class_class: class_class
+        )
+
+        errors = []
+        typecheck.overloaded_call(
+          method_type,
+          "#{self_class.singleton_class? ? "." : "#"}#{method_name}",
+          call_trace,
+          errors: errors
+        )
+
+        reject_returned_doubles!(errors)
+
+        # TODO: Use custom error class
+        raise RBS::Test::Tester::TypeError.new(errors) unless errors.empty?
+      end
+
+      def load_signatures_from_calls(calls)
+        constants = Set.new
+
+        calls.group_by(&:receiver_class).each do |klass, klass_calls|
+          calls_per_method = klass_calls.group_by(&:method_name)
+          generator = SignatureGenerator.new(klass, calls_per_method)
+
+          generator.to_rbs.then do |rbs|
+            MockSuey.logger.debug "Generated RBS for #{klass.instance_class_name}:\n#{rbs}\n"
+            load_rbs(rbs)
+          end
+
+          constants |= generator.constants
+        end
+
+        constants.each do |const|
+          next if type_defined?(const)
+
+          SignatureGenerator.new(const, {}).to_rbs.then do |rbs|
+            MockSuey.logger.debug "Generated RBS for constant #{const.instance_class_name}:\n#{rbs}\n"
+            load_rbs(rbs)
+          end
+        end
+      end
+
+      private
+
+      def load_rbs(rbs)
+        ::RBS::Parser.parse_signature(rbs).then do |declarations|
+          declarations.each do |decl|
+            env << decl
+          end
+        end
+      end
+
+      def env
+        return @env if instance_variable_defined?(:@env)
+
+        loader = RBS::EnvironmentLoader.new
+        @load_dirs&.each { loader.add(path: Pathname(_1)) }
+        @env = RBS::Environment.from_loader(loader).resolve_type_names
+      end
+
+      def builder ;  @builder ||= RBS::DefinitionBuilder.new(env: env); end
+
+      def type_for(klass, method_name)
+        type = type_for_class(klass.instance_class)
+        return unless env.class_decls[type]
+
+        decl = klass.singleton_class? ? builder.build_singleton(type) : builder.build_instance(type)
+
+        decl.methods[method_name]
+      end
+
+      def type_for_class(klass)
+        *path, name = *klass.instance_class_name.split("::").map(&:to_sym)
+
+        namespace = path.empty? ? RBS::Namespace.root : RBS::Namespace.new(absolute: true, path: path)
+
+        RBS::TypeName.new(name: name, namespace: namespace)
+      end
+
+      def type_defined?(klass)
+        !env.class_decls[type_for_class(klass.instance_class)].nil?
+      end
+
+      def reject_returned_doubles!(errors)
+        return unless defined?(::RSpec::Core)
+
+        errors.reject! do |error|
+          case error
+          in RBS::Test::Errors::ReturnTypeError[
+            type:,
+            value: ::RSpec::Mocks::InstanceVerifyingDouble => double
+          ]
+            return_class = type.instance_of?(RBS::Types::Bases::Self) ? error.klass : type.name
+            return_type = return_class.to_s.gsub(/^::/, "")
+            double_type = double.instance_variable_get(:@doubled_module).target.to_s
+
+            double_type == return_type
+          in RBS::Test::Errors::ReturnTypeError[
+            value: ::RSpec::Mocks::Double
+          ]
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/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
+
+    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:)
+      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:)
+      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/mock_suey/ext/instance_class.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MockSuey
+  module Ext
+    module InstanceClass
+      refine Class do
+        def instance_class = self
+
+        def instance_class_name = name
+      end
+
+      refine Class.singleton_class do
+        def instance_class
+          # TODO: replace with const_get
+          eval(instance_class_name) # rubocop:disable Security/Eval
+        end
+
+        def instance_class_name = inspect.sub(%r{^#<Class:}, "").sub(/>$/, "")
+      end
+    end
+  end
+end