dry-validation 0.6.0 → 0.7.0

data/spec/integration/schema/option_with_default_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Dry::Validation::Schema, 'defining an option with default value' do
+  subject(:schema) do
+    Dry::Validation.Schema do
+      configure do
+        option :db, -> { DB }
+
+        def unique?(name, value)
+          DB.none? { |item| item[name] == value }
+        end
+      end
+
+      key(:email) { filled? & unique?(:email) }
+    end
+  end
+
+  before do
+    DB = [{ email: 'jane@doe' }]
+  end
+
+  after do
+    Object.send(:remove_const, :DB)
+  end
+
+  it 'uses external dependency set by option with a default value' do
+    expect(schema.db).to be(DB)
+
+    expect(schema.(email: 'jade@doe')).to be_success
+    expect(schema.(email: 'jane@doe')).to be_failure
+  end
+end

data/spec/integration/schema/reusing_schema_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe 'Reusing schemas' do
+  subject(:schema) do
+    Dry::Validation.Schema do
+      key(:city).required
+
+      key(:location).schema(LocationSchema)
+    end
+  end
+
+  before do
+    LocationSchema = Dry::Validation.Schema do
+      configure { config.input_processor = :form }
+
+      key(:lat).required(:float?)
+      key(:lng).required(:float?)
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :LocationSchema)
+  end
+
+  it 're-uses existing schema' do
+    expect(schema.(city: 'NYC', location: { lat: 1.23, lng: 45.6 })).to be_success
+
+    expect(schema.(city: 'NYC', location: { lat: nil, lng: '45.6' }).messages).to eql(
+      location: {
+        lat: ['must be filled'],
+        lng: ['must be a float']
+      }
+    )
+  end
+end

data/spec/integration/schema/using_types_spec.rb

@@ -0,0 +1,29 @@
+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)
+    end
+  end
+
+  before do
+    Email = Dry::Types['strict.string']
+    Age = Dry::Types['strict.int'].constrained(gt: 18)
+  end
+
+  after do
+    Object.send(:remove_const, :Email)
+    Object.send(:remove_const, :Age)
+  end
+
+  it 'passes when input is valid' do
+    expect(schema.(email: 'jane@doe', age: 19)).to be_success
+    expect(schema.(email: 'jane@doe', age: nil)).to be_success
+  end
+
+  it 'fails when input is not valid' do
+    expect(schema.(email: '', age: 19)).to_not be_success
+    expect(schema.(email: 'jane@doe', age: 17)).to_not be_success
+    expect(schema.(email: 'jane@doe', age: '19')).to_not be_success
+  end
+end

data/spec/integration/schema/xor_spec.rb

@@ -1,32 +1,35 @@
 RSpec.describe 'Schema with xor rules' do
-  subject(:validate) { schema.new }
-
-  let(:schema) do
-    Class.new(Dry::Validation::Schema) do
-      def self.messages
-        Messages.default.merge(
-          en: { errors: { be_reasonable: 'you cannot eat cake and have cake!' } }
-        )
+  subject(:schema) do
+    Dry::Validation.Schema do
+      configure do
+        def self.messages
+          Messages.default.merge(
+            en: { errors: { be_reasonable: 'you cannot eat cake and have cake!' } }
+          )
+        end
       end
 
-      key(:eat_cake) { |v| v.eql?('yes!') }
-      key(:have_cake) { |v| v.eql?('yes!') }
+      key(:eat_cake).required
+
+      key(:have_cake).required
 
-      rule(:be_reasonable) { rule(:eat_cake) ^ rule(:have_cake) }
+      rule(:be_reasonable) do
+        value(:eat_cake).eql?('yes!') ^ value(:have_cake).eql?('yes!')
+      end
     end
   end
 
   describe '#messages' do
     it 'passes when only one option is selected' do
-      messages = validate.(eat_cake: 'yes!', have_cake: 'no!').messages[:be_reasonable]
+      messages = schema.(eat_cake: 'yes!', have_cake: 'no!').messages[:be_reasonable]
 
       expect(messages).to be(nil)
     end
 
     it 'fails when both options are selected' do
