dry-validation 0.13.3 → 1.7.0

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

@@ -1,391 +0,0 @@
-RSpec.describe 'Predicates: Type' do
-  context 'with required' do
-    subject(:schema) do
-      Dry::Validation.Params 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.Params 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.Params 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.Params 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.Params 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 successful' do
-            expect(result).to be_successful
-          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.Params 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.Params 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.Params 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 successful' do
-            expect(result).to be_successful
-          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
-end

data/spec/integration/result_spec.rb

@@ -1,81 +0,0 @@
-RSpec.describe Dry::Validation::Result do
-  subject(:result) { schema.(input) }
-
-  let(:schema) { Dry::Validation.Schema { required(:name).filled(:str?, size?: 2..4) } }
-
-  context 'with valid input' do
-    let(:input) { { name: 'Jane' } }
-
-    it 'is successful' do
-      expect(result).to be_successful
-    end
-
-    it 'is not a failure' do
-      expect(result).to_not be_failure
-    end
-
-    it 'coerces to validated hash' do
-      expect(Hash(result)).to eql(name: 'Jane')
-    end
-
-    describe '#messages' do
-      it 'returns an empty hash' do
-        expect(result.messages).to be_empty
-      end
-    end
-  end
-
-  context 'with invalid input' do
-    let(:input) { { name: '' } }
-
-    it 'is not successful' do
-      expect(result).to_not be_successful
-    end
-
-    it 'is failure' do
-      expect(result).to be_failure
-    end
-
-    it 'coerces to validated hash' do
-      expect(Hash(result)).to eql(name: '')
-    end
-
-    describe '#messages' do
-      it 'returns a hash with error messages' do
-        expect(result.messages).to eql(
-          name: ['must be filled', 'length must be within 2 - 4']
-        )
-      end
-
-      it 'with full: true returns full messages' do
-        expect(result.messages(full: true)).to eql(
-          name: ['name must be filled', 'name length must be within 2 - 4']
-        )
-      end
-    end
-
-    describe '#errors' do
-      let(:input) { { name: '' } }
-
-      it 'returns failure messages' do
-        expect(result.errors).to eql(name: ['must be filled'])
-      end
-    end
-
-    describe '#hints' do
-      let(:input) { { name: '' } }
-
-      it 'returns hint messages' do
-        expect(result.hints).to eql(name: ['length must be within 2 - 4'])
-      end
-    end
-
-    describe '#message_set' do
-      it 'returns message set' do
-        expect(result.message_set.to_h).to eql(
-          name: ['must be filled', 'length must be within 2 - 4']
-        )
-      end
-    end
-  end
-end

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