dry-validation 0.12.0 → 1.6.0

data/spec/integration/params/predicates/type_spec.rb

@@ -1,391 +0,0 @@
-RSpec.describe 'Predicates: Type' do
-  context 'with required' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        required(:foo) { type?(Integer) }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { 'foo' => '23' } }
-
-      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', 'must be Integer']
-      end
-    end
-
-    context 'with nil input' do
-      let(:input) { { 'foo' => nil } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-
-    context 'with blank input' do
-      let(:input) { { 'foo' => '' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-
-    context 'with invalid type' do
-      let(:input) { { 'foo' => ['x'] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-  end
-
-  context 'with optional' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        optional(:foo) { type?(Integer) }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { 'foo' => '23' } }
-
-      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 Integer']
-      end
-    end
-
-    context 'with blank input' do
-      let(:input) { { 'foo' => '' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-
-    context 'with invalid type' do
-      let(:input) { { 'foo' => ['x'] } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['must be Integer']
-      end
-    end
-  end
-
-  context 'as macro' do
-    context 'with required' do
-      context 'with value' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            required(:foo).value(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => '23' } }
-
-          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', 'must be Integer']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { 'foo' => nil } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { 'foo' => ['x'] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-
-      context 'with filled' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            required(:foo).filled(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => '23' } }
-
-          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', 'must be Integer']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { 'foo' => nil } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'must be Integer']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { 'foo' => ['x'] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-
-      context 'with maybe' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            required(:foo).maybe(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => '23' } }
-
-          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', 'must be Integer']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { 'foo' => nil } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { 'foo' => ['x'] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-    end
-
-    context 'with optional' do
-      context 'with value' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            optional(:foo).value(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => '23' } }
-
-          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 Integer']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { 'foo' => ['x'] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-
-      context 'with filled' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            optional(:foo).filled(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => '23' } }
-
-          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 filled', 'must be Integer']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'must be Integer']
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { 'foo' => ['x'] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-
-      context 'with maybe' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            optional(:foo).maybe(type?: Integer)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => '23' } }
-
-          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 successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is successful' do
-            expect(result).to be_successful
-          end
-        end
-
-        context 'with invalid type' do
-          let(:input) { { 'foo' => ['x'] } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be Integer']
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/result_spec.rb

@@ -1,81 +0,0 @@
-RSpec.describe Dry::Validation::Result do
-  subject(:result) { schema.(input) }
-
-  let(:schema) { Dry::Validation.Schema { required(:name).filled(:str?, size?: 2..4) } }
-
-  context 'with valid input' do
-    let(:input) { { name: 'Jane' } }
-
-    it 'is successful' do
-      expect(result).to be_successful
-    end
-
-    it 'is not a failure' do
-      expect(result).to_not be_failure
-    end
-
-    it 'coerces to validated hash' do
-      expect(Hash(result)).to eql(name: 'Jane')
-    end
-
-    describe '#messages' do
-      it 'returns an empty hash' do
-        expect(result.messages).to be_empty
-      end
-    end
-  end
-
-  context 'with invalid input' do
-    let(:input) { { name: '' } }
-
-    it 'is not successful' do
-      expect(result).to_not be_successful
-    end
-
-    it 'is failure' do
-      expect(result).to be_failure
-    end
-
-    it 'coerces to validated hash' do
-      expect(Hash(result)).to eql(name: '')
-    end
-
-    describe '#messages' do
-      it 'returns a hash with error messages' do
-        expect(result.messages).to eql(
-          name: ['must be filled', 'length must be within 2 - 4']
-        )
-      end
-
-      it 'with full: true returns full messages' do
-        expect(result.messages(full: true)).to eql(
-          name: ['name must be filled', 'name length must be within 2 - 4']
-        )
-      end
-    end
-
-    describe '#errors' do
-      let(:input) { { name: '' } }
-
-      it 'returns failure messages' do
-        expect(result.errors).to eql(name: ['must be filled'])
-      end
-    end
-
-    describe '#hints' do
-      let(:input) { { name: '' } }
-
-      it 'returns hint messages' do
-        expect(result.hints).to eql(name: ['length must be within 2 - 4'])
-      end
-    end
-
-    describe '#message_set' do
-      it 'returns message set' do
-        expect(result.message_set.to_h).to eql(
-          name: ['must be filled', 'length must be within 2 - 4']
-        )
-      end
-    end
-  end
-end