dry-validation 0.13.3 → 1.7.0

data/spec/integration/schema/nested_schemas_spec.rb

@@ -1,236 +0,0 @@
-RSpec.describe Schema, 'nested schemas' do
-  context 'with multiple nested schemas' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:content).schema do
-          required(:meta).schema do
-            required(:version).filled
-          end
-
-          required(:data).schema do
-            required(:city).filled
-          end
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      input = {content: {meta: {version: "1.0"}, data: {city: "Canberra"}}}
-      expect(schema.(input)).to be_success
-    end
-
-    it 'fails when one sub-key is missing' do
-      input = {content: {data: {city: "Canberra"}}}
-      expect(schema.(input).messages).to eql(content: {meta: ['is missing']})
-    end
-
-    it 'fails when both sub-keys are missing' do
-      input = {content: {}}
-      expect(schema.(input).messages).to eql(content: {meta: ['is missing'], data: ['is missing']})
-    end
-
-    it 'fails when the deeply nested keys are invalid' do
-      input = {content: {meta: {version: ""}, data: {city: ""}}}
-      expect(schema.(input).messages).to eql(content: {meta: {version: ["must be filled"]}, data: {city: ["must be filled"]}})
-    end
-  end
-
-  context 'with a 2-level deep schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:meta).schema do
-          required(:info).schema do
-            required(:details).filled
-            required(:meta).filled
-          end
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(meta: { info: { details: 'Krakow', meta: 'foo' }})).to be_success
-    end
-
-    it 'fails when root key is missing' do
-      expect(schema.({}).messages).to eql(meta: ['is missing'])
-    end
-
-    it 'fails when 1-level key is missing' do
-      expect(schema.(meta: {}).messages).to eql(
-        meta: { info: ['is missing'] }
-      )
-    end
-
-    it 'fails when 2-level key is missing' do
-      expect(schema.(meta: { info: {} }).messages).to eql(
-        meta: { info: { details: ['is missing'], meta: ['is missing'] } }
-      )
-    end
-
-    it 'fails when 1-level key has invalid value' do
-      expect(schema.(meta: { info: nil, meta: 'foo' }).messages).to eql(
-        meta: { info: ['must be a hash'] }
-      )
-    end
-
-    it 'fails when 2-level key has invalid value' do
-      expect(schema.(meta: { info: { details: nil, meta: 'foo' } }).messages).to eql(
-        meta: { info: { details: ['must be filled'] } }
-      )
-    end
-  end
-
-  context 'when duplicated key names are used in 2 subsequent levels' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:meta).schema do
-          required(:meta).filled
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(meta: { meta: 'data' })).to be_success
-    end
-
-    it 'fails when root key is missing' do
-      expect(schema.({}).messages).to eql(meta: ['is missing'])
-    end
-
-    it 'fails when 1-level key is missing' do
-      expect(schema.(meta: {}).messages).to eql(meta: { meta: ['is missing'] })
-    end
-
-    it 'fails when 1-level key value is invalid' do
-      expect(schema.(meta: { meta: '' }).messages).to eql(
-        meta: { meta: ['must be filled'] }
-      )
-    end
-  end
-
-  context 'when duplicated key names are used in 2 subsequent levels as schemas' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:meta).schema do
-          required(:meta).schema do
-            required(:data).filled
-          end
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(meta: { meta: { data: 'this is fine' } })).to be_success
-    end
-
-    it 'fails when root key is missing' do
-      expect(schema.({}).messages).to eql(meta: ['is missing'])
-    end
-
-    it 'fails when 1-level key is missing' do
-      expect(schema.(meta: {}).messages).to eql(meta: { meta: ['is missing'] })
-    end
-
-    it 'fails when 1-level key value is invalid' do
-      expect(schema.(meta: { meta: '' }).messages).to eql(
-        meta: { meta: ['must be a hash'] }
-      )
-    end
-
-    it 'fails when 2-level key is missing' do
-      expect(schema.(meta: { meta: {} }).messages).to eql(
-        meta: { meta: { data: ['is missing'] } }
-      )
-    end
-
-    it 'fails when 2-level key value is invalid' do
-      expect(schema.(meta: { meta: { data: '' } }).messages).to eql(
-        meta: { meta: { data: ['must be filled'] } }
-      )
-    end
-  end
-
-  context 'with `each` + schema inside another schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:meta).schema do
-          required(:data).each do
-            schema do
-              required(:info).schema do
-                required(:name).filled
-              end
-            end
-          end
-        end
-      end
-    end
-
-    it 'passes when data is valid' do
-      expect(schema.(meta: { data: [{ info: { name: 'oh hai' } }] })).to be_success
-    end
-
-    it 'fails when root key is missing' do
-      expect(schema.({}).messages).to eql(meta: ['is missing'])
-    end
-
-    it 'fails when root key value is invalid' do
-      expect(schema.(meta: '').messages).to eql(meta: ['must be a hash'])
-    end
-
-    it 'fails when 1-level key is missing' do
-      expect(schema.(meta: {}).messages).to eql(meta: { data: ['is missing'] })
-    end
-
-    it 'fails when 1-level key has invalid value' do
-      expect(schema.(meta: { data: '' }).messages).to eql(meta: { data: ['must be an array'] })
-    end
-
-    it 'fails when 1-level key has value with a missing key' do
-      expect(schema.(meta: { data: [{}] }).messages).to eql(
-        meta: { data: { 0 => { info: ['is missing'] } } }
-      )
-    end
-
-    it 'fails when 1-level key has value with an incorrect type' do
-      expect(schema.(meta: { data: [{ info: ''}] }).messages).to eql(
-        meta: { data: { 0 => { info: ['must be a hash'] } } }
-      )
-    end
-
-    it 'fails when 1-level key has value with a key with an invalid value' do
-      expect(schema.(meta: { data: [{ info: { name: '' } }] }).messages).to eql(
-        meta: { data: { 0 => { info: { name: ['must be filled'] } } } }
-      )
-    end
-  end
-
-  context 'with 2-level `each` + schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:data).each do
-          schema do
-            required(:tags).each do
-              required(:name).filled
-            end
-          end
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(data: [{ tags: [{ name: 'red' }, { name: 'blue' }] }])).to be_success
-    end
-
-    it 'fails when 1-level element is not valid' do
-      expect(schema.(data: [{}]).messages).to eql(
-        data: { 0 => { tags: ['is missing'] } }
-      )
-    end
-
-    it 'fails when 2-level element is not valid' do
-      expect(schema.(data: [{ tags: [{ name: 'red' }, { name: '' }] }]).messages).to eql(
-        data: { 0 => { tags: { 1 => { name: ['must be filled'] } } } }
-      )
-    end
-  end
-end

