dry-validation 0.7.4 → 0.8.0

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

@@ -0,0 +1,391 @@
+RSpec.describe 'Predicates: Type' do
+  context 'with required' do
+    subject(:schema) do
+      Dry::Validation.Schema 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.Schema 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.Schema 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.Schema 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.Schema 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 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
+    end
+
+    context 'with optional' do
+      context 'with value' do
+        subject(:schema) do
+          Dry::Validation.Schema 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.Schema 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.Schema 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 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
+    end
+  end
+end

data/spec/integration/schema/reusing_schema_spec.rb

@@ -1,9 +1,9 @@
 RSpec.describe 'Reusing schemas' do
   subject(:schema) do
     Dry::Validation.Schema do
-      key(:city).required
+      required(:city).filled
 
-      key(:location).schema(LocationSchema)
+      required(:location).schema(LocationSchema)
     end
   end
 
@@ -11,8 +11,8 @@ RSpec.describe 'Reusing schemas' do
     LocationSchema = Dry::Validation.Schema do
       configure { config.input_processor = :form }
 
-      key(:lat).required(:float?)
-      key(:lng).required(:float?)
+      required(:lat).filled(:float?)
+      required(:lng).filled(:float?)
     end
   end
 

data/spec/integration/schema/using_types_spec.rb

@@ -1,9 +1,9 @@
 RSpec.describe Dry::Validation::Schema, 'defining schema using dry types' do
   subject(:schema) do
     Dry::Validation.Schema do
-      key(:email).required(Email)
-      key(:age).maybe(Age)
-      key(:country).required(Country)
+      required(:email).filled(Email)
+      required(:age).maybe(Age)
+      required(:country).filled(Country)
       optional(:admin).maybe(AdminBit)
     end
   end
@@ -42,7 +42,8 @@ RSpec.describe Dry::Validation::Schema, 'defining schema using dry types' do
   end
 
   it 'fails when sum-type rule did not pass' do
-    expect(schema.(email: 'jane@doe', age: 19, country: 'Australia', admin: 'foo').messages).to eql(
+    result = schema.(email: 'jane@doe', age: 19, country: 'Australia', admin: 'foo')
+    expect(result.messages).to eql(
       admin: ['must be FalseClass', 'must be TrueClass']
     )
   end
@@ -50,7 +51,7 @@ RSpec.describe Dry::Validation::Schema, 'defining schema using dry types' do
   context "structs" do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:person).required(Person)
+        required(:person).filled(Person)
       end
     end
 
@@ -79,7 +80,7 @@ RSpec.describe Dry::Validation::Schema, 'defining schema using dry types' do
       Dry::Validation.Schema do
         configure { config.input_processor = :sanitizer }
 
-        key(:email).required(Dry::Types['strict.string'].constructor(&:strip))
+        required(:email).filled(Dry::Types['strict.string'].constructor(&:strip))
       end
     end
 
@@ -90,4 +91,21 @@ RSpec.describe Dry::Validation::Schema, 'defining schema using dry types' do
       expect(result.to_h).to eql(email: 'jane@doe.org')
     end
   end
+
+  context 'custom types' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        required(:quantity).filled(Dry::Types['strict.int'].constrained(gt: 1))
+        required(:percentage).filled(Dry::Types['strict.decimal'].constrained(gt: 0, lt: 1))
+        required(:switch).filled(Dry::Types['strict.bool'])
+      end
+    end
+
+    it 'applies custom types to input prior validation' do
+      result = schema.(quantity: '2', percentage: '0.5', switch: '0')
+
+      expect(result).to be_success
+      expect(result.to_h).to eql(quantity: 2, percentage: BigDecimal('0.5'), switch: false)
+    end
+  end
 end