dry-validation 0.7.4 → 0.8.0

data/spec/integration/schema/hash_schema_spec.rb

@@ -0,0 +1,47 @@
+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.Form do
+        configure { config.type_specs = true }
+
+        hash? do
+          required(:prefix, :int).filled
+          required(:value, :int).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,16 +1,16 @@
 RSpec.describe 'Inheriting schema' do
   subject(:schema) do
     Dry::Validation.Schema(base_schema) do
-      key(:location).schema do
-        key(:lat).required(:float?)
-        key(:lng).required(:float?)
+      required(:location).schema do
+        required(:lat).filled(:float?)
+        required(:lng).filled(:float?)
       end
     end
   end
 
   let(:base_schema) do
     Dry::Validation.Schema do
-      key(:city).required
+      required(:city).filled
     end
   end
 

data/spec/integration/schema/input_processor_spec.rb

@@ -5,18 +5,18 @@ RSpec.describe Dry::Validation::Schema, 'setting input processor in schema' do
         config.input_processor = :sanitizer
       end
 
-      key(:email).required
+      required(:email).filled
 
-      key(:age).maybe(:int?, gt?: 18)
+      required(:age).maybe(:int?, gt?: 18)
 
-      key(:address).schema do
-        key(:city).required
-        key(:street).required
+      required(:address).schema do
+        required(:city).filled
+        required(:street).filled
       end
 
-      key(:phone_numbers).each do
-        key(:prefix).required
-        key(:value).required
+      required(:phone_numbers).each do
+        required(:prefix).filled
+        required(:value).filled
       end
     end
   end

data/spec/integration/schema/json/explicit_types_spec.rb

@@ -0,0 +1,157 @@
+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,17 +1,23 @@
 RSpec.describe Dry::Validation::Schema::JSON, 'defining a schema' do
   subject(:schema) do
     Dry::Validation.JSON do
-      key(:email).required
+      configure do
+        def email?(value)
+          true
+        end
+      end
+
+      required(:email).filled
 
-      key(:age).maybe(:int?, gt?: 18)
+      required(:age).maybe(:int?, gt?: 18)
 
-      key(:address).schema do
-        key(:city).required
-        key(:street).required
+      required(:address).schema do
+        required(:city).filled
+        required(:street).filled
 
-        key(:loc).schema do
-          key(:lat).required(:float?)
-          key(:lng).required(:float?)
+        required(:loc).schema do
+          required(:lat).filled(:float?)
+          required(:lng).filled(:float?)
         end
       end
 
@@ -20,12 +26,6 @@ RSpec.describe Dry::Validation::Schema::JSON, 'defining a schema' do
       optional(:phone_number).maybe(:int?, gt?: 0)
 
       rule(:email_valid) { value(:email).email? }
-
-      configure do
-        def email?(value)
-          true
-        end
-      end
     end
   end
 
@@ -121,9 +121,9 @@ RSpec.describe Dry::Validation::Schema::JSON, 'defining a schema' do
   describe 'with nested schema in a high-level rule' do
     subject(:schema) do
       Dry::Validation.JSON do
-        key(:address).maybe(:hash?)
+        required(:address).maybe(:hash?)
 
-        key(:delivery).required(:bool?)
+        required(:delivery).filled(:bool?)
 
         rule(address: [:delivery, :address]) do |delivery, address|
           delivery.true?.then(address.schema(AddressSchema))
@@ -133,8 +133,8 @@ RSpec.describe Dry::Validation::Schema::JSON, 'defining a schema' do
 
     before do
       AddressSchema = Dry::Validation.JSON do
-        key(:city).required
-        key(:zipcode).required(:int?)
+        required(:city).filled
+        required(:zipcode).filled(:int?)
       end
     end
 

data/spec/integration/schema/macros/confirmation_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe 'Macros #confirmation' do
           end
         end
 
-        key(:password).maybe(min_size?: 3).confirmation
+        required(:password).maybe(min_size?: 3).confirmation
       end
     end
 

data/spec/integration/schema/macros/each_spec.rb

@@ -1,43 +1,175 @@
 RSpec.describe 'Macros #each' do
-  context 'with a block' do
-    context 'with a nested key' do
-      subject(:schema) do
-        Dry::Validation.Schema do
-          key(:songs).each do
-            key(:title).required
-          end
-        end
+  context "predicate without options" do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:foo).each(:filled?, :str?)
       end
+    end
 
-      it 'passes when all elements are valid' do
-        songs = [{ title: 'Hello' }, { title: 'World' }]
+    context 'with valid input' do
+      let(:input) { { foo: %w(a b c) } }
 
-        expect(schema.(songs: songs)).to be_success
+      it 'is successful' do
+        expect(result).to be_successful
       end
