dry-validation 0.13.3 → 1.0.0.alpha1

data/spec/integration/schema/macros/maybe_spec.rb

@@ -1,99 +0,0 @@
-RSpec.describe 'Macros #maybe' do
-  describe 'with no args' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:email).maybe
-      end
-    end
-
-    it 'generates none? | filled? rule' do
-      expect(schema.(email: nil).messages).to be_empty
-      expect(schema.(email: 'jane@doe').messages).to be_empty
-    end
-  end
-
-  describe 'with a predicate with args' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:name).maybe(min_size?: 3)
-      end
-    end
-
-    it 'generates none? | (filled? & min_size?) rule' do
-      expect(schema.(name: nil).messages).to be_empty
-
-      expect(schema.(name: 'jane').messages).to be_empty
-
-      expect(schema.(name: 'xy').messages).to eql(
-        name: ['size cannot be less than 3']
-      )
-    end
-  end
-
-  describe 'with a block' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:name).maybe { str? & min_size?(3) }
-      end
-    end
-
-    it 'generates none? | (str? & min_size?) rule' do
-      expect(schema.(name: nil).messages).to be_empty
-
-      expect(schema.(name: 'jane').messages).to be_empty
-
-      expect(schema.(name: 'xy').messages).to eql(
-        name: ['size cannot be less than 3']
-      )
-    end
-  end
-
-  describe 'with an optional key and a block with schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        optional(:employee).maybe do
-          schema do
-            required(:id).filled(:str?)
-          end
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(employee: { id: '1' })).to be_success
-    end
-
-    it 'passes when key is missing' do
-      expect(schema.({})).to be_success
-    end
-
-    it 'passes when value is nil' do
-      expect(schema.(employee: nil)).to be_success
-    end
-
-    it 'fails when value for nested schema is invalid' do
-      expect(schema.(employee: { id: 1 }).messages).to eql(
-        employee: { id: ['must be a string'] }
-      )
-    end
-  end
-
-  describe 'with a predicate and a block' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:name).maybe(:str?) { min_size?(3) }
-      end
-    end
-
-    it 'generates none? | (str? & min_size?) rule' do
-      expect(schema.(name: nil).messages).to be_empty
-
-      expect(schema.(name: 'jane').messages).to be_empty
-
-      expect(schema.(name: 'xy').messages).to eql(
-        name: ['size cannot be less than 3']
-      )
-    end
-  end
-end
-

data/spec/integration/schema/macros/rule_spec.rb

@@ -1,75 +0,0 @@
-RSpec.describe 'Macros / rule' do
-  shared_context 'password confirmation high-level rule' do
-    subject(:schema) { schema_class.new }
-
-    let(:schema_class) do
-      Dry::Validation.Schema(build: false) do
-        required(:user).schema do
-          required(:password).filled
-          required(:password_confirmation).filled
-
-          rule(password_confirmation: %i[password_confirmation password]) do |pc, p|
-            pc.eql?(p)
-          end
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(user: { password: 'foo', password_confirmation: 'foo' })).to be_successful
-    end
-
-    it 'fails when the rule failed' do
-      expect(schema.(user: { password: 'foo', password_confirmation: 'bar' }).messages).to eql(
-        user: { password_confirmation: [error_message] }
-      )
-    end
-  end
-
-  context 'with the default message' do
-    let(:error_message) { 'must be equal to foo' }
-
-    include_context 'password confirmation high-level rule'
-  end
-
-  context 'with a custom message' do
-    let(:error_message) { 'does not match' }
-
-    before do
-      schema_class.class_eval do
-        def self.messages
-          default_messages.merge(en: { errors: { password_confirmation: 'does not match' } })
-        end
-      end
-    end
-
-    include_context 'password confirmation high-level rule'
-  end
-
-  context 'with two rules relying on the same value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:x).filled(:int?)
-
-        rule(a: [:x]) do |x|
-          x.gt?(3)
-        end
-
-        rule(b: [:x]) do |x|
-          x.gt?(5)
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(x: 6)).to be_successful
-    end
-
-    it 'fails when rules failed' do
-      expect(schema.(x: 2).messages).to eql(
-        a: ['must be greater than 3'],
-        b: ['must be greater than 5']
-      )
-    end
-  end
-end

