dry-validation 0.5.0 → 0.6.0

data/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.5.0'.freeze
+    VERSION = '0.6.0'.freeze
   end
 end

data/spec/integration/error_compiler_spec.rb

@@ -9,6 +9,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
       en: {
         errors: {
           key?: '+%{name}+ key is missing in the hash',
+          attr?: 'Object does not respond to the +%{name}+ attr',
           rules: {
             address: {
               filled?: 'Please provide your address'
@@ -23,6 +24,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
     let(:ast) do
       [
         [:error, [:input, [:name, nil, [[:key, [:name, [:predicate, [:key?, []]]]]]]]],
+        [:error, [:input, [:phone, nil, [[:attr, [:phone, [:predicate, [:attr?, []]]]]]]]],
         [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
         [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]],
         [:error, [:input, [:address, "", [[:val, [:address, [:predicate, [:filled?, []]]]]]]]]
@@ -32,6 +34,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
     it 'converts error ast into another format' do
       expect(error_compiler.(ast)).to eql(
         name: [["+name+ key is missing in the hash"], nil],
+        phone: [["Object does not respond to the +phone+ attr"], nil],
         age: [["age must be greater than 18"], 18],
         email: [["email must be filled"], ''],
         address: [["Please provide your address"], '']

data/spec/integration/injecting_rules_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe 'Schema / Injecting Rules' do
+  let(:validate) { schema.new(other.rules) }
+
+  let(:other) do
+    Class.new(Dry::Validation::Schema) do
+      key(:login) { |value| value.bool? }
+    end
+  end
+
+  let(:schema) do
+    Class.new(Dry::Validation::Schema) do
+      key(:email) { |email| email.none? | email.filled? }
+
+      rule(email: :filled?) { value(:login).true? > value(:email).filled? }
+    end
+  end
+
+  it 'appends rules from another schema' do
+    expect(validate.(login: true, email: 'jane@doe')).to be_empty
+    expect(validate.(login: false, email: nil)).to be_empty
+    expect(validate.(login: true, email: nil)).to_not be_empty
+  end
+end

data/spec/integration/rule_groups_spec.rb

@@ -1,6 +1,14 @@
 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
@@ -24,6 +32,12 @@ RSpec.describe Dry::Validation::Schema do
         ])
       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?, []]]]]]]]],
@@ -31,5 +45,50 @@ RSpec.describe Dry::Validation::Schema do
         ])
       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

@@ -0,0 +1,38 @@
+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/check_rules_spec.rb

@@ -1,28 +1,74 @@
-RSpec.describe Schema, 'using generic rules' do
+RSpec.describe Schema, 'using high-level rules' do
   subject(:validate) { schema.new }
 
-  let(:schema) do
-    Class.new(Schema) do
-      def self.messages
-        Messages.default.merge(
-          en: { errors: { destiny: 'you must select either red or blue' } }
-        )
+  context 'composing rules' do
+    let(:schema) do
+      Class.new(Schema) do
+        def self.messages
+          Messages.default.merge(
+            en: { errors: { destiny: 'you must select either red or blue' } }
+          )
+        end
+
+        optional(:red, &:filled?)
+        optional(:blue, &:filled?)
+
+        rule(:destiny) { rule(:red) | rule(:blue) }
       end
+    end
 
-      optional(:red, &:filled?)
-      optional(:blue, &:filled?)
+    it 'passes when only red is filled' do
+      expect(validate.(red: '1')).to be_empty
+    end
 
-      rule(:destiny) { rule(:red) | rule(:blue) }
+    it 'fails when red and blue are not filled ' do
+      expect(validate.(red: '', blue: '').messages[:destiny]).to eql(
+        [['you must select either red or blue'], '']
+      )
     end
   end
 
-  it 'passes when only red is filled' do
-    expect(validate.(red: '1')).to be_empty
-  end
+  context 'composing specific predicates' do
+    let(:schema) do
+      Class.new(Schema) do
+        def self.messages
+          Messages.default.merge(
+            en: {
+              errors: {
+                email_presence: 'email must be present when login is set to true',
+                email_absence: 'email must not be present when login is set to false'
+              }
+            }
+          )
+        end
 
