dry-validation 0.13.3 → 1.7.0

data/spec/integration/schema/default_settings_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'default settings' do
-  subject(:schema) do
-    Dry::Validation.Schema(build: false) do
-      required(:name).filled
-    end
-  end
-
-  it 'uses :yaml messages by default' do
-    expect(schema.config.messages).to be(:yaml)
-  end
-end

data/spec/integration/schema/defining_base_schema_spec.rb

@@ -1,41 +0,0 @@
-require 'dry/validation/messages/i18n'
-require 'i18n'
-
-RSpec.describe 'Defining base schema class' do
-  subject(:schema) do
-    Dry::Validation.Schema(BaseSchema) do
-      required(:email).filled(:email?)
-    end
-  end
-
-  before do
-    class BaseSchema < Dry::Validation::Schema
-      configure do |config|
-        config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
-        config.messages = :i18n
-      end
-
-      def email?(value)
-        true
-      end
-
-      define! do
-        required(:name).filled
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :BaseSchema)
-  end
-
-  it 'inherits predicates' do
-    expect(schema).to respond_to(:email?)
-  end
-
-  it 'inherits rules' do
-    expect(schema.(name: nil).messages).to eql(
-      name: ['must be filled'], email: ['is missing', 'must be an email']
-    )
-  end
-end

data/spec/integration/schema/dynamic_predicate_args_spec.rb

@@ -1,43 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'dynamic predicate args' do
-  context 'with base rules' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def data
-            %w(a b c)
-          end
-        end
-
-        required(:letter).filled(included_in?: data)
-      end
-    end
-
-    it 'evaluates predicate arguments' do
-      expect(schema.(letter: 'a')).to be_success
-      expect(schema.(letter: 'f')).to be_failure
-    end
-  end
-
-  context 'with high-level rules' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def data
-            %w(a b c)
-          end
-        end
-
-        required(:letter).filled(:str?)
-
-        rule(valid_letter: [:letter]) do |letter|
-          letter.included_in?(data)
-        end
-      end
-    end
-
-    it 'evaluates predicate arguments' do
-      expect(schema.(letter: 'a')).to be_success
-      expect(schema.(letter: 'f')).to be_failure
-    end
-  end
-end

data/spec/integration/schema/each_with_set_spec.rb

@@ -1,70 +0,0 @@
-RSpec.describe 'Schema with each and set rules' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:payments).each do
-        required(:method).filled(:str?)
-        required(:amount).filled(:float?)
-      end
-    end
-  end
-
-  describe '#messages' do
-    it 'validates using all rules' do
-      expect(schema.(payments: [{}]).messages).to eql(
-        { payments: {
-          0 => { method: ['is missing'], amount: ['is missing'] }
-        }}
-      )
-    end
-
-    it 'validates each payment against its set of rules' do
-      input = {
-        payments: [
-          { method: 'cc', amount: 1.23 },
-          { method: 'wire', amount: 4.56 }
-        ]
-      }
-
-      expect(schema.(input).messages).to eql({})
-    end
-
-    it 'validates presence of the method key for each payment' do
-      input = {
-        payments: [
-          { method: 'cc', amount: 1.23 },
-          { amount: 4.56 }
-        ]
-      }
-
-      expect(schema.(input).messages).to eql(
-        payments: { 1 => { method: ['is missing'] } }
-      )
-    end
-
-    it 'validates type of the method value for each payment' do
-      input = {
-        payments: [
-          { method: 'cc', amount: 1.23 },
-          { method: 12, amount: 4.56 }
-        ]
-      }
-
-      expect(schema.(input).messages).to eql(
-        payments: { 1 => { method: ['must be a string'] } }
-      )
-    end
-
-    it 'validates type of the amount value for each payment' do
-      input = {
-        payments: [
-          { method: 'cc', amount: 1.23 },
-          { method: 'wire', amount: '4.56' }
-        ]
-      }
-
-      expect(schema.(input).messages).to eql(
-        payments: { 1 => { amount: ['must be a float'] } }
-      )
-    end
-  end
-end

data/spec/integration/schema/extending_dsl_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe 'Extending DSL' do
-  it 'allows configuring custom DSL methods' do
-    dsl_ext = Module.new do
-      def maybe_int(name, *predicates, &block)
-        required(name, [:nil, :integer]).maybe(:int?, *predicates, &block)
-      end
-    end
-
-    Dry::Validation::Schema.configure do |config|
-      config.dsl_extensions = dsl_ext
-    end
-
-    schema = Dry::Validation.Schema do
-      configure do
-        config.input_processor = :params
-        config.type_specs = true
-      end
-
-      maybe_int(:age)
-    end
-
-    expect(schema.(age: nil)).to be_success
-    expect(schema.(age: 1)).to be_success
-    expect(schema.(age: '1')).to be_success
-    expect(schema.(age: 'foo').messages).to eql(age: ['must be an integer'])
-  end
-end