+    end
 
-      it 'fails when value is not an array' do
-        expect(schema.(songs: 'oops').messages).to eql(songs: ['must be an array'])
+    context 'with invalid input' do
+      let(:input) { { foo: [[1, 2], "", "foo"] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing(0 => ["must be a string"], 1 => ["must be filled"])
       end
+    end
 
-      it 'fails when not all elements are valid' do
-        songs = [{ title: 'Hello' }, { title: nil }, { title: nil }]
+    context 'with invalid input type' do
+      let(:input) { { foo: nil } }
 
-        expect(schema.(songs: songs).messages).to eql(
-          songs: {
-            1 => { title: ['must be filled'] },
-            2 => { title: ['must be filled'] }
-          }
-        )
+      it 'is not successful' do
+        expect(result).to be_failing ["must be an array"]
+      end
+    end
+  end
+
+  context "predicate with options" do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:foo).each(size?: 3)
       end
     end
 
+    context 'with valid input' do
+      let(:input) { { foo: [[1,2,3], "foo"] } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'with invalid input' do
+      let(:input) { { foo: [[1,2], "foo"] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing({0=>["size must be 3"]})
+      end
+    end
+
+    context 'with invalid input type' do
+      let(:input) { { foo: nil } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ["must be an array", "size must be 3"]
+      end
+    end
+  end
+
+  context 'with filled macro' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:foo).filled(size?: 2) { each(:str?) }
+      end
+    end
+
+    context 'with valid input' do
+      let(:input) { { foo: %w(a b) } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'when value is not valid' do
+      let(:input) { { foo: ["foo"] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing(["size must be 2"])
+      end
+    end
+
+    context 'when value has invalid elements' do
+      let(:input) { { foo: [:foo, "foo"] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing(0 => ["must be a string"])
+      end
+    end
+  end
+
+  context 'with maybe macro' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:foo).maybe { each(:str?) }
+      end
+    end
+
+    context 'with nil input' do
+      let(:input) { { foo: nil } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'with valid input' do
+      let(:input) { { foo: %w(a b c) } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'with invalid input' do
+      let(:input) { { foo: [:foo, "foo"] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing(0 => ["must be a string"])
+      end
+    end
+  end
+
+  context 'with external schema macro' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:foo).each(FooSchema)
+      end
+    end
+
+    before do
+      FooSchema = Dry::Validation.Schema do
+        required(:bar).filled(:str?)
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :FooSchema)
+    end
+
+    context 'with valid input' do
+      let(:input) { { foo: [{ bar: "baz" }] } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'when value is not valid' do
+      let(:input) { { foo: [{ bar: 1 }] } }
+
+      it 'is not successful' do
+        # FIXME: our be_failing didn't work with such nested wow hash
+        expect(result.messages).to eql(foo: { 0 => { bar: ["must be a string"] } })
+      end
+    end
+  end
+
+  context 'with a block' do
     context 'with a nested schema' do
       subject(:schema) do
         Dry::Validation.Schema do
-          key(:songs).each do
+          required(:songs).each do
             schema do
-              key(:title).required
-              key(:author).required
+              required(:title).filled
+              required(:author).filled
             end
           end
         end
@@ -76,31 +208,33 @@ RSpec.describe 'Macros #each' do
   end
 
   context 'with inferred predicates and a form schema' do
-    subject(:schema) do
-      Dry::Validation.Form do
-        key(:songs).each(:str?)
+    context "predicate w/o options" do
+      subject(:schema) do
+        Dry::Validation.Form do
+          required(:songs).each(:str?)
+        end
       end
-    end
 
-    it 'passes when all elements are valid' do
-      songs = %w(hello world)
+      it 'passes when all elements are valid' do
+        songs = %w(hello world)
 
-      expect(schema.(songs: songs)).to be_success
-    end
+        expect(schema.(songs: songs)).to be_success
+      end
 
-    it 'fails when value is not an array' do
-      expect(schema.(songs: 'oops').messages).to eql(songs: ['must be an array'])
-    end
+      it 'fails when value is not an array' do
+        expect(schema.(songs: 'oops').messages).to eql(songs: ['must be an array'])
+      end
 
-    it 'fails when not all elements are valid' do
-      songs = ['hello', nil, 2]
+      it 'fails when not all elements are valid' do
+        songs = ['hello', nil, 2]
 
-      expect(schema.(songs: songs).messages).to eql(
-        songs: {
-          1 => ['must be a string'],
-          2 => ['must be a string']
-        }
-      )
+        expect(schema.(songs: songs).messages).to eql(
+          songs: {
+            1 => ['must be a string'],
+            2 => ['must be a string']
+          }
+        )
+      end
     end
   end
 end