dry-validation 0.13.3 → 1.7.0

data/spec/integration/schema/predicates/type_spec.rb

@@ -1,413 +0,0 @@
-RSpec.describe 'Predicates: Type' do
-  context 'with required' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { type?(Integer) }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: 23 } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with missing input' do
-      let(:input) { {} }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['is missing', 'must be Integer']
-      end
-    end
-
-    context 'with nil input' do
-      let(:input) { { foo: nil } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-
-    context 'with blank input' do
-      let(:input) { { foo: '' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-
-    context 'with invalid type' do
-      let(:input) { { foo: [:x] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-  end
-
-  context 'with optional' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        optional(:foo) { type?(Integer) }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: 23 } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with missing input' do
-      let(:input) { {} }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with nil input' do
-      let(:input) { { foo: nil } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-
-    context 'with blank input' do
-      let(:input) { { foo: '' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-
-    context 'with invalid type' do
-      let(:input) { { foo: [:x] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-  end
-
-  context 'as macro' do
-    context 'with required' do
-      context 'with value' do
-        subject(:schema) do
-          Dry::Validation.Schema do
-            required(:foo).value(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { foo: 23 } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with missing input' do
-          let(:input) { {} }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['is missing', 'must be Integer']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { foo: nil } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { foo: '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { foo: [:x] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-
-      context 'with filled' do
-        subject(:schema) do
-          Dry::Validation.Schema do
-            required(:foo).filled(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { foo: 23 } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with missing input' do
-          let(:input) { {} }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['is missing', 'must be Integer']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { foo: nil } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'must be Integer']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { foo: '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { foo: [:x] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-
-      context 'with maybe' do
-        subject(:schema) do
-          Dry::Validation.Schema do
-            required(:foo).maybe(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { foo: 23 } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with missing input' do
-          let(:input) { {} }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['is missing', 'must be Integer']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { foo: nil } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { foo: '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { foo: [:x] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-    end
-
-    context 'with optional' do
-      context 'with value' do
-        subject(:schema) do
-          Dry::Validation.Schema do
-            optional(:foo).value(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { foo: 23 } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with missing input' do
-          let(:input) { {} }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { foo: nil } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { foo: '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { foo: [:x] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-
-      context 'with filled' do
-        subject(:schema) do
-          Dry::Validation.Schema do
-            optional(:foo).filled(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { foo: 23 } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with missing input' do
-          let(:input) { {} }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { foo: nil } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'must be Integer']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { foo: '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { foo: [:x] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-
-      context 'with maybe' do
-        subject(:schema) do
-          Dry::Validation.Schema do
-            optional(:foo).maybe(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { foo: 23 } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with missing input' do
-          let(:input) { {} }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { foo: nil } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { foo: '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { foo: [:x] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-    end
-  end
-
-  context 'with a custom class' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo).value(type?: CustomClass)
-      end
-    end
-
-    around do |example|
-      CustomClass = Class.new
-      example.run
-      Object.send(:remove_const, :CustomClass)
-    end
-
-    it 'succeeds with valid input' do
-      expect(schema.(foo: CustomClass.new)).to be_success
-    end
-
-    it 'fails with invalid input' do
-      expect(schema.(foo: 'oops')).to be_failing ["must be #{CustomClass}"]
-    end
-  end
-end

data/spec/integration/schema/reusing_schema_spec.rb

@@ -1,33 +0,0 @@
-RSpec.describe 'Reusing schemas' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:city).filled
-
-      required(:location).schema(LocationSchema)
-    end
-  end
-
-  before do
-    LocationSchema = Dry::Validation.Schema do
-      configure { config.input_processor = :params }
-
-      required(:lat).filled(:float?)
-      required(:lng).filled(:float?)
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :LocationSchema)
-  end
-
-  it 're-uses existing schema' do
-    expect(schema.(city: 'NYC', location: { lat: 1.23, lng: 45.6 })).to be_success
-
-    expect(schema.(city: 'NYC', location: { lat: nil, lng: '45.6' }).messages).to eql(
-      location: {
-        lat: ['must be filled'],
-        lng: ['must be a float']
-      }
-    )
-  end
-end

data/spec/integration/schema/using_types_spec.rb

@@ -1,135 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'defining schema using dry types' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:email).filled(Email)
-      required(:age).maybe(Age)
-      required(:country).filled(Country)
-      optional(:admin).maybe(AdminBit)
-    end
-  end
-
-  before do
-    Email = Dry::Types['strict.string']
-    Age = Dry::Types['strict.integer'].constrained(gt: 18)
-    Country = Dry::Types['strict.string'].enum('Australia', 'Poland')
-    AdminBit = Dry::Types['strict.bool']
-  end
-
-  after do
-    Object.send(:remove_const, :Email)
-    Object.send(:remove_const, :Age)
-    Object.send(:remove_const, :Country)
-    Object.send(:remove_const, :AdminBit)
-  end
-
-  it 'passes when input is valid' do
-    expect(schema.call(email: 'jane@doe', age: 19, country: 'Australia')).to be_success
-    expect(schema.call(email: 'jane@doe', age: nil, country: 'Poland')).to be_success
-  end
-
-  it 'fails when input is not valid' do
-    expect(schema.call(email: '', age: 19, country: 'New Zealand')).to_not be_success
-    expect(schema.call(email: 'jane@doe', age: 17)).to_not be_success
-    expect(schema.call(email: 'jane@doe', age: '19')).to_not be_success
-  end
-
-  it 'correctly responds to messages' do
-    expect(schema.call({}).messages).to eq(
-      age: ['is missing', 'must be Integer', 'must be greater than 18'],
-      country: ['is missing', 'must be String', 'must be one of: Australia, Poland'],
-      email: ['is missing', 'must be String']
-    )
-  end
-
-  it 'fails when sum-type rule did not pass' do
-    result = schema.call(email: 'jane@doe', age: 19, country: 'Australia', admin: 'foo')
-    expect(result.messages).to eql(
-      admin: ['must be TrueClass or must be FalseClass']
-    )
-  end
-
-  context 'custom coercions' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure { config.input_processor = :sanitizer }
-
-        required(:email).filled(Dry::Types['strict.string'].constructor(&:strip))
-      end
-    end
-
-    it 'applies custom types to input prior validation' do
-      result = schema.call(email: ' jane@doe.org  ')
-
-      expect(result).to be_success
-      expect(result.to_h).to eql(email: 'jane@doe.org')
-    end
-  end
-
-  context 'custom types' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        required(:quantity).filled(Dry::Types['strict.integer'].constrained(gt: 1))
-        required(:percentage).filled(Dry::Types['strict.decimal'].constrained(gt: 0, lt: 1))
-        required(:switch).filled(Dry::Types['strict.bool'])
-      end
-    end
-
-    it 'applies custom types to input prior validation' do
-      result = schema.call(quantity: '2', percentage: '0.5', switch: '0')
-
-      expect(result).to be_success
-      expect(result.to_h).to eql(quantity: 2, percentage: BigDecimal('0.5'), switch: false)
-    end
-  end
-
-  context 'with a nested schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:address).schema do
-          zip = Dry::Types['strict.string'].constrained(format: /\A[0-9]{5}(-[0-9]{4})?\z/)
-
-          required(:zip).filled(zip)
-        end
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(address: { zip: '12321' })).to be_success
-    end
-
-    it 'returns failure for invalid input' do
-      expect(schema.(address: { zip: '12-321' })).to be_failure
-    end
-
-    it 'returns messages for invalid input' do
-      expect(schema.(address: nil).messages).to eql(
-        address: ['must be a hash']
-      )
-    end
-
-    it 'returns error messages for invalid input' do
-      expect(schema.(address: {}).errors).to eql(
-        address: { zip: ['is missing'] }
-      )
-
-      expect(schema.(address: { zip: '12-321' }).errors).to eql(
-        address: { zip: ['is in invalid format'] }
-      )
-    end
-  end
-
-  context 'with each' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:countries).each(Country)
-      end
-    end
-
-    it 'applies type constraint checks to each element' do
-      result = schema.call(countries: %w(Poland Australia))
-
-      expect(result).to be_success
-      expect(result.to_h).to eql(countries: %w(Poland Australia))
-    end
-  end
-end

data/spec/integration/schema/validate_spec.rb

@@ -1,120 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'arbitrary validation blocks' do
-  context 'with a single value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          option :email_regex, /@/
-
-          def self.messages
-            super.merge(en: { errors: { email?: '%{value} looks like an invalid email' } })
-          end
-        end
-
-        required(:email).filled
-
-        validate(email?: :email) do |value|
-          email_regex.match(value)
-        end
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(email: 'jane@doe.org')).to be_success
-    end
-
-    it 'returns failure for invalid input' do
-      expect(schema.(email: 'jane')).to be_failure
-    end
-
-    it 'adds correct error message' do
-      expect(schema.(email: 'jane').messages).to eql(
-        email: ['jane looks like an invalid email']
-      )
-    end
-
-    it 'is not executed when deps are invalid' do
-      expect(schema.(email: nil)).to be_failure
-    end
-  end
-
-  context 'with more than one value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def self.messages
-            super.merge(en: { errors: { email_required: 'provide email' }})
-          end
-        end
-
-        required(:email).maybe(:str?)
-        required(:newsletter).value(:bool?)
-
-        validate(email_required: %i[newsletter email]) do |newsletter, email|
-          if newsletter == true
-            !email.nil?
-          else
-            true
-          end
-        end
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(newsletter: false, email: nil)).to be_success
-      expect(schema.(newsletter: true, email: 'jane@doe.org')).to be_success
-    end
-
-    it 'returns failure for invalid input' do
-      expect(schema.(newsletter: true, email: nil)).to be_failure
-    end
-
-    it 'adds correct error message' do
-      expect(schema.(newsletter: true, email: nil).errors).to eql(
-        email_required: ['provide email']
-      )
-    end
-
-    it 'is not executed when deps are invalid' do
-      expect(schema.(newsletter: 'oops', email: '').errors).to eql(
-        newsletter: ['must be boolean']
-      )
-    end
-  end
-
-  context 'with more than one validation' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          option :email_regex, /@/
-
-          def self.messages
-            super.merge(en: {
-              errors: {
-                email?:        '%{value} looks like an invalid email',
-                google_email?: '%{value} is not a google email'
-              } })
-          end
-        end
-
-        required(:email).filled
-
-        validate(email?: :email) do |value|
-          email_regex.match(value)
-        end
-
-        validate(google_email?: :email) do |value|
-          value.end_with?('@google.com')
-        end
-      end
-    end
-
-    it 'returns errors message for both validate' do
-      expect(schema.(email: 'jane').messages).to eql(
-        email: [
-          'jane looks like an invalid email',
-          'jane is not a google email'
-        ]
-      )
-    end
-  end
-end