data/spec/integration/schema/form_spec.rb

@@ -1,236 +0,0 @@
-RSpec.describe 'Dry::Validation::Schema::Form', 'defining a schema' do
-  before(:all) { require 'dry/validation/compat/form' }
-
-  subject(:schema) do
-    Dry::Validation.Form do
-      configure do
-        def email?(value)
-          true
-        end
-      end
-
-      required(:email).filled
-
-      required(:age).maybe(:int?, gt?: 18)
-
-      required(:address).schema do
-        required(:city).filled
-        required(:street).filled
-
-        required(:loc).schema do
-          required(:lat).filled(:float?)
-          required(:lng).filled(:float?)
-        end
-      end
-
-      optional(:password).maybe.confirmation
-
-      optional(:phone_number).maybe(:int?, gt?: 0)
-
-      rule(:email_valid) { value(:email).email? }
-    end
-  end
-
-  describe '#messages' do
-    it 'returns compiled error messages' do
-      result = schema.('email' => '', 'age' => '19')
-
-      expect(result.messages).to eql(
-        email: ['must be filled'],
-        address: ['is missing']
-      )
-
-      expect(result.output).to eql(email: '', age: 19)
-    end
-
-    it 'returns hints for nested data' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'age' => '19',
-        'address' => {
-          'city' => '',
-          'street' => 'Street 1/2',
-          'loc' => { 'lat' => '123.456', 'lng' => '' }
-        }
-      )
-
-      expect(result.messages).to eql(
-        address: {
-          loc: { lng: ['must be filled'] },
-          city: ['must be filled']
-        }
-      )
-    end
-  end
-
-  describe '#call' do
-    it 'passes when attributes are valid' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'age' => '19',
-        'address' => {
-          'city' => 'NYC',
-          'street' => 'Street 1/2',
-          'loc' => { 'lat' => '123.456', 'lng' => '456.123' }
-        }
-      )
-
-      expect(result).to be_success
-
-      expect(result.output).to eql(
-        email: 'jane@doe.org', age: 19,
-        address: {
-          city: 'NYC', street: 'Street 1/2',
-          loc: { lat: 123.456, lng: 456.123 }
-        }
-      )
-    end
-
-    it 'validates presence of an email and min age value' do
-      result = schema.('email' => '', 'age' => '18')
-
-      expect(result.messages).to eql(
-        address: ['is missing'],
-        age: ['must be greater than 18'],
-        email: ['must be filled']
-      )
-    end
-
-    it 'handles optionals' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'age' => '19',
-        'phone_number' => '12',
-        'address' => {
-          'city' => 'NYC',
-          'street' => 'Street 1/2',
-          'loc' => { 'lat' => '123.456', 'lng' => '456.123' }
-        }
-      )
-
-      expect(result).to be_success
-
-      expect(result.output).to eql(
-        email: 'jane@doe.org', age: 19, phone_number: 12,
-        address: {
-          city: 'NYC', street: 'Street 1/2',
-          loc: { lat: 123.456, lng: 456.123 }
-        }
-      )
-    end
-  end
-
-  describe 'with an each and nested schema' do
-    subject(:schema) do
-      Dry::Validation.Form do
-        required(:items).each do
-          schema do
-            required(:title).filled(:str?)
-          end
-        end
-      end
-    end
-
-    it 'passes when each element passes schema check' do
-      expect(schema.(items: [{ title: 'Foo' }])).to be_success
-    end
-
-    it 'fails when one or more elements did not pass schema check' do
-      expect(schema.(items: [{ title: 'Foo' }, { title: :Foo }]).messages).to eql(
-        items: { 1 => { title: ['must be a string'] } }
-      )
-    end
-  end
-
-  describe 'symbolizing keys when coercion fails' do
-    subject(:schema) do
-      Dry::Validation.Form do
-        required(:email).value(size?: 8..60)
-        required(:birthdate).value(:date?)
-        required(:age).value(:int?, gt?: 23)
-        required(:tags).maybe(max_size?: 3)
-      end
-    end
-
-    let(:tags) { %(al b c) }
-
-    it 'symbolizes keys and coerces values' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'birthdate' => '2001-02-03',
-        'age' => '24',
-        'tags' => tags
-      ).to_h
-
-      expect(result.to_h).to eql(
-        email: 'jane@doe.org',
-        birthdate: Date.new(2001, 2, 3),
-        age: 24,
-        tags: tags
-      )
-    end
-
-    it 'symbolizes keys even when coercion fails' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'birthdate' => '2001-sutin-03',
-        'age' => ['oops'],
-        'tags' => nil
-      )
-
-      expect(result.to_h).to eql(
-        email: 'jane@doe.org',
-        birthdate: '2001-sutin-03',
-        age: ['oops'],
-        tags: nil
-      )
-
-      expect(result.messages).to eql(
-        birthdate: ['must be a date'],
-        age: ['must be an integer', 'must be greater than 23']
-      )
-    end
-  end
-
-  describe 'with nested schema in a high-level rule' do
-    subject(:schema) do
-      Dry::Validation.Form do
-        required(:address).maybe(:hash?)
-
-        required(:delivery).filled(:bool?)
-
-        rule(address: [:delivery, :address]) do |delivery, address|
-          delivery.true?.then(address.schema(AddressSchema))
-        end
-      end
-    end
-
-    before do
-      AddressSchema = Dry::Validation.Form do
-        required(:city).filled
-        required(:zipcode).filled(:int?)
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :AddressSchema)
-    end
-
-    it 'succeeds when nested form schema succeeds' do
-      result = schema.(delivery: '1', address: { city: 'NYC', zipcode: '123' })
-      expect(result).to be_success
-    end
-
-    it 'does not apply schema when there is no match' do
-      result = schema.(delivery: '0', address: nil)
-      expect(result).to be_success
-    end
-
-    it 'fails when nested schema fails' do
-      result = schema.(delivery: '1', address: { city: 'NYC', zipcode: 'foo' })
-      expect(result.messages).to eql(
-        address: { zipcode: ['must be an integer'] }
-      )
-    end
-  end
-end

