dry-validation 0.6.0 → 0.7.0

data/spec/integration/schema/form_spec.rb

@@ -0,0 +1,122 @@
+RSpec.describe Dry::Validation::Schema::Form, 'defining a schema' do
+  subject(:schema) do
+    Dry::Validation.Form do
+      key(:email).required
+
+      key(:age).maybe(:int?, gt?: 18)
+
+      key(:address).schema do
+        key(:city).required
+        key(:street).required
+
+        key(:loc) do
+          hash? do
+            key(:lat).required(:float?)
+            key(:lng).required(:float?)
+          end
+        end
+      end
+
+      optional(:password).maybe.confirmation
+
+      optional(:phone_number).maybe(:int?, gt?: 0)
+
+      rule(:email_valid) { value(:email).email? }
+
+      configure do
+        def email?(value)
+          true
+        end
+      end
+    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
+end

data/spec/integration/schema/inheriting_schema_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe 'Inheriting schema' do
+  subject(:schema) do
+    Dry::Validation.Schema(base_schema) do
+      key(:location).schema do
+        key(:lat).required(:float?)
+        key(:lng).required(:float?)
+      end
+    end
+  end
+
+  let(:base_schema) do
+    Dry::Validation.Schema do
+      key(:city).required
+    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

@@ -0,0 +1,46 @@
+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
+
+      key(:email).required
+
+      key(:age).maybe(:int?, gt?: 18)
+
+      key(:address).schema do
+        key(:city).required
+        key(:street).required
+      end
+
+      key(:phone_numbers).each do
+        key(:prefix).required
+        key(:value).required
+      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

data/spec/integration/schema/macros/confirmation_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe 'Macros #confirmation' do
+  describe 'with a maybe password with min-size specified' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        configure do
+          def self.messages
+            Messages.default.merge(
+              en: { errors: { password_confirmation: 'does not match' } }
+            )
+          end
+        end
+
+        key(:password).maybe(min_size?: 3).confirmation
+      end
+    end
+
+    it 'passes when values are equal' do
+      expect(schema.(password: 'foo', password_confirmation: 'foo')).to be_success
+    end
+
+    it 'fails when source value is invalid' do
+      expect(schema.(password: 'fo', password_confirmation: '').messages).to eql(
+        password: ['size cannot be less than 3']
+      )
+    end
+
+    it 'fails when values are not equal' do
+      expect(schema.(password: 'foo', password_confirmation: 'fo').messages).to eql(
+        password_confirmation: ['does not match']
+      )
+    end
+  end
+end

data/spec/integration/schema/macros/maybe_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe 'Macros #maybe' do
+  describe 'with no args' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:email).maybe
+      end
+    end
+
+    it 'generates none? | filled? rule' do
+      expect(schema.(email: nil).messages).to be_empty
+      expect(schema.(email: 'jane@doe').messages).to be_empty
+    end
+  end
+
+  describe 'with a predicate with args' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:name).maybe(min_size?: 3)
+      end
+    end
+
+    it 'generates none? | (filled? & min_size?) rule' do
+      expect(schema.(name: nil).messages).to be_empty
+
+      expect(schema.(name: 'jane').messages).to be_empty
+
+      expect(schema.(name: 'xy').messages).to eql(
+        name: ['size cannot be less than 3']
+      )
+    end
+  end
+end

data/spec/integration/schema/macros/required_spec.rb

@@ -0,0 +1,59 @@
+RSpec.describe 'Macros #required' do
+  describe 'with no args' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:email).required
+      end
+    end
+
+    it 'generates filled? rule' do
+      expect(schema.(email: '').messages).to eql(
+        email: ['must be filled']
+      )
+    end
+  end
+
+  describe 'with a type specification' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:age).required(:int?)
+      end
+    end
+
+    it 'generates filled? & int? rule' do
+      expect(schema.(age: nil).messages).to eql(
+        age: ['must be filled']
+      )
+    end
+  end
+
+  describe 'with a predicate with args' do
+    context 'with a flat arg' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          key(:age).required(:int?, gt?: 18)
+        end
+      end
+
+      it 'generates filled? & int? & gt? rule' do
+        expect(schema.(age: nil).messages).to eql(
+          age: ['must be filled', 'must be greater than 18']
+        )
+      end
+    end
+
+    context 'with a range arg' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          key(:age).required(:int?, size?: 18..24)
+        end
+      end
+
+      it 'generates filled? & int? & gt? rule' do
+        expect(schema.(age: nil).messages).to eql(
+          age: ['must be filled', 'size must be within 18 - 24']
+        )
+      end
+    end
+  end
+end

data/spec/integration/schema/macros/when_spec.rb

