dry-validation 0.13.3 → 1.0.0.alpha1

data/spec/integration/schema/hash_schema_spec.rb

@@ -1,47 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'for a hash' do
-  context 'without type specs' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        hash? do
-          required(:prefix).filled
-          required(:value).filled
-        end
-      end
-    end
-
-    it 'applies its rules to array input' do
-      result = schema.(prefix: 1, value: 123)
-
-      expect(result).to be_success
-
-      result = schema.(prefix: 1, value: nil)
-
-      expect(result.messages).to eql(value: ["must be filled"])
-    end
-  end
-
-  context 'with type specs' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-
-        hash? do
-          required(:prefix, :integer).filled
-          required(:value, :integer).filled
-        end
-      end
-    end
-
-    it 'applies its rules to coerced array input' do
-      result = schema.(prefix: 1, value: '123')
-
-      expect(result).to be_success
-
-      expect(result.output).to eql(prefix: 1, value: 123)
-
-      result = schema.(prefix: 1, value: nil)
-
-      expect(result.messages).to eql(value: ["must be filled"])
-    end
-  end
-end

data/spec/integration/schema/inheriting_schema_spec.rb

@@ -1,31 +0,0 @@
-RSpec.describe 'Inheriting schema' do
-  subject(:schema) do
-    Dry::Validation.Schema(base_schema) do
-      required(:location).schema do
-        required(:lat).filled(:float?)
-        required(:lng).filled(:float?)
-      end
-    end
-  end
-
-  let(:base_schema) do
-    Dry::Validation.Schema do
-      required(:city).filled
-    end
-  end
-
-  it 'inherits rules from parent schema' do
-    expect(schema.(city: 'NYC', location: { lat: 1.23, lng: 45.6 })).to be_success
-
-    expect(schema.(city: '', location: { lat: 1.23, lng: 45.6 }).messages).to eql(
-      city: ['must be filled']
-    )
-
-    expect(schema.(city: 'NYC', location: { lat: nil, lng: '45.6' }).messages).to eql(
-      location: {
-        lat: ['must be filled'],
-        lng: ['must be a float']
-      }
-    )
-  end
-end

data/spec/integration/schema/input_processor_spec.rb

@@ -1,46 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'setting input processor in schema' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      configure do
-        config.input_processor = :sanitizer
-      end
-
-      required(:email).filled
-
-      required(:age).maybe(:int?, gt?: 18)
-
-      required(:address).schema do
-        required(:city).filled
-        required(:street).filled
-      end
-
-      required(:phone_numbers).each do
-        required(:prefix).filled
-        required(:value).filled
-      end
-    end
-  end
-
-  it 'rejects unspecified keys' do
-    result = schema.(
-      email: 'jane@doe',
-      age: 19,
-      such: 'key',
-      address: { city: 'NYC', street: 'Street', wow: 'bad' },
-      phone_numbers: [
-        { prefix: '48', value: '123' },
-        { lol: '!!', prefix: '1', value: '312' }
-      ]
-    )
-
-    expect(result.output).to eql(
-      email: 'jane@doe',
-      age: 19,
-      address: { city: 'NYC', street: 'Street' },
-      phone_numbers: [
-        { prefix: '48', value: '123' },
-        { prefix: '1', value: '312' }
-      ]
-    )
-  end
-end

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