data/spec/integration/schema/nested_values_spec.rb

@@ -1,46 +0,0 @@
-RSpec.describe Schema, 'using nested values' do
-  let(:schema) do
-    Dry::Validation.Schema do
-      required(:email).maybe
-
-      required(:settings).schema do
-        optional(:offers).filled(:bool?)
-        required(:newsletter).filled(:bool?)
-      end
-
-      rule(newsletter: [[:settings, :newsletter], [:settings, :offers]]) do |newsletter, offers|
-        offers.true?.then(newsletter.false?)
-      end
-
-      rule(email: [[:settings, :newsletter], :email]) do |newsletter, email|
-        newsletter.true?.then(email.filled?)
-      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
-    input = { settings: { offers: true, newsletter: true }, email: 'jane@doe' }
-
-    expect(schema.(input).messages).to eql(
-      settings: { newsletter: ['must be false'] }
-    )
-  end
-end

data/spec/integration/schema/not_spec.rb

@@ -1,34 +0,0 @@
-RSpec.describe 'Schema with negated rules' do
-  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).filled
-      optional(:have_cake).filled
-
-      rule(:be_reasonable) do
-        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 = 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 = schema.(eat_cake: 'yes!', have_cake: 'yes!').messages[:be_reasonable]
-
-      expect(messages).to eql(['you cannot eat cake and have cake!'])
-    end
-  end
-end

data/spec/integration/schema/numbers_spec.rb