-  it 'fails when red and blue are not filled ' do
-    expect(validate.(red: '', blue: '').messages[:destiny]).to eql(
-      [['you must select either red or blue'], '']
-    )
+        key(:login) { |login| login.bool? }
+        key(:email) { |email| email.none? | email.filled? }
+
+        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(validate.(login: false, email: nil)).to be_empty
+    end
+
+    it 'fails when login is false and email is present' do
+      expect(validate.(login: false, email: 'jane@doe').messages[:email_absence]).to eql(
+        [['email must not be present when login is set to false'], nil]
+      )
+    end
+
+    it 'passes when login is true and email is present' do
+      expect(validate.(login: true, email: 'jane@doe')).to be_empty
+    end
+
+    it 'fails when login is true and email is not present' do
+      expect(validate.(login: true, email: nil).messages[:email_presence]).to eql(
+        [['email must be present when login is set to true'], nil]
+      )
+    end
   end
 end

data/spec/integration/schema/default_key_behavior_spec.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,57 @@
+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_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Dry::Validation::Schema do
   subject(:validation) { schema.new }
 
-  describe 'defining schema' do
+  describe 'defining key-based schema (hash-like)' do
     let(:schema) do
       Class.new(Dry::Validation::Schema) do
         key(:email) { |email| email.filled? }
@@ -33,7 +33,7 @@ RSpec.describe Dry::Validation::Schema do
       end
     end
 
