Sorbet support (initial)

.editorconfig

@@ -0,0 +1,10 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+

Gemfile

@@ -5,6 +5,7 @@ source "https://rubygems.org"
 gem "debug", platform: :mri
 gem "rbs", "< 3.0"
 gem "rspec"
+gem 'sorbet-runtime', require: false
 
 gemspec
 

README.md

@@ -14,6 +14,7 @@ A collection of tools to keep mocks in line with real objects.
 - [Installation](#installation)
 - [Typed doubles](#typed-doubles)
   - [Using with RBS](#using-with-rbs)
+  - [Using with Sorbet](#using-with-sorbet)
   - [Typed doubles limitations](#typed-doubles-limitations)
 - [Mock context](#mock-context)
 - [Auto-generated type signatures and post-run checks](#auto-generated-type-signatures-and-post-run-checks)
@@ -84,6 +85,33 @@ Typed doubles rely on the type signatures being defined. What if you don't have
 
 2) Auto-generating types on-the-fly from the real call traces (see below).
 
+### Using with Sorbet
+
+To use Mock Suey with Sorbet, configure it as follows:
+
+```ruby
+MockSuey.configure do |config|
+  config.type_check = :sorbet
+end
+```
+
+Make sure that `sorbet` and `sorbet-runtime` gem are present in the bundle according to the [sorbet instruction](https://sorbet.org/docs/adopting#step-1-install-dependencies).
+That's it! Now all mocked methods are type-checked.
+
+### raise_on_missing_types
+
+Gem `sorbet-runtime` does not load signatures for stdlib types (Integer, String, etc...) into runtime.
+Checking types for Integer, String, etc is only available through `rbs typecheck` command which uses [custom ruby binary](https://github.com/sorbet/sorbet/blob/master/docs/running-compiled-code.md).
+
+Therefore, you should consider changing `raise_on_missing_types` to `false` if you use Sorbet.
+
+```ruby
+MockSuey.configure do |config|
+  config.type_check = :sorbet
+  config.raise_on_missing_types = false
+end
+```
+
 ## Mock context
 
 Mock context is a re-usable mocking/stubbing configuration. Keeping a _library of mocks_
@@ -371,6 +399,7 @@ The gem is available as open source under the terms of the [MIT License](http://
 
 [the-talk]: https://evilmartians.com/events/weaving-and-seaming-mocks
 [rbs]: https://github.com/ruby/rbs
+[sorbet]: https://github.com/sorbet/sorbet
 [fixturama]: https://github.com/nepalez/fixturama
 [bogus]: https://github.com/psyho/bogus
 [compact]: https://github.com/robwold/compact

lib/mock_suey/core.rb

@@ -4,7 +4,7 @@ module MockSuey
   class Configuration
     # No freezing this const to allow third-party libraries
     # to integrate with mock_suey
-    TYPE_CHECKERS = %w[ruby]
+    TYPE_CHECKERS = %w[ruby sorbet]
 
     attr_accessor :debug,
       :logger,

lib/mock_suey/method_call.rb

@@ -12,6 +12,8 @@ class MethodCall < Struct.new(
     :return_value,
     :has_kwargs,
     :metadata,
+    :mocked_obj,
+    :block,
     keyword_init: true
   )
     def initialize(**)

lib/mock_suey/rspec/proxy_method_invoked.rb

@@ -29,9 +29,11 @@ def proxy_method_invoked(obj, *args, &block)
         end
 
         method_call = MockSuey::MethodCall.new(
+          mocked_obj: obj,
           receiver_class:,
           method_name:,
           arguments: args,
+          block:,
           metadata: {example: ::RSpec.current_example}
         )
 

lib/mock_suey/sorbet_rspec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+# Let methods with sig receive double/instance_double arguments
+T::Configuration.call_validation_error_handler = lambda do |signature, opts|
+  is_mocked = opts[:value].is_a?(RSpec::Mocks::Double) || opts[:value].is_a?(RSpec::Mocks::VerifyingDouble)
+  unless is_mocked
+    return T::Configuration.send(:call_validation_error_handler_default, signature, opts)
+  end
+
+  # https://github.com/rspec/rspec-mocks/blob/main/lib/rspec/mocks/verifying_double.rb
+  # https://github.com/rspec/rspec-mocks/blob/v3.12.3/lib/rspec/mocks/test_double.rb
+  doubled_class = if opts[:value].is_a? RSpec::Mocks::Double
+    doubled_class_name = opts[:value].instance_variable_get :@name
+    Kernel.const_get(doubled_class_name)
+  elsif opts[:value].is_a? RSpec::Mocks::VerifyingDouble
+    opts[:value].instance_variable_get(:@doubled_module).send(:object)
+  end
+  are_related = doubled_class <= opts[:type].raw_type
+  return if are_related
+
+  return T::Configuration.send(:call_validation_error_handler_default, signature, opts)
+end

lib/mock_suey/type_checks/sorbet.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+gem "sorbet-runtime", "~> 0.5"
+require "sorbet-runtime"
+require "set"
+require "pathname"
+
+require "mock_suey/sorbet_rspec"
+require "mock_suey/ext/instance_class"
+
+module MockSuey
+  module TypeChecks
+    using Ext::InstanceClass
+
+    class Sorbet
+      RAISE_ON_MISSING_MESSAGE = "Please, set raise_on_missing_types to false to disable this error. Details: https://github.com/test-prof/mock-suey#raise_on_missing_types"
+
+      def initialize(load_dirs: [])
+        @load_dirs = Array(load_dirs)
+      end
+
+      def typecheck!(method_call, raise_on_missing: false)
+        original_method_sig = get_original_method_sig(method_call)
+        return sig_is_missing(raise_on_missing) unless original_method_sig
+
+        unbound_mocked_method = get_unbound_mocked_method(method_call)
+        override_mocked_method_to_avoid_recursion(method_call)
+
+        validate_call!(
+          instance: method_call.mocked_obj,
+          original_method: unbound_mocked_method,
+          method_sig: original_method_sig,
+          args: method_call.arguments,
+          blk: method_call.block
+        )
+      end
+
+      private
+
+      def validate_call!(instance:, original_method:, method_sig:, args:, blk:)
+        T::Private::Methods::CallValidation.validate_call(
+          instance,
+          original_method,
+          method_sig,
+          args,
+          blk
+        )
+      end
+
+      def get_unbound_mocked_method(method_call)
+        method_call.mocked_obj.method(method_call.method_name).unbind
+      end
+
+      def get_original_method_sig(method_call)
+        unbound_original_method = get_unbound_original_method(method_call)
+        T::Utils.signature_for_method(unbound_original_method)
+      end
+
+      def get_unbound_original_method(method_call)
+        method_name = method_call.method_name
+        mocked_obj = method_call.mocked_obj
+        is_a_class = mocked_obj.is_a? Class
+
+        if is_a_class
+          method_call.mocked_obj.method(method_name)
+        else
+          method_call.receiver_class.instance_method(method_name)
+        end
+      end
+
+      def sig_is_missing(raise_on_missing)
+        raise MissingSignature, RAISE_ON_MISSING_MESSAGE if raise_on_missing
+      end
+
+      def override_mocked_method_to_avoid_recursion(method_call)
+        method_name = method_call.method_name
+        mocked_obj = method_call.mocked_obj
+        return_value = method_call.return_value
+        mocked_obj.define_singleton_method(method_name) { |*args, &block| return_value }
+      end
+    end
+  end
+end

spec/cases/typed_double_sorbet_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+describe "Sorbet integration tests" do
+  context "RSpec" do
+    let(:env) { {"TYPED_SORBET" => "true"} }
+
+    it "has no affect on simple double" do
+      status, output = run_rspec("double_sorbet", env: env)
+
+      expect(status).to be_success
+      expect(output).to include("6 examples, 0 failures")
+    end
+
+    context "instance_double_sorbet" do
+      it "enhances instance_double without extensions" do
+        status, output = run_rspec("instance_double_sorbet", env: env)
+
+        expect(status).not_to be_success
+        expect(output).to include("16 examples")
+        expect(output).to include("5 failures")
+        expect(output).to include("AccountantSorbet#tax_rate_for")
+        expect(output).to include("AccountantSorbet#net_pay")
+        expect(output).to include("AccountantSorbet#tax_for")
+      end
+    end
+  end
+end

spec/fixtures/rspec/double_sorbet_fixture.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+
+require_relative "./spec_helper"
+require_relative "../shared/tax_calculator_sorbet"
+require_relative "tax_calculator_sorbet_spec"
+
+describe AccountantSorbet do
+  before do
+    allow(tax_calculator).to receive(:for_income).and_return(42)
+    allow(tax_calculator).to receive(:tax_rate_for).and_return(10.0)
+    allow(tax_calculator).to receive(:for_income).with(-10).and_return(TaxCalculator::Result.new(0))
+  end
+
+  let(:tax_calculator) { double("TaxCalculatorSorbet") }
+
+  include_examples "accountant", AccountantSorbet do
+    it "incorrect" do
+      # NOTE: in fact, sorbet-runtine also checks for type errors for ALL types
+      expect { subject.net_pay("incorrect") }.to raise_error(TypeError)
+    end
+  end
+end