dry-validation 0.6.0 → 0.7.0

data/spec/integration/rule_groups_spec.rb

@@ -1,94 +0,0 @@
-RSpec.describe Dry::Validation::Schema do
-  subject(:validation) { schema.new }
-
-  before do
-    def schema.messages
-      Messages.default.merge(
-        en: { errors: { password_confirmation: 'does not match' } }
-      )
-    end
-  end
-
-  describe 'defining schema with rule groups' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        confirmation(:password)
-      end
-    end
-
-    describe '#call' do
-      it 'returns empty errors when password matches confirmation' do
-        expect(validation.(password: 'foo', password_confirmation: 'foo')).to be_empty
-      end
-
-      it 'returns error for a failed group rule' do
-        expect(validation.(password: 'foo', password_confirmation: 'bar')).to match_array([
-          [:error, [
-            :input, [
-              :password_confirmation,
-              ["foo", "bar"],
-              [[:group, [:password_confirmation, [:predicate, [:eql?, []]]]]]]]
-          ]
-        ])
-      end
-
-      it 'returns messages for a failed group rule' do
-        expect(validation.(password: 'foo', password_confirmation: 'bar').messages).to eql(
-          password_confirmation: [['does not match'], ['foo', 'bar']]
-        )
-      end
-
-      it 'returns errors for the dependent predicates, not the group rule, when any of the dependent predicates fail' do
-        expect(validation.(password: '', password_confirmation: '')).to match_array([
-          [:error, [:input, [:password, "", [[:val, [:password, [:predicate, [:filled?, []]]]]]]]],
-          [:error, [:input, [:password_confirmation, "", [[:val, [:password_confirmation, [:predicate, [:filled?, []]]]]]]]]
-        ])
-      end
-    end
-
-    describe 'confirmation' do
-      shared_examples_for 'confirmation behavior' do
-        it 'applies custom rules' do
-          expect(validation.(password: 'abcd').messages).to include(
-            password: [['password size cannot be less than 6'], 'abcd']
-          )
-        end
-
-        it 'applies confirmation equality predicate' do
-          expect(validation.(password: 'abcdef', password_confirmation: 'abcd').messages).to include(
-            password_confirmation: [['does not match'], ['abcdef', 'abcd']]
-          )
-        end
-
-        it 'skips default predicate' do
-          expect(validation.(password: '', password_confirmation: '').messages).to include(
-            password: [['password size cannot be less than 6'], ''],
-            password_confirmation: [['password_confirmation must be filled'], '']
-          )
-        end
-      end
-
-      describe 'custom predicates' do
-        let(:schema) do
-          Class.new(Dry::Validation::Schema) do
-            key(:password) { |value| value.min_size?(6) }
-
-            confirmation(:password)
-          end
-        end
-
-        it_behaves_like 'confirmation behavior'
-      end
-
-      describe 'custom predicates using shortcut options' do
-        let(:schema) do
-          Class.new(Dry::Validation::Schema) do
-            confirmation(:password, min_size: 6)
-          end
-        end
-
-        it_behaves_like 'confirmation behavior'
-      end
-    end
-  end
-end

data/spec/integration/schema/attrs_spec.rb

@@ -1,38 +0,0 @@
-require 'ostruct'
-
-RSpec.describe Schema, 'defining schema with attrs' do
-  subject(:validation) { schema.new }
-
-  let(:schema) do
-    Class.new(Dry::Validation::Schema) do
-      attr(:email) { |email| email.filled? }
-
-      attr(:address) do |address|
-        address.attr(:city, &:filled?)
-        address.attr(:street, &:filled?)
-      end
-    end
-  end
-
-  describe '#call' do
-    context 'when valid input' do
-      let(:input) do
-        struct_from_hash(email: "email@test.com", address: { city: 'NYC', street: 'Street 1/2' })
-      end
-
-      it 'should be valid' do
-        expect(validation.(input)).to be_empty
-      end
-    end
-
-    context 'when input does not have proper attributes' do
-      let(:input) do
-        struct_from_hash(name: "John", address: { country: 'US', street: 'Street 1/2' })
-      end
-
-      it 'should not be valid' do
-        expect(validation.(input)).to_not be_empty
-      end
-    end
-  end
-end

data/spec/integration/schema/default_key_behavior_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe 'Schema::Form / Default key behavior' do
-  subject(:validate) { schema.new }
-
-  let(:schema) do
-    Class.new(Dry::Validation::Schema::Form) do
-      key(:name)
-      key(:age, &:int?)
-      optional(:address)
-    end
-  end
-
-  it 'applies filled? predicate by default' do
-    expect(validate.('name' => 'jane', 'age' => '21').params).to eql(
-      name: 'jane', age: 21
-    )
-  end
-
-  it 'applies filled? predicate by default to optional key' do
-    expect(validate.('name' => 'jane', 'age' => '21', 'address' => 'Earth').params).to eql(
-      name: 'jane', age: 21, address: 'Earth'
-    )
-  end
-end

