dry-validation 0.13.3 → 1.3.1

data/spec/integration/schema/params_spec.rb

@@ -1,234 +0,0 @@
-RSpec.describe Dry::Validation::Schema::Params, 'defining a schema' do
-  subject(:schema) do
-    Dry::Validation.Params 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: { 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 an each and nested schema' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        required(:items).each do
-          schema do
-            required(:title).filled(:str?)
-          end
-        end
-      end
-    end
-
-    it 'passes when each element passes schema check' do
-      expect(schema.(items: [{ title: 'Foo' }])).to be_success
-    end
-
-    it 'fails when one or more elements did not pass schema check' do
-      expect(schema.(items: [{ title: 'Foo' }, { title: :Foo }]).messages).to eql(
-        items: { 1 => { title: ['must be a string'] } }
-      )
-    end
-  end
-
-  describe 'symbolizing keys when coercion fails' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        required(:email).value(size?: 8..60)
-        required(:birthdate).value(:date?)
-        required(:age).value(:int?, gt?: 23)
-        required(:tags).maybe(max_size?: 3)
-      end
-    end
-
-    let(:tags) { %(al b c) }
-
-    it 'symbolizes keys and coerces values' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'birthdate' => '2001-02-03',
-        'age' => '24',
-        'tags' => tags
-      ).to_h
-
-      expect(result.to_h).to eql(
-        email: 'jane@doe.org',
-        birthdate: Date.new(2001, 2, 3),
-        age: 24,
-        tags: tags
-      )
-    end
-
-    it 'symbolizes keys even when coercion fails' do
-      result = schema.(
-        'email' => 'jane@doe.org',
-        'birthdate' => '2001-sutin-03',
-        'age' => ['oops'],
-        'tags' => nil
-      )
-
-      expect(result.to_h).to eql(
-        email: 'jane@doe.org',
-        birthdate: '2001-sutin-03',
-        age: ['oops'],
-        tags: nil
-      )
-
-      expect(result.messages).to eql(
-        birthdate: ['must be a date'],
-        age: ['must be an integer', 'must be greater than 23']
-      )
-    end
-  end
-
-  describe 'with nested schema in a high-level rule' do
-    subject(:schema) do
-      Dry::Validation.Params 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.Params do
-        required(:city).filled
-        required(:zipcode).filled(:int?)
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :AddressSchema)
-    end
-
-    it 'succeeds when nested params schema succeeds' do
-      result = schema.(delivery: '1', 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: '0', address: nil)
-      expect(result).to be_success
-    end
-
-    it 'fails when nested schema fails' do
-      result = schema.(delivery: '1', address: { city: 'NYC', zipcode: 'foo' })
-      expect(result.messages).to eql(
-        address: { zipcode: ['must be an integer'] }
-      )
-    end
-  end
-end

data/spec/integration/schema/predicate_verification_spec.rb

@@ -1,9 +0,0 @@
-RSpec.describe 'Verifying predicates in the DSL' do
-  it 'raises error when invalid predicate name is used' do
-    expect { Dry::Validation.Schema { required(:age).value(filled?: 312) } }
-      .to raise_error(ArgumentError, "filled? predicate arity is invalid")
-
-    expect { Dry::Validation.Schema { required(:age) { none? | filled?(312) } } }
-      .to raise_error(ArgumentError, "filled? predicate arity is invalid")
-  end
-end

data/spec/integration/schema/predicates/array_spec.rb

