dry-validation 0.13.3 → 1.7.0

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

@@ -1,139 +0,0 @@
-RSpec.describe 'Macros #input' do
-  context 'with a flat schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        input :hash?
-
-        required(:foo).filled
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(foo: "bar")).to be_successful
-    end
-
-    it 'prepends a rule for the input' do
-      expect(schema.(nil).messages).to eql(["must be a hash"])
-    end
-
-    it 'applies other rules when input has expected type' do
-      expect(schema.(foo: '').messages).to eql(foo: ["must be filled"])
-    end
-  end
-
-  context 'with a nested schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        input(:hash?)
-
-        required(:foo).schema do
-          required(:bar).schema do
-            required(:baz).filled
-          end
-        end
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(foo: { bar: { baz: "present" }})).to be_successful
-    end
-
-    it 'fails when input has invalid type' do
-      expect(schema.(nil).messages).to eql(["must be a hash"])
-    end
-
-    it 'fails when 1-level key is missing' do
-      expect(schema.(foo: {}).messages).to eql(foo: { bar: ["is missing"] })
-    end
-
-    it 'fails when 2-level key has invalid value' do
-      expect(schema.(foo: { bar: { baz: '' }}).messages).to eql(
-        foo: { bar: { baz: ['must be filled'] } }
-      )
-    end
-  end
-
-  context 'when 2 nested schemas are under the same key' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        input :hash?
-
-        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: 'sutin' } })).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 value is invalid' do
-      expect(schema.(meta: { meta: { data: '' } }).messages).to eql(
-        meta: { meta: { data: ['must be filled'] } }
-      )
-    end
-  end
-
-  context 'using more than one predicate' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        input :hash?, size?: 2
-
-        required(:foo).filled
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(foo: "bar", bar: "baz")).to be_successful
-    end
-
-    it 'fails when one of the root-rules fails' do
-      expect(schema.(foo: "bar", bar: "baz", oops: "heh").messages).to eql(
-        ['size must be 2']
-      )
-    end
-  end
-
-  context 'using a custom predicate' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def valid_keys?(input)
-            input.size == 2 || input.size == 1
-          end
-        end
-
-        input :hash?, :valid_keys?
-
-        required(:foo).filled
-        optional(:bar).filled
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(foo: 'bar')).to be_successful
-      expect(schema.(foo: 'bar', bar: 'baz')).to be_successful
-    end
-
-    it 'fails when one of the root-rules fails' do
-      expect(schema.(foo: 'bar', bar: 'baz', oops: 'heh')).to be_failure
-    end
-  end
-end

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