dry-validation 0.6.0 → 0.7.0

data/spec/integration/hints_spec.rb

@@ -1,19 +1,23 @@
 require 'dry/validation/messages/i18n'
 
 RSpec.describe 'Validation hints' do
-  subject(:validation) { schema.new }
-
   shared_context '#messages' do
     it 'provides hints for additional rules that were not checked' do
-      expect(validation.(age: '17').messages).to eql(
-        age: [['age must be an integer', 'age must be greater than 18'], '17']
+      expect(schema.(age: '17').messages).to eql(
+        age: ['must be an integer', 'must be greater than 18']
+      )
+    end
+
+    it 'skips type-check rules' do
+      expect(schema.(age: 17).messages).to eql(
+        age: ['must be greater than 18']
       )
     end
   end
 
   context 'with yaml messages' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
+    subject(:schema) do
+      Dry::Validation.Schema do
         key(:age) do |age|
           age.none? | (age.int? & age.gt?(18))
         end
@@ -24,9 +28,9 @@ RSpec.describe 'Validation hints' do
   end
 
   context 'with i18n messages' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        configure { |c| c.messages = :i18n }
+    subject(:schema) do
+      Dry::Validation.Schema do
+        configure { configure { |c| c.messages = :i18n } }
 
         key(:age) do |age|
           age.none? | (age.int? & age.gt?(18))
@@ -36,4 +40,19 @@ RSpec.describe 'Validation hints' do
 
     include_context '#messages'
   end
+
+  context 'when type expectation is specified' do
+    subject(:schema)  do
+      Dry::Validation.Schema do
+        key(:email).required
+        key(:name).required(:str?, size?: 5..25)
+      end
+    end
+
+    it 'infers message for specific type' do
+      expect(schema.(email: 'jane@doe', name: 'HN').messages).to eql(
+        name: ['length must be within 5 - 25']
+      )
+    end
+  end
 end

data/spec/integration/injecting_rules_spec.rb

@@ -1,23 +1,22 @@
 RSpec.describe 'Schema / Injecting Rules' do
-  let(:validate) { schema.new(other.rules) }
+  subject(:schema) do
+    Dry::Validation.Schema(rules: other.class.rules) do
+      key(:email).maybe
 
-  let(:other) do
-    Class.new(Dry::Validation::Schema) do
-      key(:login) { |value| value.bool? }
+      rule(:email) { value(:login).true? > value(:email).filled? }
     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? }
+  let(:other) do
+    Dry::Validation.Schema do
+      key(:login) { |value| value.bool? }
     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
+    expect(schema.(login: true, email: 'jane@doe')).to be_success
+    expect(schema.(login: false, email: nil)).to be_success
+    expect(schema.(login: true, email: nil)).to_not be_success
+    expect(schema.(login: nil, email: 'jane@doe')).to_not be_success
   end
 end

data/spec/integration/localized_error_messages_spec.rb

@@ -1,8 +1,6 @@
 require 'dry/validation/messages/i18n'
 
 RSpec.describe Dry::Validation, 'with localized messages' do
-  subject(:validation) { schema.new }
-
   before do
     I18n.config.available_locales_set << :pl
     I18n.load_path.concat(%w(en pl).map { |l| SPEC_ROOT.join("fixtures/locales/#{l}.yml") })
@@ -11,9 +9,9 @@ RSpec.describe Dry::Validation, 'with localized messages' do
 
   describe 'defining schema' do
     context 'without a namespace' do
-      let(:schema) do
-        Class.new(Dry::Validation::Schema) do
-          configure do |config|
+      subject(:schema) do
+        Dry::Validation.Schema do
+          configure do
             config.messages = :i18n
           end
 
@@ -23,19 +21,21 @@ RSpec.describe Dry::Validation, 'with localized messages' do
 
       describe '#messages' do
         it 'returns localized error messages' do
-          expect(validation.(email: '').messages(locale: :pl)).to match_array([
-            [:email, [['Proszę podać adres email'], '']]
-          ])
+          expect(schema.(email: '').messages(locale: :pl)).to eql(
+            email: ['Proszę podać adres email']
+          )
         end
       end
     end
 
     context 'with a namespace' do
