dry-validation 0.7.4 → 0.8.0

data/spec/integration/schema/macros/{required_spec.rb → filled_spec.rb}

@@ -1,8 +1,8 @@
-RSpec.describe 'Macros #required' do
+RSpec.describe 'Macros #filled' do
   describe 'with no args' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:email).required
+        required(:email).filled
       end
     end
 
@@ -16,7 +16,7 @@ RSpec.describe 'Macros #required' do
   describe 'with a type specification' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:age).required(:int?)
+        required(:age).filled(:int?)
       end
     end
 
@@ -31,7 +31,7 @@ RSpec.describe 'Macros #required' do
     context 'with a flat arg' do
       subject(:schema) do
         Dry::Validation.Schema do
-          key(:age).required(:int?, gt?: 18)
+          required(:age).filled(:int?, gt?: 18)
         end
       end
 
@@ -45,11 +45,39 @@ RSpec.describe 'Macros #required' do
     context 'with a range arg' do
       subject(:schema) do
         Dry::Validation.Schema do
-          key(:age).required(:int?, size?: 18..24)
+          required(:age).filled(:int?, size?: 18..24)
         end
       end
 
-      it 'generates filled? & int? & gt? rule' do
+      it 'generates filled? & int? & size? rule' do
+        expect(schema.(age: nil).messages).to eql(
+          age: ['must be filled', 'size must be within 18 - 24']
+        )
+      end
+    end
+
+    context 'with a block' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:age).filled { int? & size?(18..24) }
+        end
+      end
+
+      it 'generates filled? & int? & size? rule' do
+        expect(schema.(age: nil).messages).to eql(
+          age: ['must be filled', 'size must be within 18 - 24']
+        )
+      end
+    end
+
+    context 'with a predicate and a block' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:age).filled(:int?) { size?(18..24) }
+        end
+      end
+
+      it 'generates filled? & int? & size? rule' do
         expect(schema.(age: nil).messages).to eql(
           age: ['must be filled', 'size must be within 18 - 24']
         )

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

@@ -0,0 +1,21 @@
+RSpec.describe 'Macros #input' do
+  subject(:schema) do
+    Dry::Validation.Schema do
+      input :hash?
+
+      required(:foo).filled
+    end
+  end
+
+  it 'passes when input is valid' do
+    expect(schema.(foo: "bar")).to be_successful
+  end
+
+  it 'prepends a rule for the input' do
+    expect(schema.(nil).messages).to eql(["must be a hash"])
+  end
+
+  it 'applies other rules when input has expected type' do
+    expect(schema.(foo: '').messages).to eql(foo: ["must be filled"])
+  end
+end

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

@@ -2,7 +2,7 @@ RSpec.describe 'Macros #maybe' do
   describe 'with no args' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:email).maybe
+        required(:email).maybe
       end
     end
 
@@ -15,7 +15,7 @@ RSpec.describe 'Macros #maybe' do
   describe 'with a predicate with args' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:name).maybe(min_size?: 3)
+        required(:name).maybe(min_size?: 3)
       end
     end
 
@@ -29,4 +29,41 @@ RSpec.describe 'Macros #maybe' do
       )
     end
   end
+
+  describe 'with a block' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:name).maybe { str? & min_size?(3) }
+      end
+    end
+
+    it 'generates none? | (str? & min_size?) rule' do
+      expect(schema.(name: nil).messages).to be_empty
+
+      expect(schema.(name: 'jane').messages).to be_empty
+
+      expect(schema.(name: 'xy').messages).to eql(
+        name: ['size cannot be less than 3']
+      )
+    end
+  end
+
+  describe 'with a predicate and a block' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:name).maybe(:str?) { min_size?(3) }
+      end
+    end
+
+    it 'generates none? | (str? & min_size?) rule' do
+      expect(schema.(name: nil).messages).to be_empty
+
+      expect(schema.(name: 'jane').messages).to be_empty
+
+      expect(schema.(name: 'xy').messages).to eql(
+        name: ['size cannot be less than 3']
+      )
+    end
+  end
 end
+

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

