dry-validation 0.7.4 → 0.8.0

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

@@ -0,0 +1,391 @@
+RSpec.describe 'Predicates: Type' do
+  context 'with required' do
+    subject(:schema) do
+      Dry::Validation.Form 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.Form 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.Form 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.Form 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.Form 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.Form 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.Form 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.Form 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/hints_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe 'Validation hints' do
   context 'with yaml messages' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:age) do |age|
+        required(:age) do |age|
           age.none? | (age.int? & age.gt?(18))
         end
       end
@@ -32,7 +32,7 @@ RSpec.describe 'Validation hints' do
       Dry::Validation.Schema do
         configure { configure { |c| c.messages = :i18n } }
 
-        key(:age) do |age|
+        required(:age) do |age|
           age.none? | (age.int? & age.gt?(18))
         end
       end
@@ -44,8 +44,8 @@ RSpec.describe 'Validation hints' do
   context 'when type expectation is specified' do
     subject(:schema)  do
       Dry::Validation.Schema do
-        key(:email).required
-        key(:name).required(:str?, size?: 5..25)
+        required(:email).filled
+        required(:name).filled(:str?, size?: 5..25)
       end
     end
 
@@ -55,4 +55,90 @@ RSpec.describe 'Validation hints' do
       )
     end
   end
+
+  context 'when predicate failed and there is a corresponding hint generated' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:age).value(lt?: 23)
+      end
+    end
+
+    it 'provides only failure error message' do
+      result = schema.call(age: 23)
+      expect(result.messages).to eql(age: ['must be less than 23'])
+    end
+  end
+
+  context 'with a nested schema with same rule names' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:code).filled(:str?, eql?: 'foo')
+
+        required(:nested).schema do
+          required(:code).filled(:str?, eql?: 'bar')
+        end
+      end
+    end
+
+    it 'provides error messages' do
+      result = schema.call(code: 'x', nested: { code: 'y' })
+
+      expect(result.messages).to eql(
+        code: ['must be equal to foo'],
+        nested: {
+          code: ['must be equal to bar']
+        }
+      )
+    end
+
+    it 'provides hints' do
+      result = schema.call(code: '', nested: { code: '' })
+
+      expect(result.messages).to eql(
+        code: ['must be filled', 'must be equal to foo'],
+        nested: {
+          code: ['must be filled', 'must be equal to bar']
+        }
+      )
+    end
+  end
+
+  context 'when the message uses input value' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        configure do
+          def self.messages
+            Messages.default.merge(
+              en: {
+                errors: {
+                  blue?: {
+                    failure: '%{value} is not equal to blue',
+                    hint: 'must be equal to blue'
+                  }
+                }
+              }
+            )
+          end
+
+          def blue?(value)
+            value == 'blue'
+          end
+        end
+
+        required(:pill).filled(:blue?)
+      end
+    end
+
+    it 'provides a correct failure message' do
+      expect(schema.(pill: 'red').messages).to eql(
+        pill: ['red is not equal to blue']
+      )
+    end
+
+    it 'provides a correct hint' do
+      expect(schema.(pill: nil).messages).to eql(
+        pill: ['must be filled', 'must be equal to blue']
+      )
+    end
+  end
 end