@@ -0,0 +1,65 @@
+RSpec.describe 'Macros #when' do
+  context 'with a result rule returned from the block' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:email).maybe
+
+        key(:login).required.when(:true?) do
+          value(:email).filled?
+        end
+      end
+    end
+
+    it 'generates check rule' do
+      expect(schema.(login: true, email: nil).messages).to eql(
+        email: ['must be filled']
+      )
+
+      expect(schema.(login: false, email: nil).messages).to be_empty
+    end
+  end
+
+  describe 'with a result rule depending on another result' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:left).maybe(:int?)
+        key(:right).maybe(:int?)
+
+        key(:compare).maybe(:bool?).when(:true?) do
+          value(:left).gt?(value(:right))
+        end
+      end
+    end
+
+    it 'generates check rule' do
+      expect(schema.(compare: false, left: nil, right: nil)).to be_success
+
+      expect(schema.(compare: true, left: 1, right: 2).messages).to eql(
+        left: ['must be greater than 2']
+      )
+    end
+  end
+
+  describe 'with multiple result rules' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:email).maybe
+        key(:password).maybe
+
+        key(:login).maybe(:bool?).when(:true?) do
+          value(:email).filled?
+          value(:password).filled?
+        end
+      end
+    end
+
+    it 'generates check rule' do
+      expect(schema.(login: false, email: nil, password: nil)).to be_success
+
+      expect(schema.(login: true, email: nil, password: nil).messages).to eql(
+        email: ['must be filled'],
+        password: ['must be filled']
+      )
+    end
+  end
+end

data/spec/integration/schema/nested_values_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe Schema, 'using nested values' do
+  let(:schema) do
+    Dry::Validation.Schema do
+      key(:email).maybe
+
+      key(:settings) do
+        optional(:offers).required(:bool?).when(:true?) do
+          value([:settings, :newsletter]).false?
+        end
+
+        key(:newsletter).required(:bool?).when(:true?) do
+          value(:email).filled?
+        end
+      end
+    end
+  end
+
+  it 'passes when newsletter setting is false' do
+    expect(schema.(settings: { newsletter: false }, email: nil)).to be_success
+  end
+
+  it 'passes when newsletter setting is true and email is filled' do
+    expect(schema.(settings: { newsletter: false }, email: 'jane@doe')).to be_success
+  end
+
+  it 'passes when offers is false and newsletter is true' do
+    expect(schema.(settings: { offers: false, newsletter: true }, email: 'jane@doe')).to be_success
+  end
+
+  it 'fails when newsletter is true and email is not filled' do
+    expect(schema.(settings: { newsletter: true }, email: nil).messages).to eql(
+      email: ['must be filled']
+    )
+  end
+
+  it 'fails when offers is true and newsletter is true' do
+    expect(schema.(settings: { offers: true, newsletter: true }, email: 'jane@doe').messages).to eql(
+      settings: { newsletter: ['must be false'] }
+    )
+  end
+end

data/spec/integration/schema/not_spec.rb

@@ -1,34 +1,34 @@
 RSpec.describe 'Schema with negated rules' do
-  subject(:validate) { schema.new }
-
-  let(:schema) do
-    Class.new(Dry::Validation::Schema) do
-      def self.messages
-        Messages.default.merge(
-          en: { errors: { be_reasonable: 'you cannot eat cake and have cake!' } }
-        )
+  subject(:schema) do
+    Dry::Validation.Schema do
+      configure do
+        def self.messages
+          Messages.default.merge(
+            en: { errors: { be_reasonable: 'you cannot eat cake and have cake!' } }
+          )
+        end
       end
 
-      optional(:eat_cake) { |v| v.eql?('yes!') }
-      optional(:have_cake) { |v| v.eql?('yes!') }
+      optional(:eat_cake).required
+      optional(:have_cake).required
 
       rule(:be_reasonable) do
-        rule(:eat_cake) & rule(:have_cake).not
+        value(:eat_cake).eql?('yes!') & value(:have_cake).eql?('yes!').not
       end
     end
   end
 
   describe '#messages' do
     it 'passes when only one option is selected' do
-      messages = validate.(eat_cake: 'yes!', have_cake: 'no!').messages[:be_reasonable]
+      messages = schema.(eat_cake: 'yes!', have_cake: 'no!').messages[:be_reasonable]
 
       expect(messages).to be(nil)
     end
 
     it 'fails when both options are selected' do
-      messages = validate.(eat_cake: 'yes!', have_cake: 'yes!').messages[:be_reasonable]
+      messages = schema.(eat_cake: 'yes!', have_cake: 'yes!').messages[:be_reasonable]
 
-      expect(messages).to eql([['you cannot eat cake and have cake!'], 'yes!'])
+      expect(messages).to eql(['you cannot eat cake and have cake!'])
     end
   end
 end