sorbet-rails 0.6.2 → 0.7.0

data/spec/boolean_string_spec.rb

@@ -1,59 +0,0 @@
-require 'rails_helper'
-require 'sorbet-rails/custom_types/boolean_string'
-require 'sorbet-runtime'
-
-RSpec.describe BooleanString do
-  shared_examples 'boolean string' do |str|
-    it 'acts as BooleanString perfectly' do
-      expect(str.is_a?(BooleanString)).to be(true)
-      expect(str.kind_of?(BooleanString)).to be(true)
-      expect(str.instance_of?(BooleanString)).to be(true)
-      expect(BooleanString === str).to be(true)
-    end
-  end
-
-  include_examples 'boolean string', 'true'
-  include_examples 'boolean string', 'false'
-  include_examples 'boolean string', 'True'
-  include_examples 'boolean string', 'False'
-
-  shared_examples 'non boolean string' do |str|
-    it 'does not acts as BooleanString' do
-      expect(str.is_a?(BooleanString)).to be(false)
-      expect(str.kind_of?(BooleanString)).to be(false)
-      expect(str.instance_of?(BooleanString)).to be(false)
-      expect(BooleanString === str).to be(false)
-    end
-  end
-
-  include_examples 'non boolean string', 'yes'
-  include_examples 'non boolean string', 'no'
-  include_examples 'non boolean string', 'alala'
-
-  context 'sorbet recognizes it at runtime' do
-    it 'lets boolean string pass runtime check' do
-      expect(T.let('true', BooleanString)).to eql('true')
-    end
-
-    it 'doesnt let normal string pass runtime typecheck' do
-      expect {
-        T.let('yes', BooleanString)
-      }.to raise_error(TypeError)
-    end
-  end
-
-  context 'using with TypeAssert' do
-    let!(:ta) { TA[BooleanString].new }
-
-    it 'lets boolean string pass runtime typecheck' do
-      expect(ta.assert('true')).to eql('true')
-    end
-
-    it 'doesnt let normal string pass runtime typecheck' do
-      expect {
-        ta.assert('yes')
-      }.to raise_error(TypeError)
-    end
-  end
-end
-

data/spec/custom_params_methods_spec.rb

@@ -1,138 +0,0 @@
-require 'rails_helper'
-
-describe ActionController::Parameters do
-  let!(:params) do
-    ActionController::Parameters.new({
-      age: 11,
-      name: 'Harry Potter',
-      info: {
-        birthday: Date.parse('1980-07-31'),
-        friends: [
-          'Hermione',
-          'Ron',
-        ],
-        grandson: nil,
-      },
-    })
-  end
-  let!(:params_info) { params.require(:info) }
-
-  context 'require_typed' do
-    it 'gets basic param correctly' do
-      val = params.require_typed(:age, TA[Integer].new)
-      expect(val).to eql(11)
-
-      val = params.require_typed(:name, TA[String].new)
-      expect(val).to eql('Harry Potter')
-    end
-
-    it 'gets param with complex type correctly' do
-      val = params.require_typed(:age, TA[T.any(String, Integer)].new)
-      expect(val).to eql(11)
-    end
-
-    it 'gets param object correctly' do
-      val = params.require_typed(:info, TA[ActionController::Parameters].new)
-      expect(val.is_a?(ActionController::Parameters))
-      expect(val).to eql(params_info)
-
-      friends = val.require_typed(:friends, TA[T::Array[String]].new)
-      expect(friends).to eql([
-        'Hermione',
-        'Ron',
-      ])
-    end
-
-    it 'raises error when param doesnt exist' do
-      expect {
-        params.require_typed(:nonexistence, TA[String].new)
-      }.to raise_error(ActionController::ParameterMissing)
-    end
-
-    it 'raises error when param is nil' do
-      expect {
-        params_info.require_typed(:grandson, TA[T::Array[String]].new)
-      }.to raise_error(ActionController::ParameterMissing)
-    end
-
-    it 'raises error when param has wrong type' do
-      expect {
-        params.require_typed(:age, TA[String].new)
-      }.to raise_error(ActionController::BadRequest)
-    end
-
-    it 'raises error when param has wrong complex type' do
-      expect {
-        params.require_typed(:age, TA[T::Array[String]].new)
-      }.to raise_error(ActionController::BadRequest)
-    end
-  end
-
-  context 'fetch_typed' do
-    it 'gets basic param correctly' do
-      val = params.fetch_typed(:age, TA[Integer].new)
-      expect(val).to eql(11)
-
-      val = params.fetch_typed(:name, TA[String].new)
-      expect(val).to eql('Harry Potter')
-    end
-
-    it 'gets param object correctly' do
-      val = params.fetch_typed(:info, TA[ActionController::Parameters].new)
-      expect(val.is_a?(ActionController::Parameters))
-      expect(val).to eql(params_info)
-
-      friends = val.fetch_typed(:friends, TA[T::Array[String]].new)
-      expect(friends).to eql([
-        'Hermione',
-        'Ron',
-      ])
-    end
-
-    it 'raises error when param doesnt exist' do
-      expect {
-        val = params.fetch_typed(:nonexistence, TA[String].new)
-      }.to raise_error(ActionController::ParameterMissing)
-    end
-
-    it 'raises error when param has wrong type' do
-      expect {
-        val = params.fetch_typed(:age, TA[String].new)
-      }.to raise_error(ActionController::BadRequest)
-    end
-
-    it 'returns nil when param is nil' do
-      grandson = params_info.fetch_typed(:grandson, TA[T.nilable(T::Array[String])].new)
-      expect(grandson).to eql(nil)
-    end
-
-    context 'when there is a default value' do
-      it 'uses default value when param is nil and has a default' do
-        fetched = params.fetch_typed(:nonexistence, TA[T::Array[String]].new, [])
-        expect(fetched).to eql([])
-      end
-
-      it 'ignores default value when there is a real value' do
-        name = params.fetch_typed(:name, TA[String].new, 'John Doe')
-        expect(name).to eql('Harry Potter')
-      end
-
-      it 'converts hash default value into a params' do
-        # this is `fetch` documented behavior
-        fetched = params.fetch_typed(
-          :nonexistence,
-          TA[ActionController::Parameters].new,
-          { unknown: "baby" },
-        )
-        expect(fetched.is_a?(ActionController::Parameters)).to be(true)
-        expect(fetched.permit(:unknown).to_h).to eql({ "unknown" => "baby" })
-      end
-
-      it 'raises error when param is nil and given a wrong default' do
-        expect {
-          fetched = params.fetch_typed(:nonexistence, TA[T::Array].new, 5)
-        }.to raise_error(ActionController::BadRequest)
-      end
-    end
-  end
-end

