dry-validation 0.13.3 → 1.0.0.alpha1

data/spec/integration/messages/i18n_spec.rb

@@ -1,104 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe Messages::I18n do
-  subject(:messages) { Messages::I18n.new }
-
-  before do
-    I18n.config.available_locales_set << :pl
-    I18n.load_path.concat(%w(en pl).map { |l| SPEC_ROOT.join("fixtures/locales/#{l}.yml") })
-    I18n.backend.load_translations
-    I18n.locale = :pl
-  end
-
-  describe '#[]' do
-    context 'with the default locale' do
-      it 'returns nil when message is not defined' do
-        expect(messages[:not_here, rule: :srsly]).to be(nil)
-      end
-
-      it 'returns a message for a predicate' do
-        message = messages[:filled?, rule: :name].text
-
-        expect(message).to eql("nie może być pusty")
-      end
-
-      it 'returns a message for a specific rule' do
-        message = messages[:filled?, rule: :email].text
-
-        expect(message).to eql("Proszę podać adres email")
-      end
-
-      it 'returns a message for a specific val type' do
-        message = messages[:size?, rule: :pages, val_type: String].text
-
-        expect(message).to eql("wielkość musi być równa \#{size}")
-      end
-
-      it 'returns a message for a specific rule and its default arg type' do
-        message = messages[:size?, rule: :pages].text
-
-        expect(message).to eql("wielkość musi być równa \#{size}")
-      end
-
-      it 'returns a message for a specific rule and its arg type' do
-        message = messages[:size?, rule: :pages, arg_type: Range].text
-
-        expect(message).to eql("wielkość musi być między \#{size_left} a \#{size_right}")
-      end
-    end
-
-    context 'rule name translations' do
-      it 'translates rule name' do
-        msg = messages.rule('email')
-
-        expect(msg).to eql('Adres email')
-      end
-    end
-
-    context 'with a different locale' do
-      it 'returns a message for a predicate' do
-        message = messages[:filled?, rule: :name, locale: :en].text
-
-        expect(message).to eql("must be filled")
-      end
-
-      it 'returns a message for a specific rule' do
-        message = messages[:filled?, rule: :email, locale: :en].text
-
-        expect(message).to eql("Please provide your email")
-      end
-
-      it 'returns a message for a specific rule and its default arg type' do
-        message = messages[:size?, rule: :pages, locale: :en].text
-
-        expect(message).to eql("size must be \#{size}")
-      end
-
-      it 'returns a message for a specific rule and its arg type' do
-        message = messages[:size?, rule: :pages, arg_type: Range, locale: :en].text
-
-        expect(message).to eql("size must be within \#{size_left} - \#{size_right}")
-      end
-    end
-
-    context 'fallbacking to I18n.default_locale with fallback backend config' do
-      before do
-        require "i18n/backend/fallbacks"
-        I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-      end
-
-      it 'returns a message for a predicate in the default_locale' do
-        pending 'FIXME: this got broken for some reason, probably an I18n issue'
-
-        message = messages[:even?, rule: :some_number].text
-
-        expect(I18n.locale).to eql(:pl)
-        expect(message).to eql("must be even")
-      end
-    end
-  end
-
-  after(:all) do
-    I18n.locale = I18n.default_locale
-  end
-end

data/spec/integration/optional_keys_spec.rb

@@ -1,28 +0,0 @@
-RSpec.describe Dry::Validation::Schema do
-  describe 'defining schema with optional keys' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        optional(:email) { |email| email.filled? }
-
-        required(:address).schema do
-          required(:city, &:filled?)
-          required(:street, &:filled?)
-
-          optional(:phone_number) do
-            none? | str?
-          end
-        end
-      end
-    end
-
-    describe '#call' do
-      it 'skips rules when key is not present' do
-        expect(schema.(address: { city: 'NYC', street: 'Street 1/2' })).to be_success
-      end
-
-      it 'applies rules when key is present' do
-        expect(schema.(email: '')).to_not be_success
-      end
-    end
-  end
-end

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

@@ -1,287 +0,0 @@
-RSpec.describe 'Predicates: Array' do
-  context 'with required' do
-    subject(:schema) do
-      Dry::Validation.Params 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.Params 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.Params 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.Params 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
-
-  context 'with maybe macro' do
-    subject(:schema) { Dry::Validation.Params { required(:foo).maybe(:array?) } }
-
-    context 'with empty string' do
-      let(:input) { { 'foo' => '' } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with nil' do
-      let(:input) { { 'foo' => nil } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with empty array' do
-      let(:input) { { 'foo' => [] } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with filled array' do
-      let(:input) { { 'foo' => [1, 2, 3] } }
-
-      it 'is successful' do
-        expect(result).to be_successful
-      end
-    end
-
-    context 'with invalid value' do
-      let(:input) { { 'foo' => 'oops' } }
-
-      it 'is not successful' do
-        expect(result).to be_failing(['must be an array'])
-      end
-    end
-  end
-end

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

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