dry-validation 0.12.0 → 1.6.0

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

@@ -1,35 +0,0 @@
-RSpec.describe 'Macros #confirmation' do
-  describe 'with a maybe password with min-size specified' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          config.input_processor = :sanitizer
-
-          def self.messages
-            Messages.default.merge(
-              en: { errors: { password_confirmation: 'does not match' } }
-            )
-          end
-        end
-
-        required(:password).maybe(min_size?: 3).confirmation
-      end
-    end
-
-    it 'passes when values are equal' do
-      expect(schema.(password: 'foo', password_confirmation: 'foo')).to be_success
-    end
-
-    it 'fails when source value is invalid' do
-      expect(schema.(password: 'fo', password_confirmation: nil).messages).to eql(
-        password: ['size cannot be less than 3']
-      )
-    end
-
-    it 'fails when values are not equal' do
-      expect(schema.(password: 'foo', password_confirmation: 'fo').messages).to eql(
-        password_confirmation: ['does not match']
-      )
-    end
-  end
-end

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

@@ -1,268 +0,0 @@
-RSpec.describe 'Macros #each' do
-  context "predicate without options" do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo).each(:filled?, :str?)
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: %w(a b c) } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with invalid input' do
-      let(:input) { { foo: [[1, 2], "", "foo"] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing(0 => ["must be a string"], 1 => ["must be filled"])
-      end
-    end
-
-    context 'with invalid input type' do
-      let(:input) { { foo: nil } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ["must be an array"]
-      end
-    end
-  end
-
-  context "predicate with options" do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo).each(size?: 3)
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: [[1,2,3], "foo"] } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with invalid input' do
-      let(:input) { { foo: [[1,2], "foo"] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing(0 => ["size must be 3"])
-      end
-    end
-
-    context 'with invalid input type' do
-      let(:input) { { foo: nil } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ["must be an array"]
-      end
-    end
-  end
-
-  context 'with filled macro' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo).filled(size?: 2) { each(:str?) }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: %w(a b) } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'when value is not valid' do
-      let(:input) { { foo: ["foo"] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing(["size must be 2"])
-      end
-    end
-
-    context 'when value has invalid elements' do
-      let(:input) { { foo: [:foo, "foo"] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing(0 => ["must be a string"])
-      end
-    end
-  end
-
-  context 'with maybe macro' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo).maybe { each(:str?) }
-      end
-    end
-
-    context 'with nil input' do
-      let(:input) { { foo: nil } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: %w(a b c) } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with invalid input' do
-      let(:input) { { foo: [:foo, "foo"] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing(0 => ["must be a string"])
-      end
-    end
-  end
-
-  context 'with external schema macro' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo).each(FooSchema)
-      end
-    end
-
-    before do
-      FooSchema = Dry::Validation.Schema do
-        required(:bar).filled(:str?)
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :FooSchema)
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: [{ bar: "baz" }] } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'when value is not valid' do
-      let(:input) { { foo: [{ bar: 1 }] } }
-
-      it 'is not successful' do
-        # FIXME: our be_failing didn't work with such nested wow hash
-        expect(result.messages).to eql(foo: { 0 => { bar: ["must be a string"] } })
-      end
-    end
-  end
-
-  context 'with a block' do
-    context 'with a nested schema' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:songs).each do
-            schema do
-              required(:title).filled
-              required(:author).filled
-            end
-          end
-        end
-      end
-
-      it 'passes when all elements are valid' do
-        songs = [
-          { title: 'Hello', author: 'Jane' },
-          { title: 'World', author: 'Joe' }
-        ]
-
-        expect(schema.(songs: songs)).to be_success
-      end
-
-      it 'fails when value is not an array' do
-        expect(schema.(songs: 'oops').messages).to eql(songs: ['must be an array'])
-      end
-
-      it 'fails when not all elements are valid' do
-        songs = [
-          { title: 'Hello', author: 'Jane' },
-          { title: nil, author: 'Joe' },
-          { title: 'World', author: nil },
-          { title: nil, author: nil }
-        ]
-
-        expect(schema.(songs: songs).messages).to eql(
-          songs: {
-            1 => { title: ['must be filled'] },
-            2 => { author: ['must be filled'] },
-            3 => { title: ['must be filled'], author: ['must be filled'] }
-          }
-        )
-      end
-    end
-  end
-
-  context 'with inferred predicates and a form schema' do
-    context "predicate w/o options" do
-      subject(:schema) do
-        Dry::Validation.Params do
-          required(:songs).each(:str?)
-        end
-      end
-
-      it 'passes when all elements are valid' do
-        songs = %w(hello world)
-
-        expect(schema.(songs: songs)).to be_success
-      end
-
-      it 'fails when value is not an array' do
-        expect(schema.(songs: 'oops').messages).to eql(songs: ['must be an array'])
-      end
-
-      it 'fails when not all elements are valid' do
-        songs = ['hello', nil, 2]
-
-        expect(schema.(songs: songs).messages).to eql(
-          songs: {
-            1 => ['must be a string'],
-            2 => ['must be a string']
-          }
-        )
-      end
-    end
-  end
-
-  context 'with a custom predicate' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def self.messages
-            super.merge(en: { errors: { valid_content?: 'must have type key' }})
-          end
-
-          def valid_content?(content)
-            content.key?(:type)
-          end
-        end
-
-        required(:contents).each(:valid_content?)
-      end
-    end
-
-    it 'passes when all elements are valid' do
-      expect(schema.(contents: [{ type: 'foo' }, { type: 'bar' }]))
-    end
-
-    it 'fails when some elements are not valid' do
-      expect(schema.(contents: [{ type: 'foo' }, { oops: 'bar' }]).errors).to eql(
-        contents: { 1 => ['must have type key']}
-      )
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-RSpec.describe 'Macros #filled' do
-  describe 'with no args' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:email).filled
-      end
-    end
-
-    it 'generates filled? rule' do
-      expect(schema.(email: '').messages).to eql(
-        email: ['must be filled']
-      )
-    end
-  end
-
-  describe 'with a type specification' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:age).filled(:int?)
-      end
-    end
-
-    it 'generates filled? & int? rule' do
-      expect(schema.(age: nil).messages).to eql(
-        age: ['must be filled']
-      )
-    end
-  end
-
-  describe 'with a predicate with args' do
-    context 'with a flat arg' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:age).filled(:int?, gt?: 18)
-        end
-      end
-
-      it 'generates filled? & int? & gt? rule' do
-        expect(schema.(age: nil).messages).to eql(
-          age: ['must be filled', 'must be greater than 18']
-        )
-      end
-    end
-
-    context 'with a range arg' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:age).filled(:int?, size?: 18..24)
-        end
-      end
-
-      it 'generates filled? & int? & size? rule' do
-        expect(schema.(age: nil).messages).to eql(
-          age: ['must be filled', 'size must be within 18 - 24']
-        )
-      end
-    end
-
-    context 'with a block' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:age).filled { int? & size?(18..24) }
-        end
-      end
-
-      it 'generates filled? & int? & size? rule' do
-        expect(schema.(age: nil).messages).to eql(
-          age: ['must be filled', '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).filled(:int?) { size?(18..24) }
-        end
-      end
-
-      it 'generates filled? & int? & size? rule' do
-        expect(schema.(age: nil).messages).to eql(
-          age: ['must be filled', 'size must be within 18 - 24']
-        )
-      end
-    end
-  end
-end

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