dry-validation 0.13.3 → 1.0.0.alpha1

data/spec/integration/schema/array_schema_spec.rb

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

data/spec/integration/schema/check_rules_spec.rb

@@ -1,119 +0,0 @@
-RSpec.describe Schema, 'using high-level rules' do
-  context 'composing rules' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def self.messages
-            Messages.default.merge(
-              en: { errors: { destiny: 'you must select either red or blue' } }
-            )
-          end
-        end
-
-        optional(:red).maybe
-        optional(:blue).maybe
-
-        rule(destiny: [:red, :blue]) do |red, blue|
-          red.filled? | blue.filled?
-        end
-      end
-    end
-
-    it 'passes when only red is filled' do
-      expect(schema.(red: '1')).to be_success
-    end
-
-    it 'fails when keys are missing' do
-      expect(schema.({})).to be_failure
-    end
-
-    it 'fails when red and blue are not filled ' do
-      expect(schema.(red: nil, blue: nil).messages).to eql(
-        destiny: ['you must select either red or blue']
-      )
-    end
-  end
-
-  context 'composing specific predicates' do
-    let(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def self.messages
-            Messages.default.merge(
-              en: {
-                errors: {
-                  email_presence: 'must be present when login is set to true',
-                  email_absence: 'must not be present when login is set to false'
-                }
-              }
-            )
-          end
-        end
-
-        required(:login).filled(:bool?)
-        required(:email).maybe
-
-        rule(:email_presence) { value(:login).true?.then(value(:email).filled?) }
-
-        rule(:email_absence) { value(:login).false?.then(value(:email).none?) }
-      end
-    end
-
-    it 'passes when login is false and email is nil' do
-      expect(schema.(login: false, email: nil)).to be_success
-    end
-
-    it 'fails when login is false and email is present' do
-      expect(schema.(login: false, email: 'jane@doe').messages).to eql(
-        email_absence: ['must not be present when login is set to false']
-      )
-    end
-
-    it 'passes when login is true and email is present' do
-      expect(schema.(login: true, email: 'jane@doe')).to be_success
-    end
-
-    it 'fails when login is true and email is not present' do
-      expect(schema.(login: true, email: nil).messages).to eql(
-        email_presence: ['must be present when login is set to true']
-      )
-    end
-  end
-
-  describe 'with nested schemas' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:command).filled(:str?, included_in?: %w(First Second))
-
-        required(:args).filled(:hash?)
-
-        rule(first_args: [:command, :args]) do |command, args|
-          command.eql?('First')
-            .then(args.schema { required(:first).filled(:bool?) })
-        end
-
-        rule(second_args: [:command, :args]) do |command, args|
-          command.eql?('Second')
-            .then(args.schema { required(:second).filled(:bool?) })
-        end
-      end
-    end
-
-    it 'generates check rule matching on value' do
-      expect(schema.(command: 'First', args: { first: true })).to be_success
-      expect(schema.(command: 'Second', args: { second: true })).to be_success
-
-      expect(schema.(command: 'oops', args: { such: 'validation' }).messages).to eql(
-        command: ['must be one of: First, Second']
-      )
-
-      expect(schema.(command: 'First', args: { second: true }).messages).to eql(
-        args: { first: ['is missing'] }
-      )
-
-      expect(schema.(command: 'Second', args: { first: true }).messages).to eql(
-        args: { second: ['is missing'] }
-      )
-    end
-  end
-end

data/spec/integration/schema/check_with_nested_el_spec.rb

@@ -1,37 +0,0 @@
-RSpec.describe 'Check depending on a nested value from a hash' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:tag).schema do
-        required(:color).schema do
-          required(:value).filled(:str?)
-        end
-      end
-
-      rule(tag: [[:tag, :color, :value]]) do |value|
-        value.eql?('red')
-      end
-    end
-  end
-
-  it 'passes when check passes' do
-    expect(schema.(tag: { color: { value: 'red' }})).to be_success
-  end
-
-  it 'skips check when parent of the dependency failed' do
-    expect(schema.(tag: { color: :oops }).messages).to eql(
-      tag: { color: ['must be a hash'] }
-    )
-  end
-
-  it 'skips check when dependency failed' do
-    expect(schema.(tag: { color: { value: :oops }}).messages).to eql(
-      tag: { color: { value: ['must be a string'] } }
-    )
-  end
-
-  it 'fails when check fails' do
-    expect(schema.(tag: { color: { value: 'blue' }}).messages).to eql(
-      tag: { color: { value: ['must be equal to red'] } }
-    )
-  end
-end

data/spec/integration/schema/check_with_nth_el_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe 'Check depending on nth element in an array' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:tags).each(:str?)
-
-      rule(tags: [[:tags, 0]]) do |value|
-        value.eql?('red')
-      end
-    end
-  end
-
-  it 'skips check when dependency failed' do
-    expect(schema.(tags: 'oops')).to be_failure
-  end
-
-  it 'passes when check passes' do
-    expect(schema.(tags: %w(red green blue))).to be_success
-  end
-
-  it 'fails when check fails' do
-    expect(schema.(tags: %w(blue green red)).messages).to eql(
-      tags: { 0 => ["must be equal to red"] }
-    )
-  end
-end

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