dry-validation 0.13.3 → 1.7.0

data/spec/integration/schema/json/explicit_types_spec.rb

@@ -1,157 +0,0 @@
-RSpec.describe Dry::Validation::Schema::JSON, 'explicit types' do
-  context 'single type spec without rules' do
-    subject(:schema) do
-      Dry::Validation.JSON do
-        configure { config.type_specs = true }
-        required(:bdate, :date)
-      end
-    end
-
-    it 'uses json coercion' do
-      expect(schema.('bdate' => '2010-09-08').to_h).to eql(bdate: Date.new(2010, 9, 8))
-    end
-  end
-
-  context 'single type spec with rules' do
-    subject(:schema) do
-      Dry::Validation.JSON do
-        configure { config.type_specs = true }
-        required(:bdate, :date).value(:date?, gt?: Date.new(2009))
-      end
-    end
-
-    it 'applies rules to coerced value' do
-      expect(schema.(bdate: "2010-09-07").messages).to be_empty
-      expect(schema.(bdate: "2008-01-01").messages).to eql(bdate: ['must be greater than 2009-01-01'])
-    end
-  end
-
-  context 'sum type spec without rules' do
-    subject(:schema) do
-      Dry::Validation.JSON do
-        configure { config.type_specs = true }
-        required(:bdate, [:nil, :date])
-      end
-    end
-
-    it 'uses form coercion' do
-      expect(schema.('bdate' => '2010-09-08').to_h).to eql(bdate: Date.new(2010, 9, 8))
-      expect(schema.('bdate' => '').to_h).to eql(bdate: nil)
-    end
-  end
-
-  context 'sum type spec with rules' do
-    subject(:schema) do
-      Dry::Validation.JSON do
-        configure { config.type_specs = true }
-        required(:bdate, [:nil, :date]).maybe(:date?, gt?: Date.new(2008))
-      end
-    end
-
-    it 'applies rules to coerced value' do
-      expect(schema.(bdate: nil).messages).to be_empty
-      expect(schema.(bdate: "2010-09-07").messages).to be_empty
-      expect(schema.(bdate: "2008-01-01").messages).to eql(bdate: ['must be greater than 2008-01-01'])
-    end
-  end
-
-  context 'using a type object' do
-    subject(:schema) do
-      Dry::Validation.JSON do
-        configure { config.type_specs = true }
-        required(:bdate, Types::JSON::Nil | Types::JSON::Date)
-      end
-    end
-
-    it 'uses form coercion' do
-      expect(schema.('bdate' => '').to_h).to eql(bdate: nil)
-      expect(schema.('bdate' => '2010-09-08').to_h).to eql(bdate: Date.new(2010, 9, 8))
-    end
-  end
-
-  context 'nested schema' do
-    subject(:schema) do
-      Dry::Validation.JSON do
-        configure { config.type_specs = true }
-
-        required(:user).schema do
-          required(:email, :string)
-          required(:bdate, :date)
-
-          required(:address).schema do
-            required(:street, :string)
-            required(:city, :string)
-            required(:zipcode, :string)
-
-            required(:location).schema do
-              required(:lat, :float)
-              required(:lng, :float)
-            end
-          end
-        end
-      end
-    end
-
-    it 'uses form coercion for nested input' do
-      input = {
-        'user' => {
-          'email' => 'jane@doe.org',
-          'bdate' => '2010-09-08',
-          'address' => {
-            'street' => 'Street 1',
-            'city' => 'NYC',
-            'zipcode' => '1234',
-            'location' => { 'lat' => 1.23, 'lng' => 4.56 }
-          }
-        }
-      }
-
-      expect(schema.(input).to_h).to eql(
-        user:  {
-          email: 'jane@doe.org',
-          bdate: Date.new(2010, 9, 8),
-          address: {
-            street: 'Street 1',
-            city: 'NYC',
-            zipcode:  '1234',
-            location: { lat: 1.23, lng: 4.56 }
-          }
-        }
-      )
-    end
-  end
-
-  context 'nested schema with arrays' do
-    subject(:schema) do
-      Dry::Validation.JSON do
-        configure { config.type_specs = true }
-
-        required(:song).schema do
-          required(:title, :string)
-
-          required(:tags).each do
-            schema do
-              required(:name, :string)
-            end
-          end
-        end
-      end
-    end
-
-    it 'uses form coercion for nested input' do
-      input = {
-        'song' => {
-          'title' => 'dry-rb is awesome lala',
-          'tags' => [{ 'name' => 'red' }, { 'name' => 'blue' }]
-        }
-      }
-
-      expect(schema.(input).to_h).to eql(
-        song: {
-          title: 'dry-rb is awesome lala',
-          tags: [{ name: 'red' }, { name: 'blue' }]
-        }
-      )
-    end
-  end
-end