-      let(:schema) do
-        Class.new(Dry::Validation::Schema) do
-          configure do |config|
-            config.messages = :i18n
-            config.namespace = :user
+      subject(:schema) do
+        Dry::Validation.Schema do
+          configure do
+            configure do |config|
+              config.messages = :i18n
+              config.namespace = :user
+            end
           end
 
           key(:email) { |email| email.filled? }
@@ -44,9 +44,9 @@ RSpec.describe Dry::Validation, 'with localized messages' do
 
       describe '#messages' do
         it 'returns localized error messages' do
-          expect(validation.(email: '').messages(locale: :pl)).to match_array([
-            [:email, [['Hej user! Dawaj ten email no!'], '']]
-          ])
+          expect(schema.(email: '').messages(locale: :pl)).to eql(
+            email: ['Hej user! Dawaj ten email no!']
+          )
         end
       end
     end

data/spec/integration/messages/i18n_spec.rb

@@ -11,10 +11,14 @@ RSpec.describe Messages::I18n do
 
   describe '#[]' do
     context 'with the default locale' do
+      it 'returns nil when message is not defined' do
+        expect(messages[:not_here, rule: :srsly]).to be(nil)
+      end
+
       it 'returns a message for a predicate' do
         message = messages[:filled?, rule: :name]
 
-        expect(message).to eql("%{name} must be filled")
+        expect(message).to eql("must be filled")
       end
 
       it 'returns a message for a specific rule' do
@@ -26,19 +30,19 @@ RSpec.describe Messages::I18n do
       it 'returns a message for a specific val type' do
         message = messages[:size?, rule: :pages, val_type: String]
 
-        expect(message).to eql("%{name} length must be %{num}")
+        expect(message).to eql("length must be %{num}")
       end
 
       it 'returns a message for a specific rule and its default arg type' do
         message = messages[:size?, rule: :pages]
 
-        expect(message).to eql("%{name} size must be %{num}")
+        expect(message).to eql("size must be %{num}")
       end
 
       it 'returns a message for a specific rule and its arg type' do
         message = messages[:size?, rule: :pages, arg_type: Range]
 
-        expect(message).to eql("%{name} size must be within %{left} - %{right}")
+        expect(message).to eql("size must be within %{left} - %{right}")
       end
     end
 
@@ -46,7 +50,7 @@ RSpec.describe Messages::I18n do
       it 'returns a message for a predicate' do
         message = messages[:filled?, rule: :name, locale: :pl]
 
-        expect(message).to eql("%{name} nie może być pusty")
+        expect(message).to eql("nie może być pusty")
       end
 
       it 'returns a message for a specific rule' do

data/spec/integration/optional_keys_spec.rb

@@ -1,17 +1,15 @@
 RSpec.describe Dry::Validation::Schema do
-  subject(:validation) { schema.new }
-
   describe 'defining schema with optional keys' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
+    subject(:schema) do
+      Dry::Validation.Schema do
         optional(:email) { |email| email.filled? }
 
-        key(:address) do |address|
-          address.key(:city, &:filled?)
-          address.key(:street, &:filled?)
+        key(:address) do
+          key(:city, &:filled?)
+          key(:street, &:filled?)
 
-          address.optional(:phone_number) do |phone_number|
-            phone_number.none? | phone_number.str?
+          optional(:phone_number) do
+            none? | str?
           end
         end
       end
@@ -19,11 +17,11 @@ RSpec.describe Dry::Validation::Schema do
 
     describe '#call' do
       it 'skips rules when key is not present' do
-        expect(validation.(address: { city: 'NYC', street: 'Street 1/2' })).to be_empty
+        expect(schema.(address: { city: 'NYC', street: 'Street 1/2' })).to be_success
       end
 
       it 'applies rules when key is present' do
-        expect(validation.(email: '')).to_not be_empty
+        expect(schema.(email: '')).to_not be_success
       end
     end
   end

data/spec/integration/schema/array_schema_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Dry::Validation::Schema, 'for an array' do
+  subject(:schema) do
+    Dry::Validation.Schema do
+      each do
+        key(:prefix).required
+        key(:value).required
+      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