data/spec/integration/schema/hash_schema_spec.rb

@@ -1,47 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'for a hash' do
-  context 'without type specs' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        hash? do
-          required(:prefix).filled
-          required(:value).filled
-        end
-      end
-    end
-
-    it 'applies its rules to array input' do
-      result = schema.(prefix: 1, value: 123)
-
-      expect(result).to be_success
-
-      result = schema.(prefix: 1, value: nil)
-
-      expect(result.messages).to eql(value: ["must be filled"])
-    end
-  end
-
-  context 'with type specs' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-
-        hash? do
-          required(:prefix, :integer).filled
-          required(:value, :integer).filled
-        end
-      end
-    end
-
-    it 'applies its rules to coerced array input' do
-      result = schema.(prefix: 1, value: '123')
-
-      expect(result).to be_success
-
-      expect(result.output).to eql(prefix: 1, value: 123)
-
-      result = schema.(prefix: 1, value: nil)
-
-      expect(result.messages).to eql(value: ["must be filled"])
-    end
-  end
-end

data/spec/integration/schema/inheriting_schema_spec.rb

@@ -1,31 +0,0 @@
-RSpec.describe 'Inheriting schema' do
-  subject(:schema) do
-    Dry::Validation.Schema(base_schema) do
-      required(:location).schema do
-        required(:lat).filled(:float?)
-        required(:lng).filled(:float?)
-      end
-    end
-  end
-
-  let(:base_schema) do
-    Dry::Validation.Schema do
-      required(:city).filled
-    end
-  end
-
-  it 'inherits rules from parent schema' do
-    expect(schema.(city: 'NYC', location: { lat: 1.23, lng: 45.6 })).to be_success
-
-    expect(schema.(city: '', location: { lat: 1.23, lng: 45.6 }).messages).to eql(
-      city: ['must be filled']
-    )
-
-    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/input_processor_spec.rb

@@ -1,46 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'setting input processor in schema' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      configure do
-        config.input_processor = :sanitizer
-      end
-
-      required(:email).filled
-
-      required(:age).maybe(:int?, gt?: 18)
-
-      required(:address).schema do
-        required(:city).filled
-        required(:street).filled
-      end
-
-      required(:phone_numbers).each do
-        required(:prefix).filled
-        required(:value).filled
-      end
-    end
-  end
-
-  it 'rejects unspecified keys' do
-    result = schema.(
-      email: 'jane@doe',
-      age: 19,
-      such: 'key',
-      address: { city: 'NYC', street: 'Street', wow: 'bad' },
-      phone_numbers: [
-        { prefix: '48', value: '123' },
-        { lol: '!!', prefix: '1', value: '312' }
-      ]
-    )
-
-    expect(result.output).to eql(
-      email: 'jane@doe',
-      age: 19,
-      address: { city: 'NYC', street: 'Street' },
-      phone_numbers: [
-        { prefix: '48', value: '123' },
-        { prefix: '1', value: '312' }
-      ]
-    )
-  end
-end