-      messages = validate.(eat_cake: 'yes!', have_cake: 'yes!').messages[:be_reasonable]
+      messages = schema.(eat_cake: 'yes!', have_cake: 'yes!').messages[:be_reasonable]
 
-      expect(messages).to eql([['you cannot eat cake and have cake!'], 'yes!'])
+      expect(messages).to eql(['you cannot eat cake and have cake!'])
     end
   end
 end

data/spec/integration/schema_spec.rb

@@ -1,179 +1,55 @@
-RSpec.describe Dry::Validation::Schema do
-  subject(:validation) { schema.new }
-
-  describe 'defining key-based schema (hash-like)' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        key(:email) { |email| email.filled? }
-
-        key(:age) do |age|
-          age.none? | (age.int? & age.gt?(18))
-        end
-
-        key(:address) do |address|
-          address.hash? do
-            address.key(:city) do |city|
-              city.min_size?(3)
-            end
-
-            address.key(:street) do |street|
-              street.filled?
-            end
-
-            address.key(:country) do |country|
-              country.key(:name, &:filled?)
-              country.key(:code, &:filled?)
-            end
-          end
-        end
-
-        key(:phone_numbers) do |phone_numbers|
-          phone_numbers.array? { phone_numbers.each(&:str?) }
-        end
+RSpec.describe Dry::Validation::Schema, 'defining key-based schema' do
+  describe 'with a flat structure' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:email).required
+        key(:age) { none? | (int? & gt?(18)) }
       end
     end
 
-    let(:input) do
-      {
-        email: 'jane@doe.org',
-        age: 19,
-        address: { city: 'NYC', street: 'Street 1/2', country: { code: 'US', name: 'USA' } },
-        phone_numbers: [
-          '123456', '234567'
-        ]
-      }.freeze
+    it 'passes when input is valid' do
+      expect(schema.(email: 'jane@doe', age: 19)).to be_success
+      expect(schema.(email: 'jane@doe', age: nil)).to be_success
     end
 
-    describe '#messages' do
-      it 'returns compiled error messages' do
-        expect(validation.(input.merge(email: '')).messages).to match_array([
-          [:email, [['email must be filled'], '']]
-        ])
-      end
+    it 'fails when input is not valid' do
+      expect(schema.(email: 'jane@doe', age: 17)).to_not be_success
     end
 
-    describe '#call' do
-      it 'passes when attributes are valid' do
-        expect(validation.(input)).to be_empty
-      end
-
-      it 'validates presence of an email and min age value' do
-        expect(validation.(input.merge(email: '', age: 18))).to match_array([
-          [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
-          [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]]
-        ])
-      end
-
-      it 'validates presence of the email key and type of age value' do
-        expect(validation.(name: 'Jane', age: '18', address: input[:address], phone_numbers: input[:phone_numbers])).to match_array([
-          [:error, [:input, [:age, "18", [[:val, [:age, [:predicate, [:int?, []]]]]]]]],
-          [:error, [:input, [:email, nil, [[:key, [:email, [:predicate, [:key?, [:email]]]]]]]]]
-        ])
-      end
-
-      it 'validates presence of the address and phone_number keys' do
-        expect(validation.(email: 'jane@doe.org', age: 19)).to match_array([
-          [:error, [:input, [:address, nil, [[:key, [:address, [:predicate, [:key?, [:address]]]]]]]]],
-          [:error, [:input, [:phone_numbers, nil, [[:key, [:phone_numbers, [:predicate, [:key?, [:phone_numbers]]]]]]]]]
-        ])
-      end
-
-      it 'validates presence of keys under address and min size of the city value' do
-        expect(validation.(input.merge(address: { city: 'NY' }))).to match_array([
-          [:error, [
-            :input, [
-              :address, {city: "NY"},
-              [
-                [:input, [:city, "NY", [[:val, [:city, [:predicate, [:min_size?, [3]]]]]]]],
-                [:input, [:street, nil, [[:key, [:street, [:predicate, [:key?, [:street]]]]]]]],
-                [:input, [:country, nil, [[:key, [:country, [:predicate, [:key?, [:country]]]]]]]]
-              ]
-            ]
-          ]]
-        ])
-      end
+    it 'returns result which quacks like hash' do
+      input = { email: 'jane@doe', age: 19 }
+      result = schema.(input)
 
