dry-validation 0.13.3 → 1.7.0

data/spec/integration/localized_error_messages_spec.rb

@@ -1,72 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe Dry::Validation, 'with localized messages' do
-  before do
-    I18n.config.available_locales_set << :pl
-    I18n.load_path.concat(%w(en pl).map { |l| SPEC_ROOT.join("fixtures/locales/#{l}.yml") })
-    I18n.backend.load_translations
-  end
-
-  describe 'defining schema' do
-    context 'without a namespace' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          configure do
-            config.messages = :i18n
-          end
-
-          required(:email) { |email| email.filled? }
-        end
-      end
-
-      describe '#messages' do
-        it 'returns localized error messages' do
-          expect(schema.(email: '').messages(locale: :pl)).to eql(
-            email: ['Proszę podać adres email']
-          )
-        end
-      end
-    end
-
-    context 'with a namespace' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          configure do
-            configure do |config|
-              config.messages = :i18n
-              config.namespace = :user
-            end
-          end
-
-          required(:email) { |email| email.filled? }
-        end
-      end
-
-      describe '#messages' do
-        it 'returns localized error messages' do
-          expect(schema.(email: '').messages(locale: :pl)).to eql(
-            email: ['Hej user! Dawaj ten email no!']
-          )
-        end
-      end
-
-      describe '#errors' do
-        context 'with different locale' do
-          before do
-            I18n.locale = :pl
-          end
-
-          after do
-            I18n.locale = :en
-          end
-
-          it 'contains the localized errors' do
-            expect(schema.(email: '').errors).to eql(
-              { email: ['Hej user! Dawaj ten email no!'] }
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/message_compiler_spec.rb

@@ -1,405 +0,0 @@
-require 'dry/validation/message_compiler'
-
-RSpec.describe Dry::Validation::MessageCompiler do
-  subject(:message_compiler) { MessageCompiler.new(messages) }
-
-  include_context 'predicate helper'
-
-  let(:messages) do
-    Messages.default.merge(
-      en: {
-        errors: {
-          key?: {
-            arg: {
-              default: '+%{name}+ key is missing in the hash',
-            },
-            value: {
-              gender: 'Please provide your gender'
-            }
-          },
-          rules: {
-            address: {
-              filled?: 'Please provide your address'
-            }
-          }
-        }
-      },
-      pl: {
-        rules: {
-          email: 'adres email'
-        },
-        errors: {
-          email?: 'nie jest poprawny'
-        }
-      }
-    )
-  end
-
-  describe '#call with flat inputs' do
-    let(:ast) do
-      [
-        [:failure, [:name, p(:key?, :name)]],
-        [:failure, [:gender, p(:key?, :gender)]],
-        [:key, [:age, [:failure, [:age, p(:gt?, 18)]]]],
-        [:key, [:email, [:failure, [:email, p(:filled?, '')]]]],
-        [:key, [:address, [:failure, [:address, p(:filled?, '')]]]]
-      ]
-    end
-
-    it 'converts error ast into another format' do
-      expect(message_compiler.(ast).to_h).to eql(
-        name: ["+name+ key is missing in the hash"],
-        gender: ["Please provide your gender"],
-        age: ["must be greater than 18"],
-        email: ["must be filled"],
-        address: ["Please provide your address"]
-      )
-    end
-  end
-
-  describe '#visit with an :input node' do
-    context 'full message' do
-      it 'returns full message including rule name' do
-        msg = message_compiler.with(full: true).visit(
-          [:failure, [:num, [:key, [:num, p(:int?, '2')]]]]
-        )
-
-        expect(msg).to eql('num must be an integer')
-      end
-    end
-
-    context 'rule name translations' do
-      it 'translates rule name and its message' do
-        msg = message_compiler.with(locale: :pl, full: true).visit(
-          [:failure, [:email, [:key, [:email, p(:email?, 'oops')]]]]
-        )
-
-        expect(msg).to eql('adres email nie jest poprawny')
-      end
-    end
-
-    describe ':empty?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:tags, [:key, [:tags, p(:empty?, nil)]]]]
-        )
-
-        expect(msg).to eql('must be empty')
-      end
-    end
-
-    describe ':excluded_from?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:excluded_from?, [1, 2, 3], 2)]]]]
-        )
-
-        expect(msg).to eql('must not be one of: 1, 2, 3')
-      end
-    end
-
-    describe ':excludes?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:array, [:key, [:array, p(:excludes?, 2, [1, 2])]]]]
-        )
-
-        expect(msg).to eql('must not include 2')
-      end
-    end
-
-    describe ':included_in?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:included_in?, [1, 2, 3], :num)]]]]
-        )
-
-        expect(msg).to eql('must be one of: 1, 2, 3')
-      end
-    end
-
-    describe ':includes?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:includes?, 2, [1])]]]]
-        )
-
-        expect(msg).to eql('must include 2')
-      end
-    end
-
-    describe ':gt?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:gt?, 3, 2)]]]]
-        )
-
-        expect(msg).to eql('must be greater than 3')
-      end
-    end
-
-    describe ':gteq?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:gteq?, 3, 2)]]]]
-        )
-
-        expect(msg).to eql('must be greater than or equal to 3')
-      end
-    end
-
-    describe ':lt?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:lt?, 3, 2)]]]]
-        )
-
-        expect(msg).to eql('must be less than 3')
-      end
-    end
-
-    describe ':lteq?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:lteq?, 3, 2)]]]]
-        )
-
-        expect(msg).to eql('must be less than or equal to 3')
-      end
-    end
-
-    describe ':hash?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:address, [:key, [:address, p(:hash?, '')]]]]
-        )
-
-        expect(msg).to eql('must be a hash')
-      end
-    end
-
-    describe ':array?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:phone_numbers, [:key, [:phone, p(:array?,'')]]]]
-        )
-
-        expect(msg).to eql('must be an array')
-      end
-    end
-
-    describe ':int?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:int?, '2')]]]]
-        )
-
-        expect(msg).to eql('must be an integer')
-      end
-    end
-
-    describe ':float?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:float?, '2')]]]]
-        )
-
-        expect(msg).to eql('must be a float')
-      end
-    end
-
-    describe ':decimal?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:decimal?, '2')]]]]
-        )
-
-        expect(msg).to eql('must be a decimal')
-      end
-    end
-
-    describe ':date?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:date?, '2')]]]]
-        )
-
-        expect(msg).to eql('must be a date')
-      end
-    end
-
-    describe ':date_time?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:date_time?, '2')]]]]
-        )
-
-        expect(msg).to eql('must be a date time')
-      end
-    end
-
-    describe ':time?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:time?, '2')]]]]
-        )
-
-        expect(msg).to eql('must be a time')
-      end
-    end
-
-    describe ':max_size?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:max_size?, 3, 'abcd')]]]]
-        )
-
-        expect(msg).to eql('size cannot be greater than 3')
-      end
-    end
-
-    describe ':min_size?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:min_size?, 3, 'ab')]]]]
-        )
-
-        expect(msg).to eql('size cannot be less than 3')
-      end
-    end
-
-    describe ':none?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:none?, nil)]]]]
-        )
-
-        expect(msg).to eql('cannot be defined')
-      end
-    end
-
-    describe ':size?' do
-      it 'returns valid message when val is array and arg is int' do
-        msg = message_compiler.visit(
-          [:failure, [:numbers, [:key, [:numbers, p(:size?, 3, [1])]]]]
-        )
-
-        expect(msg).to eql('size must be 3')
-      end
-
-      it 'returns valid message when val is array and arg is range' do
-        msg = message_compiler.visit(
-          [:failure, [:numbers, [:key, [:numbers, p(:size?, 3..4, [1])]]]]
-        )
-
-        expect(msg).to eql('size must be within 3 - 4')
-      end
-
-      it 'returns valid message when arg is int' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:size?, 3, 'ab')]]]]
-        )
-
-        expect(msg).to eql('length must be 3')
-      end
-
-      it 'returns valid message when arg is range' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:size?, 3..4, 'ab')]]]]
-        )
-
-        expect(msg).to eql('length must be within 3 - 4')
-      end
-    end
-
-    describe ':str?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:str?, 3)]]]]
-        )
-
-        expect(msg).to eql('must be a string')
-      end
-    end
-
-    describe ':bool?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:num, [:key, [:num, p(:bool?, 3)]]]]
-        )
-
-        expect(msg).to eql('must be boolean')
-      end
-    end
-
-    describe ':format?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:str, [:key, [:str, p(:format?, /^F/, 'Bar')]]]]
-        )
-
-        expect(msg).to eql('is in invalid format')
-      end
-    end
-
-    describe ':number?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:str, [:key, [:str, p(:number?, 'not a number')]]]]
-        )
-
-        expect(msg).to eql('must be a number')
-      end
-    end
-
-    describe ':odd?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:str, [:key, [:str, p(:odd?, 1)]]]]
-        )
-
-        expect(msg).to eql('must be odd')
-      end
-    end
-
-    describe ':even?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:str, [:key, [:str, p(:even?, 2)]]]]
-        )
-
-        expect(msg).to eql('must be even')
-      end
-    end
-
-    describe ':eql?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:str, [:key, [:str, p(:eql?, 'Bar', 'Foo')]]]]
-        )
-
-        expect(msg).to eql('must be equal to Bar')
-      end
-    end
-
-    describe ':not_eql?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:str, [:key, [:str, p(:not_eql?, 'Foo', 'Foo')]]]]
-        )
-
-        expect(msg).to eql('must not be equal to Foo')
-      end
-    end
-
-    describe ':type?' do
-      it 'returns valid message' do
-        msg = message_compiler.visit(
-          [:failure, [:age, [:key, [:age, p(:type?, Integer, '1')]]]]
-        )
-
-        expect(msg).to eql('must be Integer')
-      end
-    end
-  end
-end