@@ -0,0 +1,105 @@
+RSpec.describe 'Macros #value' do
+  describe 'with no args' do
+    it 'raises an exception' do
+      expect { Dry::Validation.Schema { required(:email).value } }.to raise_error(
+        ArgumentError, "wrong number of arguments (given 0, expected at least 1)"
+      )
+    end
+  end
+
+  describe 'with a type specification' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:age).value(:int?)
+      end
+    end
+
+    it 'generates int? rule' do
+      expect(schema.(age: nil).messages).to eql(
+        age: ['must be an integer']
+      )
+    end
+  end
+
+  describe 'with a predicate with args' do
+    context 'with a flat arg' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:age).value(:int?, gt?: 18)
+        end
+      end
+
+      it 'generates int? & gt? rule' do
+        expect(schema.(age: nil).messages).to eql(
+          age: ['must be an integer', 'must be greater than 18']
+        )
+      end
+    end
+
+    context 'with a range arg' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:age).value(:int?, size?: 18..24)
+        end
+      end
+
+      it 'generates int? & gt? rule' do
+        expect(schema.(age: nil).messages).to eql(
+          age: ['must be an integer', 'size must be within 18 - 24']
+        )
+      end
+    end
+
+    context 'with a block' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:age).value { int? & size?(18..24) }
+        end
+      end
+
+      it 'generates int? & gt? rule' do
+        expect(schema.(age: nil).messages).to eql(
+          age: ['must be an integer', 'size must be within 18 - 24']
+        )
+      end
+    end
+
+    context 'with a predicate and a block' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:age).value(:int?) { size?(18..24) }
+        end
+      end
+
+      it 'generates int? & gt? rule' do
+        expect(schema.(age: nil).messages).to eql(
+          age: ['must be an integer', 'size must be within 18 - 24']
+        )
+      end
+    end
+
+    context 'with a schema' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:data).value(DataSchema)
+        end
+      end
+
+      before do
+        DataSchema = Dry::Validation.Schema do
+          required(:foo).filled(size?: 2..10)
+        end
+      end
+
+      after do
+        Object.send(:remove_const, :DataSchema)
+      end
+
+      it 'uses the schema' do
+        expect(schema.(data: { foo: '' }).messages).to eql(
+          data: { foo: ['must be filled', 'size must be within 2 - 10'] }
+        )
+      end
+    end
+  end
+end

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

@@ -2,9 +2,9 @@ RSpec.describe 'Macros #when' do
   context 'with a result rule returned from the block' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:email).maybe
+        required(:email).maybe
 
-        key(:login).required.when(:true?) do
+        required(:login).filled.when(:true?) do
           value(:email).filled?
         end
       end
@@ -22,10 +22,10 @@ RSpec.describe 'Macros #when' do
   describe 'with a result rule depending on another result' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:left).maybe(:int?)
-        key(:right).maybe(:int?)
+        required(:left).maybe(:int?)
+        required(:right).maybe(:int?)
 
-        key(:compare).maybe(:bool?).when(:true?) do
+        required(:compare).maybe(:bool?).when(:true?) do
           value(:left).gt?(value(:right))
         end
       end
@@ -43,10 +43,10 @@ RSpec.describe 'Macros #when' do
   describe 'with multiple result rules' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:email).maybe
-        key(:password).maybe
+        required(:email).maybe
+        required(:password).maybe
 
-        key(:login).maybe(:bool?).when(:true?) do
+        required(:login).maybe(:bool?).when(:true?) do
           value(:email).filled?
           value(:password).filled?
         end
@@ -62,4 +62,24 @@ RSpec.describe 'Macros #when' do
       )
     end
   end
+
+  context "predicate with options" do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:bar).maybe
+
+        required(:foo).filled.when(size?: 3) do
+          value(:bar).filled?
+        end
+      end
+    end
+
+    it 'generates check rule' do
+      expect(schema.(foo: [1,2,3], bar: nil).messages).to eql(
+        bar: ['must be filled']
+      )
+
+      expect(schema.(foo: [1,2], bar: nil).messages).to be_empty
+    end
+  end
 end

data/spec/integration/schema/nested_values_spec.rb

@@ -1,16 +1,19 @@
 RSpec.describe Schema, 'using nested values' do
   let(:schema) do
     Dry::Validation.Schema do
-      key(:email).maybe
+      required(:email).maybe
 
-      key(:settings) do
-        optional(:offers).required(:bool?).when(:true?) do
-          value([:settings, :newsletter]).false?
-        end
+      required(:settings).schema do
+        optional(:offers).filled(:bool?)
+        required(:newsletter).filled(:bool?)
+      end
+
+      rule(newsletter: [[:settings, :newsletter], [:settings, :offers]]) do |newsletter, offers|
+        offers.true?.then(newsletter.false?)
+      end
 
-        key(:newsletter).required(:bool?).when(:true?) do
-          value(:email).filled?
-        end
+      rule(email: [[:settings, :newsletter], :email]) do |newsletter, email|
+        newsletter.true?.then(email.filled?)
       end
     end
   end

data/spec/integration/schema/not_spec.rb

@@ -9,8 +9,8 @@ RSpec.describe 'Schema with negated rules' do
         end
       end
 
-      optional(:eat_cake).required
-      optional(:have_cake).required
+      optional(:eat_cake).filled
+      optional(:have_cake).filled
 
       rule(:be_reasonable) do
         value(:eat_cake).eql?('yes!') & value(:have_cake).eql?('yes!').not

data/spec/integration/schema/numbers_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Dry::Validation::Schema do
   subject(:schema) do
     Dry::Validation.Schema do
-      key(:age).required(:number?, :int?)
+      required(:age).filled(:number?, :int?)
     end
   end
 

data/spec/integration/schema/option_with_default_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Dry::Validation::Schema, 'defining an option with default value'
         end
       end
 
-      key(:email) { filled? & unique?(:email) }
+      required(:email) { filled? & unique?(:email) }
     end
   end
 

