dry-validation 0.7.4 → 0.8.0

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

@@ -0,0 +1,243 @@
+RSpec.describe 'Predicates: Array' do
+  context 'with required' do
+    subject(:schema) do
+      Dry::Validation.Form 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 successful' do
+        expect(result).to be_successful
+      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' => %w(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 (mixed array)' do
+      let(:input) { { 'foo' => %w(1 bar) } }
+
+      it 'is not successful' do
+        expect(result).to be_failing 1 => ['must be an integer']
+      end
+    end
+  end
+
+  context 'with optional' do
+    subject(:schema) do
+      Dry::Validation.Form 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 successful' do
+        expect(result).to be_successful
+      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' => %w(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 (mixed array)' do
+      let(:input) { { 'foo' => %w(1 bar) } }
+
+      it 'is not successful' do
+        expect(result).to be_failing 1 => ['must be an integer']
+      end
+    end
+  end
+
+  context 'as macro' do
+    context 'with required' do
+      subject(:schema) do
+        Dry::Validation.Form 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 successful' do
+          expect(result).to be_successful
+        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
+
+    context 'with optional' do
+      subject(:schema) do
+        Dry::Validation.Form do
+          optional(:foo).each(:int?)
+        end
+      end
+
+      context 'with missing input' do
+        let(:input) { {} }
+
+        it 'is not 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 successful' do
+          expect(result).to be_successful
+        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

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

@@ -0,0 +1,263 @@
+RSpec.describe 'Predicates: Empty' do
+  context 'with required' do
+    subject(:schema) do
+      Dry::Validation.Form 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.Form 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.Form 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.Form do
+            required(:foo).filled(:empty?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+
+      context 'with maybe' do
+        it "should raise error" do
+          expect { Dry::Validation.Form 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.Form 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.Form do
+            optional(:foo).filled(:empty?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+
+      context 'with maybe' do
+        it "should raise error" do
+          expect { Dry::Validation.Form do
+            optional(:foo).maybe(:empty?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+    end
+  end
+end