-    let(:attrs) do
+    let(:input) do
       {
         email: 'jane@doe.org',
         age: 19,
@@ -46,7 +46,7 @@ RSpec.describe Dry::Validation::Schema do
 
     describe '#messages' do
       it 'returns compiled error messages' do
-        expect(validation.(attrs.merge(email: '')).messages).to match_array([
+        expect(validation.(input.merge(email: '')).messages).to match_array([
           [:email, [['email must be filled'], '']]
         ])
       end
@@ -54,18 +54,18 @@ RSpec.describe Dry::Validation::Schema do
 
     describe '#call' do
       it 'passes when attributes are valid' do
-        expect(validation.(attrs)).to be_empty
+        expect(validation.(input)).to be_empty
       end
 
       it 'validates presence of an email and min age value' do
-        expect(validation.(attrs.merge(email: '', age: 18))).to match_array([
+        expect(validation.(input.merge(email: '', age: 18))).to match_array([
           [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
           [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]]
         ])
       end
 
       it 'validates presence of the email key and type of age value' do
-        expect(validation.(name: 'Jane', age: '18', address: attrs[:address], phone_numbers: attrs[:phone_numbers])).to match_array([
+        expect(validation.(name: 'Jane', age: '18', address: input[:address], phone_numbers: input[:phone_numbers])).to match_array([
           [:error, [:input, [:age, "18", [[:val, [:age, [:predicate, [:int?, []]]]]]]]],
           [:error, [:input, [:email, nil, [[:key, [:email, [:predicate, [:key?, [:email]]]]]]]]]
         ])
@@ -79,7 +79,7 @@ RSpec.describe Dry::Validation::Schema do
       end
 
       it 'validates presence of keys under address and min size of the city value' do
-        expect(validation.(attrs.merge(address: { city: 'NY' }))).to match_array([
+        expect(validation.(input.merge(address: { city: 'NY' }))).to match_array([
           [:error, [
             :input, [
               :address, {city: "NY"},
@@ -94,13 +94,13 @@ RSpec.describe Dry::Validation::Schema do
       end
 
       it 'validates address type' do
-        expect(validation.(attrs.merge(address: 'totally not a hash'))).to match_array([
+        expect(validation.(input.merge(address: 'totally not a hash'))).to match_array([
           [:error, [:input, [:address, "totally not a hash", [[:val, [:address, [:predicate, [:hash?, []]]]]]]]]
         ])
       end
 
       it 'validates address code and name values' do
-        expect(validation.(attrs.merge(address: attrs[:address].merge(country: { code: 'US', name: '' })))).to match_array([
+        expect(validation.(input.merge(address: input[:address].merge(country: { code: 'US', name: '' })))).to match_array([
           [:error, [
             :input, [
               :address, {city: "NYC", street: "Street 1/2", country: {code: "US", name: ""}},
@@ -123,7 +123,7 @@ RSpec.describe Dry::Validation::Schema do
       end
 
       it 'validates each phone number' do
-        expect(validation.(attrs.merge(phone_numbers: ['123', 312]))).to match_array([
+        expect(validation.(input.merge(phone_numbers: ['123', 312]))).to match_array([
           [:error, [
             :input, [
               :phone_numbers, ["123", 312],
@@ -142,4 +142,169 @@ RSpec.describe Dry::Validation::Schema do
       end
     end
   end
+
+  describe 'defining attr-based schema (model-like)' do
+    let(:schema) do
+      Class.new(Dry::Validation::Schema) do
+        attr(:email) { |email| email.filled? }
+
+        attr(:age) do |age|
+          age.none? | (age.int? & age.gt?(18))
+        end
+
+        attr(:address) do |address|
+          address.attr(:city) do |city|
+            city.min_size?(3)
+          end
+
+          address.attr(:street) do |street|
+            street.filled?
+          end
+
+          address.attr(:country) do |country|
+            country.attr(:name, &:filled?)
+            country.attr(:code, &:filled?)
+          end
+        end
+
+        attr(:phone_numbers) do |phone_numbers|
+          phone_numbers.array? { phone_numbers.each(&:str?) }
+        end
+      end
+    end
+
+    let(:input_data) do
+      {
+        email: 'jane@doe.org',
+        age: 19,
+        address: { city: 'NYC', street: 'Street 1/2', country: { code: 'US', name: 'USA' } },
+        phone_numbers: [
+          '123456', '234567'
+        ]
+      }.freeze
+    end
+
+    def input(data = input_data)
+      struct_from_hash(data)
+    end
+
+    describe '#messages' do
+      it 'returns compiled error messages' do
+        expect(validation.(input(input_data.merge(email: ''))).messages).to match_array([
+          [:email, [["email must be filled"], '']]
+        ])
+      end
+    end
+
+    describe '#call' do
+      it 'passes when attributes are valid' do
+        expect(validation.(input)).to be_empty
+      end
+
+      it 'validates presence of an email and min age value' do
+        expect(validation.(input(input_data.merge(email: '', age: 18)))).to match_array([
+          [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
+          [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]]
+        ])
+      end
+
+      it 'validates presence of the email attr and type of age value' do
+        input_object = input(input_data.reject { |k, v| k == :email }.merge(age: '18'))
+
+        expect(validation.(input_object)).to match_array([
+          [:error, [:input, [:age, "18", [[:val, [:age, [:predicate, [:int?, []]]]]]]]],
+          [:error, [:input, [:email, input_object, [[:attr, [:email, [:predicate, [:attr?, [:email]]]]]]]]]
+        ])
+      end
+
+      it 'validates presence of the address and phone_number keys' do
+        input_object = input(email: 'jane@doe.org', age: 19)
+
+        expect(validation.(input_object)).to match_array([
+          [:error, [
+            :input, [
+              :address, input_object,
+              [
+                [:attr, [:address, [:predicate, [:attr?, [:address]]]]]
+              ]
+            ]
+          ]],
+          [:error, [
+            :input, [
+              :phone_numbers, input_object,
+              [
+                [:attr, [:phone_numbers, [:predicate, [:attr?, [:phone_numbers]]]]]
+              ]
+            ]
+          ]]
+        ])
+      end
+
+      it 'validates presence of keys under address and min size of the city value' do
+        address = { city: 'NY' }
+        input_object = input(input_data.merge(address: address))
+        address_object = input_object.address.class.from_hash(address)
+
+        expect(validation.(input_object)).to match_array([
+          [:error, [
+            :input, [
+              :address, address_object,
+              [
+                [:input, [:city, "NY", [[:val, [:city, [:predicate, [:min_size?, [3]]]]]]]],
+                [:input, [:street, address_object, [[:attr, [:street, [:predicate, [:attr?, [:street]]]]]]]],
+                [:input, [:country, address_object, [[:attr, [:country, [:predicate, [:attr?, [:country]]]]]]]]
+              ]
+            ]
+          ]]
+        ])
+      end
+
+      it 'validates address code and name values' do
+        input_object = input(input_data.merge(address: input_data[:address].merge(country: { code: 'US', name: '' })))
+
+        country_object = input_object.address.country.class.from_hash(code: "US", name: "")
+
+        expect(validation.(input_object)).to match_array([
+          [:error, [
+            :input, [
+              :address, input_object.address.class.from_hash(city: "NYC", street: "Street 1/2", country: country_object),
+              [
+                [
+                  :input, [
+                    :country, country_object, [
+                      [
+                        :input, [
+                          :name, "", [[:val, [:name, [:predicate, [:filled?, []]]]]]
+                        ]
+                      ]
+                    ]
+                  ]
+                ]
+              ]
+            ]
+          ]]
+        ])
+      end
+
+      it 'validates each phone number' do
+        input_object = input(input_data.merge(phone_numbers: ['123', 312]))
+
+        expect(validation.(input_object)).to match_array([
+          [:error, [
+            :input, [
+              :phone_numbers, ["123", 312],[
+                [
+                  :input, [
+                    :phone_numbers, 312, [
+                      [:val, [:phone_numbers, [:predicate, [:str?, []]]]]
+                    ]
+                  ]
+                ]
+              ]
+            ]
+          ]]
+        ])
+      end
+    end
+  end
 end