@@ -1,295 +0,0 @@
-RSpec.describe 'Predicates: Array' do
-  context 'with required' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { array? { each { int? } } }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: [3] } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with missing input' do
-      let(:input) { {} }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['is missing']
-      end
-    end
-
-    context 'with nil input' do
-      let(:input) { { foo: nil } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be an array']
-      end
-    end
-
-    context 'with blank input' do
-      let(:input) { { foo: '' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be an array']
-      end
-    end
-
-    context 'with invalid type' do
-      let(:input) { { foo: { a: 1 } } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be an array']
-      end
-    end
-
-    context 'with invalid input (integer)' do
-      let(:input) { { foo: 4 } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be an array']
-      end
-    end
-
-    context 'with invalid input (array with non-integers)' do
-      let(:input) { { foo: [:foo, :bar] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing 0 => ['must be an integer'], 1 => ['must be an integer']
-      end
-    end
-
-    context 'with invalid input (miexed array)' do
-      let(:input) { { foo: [1, '2', :bar] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing 1 => ['must be an integer'], 2 => ['must be an integer']
-      end
-    end
-  end
-
-  context 'with optional' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        optional(:foo) { array? { each { int? } } }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { foo: [3] } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with missing input' do
-      let(:input) { {} }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with nil input' do
-      let(:input) { { foo: nil } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be an array']
-      end
-    end
-
-    context 'with blank input' do
-      let(:input) { { foo: '' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be an array']
-      end
-    end
-
-    context 'with invalid type' do
-      let(:input) { { foo: { a: 1 } } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be an array']
-      end
-    end
-
-    context 'with invalid input (integer)' do
-      let(:input) { { foo: 4 } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be an array']
-      end
-    end
-
-    context 'with invalid input (array with non-integers)' do
-      let(:input) { { foo: [:foo, :bar] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing 0 => ['must be an integer'], 1 => ['must be an integer']
-      end
-    end
-
-    context 'with invalid input (miexed array)' do
-      let(:input) { { foo: [1, '2', :bar] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing 1 => ['must be an integer'], 2 => ['must be an integer']
-      end
-    end
-  end
-
-  context 'as macro' do
-    context 'with required' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          required(:foo).each(:int?)
-        end
-      end
-
-      context 'with missing input' do
-        let(:input) { {} }
-
-        it 'is not successful' do
-          expect(result).to be_failing ['is missing']
-        end
-      end
-
-      context 'with nil input' do
-        let(:input) { { foo: nil } }
-
-        it 'is not successful' do
-          expect(result).to be_failing ['must be an array']
-        end
-      end
-
-      context 'with blank input' do
-        let(:input) { { foo: '' } }
-
-        it 'is not successful' do
-          expect(result).to be_failing ['must be an array']
-        end
-      end
-
-      context 'with valid input' do
-        let(:input) { { foo: [3] } }
-
-        it 'is successful' do
-          expect(result).to be_successful
-        end
-      end
-
-      context 'with invalid input' do
-        let(:input) { { foo: [:bar] } }
-
-        it 'is not successful' do
-          expect(result).to be_failing 0 => ['must be an integer']
-        end
-      end
-
-      context "when using an input_processor" do
-        subject(:schema) do
-          Dry::Validation.Schema do
-            configure do
-              config.input_processor = :sanitizer
-            end
-
-            required(:foo).each(:int?)
-          end
-        end
-
-        context 'with missing input' do
-          let(:input) { {} }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['is missing']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { foo: nil } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be an array']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { foo: '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be an array']
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { foo: [3] } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with invalid input' do
-          let(:input) { { foo: [:bar] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing 0 => ['must be an integer']
-          end
-        end
-      end
-    end
-
-    context 'with optional' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          optional(:foo).each(:int?)
-        end
-      end
-
-      context 'with missing input' do
-        let(:input) { {} }
-
-        it 'is successful' do
-          expect(result).to be_successful
-        end
-      end
-
-      context 'with nil input' do
-        let(:input) { { foo: nil } }
-
-        it 'is not successful' do
-          expect(result).to be_failing ['must be an array']
-        end
-      end
-
-      context 'with blank input' do
-        let(:input) { { foo: '' } }
-
-        it 'is not successful' do
-          expect(result).to be_failing ['must be an array']
-        end
-      end
-
-      context 'with valid input' do
-        let(:input) { { foo: [3] } }
-
-        it 'is successful' do
-          expect(result).to be_successful
-        end
-      end
-
-      context 'with invalid input' do
-        let(:input) { { foo: [:bar] } }
-
-        it 'is not successful' do
-          expect(result).to be_failing 0 => ['must be an integer']
-        end
-      end
-    end
-  end
-end