dry-validation 0.7.4 → 0.8.0

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

@@ -0,0 +1,391 @@
+RSpec.describe 'Predicates: Includes' do
+  context 'with required' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        required(:foo) { array? { each { int? } & includes?(1) } }
+      end
+    end
+
+    context 'with valid input' do
+      let(:input) { { 'foo' => ['1', '2', '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', 'must include 1']
+      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", "must include 1"]
+      end
+    end
+
+    context 'with blank input' do
+      let(:input) { { 'foo' => '' } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must include 1']
+      end
+    end
+
+    context 'with invalid input' do
+      let(:input) { { 'foo' => ['2', '3', '4'] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must include 1']
+      end
+    end
+  end
+
+  context 'with optional' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        optional(:foo) { array? { each { int? } & includes?(1) } }
+      end
+    end
+
+    context 'with valid input' do
+      let(:input) { { 'foo' => ['1', '2', '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", "must include 1"]
+      end
+    end
+
+    context 'with blank input' do
+      let(:input) { { 'foo' => '' } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must include 1']
+      end
+    end
+
+    context 'with invalid input' do
+      let(:input) { { 'foo' => ['2', '3', '4'] } }
+
+      it 'is not successful' do
+        expect(result).to be_failing ['must include 1']
+      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(includes?: 'Hello')
+          end
+        end
+
+        context 'with valid input' do
+          let(:input) { { 'foo' => 'Hello World' } }
+
+          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 include Hello']
+          end
+        end
+
+        context 'with nil input' do
+          let(:input) { { 'foo' => nil } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+
+        context 'with blank input' do
+          let(:input) { { 'foo' => '' } }
+
+          it 'is successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+
+        context 'with invalid input' do
+          let(:input) { { 'foo' => 'bar' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+      end
+
+      context 'with filled' do
+        subject(:schema) do
+          Dry::Validation.Form do
+            required(:foo).filled(includes?: 'Hello')
+          end
+        end
+
+        context 'with valid input' do
+          let(:input) { { 'foo' => 'Hello World' } }
+
+          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 include Hello']
+          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 include Hello']
+          end
+        end
+
+        context 'with blank input' do
+          let(:input) { { 'foo' => '' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be filled', 'must include Hello']
+          end
+        end
+
+        context 'with invalid input' do
+          let(:input) { { 'foo' => 'bar' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+      end
+
+      context 'with maybe' do
+        subject(:schema) do
+          Dry::Validation.Form do
+            required(:foo).maybe(includes?: 'Hello')
+          end
+        end
+
+        context 'with valid input' do
+          let(:input) { { 'foo' => 'Hello World' } }
+
+          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 include Hello']
+          end
+        end
+
+        context 'with nil input' do
+          let(:input) { { 'foo' => nil } }
+
+          it 'is successful' do
+            expect(result).to be_success
+          end
+        end
+
+        context 'with blank input' do
+          let(:input) { { 'foo' => '' } }
+
+          it 'is successful' do
+            expect(result).to be_success
+          end
+        end
+
+        context 'with invalid input' do
+          let(:input) { { 'foo' => 'bar' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+      end
+    end
+
+    context 'with optional' do
+      context 'with value' do
+        subject(:schema) do
+          Dry::Validation.Form do
+            optional(:foo).value(includes?: 'Hello')
+          end
+        end
+
+        context 'with valid input' do
+          let(:input) { { 'foo' => 'Hello World' } }
+
+          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 include Hello']
+          end
+        end
+
+        context 'with blank input' do
+          let(:input) { { 'foo' => '' } }
+
+          it 'is successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+
+        context 'with invalid input' do
+          let(:input) { { 'foo' => 'bar' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+      end
+
+      context 'with filled' do
+        subject(:schema) do
+          Dry::Validation.Form do
+            optional(:foo).filled(includes?: 'Hello')
+          end
+        end
+
+        context 'with valid input' do
+          let(:input) { { 'foo' => 'Hello World' } }
+
+          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 include Hello']
+          end
+        end
+
+        context 'with blank input' do
+          let(:input) { { 'foo' => '' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must be filled', 'must include Hello']
+          end
+        end
+
+        context 'with invalid input' do
+          let(:input) { { 'foo' => 'bar' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+      end
+
+      context 'with maybe' do
+        subject(:schema) do
+          Dry::Validation.Form do
+            optional(:foo).maybe(includes?: 'Hello')
+          end
+        end
+
+        context 'with valid input' do
+          let(:input) { { 'foo' => 'Hello World' } }
+
+          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' => 'bar' } }
+
+          it 'is not successful' do
+            expect(result).to be_failing ['must include Hello']
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+#see: https://github.com/dry-rb/dry-validation/issues/127
+
+RSpec.describe 'Predicates: Key' do
+  context 'with required' do
+    xit "should raise error" do
+      expect { Dry::Validation.Form do
+        required(:foo) { key? }
+      end }.to raise_error InvalidSchemaError
+    end
+  end
+
+  context 'with optional' do
+    subject(:schema) do
+      xit "should raise error" do
+        expect { Dry::Validation.Form do
+          optional(:foo) { key? }
+        end }.to raise_error InvalidSchemaError
+      end
+    end
+  end
+
+  context 'as macro' do
+    context 'with required' do
+      context 'with value' do
+        xit "should raise error" do
+          expect { Dry::Validation.Form do
+            required(:foo).value(:key?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+
+      context 'with filled' do
+        xit "should raise error" do
+          expect { Dry::Validation.Form do
+            required(:foo).filled(:key?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+
+      context 'with maybe' do
+        xit "should raise error" do
+          expect { Dry::Validation.Form do
+            required(:foo).maybe(:key?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+    end
+
+    context 'with optional' do
+      context 'with value' do
+        xit "should raise error" do
+          expect { Dry::Validation.Schema do
+            optional(:foo).value(:key?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+
+      context 'with filled' do
+        xit "should raise error" do
+          expect { Dry::Validation.Schema do
+            optional(:foo).filled(:key?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+
+      context 'with maybe' do
+        xit "should raise error" do
+          expect { Dry::Validation.Schema do
+            optional(:foo).maybe(:key?)
+          end }.to raise_error InvalidSchemaError
+        end
+      end
+    end
+  end
+end