data/spec/integration/messages/i18n_spec.rb

@@ -1,104 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe Messages::I18n do
-  subject(:messages) { Messages::I18n.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") })
-    I18n.backend.load_translations
-    I18n.locale = :pl
-  end
-
-  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].text
-
-        expect(message).to eql("nie może być pusty")
-      end
-
-      it 'returns a message for a specific rule' do
-        message = messages[:filled?, rule: :email].text
-
-        expect(message).to eql("Proszę podać adres email")
-      end
-
-      it 'returns a message for a specific val type' do
-        message = messages[:size?, rule: :pages, val_type: String].text
-
-        expect(message).to eql("wielkość musi być równa \#{size}")
-      end
-
-      it 'returns a message for a specific rule and its default arg type' do
-        message = messages[:size?, rule: :pages].text
-
-        expect(message).to eql("wielkość musi być równa \#{size}")
-      end
-
-      it 'returns a message for a specific rule and its arg type' do
-        message = messages[:size?, rule: :pages, arg_type: Range].text
-
-        expect(message).to eql("wielkość musi być między \#{size_left} a \#{size_right}")
-      end
-    end
-
-    context 'rule name translations' do
-      it 'translates rule name' do
-        msg = messages.rule('email')
-
-        expect(msg).to eql('Adres email')
-      end
-    end
-
-    context 'with a different locale' do
-      it 'returns a message for a predicate' do
-        message = messages[:filled?, rule: :name, locale: :en].text
-
-        expect(message).to eql("must be filled")
-      end
-
-      it 'returns a message for a specific rule' do
-        message = messages[:filled?, rule: :email, locale: :en].text
-
-        expect(message).to eql("Please provide your email")
-      end
-
-      it 'returns a message for a specific rule and its default arg type' do
-        message = messages[:size?, rule: :pages, locale: :en].text
-
-        expect(message).to eql("size must be \#{size}")
-      end
-
-      it 'returns a message for a specific rule and its arg type' do
-        message = messages[:size?, rule: :pages, arg_type: Range, locale: :en].text
-
-        expect(message).to eql("size must be within \#{size_left} - \#{size_right}")
-      end
-    end
-
-    context 'fallbacking to I18n.default_locale with fallback backend config' do
-      before do
-        require "i18n/backend/fallbacks"
-        I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-      end
-
-      it 'returns a message for a predicate in the default_locale' do
-        pending 'FIXME: this got broken for some reason, probably an I18n issue'
-
-        message = messages[:even?, rule: :some_number].text
-
-        expect(I18n.locale).to eql(:pl)
-        expect(message).to eql("must be even")
-      end
-    end
-  end
-
-  after(:all) do
-    I18n.locale = I18n.default_locale
-  end
-end

data/spec/integration/optional_keys_spec.rb

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