dry-validation 0.12.0 → 1.6.0

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

@@ -1,103 +0,0 @@
-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(/\@/).nil?
-          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
-
-            def self.email?(current)
-              !current.match(/\@/).nil?
-            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[:details]).to eq(foo: ['must be odd'])
-    end
-  end
-end

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

@@ -1,263 +0,0 @@
-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 "raises error" do
-          expect { Dry::Validation.Schema do
-            required(:foo).filled(:empty?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-
-      context 'with maybe' do
-        it "raises 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 "raises error" do
-          expect { Dry::Validation.Schema do
-            optional(:foo).filled(:empty?)
-          end }.to raise_error InvalidSchemaError
-        end
-      end
-
-      context 'with maybe' do
-        it "raises 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

@@ -1,327 +0,0 @@
-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