dry-validation 0.12.0 → 1.6.0

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

@@ -1,391 +0,0 @@
-RSpec.describe 'Predicates: Includes' do
-  context 'with required' do
-    subject(:schema) do
-      Dry::Validation.Params 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.Params 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.Params 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.Params 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.Params 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.Params 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.Params 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.Params 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/params/predicates/key_spec.rb

@@ -1,67 +0,0 @@
-RSpec.describe 'Predicates: Key' do
-  context 'with required' do
-    it "raises error" do
-      expect { Dry::Validation.Params { required(:foo) { key? } } }.to raise_error InvalidSchemaError
-    end
-  end
-
-  context 'with optional' do
-    it "raises error" do
-      expect { Dry::Validation.Params { optional(:foo) { key? } } }.to raise_error InvalidSchemaError
-    end
-  end
-
-  context 'as macro' do
-    context 'with required' do
-      context 'with value' do
-        it "raises error" do
-          expect { Dry::Validation.Params do
-            required(:foo).value(:key?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-
-      context 'with filled' do
-        it "raises error" do
-          expect { Dry::Validation.Params do
-            required(:foo).filled(:key?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-
-      context 'with maybe' do
-        it "raises error" do
-          expect { Dry::Validation.Params do
-            required(:foo).maybe(:key?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-    end
-
-    context 'with optional' do
-      context 'with value' do
-        it "raises error" do
-          expect { Dry::Validation.Schema do
-            optional(:foo).value(:key?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-
-      context 'with filled' do
-        it "raises error" do
-          expect { Dry::Validation.Schema do
-            optional(:foo).filled(:key?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-
-      context 'with maybe' do
-        it "raises error" do
-          expect { Dry::Validation.Schema do
-            optional(:foo).maybe(:key?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-    end
-  end
-end