data/spec/integration/schema/macros/value_spec.rb

@@ -1,119 +0,0 @@
-RSpec.describe 'Macros #value' do
-  describe 'with no args' do
-    it 'raises an exception' do
-      expect { Dry::Validation.Schema { required(:email).value } }.to raise_error(
-        ArgumentError, "wrong number of arguments (given 0, expected at least 1)"
-      )
-    end
-  end
-
-  describe 'with a type specification' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:age).value(:int?)
-      end
-    end
-
-    it 'generates int? rule' do
-      expect(schema.(age: nil).messages).to eql(
-        age: ['must be an integer']
-      )
-    end
-  end
-
-  describe 'with a predicate with args' do
-    context 'with a flat arg' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:age).value(:int?, gt?: 18)
-        end
-      end
-
-      it 'generates int? & gt? rule' do
-        expect(schema.(age: nil).messages).to eql(
-          age: ['must be an integer', 'must be greater than 18']
-        )
-      end
-    end
-
-    context 'with a second predicate with args' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:name).value(:str?, min_size?: 3, max_size?: 6)
-        end
-      end
-
-      it 'generates str? & min_size? & max_size?' do
-        expect(schema.(name: 'fo').messages).to eql(
-          name: ['size cannot be less than 3', 'size cannot be greater than 6']
-        )
-      end
-    end
-
-    context 'with a range arg' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:age).value(:int?, size?: 18..24)
-        end
-      end
-
-      it 'generates int? & gt? rule' do
-        expect(schema.(age: nil).messages).to eql(
-          age: ['must be an integer', 'size must be within 18 - 24']
-        )
-      end
-    end
-
-    context 'with a block' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:age).value { int? & size?(18..24) }
-        end
-      end
-
-      it 'generates int? & gt? rule' do
-        expect(schema.(age: nil).messages).to eql(
-          age: ['must be an integer', 'size must be within 18 - 24']
-        )
-      end
-    end
-
-    context 'with a predicate and a block' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:age).value(:int?) { size?(18..24) }
-        end
-      end
-
-      it 'generates int? & gt? rule' do
-        expect(schema.(age: nil).messages).to eql(
-          age: ['must be an integer', 'size must be within 18 - 24']
-        )
-      end
-    end
-
-    context 'with a schema' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:data).value(DataSchema)
-        end
-      end
-
-      before do
-        DataSchema = Dry::Validation.Schema do
-          required(:foo).filled(size?: 2..10)
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :DataSchema)
-      end
-
-      it 'uses the schema' do
-        expect(schema.(data: { foo: '' }).messages).to eql(
-          data: { foo: ['must be filled', 'length must be within 2 - 10'] }
-        )
-      end
-    end
-  end
-end

data/spec/integration/schema/macros/when_spec.rb

@@ -1,62 +0,0 @@
-RSpec.describe 'Macros #when' do
-  context 'with a result rule returned from the block' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:email).maybe
-
-        required(:login).filled.when(:true?) do
-          value(:email).filled?
-        end
-      end
-    end
-
-    it 'generates check rule' do
-      expect(schema.(login: true, email: nil).messages).to eql(
-        email: ['must be filled']
-      )
-
-      expect(schema.(login: false, email: nil).messages).to be_empty
-    end
-  end
-
-  describe 'with a result rule depending on another result' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:left).maybe(:int?)
-        required(:right).maybe(:int?)
-
-        required(:compare).maybe(:bool?).when(:true?) do
-          value(:left).gt?(value(:right))
-        end
-      end
-    end
-
-    it 'generates check rule' do
-      expect(schema.(compare: false, left: nil, right: nil)).to be_success
-
-      expect(schema.(compare: true, left: 1, right: 2).messages).to eql(
-        left: ['must be greater than 2']
-      )
-    end
-  end
-
-  context 'predicate with options' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:bar).maybe
-
-        required(:foo).filled.when(size?: 3) do
-          value(:bar).filled?
-        end
-      end
-    end
-
-    it 'generates check rule' do
-      expect(schema.(foo: [1,2,3], bar: nil).messages).to eql(
-        bar: ['must be filled']
-      )
-
-      expect(schema.(foo: [1,2], bar: nil).messages).to be_empty
-    end
-  end
-end

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