dry-validation 0.13.3 → 1.3.1

data/spec/integration/hints_spec.rb

@@ -1,170 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe 'Validation hints' do
-  shared_context '#messages' do
-    it 'provides hints for additional rules that were not checked' do
-      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
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:age).maybe(:int?, gt?: 18)
-      end
-    end
-
-    include_context '#messages'
-  end
-
-  context 'with i18n messages' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure { configure { |c| c.messages = :i18n } }
-
-        required(:age).maybe(:int?, gt?: 18)
-      end
-    end
-
-    include_context '#messages'
-  end
-
-  context 'when type expectation is specified' do
-    subject(:schema)  do
-      Dry::Validation.Schema do
-        required(:email).filled
-        required(:name).filled(: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
-
-  context 'when predicate failed and there is a corresponding hint generated' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:age).value(lt?: 23)
-      end
-    end
-
-    it 'provides only failure error message' do
-      result = schema.call(age: 23)
-      expect(result.messages).to eql(age: ['must be less than 23'])
-    end
-  end
-
-  context 'with a nested schema with same rule names' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:code).filled(:str?, eql?: 'foo')
-
-        required(:nested).schema do
-          required(:code).filled(:str?, eql?: 'bar')
-        end
-      end
-    end
-
-    it 'provides error messages' do
-      result = schema.call(code: 'x', nested: { code: 'y' })
-
-      expect(result.messages).to eql(
-        code: ['must be equal to foo'],
-        nested: {
-          code: ['must be equal to bar']
-        }
-      )
-    end
-
-    it 'provides hints' do
-      result = schema.call(code: '', nested: { code: '' })
-
-      expect(result.messages).to eql(
-        code: ['must be filled', 'must be equal to foo'],
-        nested: {
-          code: ['must be filled', 'must be equal to bar']
-        }
-      )
-    end
-  end
-
-  context 'with an each rule' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:nums).each(:int?, gt?: 0)
-      end
-    end
-
-    it 'provides hints for each element' do
-      expect(schema.(nums: [1, 'foo', 0]).messages).to eql(
-        nums: {
-          1 => ['must be an integer', 'must be greater than 0'],
-          2 => ['must be greater than 0']
-        }
-      )
-    end
-  end
-
-  context 'with a format? predicate' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:name).value(size?: 2, format?: /xy/)
-      end
-    end
-
-    it 'skips hints' do
-      expect(schema.(name: 'x').messages[:name]).to_not include('is in invalid format')
-      expect(schema.(name: 'ab').messages[:name]).to include('is in invalid format')
-    end
-  end
-
-  context 'when the message uses input value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def self.messages
-            Messages.default.merge(
-              en: {
-                errors: {
-                  blue?: {
-                    failure: '%{value} is not equal to blue',
-                    hint: 'must be equal to blue'
-                  }
-                }
-              }
-            )
-          end
-
-          def blue?(value)
-            value == 'blue'
-          end
-        end
-
-        required(:pill).filled(:blue?)
-      end
-    end
-
-    it 'provides a correct failure message' do
-      expect(schema.(pill: 'red').messages).to eql(
-        pill: ['red is not equal to blue']
-      )
-    end
-
-    it 'provides a correct hint' do
-      expect(schema.(pill: nil).messages).to eql(
-        pill: ['must be filled', 'must be equal to blue']
-      )
-    end
-  end
-end

data/spec/integration/injecting_rules_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe 'Schema / Injecting Rules' do
-  subject(:schema) do
-    Dry::Validation.Schema(rules: other.class.rules) do
-      required(:email).maybe
-
-      rule(:email) { value(:login).true? > value(:email).filled? }
-    end
-  end
-
-  let(:other) do
-    Dry::Validation.Schema do
-      required(:login) { |value| value.bool? }
-    end
-  end
-
-  it 'appends rules from another schema' do
-    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
-
-  it 'keeps the original schema rules intact' do
-    expect(other.class.rules.size).to eq(1)
-
-    schema.(login: true, email: 'jane@doe')
-
-    expect(other.class.rules.size).to eq(1)
-  end
-end

data/spec/integration/json/defining_base_schema_spec.rb

@@ -1,41 +0,0 @@
-require 'dry/validation/messages/i18n'
-require 'i18n'
-
-RSpec.describe 'Defining base schema class' do
-  subject(:schema) do
-    Dry::Validation.JSON(BaseSchema) do
-      required(:email).filled(:email?)
-    end
-  end
-
-  before do
-    class BaseSchema < Dry::Validation::Schema
-      configure do |config|
-        config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
-        config.messages = :i18n
-      end
-
-      def email?(value)
-        true
-      end
-
-      define! do
-        required(:name).filled
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :BaseSchema)
-  end
-
-  it 'inherits predicates' do
-    expect(schema).to respond_to(:email?)
-  end
-
-  it 'inherits rules' do
-    expect(schema.('name' => '').messages).to eql(
-      name: ['must be filled'], email: ['is missing', 'must be an email']
-    )
-  end
-end

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