dry-validation 0.7.4 → 0.8.0

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

@@ -0,0 +1,103 @@
+RSpec.describe 'Predicates: custom' do
+  context 'with custom predicate' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        configure do
+          config.messages_file = 'spec/fixtures/locales/en.yml'
+
+          def email?(current)
+            current.match(/\@/)
+          end
+        end
+
+        required(:foo) { email? }
+      end
+    end
+
+    context 'with valid input' do
+      let(:input) { { foo: 'test@dry-rb.org' } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'with invalid input' do
+      let(:input) { { foo: 'test' } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be an email']
+      end
+    end
+  end
+
+  context 'with custom predicates as module' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        configure do
+          config.messages_file = 'spec/fixtures/locales/en.yml'
+          predicates (Module.new do
+            include Dry::Logic::Predicates
+
+            predicate(:email?) do |current|
+              current.match(/@/)
+            end
+          end)
+        end
+
+        required(:foo) { email? }
+      end
+    end
+
+    context 'with valid input' do
+      let(:input) { { foo: 'test@hanamirb.org' } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'with invalid input' do
+      let(:input) { { foo: 'test' } }
+
+      it 'is successful' do
+        expect(result).to be_failing ['must be an email']
+      end
+    end
+  end
+
+  context 'without custom predicate' do
+    it 'raises error if try to use an unknown predicate' do
+      expect do
+        Dry::Validation.Schema do
+          required(:foo) { email? }
+        end
+      end.to raise_error(ArgumentError, '+email?+ is not a valid predicate name')
+    end
+  end
+
+  context 'with nested validations' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:details).schema do
+          configure do
+            config.messages_file = 'spec/fixtures/locales/en.yml'
+
+            def odd?(current)
+              current.odd?
+            end
+          end
+
+          required(:foo) { odd? }
+        end
+      end
+    end
+
+    let(:input) { { details: { foo: 2 } } }
+
+    it 'allows groups to define their own custom predicates' do
+      expect(result).to_not be_success
+      expect(result.messages.fetch(:details)).to eq(foo: ['must be odd'])
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+RSpec.describe 'Predicates: Empty' do
+  context 'with required' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:foo) { empty? }
+      end
+    end
+
+    context 'with valid input (array)' do
+      let(:input) { { foo: [] } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'with valid input (hash)' do
+      let(:input) { { foo: {} } }
+
+      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 empty']
+      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 input' do
+      let(:input) { { foo: [23] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be empty']
+      end
+    end
+  end
+
+  context 'with optional' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        optional(:foo) { empty? }
+      end
+    end
+
+    context 'with valid input (array)' do
+      let(:input) { { foo: [] } }
+
+      it 'is successful' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'with valid input (hash)' do
+      let(:input) { { foo: {} } }
+
+      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 input' do
+      let(:input) { { foo: [23] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be empty']
+      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(:empty?)
+          end
+        end
+
+        context 'with valid input (array)' do
+          let(:input) { { foo: [] } }
+
+          it 'is successful' do
+            expect(result).to be_successful
+          end
+        end
+
+        context 'with valid input (hash)' do
+          let(:input) { { foo: {} } }
+
+          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 empty']
+          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 input' do
+          let(:input) { { foo: [23] } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be empty']
+          end
+        end
+      end
+
+      context 'with filled' do
+        it "should raise error" do
+          expect { Dry::Validation.Schema do
+            required(:foo).filled(:empty?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+
+      context 'with maybe' do
+        it "should raise error" do
+          expect { Dry::Validation.Schema do
+            required(:foo).maybe(:empty?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+    end
+
+    context 'with optional' do
+      context 'with value' do
+        subject(:schema) do
+          Dry::Validation.Schema do
+            optional(:foo).value(:empty?)
+          end
+        end
+
+        context 'with valid input (array)' do
+          let(:input) { { foo: [] } }
+
+          it 'is successful' do
+            expect(result).to be_successful
+          end
+        end
+
+        context 'with valid input (hash)' do
+          let(:input) { { foo: {} } }
+
+          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 input' do
+          let(:input) { { foo: [23] } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be empty']
+          end
+        end
+      end
+
+      context 'with filled' do
+        it "should raise error" do
+          expect { Dry::Validation.Schema do
+            optional(:foo).filled(:empty?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+
+      context 'with maybe' do
+        it "should raise error" do
+          expect { Dry::Validation.Schema do
+            optional(:foo).maybe(:empty?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,327 @@
+RSpec.describe 'Predicates: Eql' do
+  context 'with required' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:foo) { eql?(23) }
+      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 equal to 23']
+      end
+    end
+
+    context 'with nil input' do
+      let(:input) { { foo: nil } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be equal to 23']
+      end
+    end
+
+    context 'with blank input' do
+      let(:input) { { foo: '' } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be equal to 23']
+      end
+    end
+  end
+
+  context 'with optional' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        optional(:foo) { eql?(23) }
+      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 equal to 23']
+      end
+    end
+
+    context 'with blank input' do
+      let(:input) { { foo: '' } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must be equal to 23']
+      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(eql?: 23)
+          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 equal to 23']
+          end
+        end
+
+        context 'with nil input' do
+          let(:input) { { foo: nil } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be equal to 23']
+          end
+        end
+
+        context 'with blank input' do
+          let(:input) { { foo: '' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be equal to 23']
+          end
+        end
+      end
+
+      context 'with filled' do
+        subject(:schema) do
+          Dry::Validation.Schema do
+            required(:foo).filled(eql?: 23)
+          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 equal to 23']
+          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 equal to 23']
+          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 equal to 23']
+          end
+        end
+      end
+
+      context 'with maybe' do
+        subject(:schema) do
+          Dry::Validation.Schema do
+            required(:foo).maybe(eql?: 23)
+          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 equal to 23']
+          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 equal to 23']
+          end
+        end
+      end
+    end
+
+    context 'with optional' do
+      context 'with value' do
+        subject(:schema) do
+          Dry::Validation.Schema do
+            optional(:foo).value(eql?: 23)
+          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 equal to 23']
+          end
+        end
+
+        context 'with blank input' do
+          let(:input) { { foo: '' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be equal to 23']
+          end
+        end
+      end
+
+      context 'with filled' do
+        subject(:schema) do
+          Dry::Validation.Schema do
+            optional(:foo).filled(eql?: 23)
+          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 equal to 23']
+          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 equal to 23']
+          end
+        end
+      end
+
+      context 'with maybe' do
+        subject(:schema) do
+          Dry::Validation.Schema do
+            optional(:foo).maybe(eql?: 23)
+          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 equal to 23']
+          end
+        end
+      end
+    end
+  end
+end