data/spec/integration/schema/check_rules_spec.rb

@@ -1,49 +1,57 @@
 RSpec.describe Schema, 'using high-level rules' do
-  subject(:validate) { schema.new }
-
   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' } }
-          )
+    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, &:filled?)
-        optional(:blue, &:filled?)
+        optional(:red).maybe
+        optional(:blue).maybe
 
-        rule(:destiny) { rule(:red) | rule(:blue) }
+        rule(destiny: [:red, :blue]) do |red, blue|
+          red.filled? | blue.filled?
+        end
       end
     end
 
     it 'passes when only red is filled' do
-      expect(validate.(red: '1')).to be_empty
+      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(validate.(red: '', blue: '').messages[:destiny]).to eql(
-        [['you must select either red or blue'], '']
+      expect(schema.(red: nil, blue: nil).messages[:destiny]).to eql(
+        ['you must select either red or blue']
       )
     end
   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'
+      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
 
-        key(:login) { |login| login.bool? }
-        key(:email) { |email| email.none? | email.filled? }
+        key(:login).required(:bool?)
+        key(:email).maybe
 
         rule(:email_presence) { value(:login).true?.then(value(:email).filled?) }
 
@@ -52,22 +60,22 @@ RSpec.describe Schema, 'using high-level rules' do
     end
 
     it 'passes when login is false and email is nil' do
-      expect(validate.(login: false, email: nil)).to be_empty
+      expect(schema.(login: false, email: nil)).to be_success
     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]
+      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(validate.(login: true, email: 'jane@doe')).to be_empty
+      expect(schema.(login: true, email: 'jane@doe')).to be_success
     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]
+      expect(schema.(login: true, email: nil).messages).to eql(
+        email_presence: ['must be present when login is set to true']
       )
     end
   end

data/spec/integration/schema/check_with_nth_el_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe 'Check depending on nth element in an array' do
+  subject(:schema) do
+    Dry::Validation.Schema do
+      key(:tags).each(:str?)
+
+      rule(red: [[: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/each_with_set_spec.rb

@@ -1,20 +1,22 @@
 RSpec.describe 'Schema with each and set rules' do
-  subject(:validation) { schema.new }
-
-  let(:schema) do
-    Class.new(Dry::Validation::Schema) do
-      key(:payments) do |payments|
-        payments.array? do
-          payments.each do |payment|
-            payment.key(:method, &:str?)
-            payment.key(:amount, &:float?)
-          end
-        end
+  subject(:schema) do
+    Dry::Validation.Schema do
+      key(:payments).each do
+        key(:method).required(:str?)
+        key(:amount).required(: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: [
@@ -23,7 +25,7 @@ RSpec.describe 'Schema with each and set rules' do
         ]
       }
 
-      expect(validation.(input).messages).to eql({})
+      expect(schema.(input).messages).to eql({})
     end
 
     it 'validates presence of the method key for each payment' do
@@ -34,10 +36,9 @@ RSpec.describe 'Schema with each and set rules' do
         ]
       }
 
-      expect(validation.(input).messages[:payments]).to eql([
-        [payments: [[method: [["method is missing"], nil]], input[:payments][1]]],
-        input[:payments]
-      ])
+      expect(schema.(input).messages).to eql(
+        payments: { 1 => { method: ['is missing'] } }
+      )
     end
 
     it 'validates type of the method value for each payment' do
@@ -48,10 +49,9 @@ RSpec.describe 'Schema with each and set rules' do
         ]
       }
 
-      expect(validation.(input).messages[:payments]).to eql([
-        [payments: [[method: [["method must be a string"], 12]], input[:payments][1]]],
-        input[:payments]
-      ])
+      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
@@ -62,10 +62,9 @@ RSpec.describe 'Schema with each and set rules' do
         ]
       }
 
-      expect(validation.(input).messages[:payments]).to eql([
-        [payments: [[amount: [["amount must be a float"], '4.56']], input[:payments][1]]],
-        input[:payments]
-      ])
+      expect(schema.(input).messages).to eql(
+        payments: { 1 => { amount: ['must be a float'] } }
+      )
     end
   end
 end