data/spec/integration/schema/grouped_rules_spec.rb

@@ -1,57 +0,0 @@
-RSpec.describe Schema, 'using high-level grouped rules' do
-  subject(:validate) { schema.new }
-
-  let(:schema) do
-    Class.new(Schema) do
-      def self.messages
-        Messages.default.merge(
-          en: {
-            errors: {
-              email: {
-                absence: 'email must not be selected',
-                presence: 'email must be selected',
-                format: 'this is not an email lol',
-                inclusion: 'sorry, did not expect this lol'
-              }
-            }
-          }
-        )
-      end
-
-      key(:email) { |email| email.none? | email.filled? }
-      key(:login) { |login| login.bool? }
-
-      rule(email: :absence) do
-        value(:login).false? > value(:email).none?
-      end
-
-      rule(email: :presence) do
-        value(:login).true? > value(:email).filled?
-      end
-
-      rule(email: :format) do
-        value(:email).filled? > value(:email).format?(/[a-z]@[a-z]/)
-      end
-
-      rule(email: :inclusion) do
-        value(:email).filled? > value(:email).inclusion?(%w[jane@doe])
-      end
-    end
-  end
-
-  it 'passes when login is true and email is present' do
-    expect(validate.(login: true, email: 'jane@doe').messages).to be_empty
-  end
-
-  it 'fails when login is false and email is not present' do
-    expect(validate.(login: true, email: nil).messages).to_not be_empty
-  end
-
-  it 'provides merged error messages' do
-    expect(validate.(login: true, email: 'not-an-email-lol').messages).to eql(
-      email: [
-        ["sorry, did not expect this lol", "this is not an email lol"], nil
-      ]
-    )
-  end
-end

data/spec/integration/schema/nested_spec.rb

@@ -1,31 +0,0 @@
-RSpec.describe Schema, 'using nested schemas' do
-  subject(:validate) { schema.new }
-
-  let(:schema) do
-    Class.new(Schema) do
-      schema(:location) do |loc|
-        loc.key(:lat, &:filled?)
-        loc.key(:lng, &:filled?)
-      end
-    end
-  end
-
-  it 'passes when location has lat and lng filled' do
-    expect(validate.(location: { lat: 1.23, lng: 4.56 })).to be_empty
-  end
-
-  it 'fails when location has missing lat' do
-    expect(validate.(location: { lng: 4.56 })).to match_array([
-      [
-        :error, [
-          :input, [
-            :location, { lng: 4.56 },
-            [
-              [:input, [:lat, nil, [[:key, [:lat, [:predicate, [:key?, [:lat]]]]]]]]
-            ]
-          ]
-        ]
-      ]
-    ])
-  end
-end

data/spec/integration/schema_form_spec.rb

@@ -1,97 +0,0 @@
-RSpec.describe Dry::Validation::Schema::Form do
-  subject(:validation) { schema.new }
-
-  describe 'defining schema' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema::Form) do
-        key(:email) { |email| email.filled? }
-
-        key(:age) { |age| age.none? | (age.int? & age.gt?(18)) }
-
-        key(:address) do |address|
-          address.hash? do
-            address.key(:city, &:filled?)
-            address.key(:street, &:filled?)
-
-            address.key(:loc) do |loc|
-              loc.key(:lat) { |lat| lat.filled? & lat.float? }
-              loc.key(:lng) { |lng| lng.filled? & lng.float? }
-            end
-          end
-        end
-
-        optional(:phone_number) do |phone_number|
-          phone_number.none? | (phone_number.int? & phone_number.gt?(0))
-        end
-      end
-    end
-
-    describe '#messages' do
-      it 'returns compiled error messages' do
-        result = validation.('email' => '', 'age' => '19')
-
-        expect(result.messages).to match_array([
-          [:email, [['email must be filled'], '']],
-          [:address, [['address is missing'], nil]]
-        ])
-
-        expect(result.params).to eql(email: '', age: 19)
-      end
-    end
-
-    describe '#call' do
-      it 'passes when attributes are valid' do
-        result = validation.(
-          'email' => 'jane@doe.org',
-          'age' => '19',
-          'address' => {
-            'city' => 'NYC',
-            'street' => 'Street 1/2',
-            'loc' => { 'lat' => '123.456', 'lng' => '456.123' }
-          }
-        )
-
-        expect(result).to be_empty
-
-        expect(result.params).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
-        expect(validation.('email' => '', 'age' => '18')).to match_array([
-          [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
-          [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]],
-          [:error, [:input, [:address, nil, [[:key, [:address, [:predicate, [:key?, [:address]]]]]]]]]
-        ])
-      end
-
-      it 'handles optionals' do
-        result = validation.(
-          '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_empty
-
-        expect(result.params).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
-  end
-end