data/spec/integer_string_spec.rb

@@ -1,46 +0,0 @@
-require 'rails_helper'
-require 'sorbet-rails/custom_types/integer_string'
-require 'sorbet-runtime'
-
-RSpec.describe IntegerString do
-  it 'lets integer string acts as IntegerString perfectly' do
-    expect('1'.is_a?(IntegerString)).to be(true)
-    expect('12'.kind_of?(IntegerString)).to be(true)
-    expect('123'.instance_of?(IntegerString)).to be(true)
-    expect(IntegerString === '1234').to be(true)
-  end
-
-  it 'does not let other string acts as IntegerString' do
-    expect('a1'.is_a?(IntegerString)).to be(false)
-    expect('a12'.kind_of?(IntegerString)).to be(false)
-    expect('a123'.instance_of?(IntegerString)).to be(false)
-    expect(IntegerString === 'a1234').to be(false)
-  end
-
-  context 'sorbet recognizes it at runtime' do
-    it 'lets integer string pass runtime check' do
-      expect(T.let('123', IntegerString)).to eql('123')
-    end
-
-    it 'doesnt let normal string pass runtime typecheck' do
-      expect {
-        T.let('a123', IntegerString)
-      }.to raise_error(TypeError)
-    end
-  end
-
-  context 'using with TypeAssert' do
-    let!(:ta) { TA[IntegerString].new }
-
-    it 'lets integer string pass runtime typecheck' do
-      expect(ta.assert('123')).to eql('123')
-    end
-
-    it 'doesnt let normal string pass runtime typecheck' do
-      expect {
-        ta.assert('a123')
-      }.to raise_error(TypeError)
-    end
-  end
-end
-

data/spec/support/v5.0/typed-override.yaml

@@ -1,2 +0,0 @@
-true:
-- ./sorbet_test_cases.rb

data/spec/support/v5.1/typed-override.yaml

@@ -1,2 +0,0 @@
-true:
-- ./sorbet_test_cases.rb

data/spec/support/v5.2/typed-override.yaml

@@ -1,2 +0,0 @@
-true:
-- ./sorbet_test_cases.rb

data/spec/support/v6.0/typed-override.yaml

@@ -1,2 +0,0 @@
-true:
-- ./sorbet_test_cases.rb