samuelgiles/rspec-sorbet

A small gem consisting of helpers for using Sorbet & RSpec together.

RSpec Sorbet

A small gem consisting of helpers for using Sorbet & RSpec together.

Install

gem 'rspec-sorbet'

Usage

In your spec_helper.rb you need to first add a require:

require 'rspec/sorbet'

Allowing Instance/Class/Object Doubles

Out of the box if you're using instance_double, class_double or object_double in your specs you'll encounter errors such as the following:

 TypeError:
       Parameter 'my_parameter': Expected type MyObject, got type RSpec::Mocks::InstanceVerifyingDouble with value #<InstanceDouble(MyObject) (anonymous)>
       Caller: /Users/samuelgiles/Documents/Projects/Clients/Bellroy/bellroy/spec/lib/checkout/use_cases/my_use_case.rb:9

Drop the following into your spec_helper.rb to allow doubles to be used without breaking type checking:

RSpec::Sorbet.allow_doubles!

eq matcher usage with T::Struct's

Using the eq matcher to compare T::Struct's might not behave as you'd expect whereby two separate instances of the same struct class with identical attributes are not == out of the box. The standalone sorbet-struct-comparable gem may be of interest if you are looking for a simple attribute based comparison that will help make the eq matcher behave as you expect.

Specifying a custom validation handler

You can customise the handler of Sorbet validation errors if you so desire.

def handler(signature, opts)
  raise MyCustomException, "The options were #{opts}"
end

T::Configuration.call_validation_error_handler = handler

rspec-sorbet's Issues

Exhaustiveness checking fails with doubles

For example code like this:

sig {params(x: T.any(A, B, C)).void}
def foo(x)
  case x
  when A
    do_a(x)
  when B
    do_b(x)
  else
    T.absurd(x)
  end
end

If a test does something like this:

let(:fake_a) { instance_double(A) }
it 'probably does not explode' do
  foo(fake_a)
end

It will hit the T.absurd, resulting in an error like this:

     TypeError:
       Control flow reached T.absurd. Got value: #[InstanceDouble(A) (anonymous)]

I'm not sure there is any way to get around this given the way the case statement works but I figured it couldn't hurt to report in case someone had an idea 😄

Method `eq` does not exist on <describe ...>

Not sure if the above error falls in the scope of rspec-sorbet, but I have a simple test case:

describe Direction do
  it ".values contain all 4 basic directions" do
    expected = [
      Direction::N,
      Direction::E,
      Direction::S,
      Direction::W,
    ]
    expect(Direction.values).to eq(expected)
  end
end

And srb tc keeps failing with the error:

Method eq does not exist on <describe 'Direction'> https://srb.help/7003
    14 |    expect(Direction.values).to eq(expected)

Here's my spec_helper.rb file:

require 'sorbet-runtime'
require 'rspec/sorbet'

My question is whether rspec-sorbet is supposed to help resolve this issue? Or is it normal to get this error? Maybe I'll be better off disabling type-checking for my tests, but it'll be a bit sad to do so. Any help will be appreciated.

Best practices when using "let"

We use let quite often in our tests. eg

let(:foo) { SomeBar.new }

I can well imagine that would require quite some work to add type checking for (resolving at the access line). Just in case I have missed something obvious, does rspec-sorbet have anything that could help here? Is it planned, or do you have any guidance as to what we should do?

nilable class_of double not supported

Hello 👋 I found an instance where the INLINE_DOUBLE_REGEX doesn't quite work.

If a method consumes a T.nilable(T.class_of(Class)), and you pass a class_double(Class) to it, you will get an error.

here's a minimum example:

RSpec::Sorbet.allow_doubles!

describe 'nilable class_double' do
  class TestClass; end
  class MyClass
    extend T::Sig

    sig { params(arg: T.nilable(T.class_of(TestClass))).void }
    def do_test(arg); end
  end
  let(:test_class_double) { class_double(TestClass) }

  it 'accepts the double' do
    expect { MyClass.new.do_test(TestClass) }.not_to raise_error # works
    expect { MyClass.new.do_test(test_class_double) }.not_to raise_error # fails
  end
end

i imagine it's a case of just updated the regex to accept an inner T.class_of 🤔 but it's a pretty complicated regex

Uninitialized constant Namespace::MyModel::PrivateRelationWhereChain

Hello. When I run my RSpec tests, this error arises. I'm not sure why, but Sorbet detects this successfully. There are no runtime errors that occur as well.

I'm not sure how I would test this whenever I use ActiveRecord relationships.

sig { returns(NotificationScheduler::Queuer::App::PrivateRelationWhereChain)

The error comes from above. However, this is defined in a Sorbet RBI in DSL. Please let me know if there is a solution to this problem. Sorbet doesn't complain and returns no errors, but when I run my RSpec, the error occurs as in title.