dry-validation 0.13.3 → 1.7.0

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

@@ -1,391 +0,0 @@
-RSpec.describe 'Predicates: Min Size' do
-  context 'with required' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        required(:foo) { min_size?(3) }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { 'foo' => %w(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', 'size cannot be less than 3']
-      end
-    end
-
-    context 'with nil input' do
-      let(:input) { { 'foo' => nil } }
-
-      it 'raises error' do
-        expect { result }.to raise_error(NoMethodError)
-      end
-    end
-
-    context 'with blank input' do
-      let(:input) { { 'foo' => '' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['size cannot be less than 3']
-      end
-    end
-
-    context 'with invalid input' do
-      let(:input) { { 'foo' => { 'a' => '1', 'b' => '2' } } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['size cannot be less than 3']
-      end
-    end
-  end
-
-  context 'with optional' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        optional(:foo) { min_size?(3) }
-      end
-    end
-
-    context 'with valid input' do
-      let(:input) { { 'foo' => %w(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 'raises error' do
-        expect { result }.to raise_error(NoMethodError)
-      end
-    end
-
-    context 'with blank input' do
-      let(:input) { { 'foo' => '' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['size cannot be less than 3']
-      end
-    end
-
-    context 'with invalid input' do
-      let(:input) { { 'foo' => { 'a' => '1', 'b' => '2' } } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['size cannot be less than 3']
-      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(min_size?: 3)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => %w(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', 'size cannot be less than 3']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { 'foo' => nil } }
-
-          it 'raises error' do
-            expect { result }.to raise_error(NoMethodError)
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['size cannot be less than 3']
-          end
-        end
-
-        context 'with invalid input' do
-          let(:input) { { 'foo' => { 'a' => '1', 'b' => '2' } } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['size cannot be less than 3']
-          end
-        end
-      end
-
-      context 'with filled' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            required(:foo).filled(min_size?: 3)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => %w(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', 'size cannot be less than 3']
-          end
-        end
-
-        context 'with nil input' do
-          let(:input) { { 'foo' => nil } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'size cannot be less than 3']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'size cannot be less than 3']
-          end
-        end
-
-        context 'with invalid input' do
-          let(:input) { { 'foo' => { 'a' => '1', 'b' => '2' } } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['size cannot be less than 3']
-          end
-        end
-      end
-
-      context 'with maybe' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            required(:foo).maybe(min_size?: 3)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => %w(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', 'size cannot be less than 3']
-          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' => { 'a' => '1', 'b' => '2' } } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['size cannot be less than 3']
-          end
-        end
-      end
-    end
-
-    context 'with optional' do
-      context 'with value' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            optional(:foo).value(min_size?: 3)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => %w(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 'raises error' do
-            expect { result }.to raise_error(NoMethodError)
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['size cannot be less than 3']
-          end
-        end
-
-        context 'with invalid input' do
-          let(:input) { { 'foo' => { 'a' => '1', 'b' => '2' } } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['size cannot be less than 3']
-          end
-        end
-      end
-
-      context 'with filled' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            optional(:foo).filled(min_size?: 3)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => %w(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 filled', 'size cannot be less than 3']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled', 'size cannot be less than 3']
-          end
-        end
-
-        context 'with invalid input' do
-          let(:input) { { 'foo' => { 'a' => '1', 'b' => '2' } } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['size cannot be less than 3']
-          end
-        end
-      end
-
-      context 'with maybe' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            optional(:foo).maybe(min_size?: 3)
-          end
-        end
-
-        context 'with valid input' do
-          let(:input) { { 'foo' => %w(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 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' => { 'a' => '1', 'b' => '2' } } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['size cannot be less than 3']
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,265 +0,0 @@
-RSpec.describe 'Predicates: None' do
-  context 'with required' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        required(:foo) { none? }
-      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 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 other input' do
-      let(:input) { { 'foo' => '23' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['cannot be defined']
-      end
-    end
-  end
-
-  context 'with optional' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        optional(:foo) { none? }
-      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 other input' do
-      let(:input) { { 'foo' => '23' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing ['cannot be defined']
-      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(:none?)
-          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 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 other input' do
-          let(:input) { { 'foo' => '23' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['cannot be defined']
-          end
-        end
-      end
-
-      context 'with filled' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            required(:foo).filled(:none?)
-          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 filled']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled']
-          end
-        end
-
-        context 'with other input' do
-          let(:input) { { 'foo' => '23' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['cannot be defined']
-          end
-        end
-      end
-
-      #makes no sense see: #134
-      context 'with maybe' do
-        it "raises error" do
-          expect { Dry::Validation.Params do
-            required(:foo).maybe(:none?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-    end
-
-    context 'with optional' do
-      context 'with value' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            optional(:foo).value(:none?)
-          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 other input' do
-          let(:input) { { 'foo' => '23' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['cannot be defined']
-          end
-        end
-      end
-
-      context 'with filled' do
-        subject(:schema) do
-          Dry::Validation.Params do
-            optional(:foo).filled(:none?)
-          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']
-          end
-        end
-
-        context 'with blank input' do
-          let(:input) { { 'foo' => '' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['must be filled']
-          end
-        end
-
-        context 'with other input' do
-          let(:input) { { 'foo' => '23' } }
-
-          it 'is not successful' do
-            expect(result).to be_failing ['cannot be defined']
-          end
-        end
-      end
-
-      #makes no sense see: #134
-      context 'with maybe' do
-        it "raises error" do
-          expect { Dry::Validation.Params do
-            optional(:foo).maybe(:none?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-    end
-  end
-end