-      it 'validates address type' do
-        expect(validation.(input.merge(address: 'totally not a hash'))).to match_array([
-          [:error, [:input, [:address, "totally not a hash", [[:val, [:address, [:predicate, [:hash?, []]]]]]]]]
-        ])
-      end
-
-      it 'validates address code and name values' do
-        expect(validation.(input.merge(address: input[:address].merge(country: { code: 'US', name: '' })))).to match_array([
-          [:error, [
-            :input, [
-              :address, {city: "NYC", street: "Street 1/2", country: {code: "US", name: ""}},
-              [
-                [
-                  :input, [
-                    :country, {code: "US", name: ""}, [
-                      [
-                        :input, [
-                          :name, "", [[:val, [:name, [:predicate, [:filled?, []]]]]]
-                        ]
-                      ]
-                    ]
-                  ]
-                ]
-              ]
-            ]
-          ]]
-        ])
-      end
+      expect(result[:email]).to eql('jane@doe')
+      expect(Hash[result]).to eql(input)
 
-      it 'validates each phone number' do
-        expect(validation.(input.merge(phone_numbers: ['123', 312]))).to match_array([
-          [:error, [
-            :input, [
-              :phone_numbers, ["123", 312],
-              [
-                [
-                  :input, [
-                    :phone_numbers, 312, [
-                      [:val, [:phone_numbers, [:predicate, [:str?, []]]]]
-                    ]
-                  ]
-                ]
-              ]
-            ]
-          ]]
-        ])
-      end
+      expect(result.to_a).to eql([[:email, 'jane@doe'], [:age, 19]])
     end
   end
 
-  describe 'defining attr-based schema (model-like)' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        attr(:email) { |email| email.filled? }
+  describe 'with nested structures' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        key(:email).required
 
-        attr(:age) do |age|
-          age.none? | (age.int? & age.gt?(18))
-        end
+        key(:age).maybe(:int?, gt?: 18)
 
-        attr(:address) do |address|
-          address.attr(:city) do |city|
-            city.min_size?(3)
-          end
+        key(:address).schema do
+          key(:city).required(min_size?: 3)
 
-          address.attr(:street) do |street|
-            street.filled?
-          end
+          key(:street).required
 
-          address.attr(:country) do |country|
-            country.attr(:name, &:filled?)
-            country.attr(:code, &:filled?)
+          key(:country).schema do
+            key(:name).required
+            key(:code).required
           end
         end
 
-        attr(:phone_numbers) do |phone_numbers|
-          phone_numbers.array? { phone_numbers.each(&:str?) }
-        end
+        key(:phone_numbers).each(:str?)
       end
     end
 
-    let(:input_data) do
+    let(:input) do
       {
         email: 'jane@doe.org',
         age: 19,
@@ -184,126 +60,80 @@ RSpec.describe Dry::Validation::Schema do
       }.freeze
     end
 
-    def input(data = input_data)
-      struct_from_hash(data)
-    end
-
     describe '#messages' do
       it 'returns compiled error messages' do
-        expect(validation.(input(input_data.merge(email: ''))).messages).to match_array([
-          [:email, [["email must be filled"], '']]
-        ])
+        expect(schema.(input.merge(email: '')).messages).to eql(
+          email: ['must be filled']
+        )
       end
     end
 
     describe '#call' do
       it 'passes when attributes are valid' do
-        expect(validation.(input)).to be_empty
+        expect(schema.(input)).to be_success
       end
 
       it 'validates presence of an email and min age value' do
-        expect(validation.(input(input_data.merge(email: '', age: 18)))).to match_array([
-          [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
-          [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]]
-        ])
+        expect(schema.(input.merge(email: '', age: 18)).messages).to eql(
+          email: ['must be filled'], age: ['must be greater than 18']
+        )
       end
 
-      it 'validates presence of the email attr and type of age value' do
-        input_object = input(input_data.reject { |k, v| k == :email }.merge(age: '18'))
+      it 'validates presence of the email key and type of age value' do
+        attrs = {
+          name: 'Jane',
+          age: '18',
+          address: input[:address], phone_numbers: input[:phone_numbers]
+        }
 