data/spec/integration/schema/json_spec.rb

@@ -1,163 +0,0 @@
-RSpec.describe Dry::Validation::Schema::JSON, 'defining a schema' do
-  subject(:schema) do
-    Dry::Validation.JSON do
-      configure do
-        def email?(value)
-          true
-        end
-      end
-
-      required(:email).filled
-
-      required(:age).maybe(:int?, gt?: 18)
-
-      required(:address).schema do
-        required(:city).filled
-        required(:street).filled
-
-        required(:loc).schema do
-          required(:lat).filled(:float?)
-          required(:lng).filled(:float?)
-        end
-      end
-
-      optional(:password).maybe.confirmation
-
-      optional(:phone_number).maybe(:int?, gt?: 0)
-
-      rule(:email_valid) { value(:email).email? }
-    end
-  end
-
-  describe '#messages' do
-    it 'returns compiled error messages' do
-      result = schema.('email' => '', 'age' => 19)
-
-      expect(result.messages).to eql(
-        email: ['must be filled'],
-        address: ['is missing'],
-      )
-
-      expect(result.output).to eql(email: '', age: 19)
-    end
-
-    it 'returns hints for nested data' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'age' => 19,
-        'address' => {
-          'city' => '',
-          'street' => 'Street 1/2',
-          'loc' => { 'lat' => '123.456', 'lng' => '' }
-        }
-      )
-
-      expect(result.messages).to eql(
-        address: {
-          loc: { lat: ['must be a float'], lng: ['must be filled'] },
-          city: ['must be filled']
-        }
-      )
-    end
-  end
-
-  describe '#call' do
-    it 'passes when attributes are valid' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'age' => 19,
-        'address' => {
-          'city' => 'NYC',
-          'street' => 'Street 1/2',
-          'loc' => { 'lat' => 123.456, 'lng' => 456.123 }
-        }
-      )
-
-      expect(result).to be_success
-
-      expect(result.output).to eql(
-        email: 'jane@doe.org', age: 19,
-        address: {
-          city: 'NYC', street: 'Street 1/2',
-          loc: { lat: 123.456, lng: 456.123 }
-        }
-      )
-    end
-
-    it 'validates presence of an email and min age value' do
-      result = schema.('email' => '', 'age' => 18)
-
-      expect(result.messages).to eql(
-        address: ['is missing'],
-        age: ['must be greater than 18'],
-        email: ['must be filled']
-      )
-    end
-
-    it 'handles optionals' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'age' => 19,
-        'phone_number' => 12,
-        'address' => {
-          'city' => 'NYC',
-          'street' => 'Street 1/2',
-          'loc' => { 'lat' => 123.456, 'lng' => 456.123 }
-        }
-      )
-
-      expect(result).to be_success
-
-      expect(result.output).to eql(
-        email: 'jane@doe.org', age: 19, phone_number: 12,
-        address: {
-          city: 'NYC', street: 'Street 1/2',
-          loc: { lat: 123.456, lng: 456.123 }
-        }
-      )
-    end
-  end
-
-  describe 'with nested schema in a high-level rule' do
-    subject(:schema) do
-      Dry::Validation.JSON do
-        required(:address).maybe(:hash?)
-
-        required(:delivery).filled(:bool?)
-
-        rule(address: [:delivery, :address]) do |delivery, address|
-          delivery.true?.then(address.schema(AddressSchema))
-        end
-      end
-    end
-
-    before do
-      AddressSchema = Dry::Validation.JSON do
-        required(:city).filled
-        required(:zipcode).filled(:int?)
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :AddressSchema)
-    end
-
-    it 'succeeds when nested form schema succeeds' do
-      result = schema.(delivery: true, address: { city: 'NYC', zipcode: 123 })
-      expect(result).to be_success
-    end
-
-    it 'does not apply schema when there is no match' do
-      result = schema.(delivery: false, address: nil)
-      expect(result).to be_success
-    end
-
-    it 'fails when nested schema fails' do
-      result = schema.(delivery: true, address: { city: 'NYC', zipcode: 'foo' })
-
-      expect(result.messages).to eql(
-        address: { zipcode: ['must be an integer'] }
-      )
-    end
-  end
-end

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