@@ -1,19 +0,0 @@
-RSpec.describe Dry::Validation::Schema do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:age).filled(:number?, :int?)
-    end
-  end
-
-  it 'passes when value is a number and an int' do
-    expect(schema.(age: 132)).to be_success
-  end
-
-  it 'fails when value is not a number' do
-    expect(schema.(age: 'ops').messages).to eql(age: ['must be a number'])
-  end
-
-  it 'fails when value is not an integer' do
-    expect(schema.(age: 1.0).messages).to eql(age: ['must be an integer'])
-  end
-end

data/spec/integration/schema/option_with_default_spec.rb

@@ -1,64 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'defining schema context with option API' do
-  shared_context 'valid schema with :db option' do
-    before do
-      DB = [{ email: 'jane@doe' }]
-    end
-
-    after do
-      Object.send(:remove_const, :DB)
-    end
-
-    it 'uses external dependency set by option with a default value' do
-      expect(schema.db).to be(DB)
-
-      expect(schema.(email: 'jade@doe', contact: { email: 'jade2@doe' })).to be_success
-      expect(schema.(email: 'jane@doe', contact: { email: 'jane2@doe' })).to be_failure
-      expect(schema.(email: 'jade@doe', contact: { email: 'jane@doe' })).to be_failure
-    end
-  end
-
-
-  context 'with a default value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          option :db, -> { DB }
-
-          def unique?(name, value)
-            db.none? { |item| item[name] == value }
-          end
-        end
-
-        required(:email).filled(unique?: :email)
-
-        required(:contact).schema do
-          required(:email).filled(unique?: :email)
-        end
-      end
-    end
-
-    include_context 'valid schema with :db option'
-  end
-
-  context 'without a default value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          option :db
-
-          def unique?(name, value)
-            db.none? { |item| item[name] == value }
-          end
-        end
-
-        required(:email).filled(unique?: :email)
-
-        required(:contact).schema do
-          required(:email).filled(unique?: :email)
-        end
-      end.with(db: DB)
-    end
-
-    include_context 'valid schema with :db option'
-  end
-end

data/spec/integration/schema/or_spec.rb

@@ -1,87 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'OR messages' do
-  context 'with two predicates' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { str? | int? }
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(foo: 'bar')).to be_success
-      expect(schema.(foo: 321)).to be_success
-    end
-
-    it 'provides OR error message for invalid input where all both sides failed' do
-      expect(schema.(foo: []).errors).to eql(foo: ['must be a string or must be an integer'])
-    end
-  end
-
-  context 'with a predicate and a conjunction of predicates' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { str? | (int? & gt?(18)) }
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(foo: 'bar')).to be_success
-      expect(schema.(foo: 321)).to be_success
-    end
-
-    it 'provides OR message for invalid input where both sides failed' do
-      expect(schema.(foo: []).errors).to eql(foo: ['must be a string or must be an integer'])
-    end
-
-    it 'provides error messages for invalid input where right side failed' do
-      expect(schema.(foo: 17).errors).to eql(foo: ['must be a string or must be greater than 18'])
-    end
-  end
-
-  context 'with a predicate and an each operation' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { str? | each(:int?) }
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(foo: 'bar')).to be_success
-      expect(schema.(foo: [1, 2, 3])).to be_success
-    end
-
-    it 'provides OR message for invalid input where both sides failed' do
-      expect(schema.(foo: {}).errors).to eql(foo: ['must be a string or must be an array'])
-    end
-
-    it 'provides error messages for invalid input where right side failed' do
-      expect(schema.(foo: %w(1 2 3)).errors).to eql(
-        foo: {
-          0 => ['must be an integer'],
-          1 => ['must be an integer'],
-          2 => ['must be an integer']
-        }
-      )
-    end
-  end
-
-  context 'with a predicate and a schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { str? | schema { required(:bar).filled } }
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(foo: 'bar')).to be_success
-      expect(schema.(foo: { bar: 'baz' })).to be_success
-    end
-
-    it 'provides OR message for invalid input where both sides failed' do
-      expect(schema.(foo: []).errors).to eql(foo: ['must be a string or must be a hash'])
-    end
-
-    it 'provides error messages for invalid input where right side rules failed' do
-      expect(schema.(foo: { bar: '' }).errors).to eql(foo: { bar: ['must be filled'] })
-    end
-  end
-end

data/spec/integration/schema/params/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.Params(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