data/spec/integration/schema/predicate_verification_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe 'Verifying predicates in the DSL' do
+  it 'raises error when invalid predicate name is used' do
+    expect { Dry::Validation.Schema { required(:age).value(filled?: 312) } }
+      .to raise_error(ArgumentError, "filled? predicate arity is invalid")
+
+    expect { Dry::Validation.Schema { required(:age) { none? | filled?(312) } } }
+      .to raise_error(ArgumentError, "filled? predicate arity is invalid")
+  end
+end

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

@@ -0,0 +1,295 @@
+RSpec.describe 'Predicates: Array' do
+  context 'with required' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:foo) { array? { each { int? } } }
+      end
+    end
+
+    context 'with valid input' do
+      let(:input) { { foo: [3] } }
+
+      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']
+      end
+    end
+
+    context 'with nil input' do
+      let(:input) { { foo: nil } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be an array']
+      end
+    end
+
+    context 'with blank input' do
+      let(:input) { { foo: '' } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be an array']
+      end
+    end
+
+    context 'with invalid type' do
+      let(:input) { { foo: { a: 1 } } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be an array']
+      end
+    end
+
+    context 'with invalid input (integer)' do
+      let(:input) { { foo: 4 } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be an array']
+      end
+    end
+
+    context 'with invalid input (array with non-integers)' do
+      let(:input) { { foo: [:foo, :bar] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing 0 => ['must be an integer'], 1 => ['must be an integer']
+      end
+    end
+
+    context 'with invalid input (miexed array)' do
+      let(:input) { { foo: [1, '2', :bar] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing 1 => ['must be an integer'], 2 => ['must be an integer']
+      end
+    end
+  end
+
+  context 'with optional' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        optional(:foo) { array? { each { int? } } }
+      end
+    end
+
+    context 'with valid input' do
+      let(:input) { { foo: [3] } }
+
+      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 an array']
+      end
+    end
+
+    context 'with blank input' do
+      let(:input) { { foo: '' } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be an array']
+      end
+    end
+
+    context 'with invalid type' do
+      let(:input) { { foo: { a: 1 } } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be an array']
+      end
+    end
+
+    context 'with invalid input (integer)' do
+      let(:input) { { foo: 4 } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be an array']
+      end
+    end
+
+    context 'with invalid input (array with non-integers)' do
+      let(:input) { { foo: [:foo, :bar] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing 0 => ['must be an integer'], 1 => ['must be an integer']
+      end
+    end
+
+    context 'with invalid input (miexed array)' do
+      let(:input) { { foo: [1, '2', :bar] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing 1 => ['must be an integer'], 2 => ['must be an integer']
+      end
+    end
+  end
+
+  context 'as macro' do
+    context 'with required' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:foo).each(:int?)
+        end
+      end
+
+      context 'with missing input' do
+        let(:input) { {} }
+
+        it 'is not successful' do
+          expect(result).to be_failing ['is missing']
+        end
+      end
+
+      context 'with nil input' do
+        let(:input) { { foo: nil } }
+
+        it 'is not successful' do
+          expect(result).to be_failing ['must be an array']
+        end
+      end
+
+      context 'with blank input' do
+        let(:input) { { foo: '' } }
+
+        it 'is not successful' do
+          expect(result).to be_failing ['must be an array']
+        end
+      end
+
+      context 'with valid input' do
+        let(:input) { { foo: [3] } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with invalid input' do
+        let(:input) { { foo: [:bar] } }
+
+        it 'is not successful' do
+          expect(result).to be_failing 0 => ['must be an integer']
+        end
+      end
+
+      context "when using an input_processor" do
+        subject(:schema) do
+          Dry::Validation.Schema do
+            configure do
+              config.input_processor = :sanitizer
+            end
+
+            required(:foo).each(:int?)
+          end
+        end
+
+        context 'with missing input' do
+          let(:input) { {} }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['is missing']
+          end
+        end
+
+        context 'with nil input' do
+          let(:input) { { foo: nil } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be an array']
+          end
+        end
+
+        context 'with blank input' do
+          let(:input) { { foo: '' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be an array']
+          end
+        end
+
+        context 'with valid input' do
+          let(:input) { { foo: [3] } }
+
+          it 'is successful' do
+            expect(result).to be_successful
+          end
+        end
+
+        context 'with invalid input' do
+          let(:input) { { foo: [:bar] } }
+
+          it 'is not successful' do
+            expect(result).to be_failing 0 => ['must be an integer']
+          end
+        end
+      end
+    end
+
+    context 'with optional' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          optional(:foo).each(:int?)
+        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 an array']
+        end
+      end
+
+      context 'with blank input' do
+        let(:input) { { foo: '' } }
+
+        it 'is not successful' do
+          expect(result).to be_failing ['must be an array']
+        end
+      end
+
+      context 'with valid input' do
+        let(:input) { { foo: [3] } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with invalid input' do
+        let(:input) { { foo: [:bar] } }
+
+        it 'is not successful' do
+          expect(result).to be_failing 0 => ['must be an integer']
+        end
+      end
+    end
+  end
+end