mock-suey 0.0.1 → 0.1.0

data/lib/.rbnext/3.0/mock_suey/mock_contract.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+using RubyNext;
+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)
+      (__m__ = call_obj) && ((((receiver_class, method_name, return_value) = nil) || (__m__.respond_to?(:deconstruct_keys) && (((__m_hash__ = __m__.deconstruct_keys([:receiver_class, :method_name, :return_value])) || true) && (Hash === __m_hash__ || Kernel.raise(TypeError, "#deconstruct_keys must return Hash"))) && (((__m_hash__.key?(:receiver_class) && __m_hash__.key?(:method_name)) && __m_hash__.key?(:return_value)) && (((receiver_class = __m_hash__[:receiver_class]) || true) && (((method_name = __m_hash__[:method_name]) || true) && ((return_value = __m_hash__[:return_value]) || true)))))) || Kernel.raise(NoMatchingPatternError, __m__.inspect))
+
+      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 }; end
+
+    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.0/mock_suey/rspec/mock_context.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+using RubyNext;
+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; end
+
+        def collector ;  @collector ||= MocksCollector.new; end
+
+        def registry ;  collector.registry; end
+      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 ;  {}; end
+
+            def self.filtered_examples ;  examples; end
+
+            ::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 (__m__ = stub.expected_args) && (__m__.respond_to?(:deconstruct) && (((__m_arr__ = __m__.deconstruct) || true) && (Array === __m_arr__ || Kernel.raise(TypeError, "#deconstruct must return Array"))) && (1 == __m_arr__.size) && (::RSpec::Mocks::ArgumentMatchers::NoArgsMatcher === __m_arr__[0]))
+                        []
+                      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.0/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