-        expect(validation.(input_object)).to match_array([
-          [:error, [:input, [:age, "18", [[:val, [:age, [:predicate, [:int?, []]]]]]]]],
-          [:error, [:input, [:email, input_object, [[:attr, [:email, [:predicate, [:attr?, [:email]]]]]]]]]
-        ])
+        expect(schema.(attrs).messages).to eql(
+          email: ['is missing'],
+          age: ['must be an integer', 'must be greater than 18']
+        )
       end
 
       it 'validates presence of the address and phone_number keys' do
-        input_object = input(email: 'jane@doe.org', age: 19)
+        attrs = { email: 'jane@doe.org', age: 19 }
 
-        expect(validation.(input_object)).to match_array([
-          [:error, [
-            :input, [
-              :address, input_object,
-              [
-                [:attr, [:address, [:predicate, [:attr?, [:address]]]]]
-              ]
-            ]
-          ]],
-          [:error, [
-            :input, [
-              :phone_numbers, input_object,
-              [
-                [:attr, [:phone_numbers, [:predicate, [:attr?, [:phone_numbers]]]]]
-              ]
-            ]
-          ]]
-        ])
+        expect(schema.(attrs).messages).to eql(
+          address: ['is missing'], phone_numbers: ['is missing']
+        )
       end
 
       it 'validates presence of keys under address and min size of the city value' do
-        address = { city: 'NY' }
-        input_object = input(input_data.merge(address: address))
-        address_object = input_object.address.class.from_hash(address)
+        attrs = input.merge(address: { city: 'NY' })
 
-        expect(validation.(input_object)).to match_array([
-          [:error, [
-            :input, [
-              :address, address_object,
-              [
-                [:input, [:city, "NY", [[:val, [:city, [:predicate, [:min_size?, [3]]]]]]]],
-                [:input, [:street, address_object, [[:attr, [:street, [:predicate, [:attr?, [:street]]]]]]]],
-                [:input, [:country, address_object, [[:attr, [:country, [:predicate, [:attr?, [:country]]]]]]]]
-              ]
-            ]
-          ]]
-        ])
+        expect(schema.(attrs).messages).to eql(
+          address: {
+            street: ['is missing'],
+            country: ['is missing'],
+            city: ['size cannot be less than 3']
+          }
+        )
       end
 
-      it 'validates address code and name values' do
-        input_object = input(input_data.merge(address: input_data[:address].merge(country: { code: 'US', name: '' })))
+      it 'validates address type' do
+        expect(schema.(input.merge(address: 'totally not a hash')).messages).to eql(
+          address: ['must be a hash']
+        )
+      end
 
-        country_object = input_object.address.country.class.from_hash(code: "US", name: "")
+      it 'validates address code and name values' do
+        attrs = input.merge(
+          address: input[:address].merge(country: { code: 'US', name: '' })
+        )
 
-        expect(validation.(input_object)).to match_array([
-          [:error, [
-            :input, [
-              :address, input_object.address.class.from_hash(city: "NYC", street: "Street 1/2", country: country_object),
-              [
-                [
-                  :input, [
-                    :country, country_object, [
-                      [
-                        :input, [
-                          :name, "", [[:val, [:name, [:predicate, [:filled?, []]]]]]
-                        ]
-                      ]
-                    ]
-                  ]
-                ]
-              ]
-            ]
-          ]]
-        ])
+        expect(schema.(attrs).messages).to eql(
+          address: { country: { name: ['must be filled'] } }
+        )
       end
 
       it 'validates each phone number' do
-        input_object = input(input_data.merge(phone_numbers: ['123', 312]))
+        attrs = input.merge(phone_numbers: ['123', 312])
 
-        expect(validation.(input_object)).to match_array([
-          [:error, [
-            :input, [
-              :phone_numbers, ["123", 312],[
-                [
-                  :input, [
-                    :phone_numbers, 312, [
-                      [:val, [:phone_numbers, [:predicate, [:str?, []]]]]
-                    ]
-                  ]
-                ]
-              ]
-            ]
-          ]]
-        ])
+        expect(schema.(attrs).messages).to eql(
+          phone_numbers: { 1 => ['must be a string'] }
+        )
       end
     end
   end