dry-validation 0.13.3 → 1.3.1

data/spec/integration/schema/nested_values_spec.rb

@@ -1,46 +0,0 @@
-RSpec.describe Schema, 'using nested values' do
-  let(:schema) do
-    Dry::Validation.Schema do
-      required(:email).maybe
-
-      required(:settings).schema do
-        optional(:offers).filled(:bool?)
-        required(:newsletter).filled(:bool?)
-      end
-
-      rule(newsletter: [[:settings, :newsletter], [:settings, :offers]]) do |newsletter, offers|
-        offers.true?.then(newsletter.false?)
-      end
-
-      rule(email: [[:settings, :newsletter], :email]) do |newsletter, email|
-        newsletter.true?.then(email.filled?)
-      end
-    end
-  end
-
-  it 'passes when newsletter setting is false' do
-    expect(schema.(settings: { newsletter: false }, email: nil)).to be_success
-  end
-
-  it 'passes when newsletter setting is true and email is filled' do
-    expect(schema.(settings: { newsletter: false }, email: 'jane@doe')).to be_success
-  end
-
-  it 'passes when offers is false and newsletter is true' do
-    expect(schema.(settings: { offers: false, newsletter: true }, email: 'jane@doe')).to be_success
-  end
-
-  it 'fails when newsletter is true and email is not filled' do
-    expect(schema.(settings: { newsletter: true }, email: nil).messages).to eql(
-      email: ['must be filled']
-    )
-  end
-
-  it 'fails when offers is true and newsletter is true' do
-    input = { settings: { offers: true, newsletter: true }, email: 'jane@doe' }
-
-    expect(schema.(input).messages).to eql(
-      settings: { newsletter: ['must be false'] }
-    )
-  end
-end

data/spec/integration/schema/not_spec.rb

@@ -1,34 +0,0 @@
-RSpec.describe 'Schema with negated rules' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      configure do
-        def self.messages
-          Messages.default.merge(
-            en: { errors: { be_reasonable: 'you cannot eat cake and have cake!' } }
-          )
-        end
-      end
-
-      optional(:eat_cake).filled
-      optional(:have_cake).filled
-
-      rule(:be_reasonable) do
-        value(:eat_cake).eql?('yes!') & value(:have_cake).eql?('yes!').not
-      end
-    end
-  end
-
-  describe '#messages' do
-    it 'passes when only one option is selected' do
-      messages = schema.(eat_cake: 'yes!', have_cake: 'no!').messages[:be_reasonable]
-
-      expect(messages).to be(nil)
-    end
-
-    it 'fails when both options are selected' do
-      messages = schema.(eat_cake: 'yes!', have_cake: 'yes!').messages[:be_reasonable]
-
-      expect(messages).to eql(['you cannot eat cake and have cake!'])
-    end
-  end
-end

data/spec/integration/schema/numbers_spec.rb

@@ -1,19 +0,0 @@
-RSpec.describe Dry::Validation::Schema do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:age).filled(:number?, :int?)
-    end
-  end
-
-  it 'passes when value is a number and an int' do
-    expect(schema.(age: 132)).to be_success
-  end
-
-  it 'fails when value is not a number' do
-    expect(schema.(age: 'ops').messages).to eql(age: ['must be a number'])
-  end
-
-  it 'fails when value is not an integer' do
-    expect(schema.(age: 1.0).messages).to eql(age: ['must be an integer'])
-  end
-end

data/spec/integration/schema/option_with_default_spec.rb

@@ -1,64 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'defining schema context with option API' do
-  shared_context 'valid schema with :db option' do
-    before do
-      DB = [{ email: 'jane@doe' }]
-    end
-
-    after do
-      Object.send(:remove_const, :DB)
-    end
-
-    it 'uses external dependency set by option with a default value' do
-      expect(schema.db).to be(DB)
-
-      expect(schema.(email: 'jade@doe', contact: { email: 'jade2@doe' })).to be_success
-      expect(schema.(email: 'jane@doe', contact: { email: 'jane2@doe' })).to be_failure
-      expect(schema.(email: 'jade@doe', contact: { email: 'jane@doe' })).to be_failure
-    end
-  end
-
-
-  context 'with a default value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          option :db, -> { DB }
-
-          def unique?(name, value)
-            db.none? { |item| item[name] == value }
-          end
-        end
-
-        required(:email).filled(unique?: :email)
-
-        required(:contact).schema do
-          required(:email).filled(unique?: :email)
-        end
-      end
-    end
-
-    include_context 'valid schema with :db option'
-  end
-
-  context 'without a default value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          option :db
-
-          def unique?(name, value)
-            db.none? { |item| item[name] == value }
-          end
-        end
-
-        required(:email).filled(unique?: :email)
-
-        required(:contact).schema do
-          required(:email).filled(unique?: :email)
-        end
-      end.with(db: DB)
-    end
-
-    include_context 'valid schema with :db option'
-  end
-end

data/spec/integration/schema/or_spec.rb

@@ -1,87 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'OR messages' do
-  context 'with two predicates' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { str? | int? }
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(foo: 'bar')).to be_success
-      expect(schema.(foo: 321)).to be_success
-    end
-
-    it 'provides OR error message for invalid input where all both sides failed' do
-      expect(schema.(foo: []).errors).to eql(foo: ['must be a string or must be an integer'])
-    end
-  end
-
-  context 'with a predicate and a conjunction of predicates' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { str? | (int? & gt?(18)) }
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(foo: 'bar')).to be_success
-      expect(schema.(foo: 321)).to be_success
-    end
-
-    it 'provides OR message for invalid input where both sides failed' do
-      expect(schema.(foo: []).errors).to eql(foo: ['must be a string or must be an integer'])
-    end
-
-    it 'provides error messages for invalid input where right side failed' do
-      expect(schema.(foo: 17).errors).to eql(foo: ['must be a string or must be greater than 18'])
-    end
-  end
-
-  context 'with a predicate and an each operation' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { str? | each(:int?) }
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(foo: 'bar')).to be_success
-      expect(schema.(foo: [1, 2, 3])).to be_success
-    end
-
-    it 'provides OR message for invalid input where both sides failed' do
-      expect(schema.(foo: {}).errors).to eql(foo: ['must be a string or must be an array'])
-    end
-
-    it 'provides error messages for invalid input where right side failed' do
-      expect(schema.(foo: %w(1 2 3)).errors).to eql(
-        foo: {
-          0 => ['must be an integer'],
-          1 => ['must be an integer'],
-          2 => ['must be an integer']
-        }
-      )
-    end
-  end
-
-  context 'with a predicate and a schema' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:foo) { str? | schema { required(:bar).filled } }
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(foo: 'bar')).to be_success
-      expect(schema.(foo: { bar: 'baz' })).to be_success
-    end
-
-    it 'provides OR message for invalid input where both sides failed' do
-      expect(schema.(foo: []).errors).to eql(foo: ['must be a string or must be a hash'])
-    end
-
-    it 'provides error messages for invalid input where right side rules failed' do
-      expect(schema.(foo: { bar: '' }).errors).to eql(foo: { bar: ['must be filled'] })
-    end
-  end
-end

data/spec/integration/schema/params/defining_base_schema_spec.rb

@@ -1,41 +0,0 @@
-require 'dry/validation/messages/i18n'
-require 'i18n'
-
-RSpec.describe 'Defining base schema class' do
-  subject(:schema) do
-    Dry::Validation.Params(BaseSchema) do
-      required(:email).filled(:email?)
-    end
-  end
-
-  before do
-    class BaseSchema < Dry::Validation::Schema
-      configure do |config|
-        config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
-        config.messages = :i18n
-      end
-
-      def email?(value)
-        true
-      end
-
-      define! do
-        required(:name).filled
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :BaseSchema)
-  end
-
-  it 'inherits predicates' do
-    expect(schema).to respond_to(:email?)
-  end
-
-  it 'inherits rules' do
-    expect(schema.('name' => '').messages).to eql(
-      name: ['must be filled'], email: ['is missing', 'must be an email']
-    )
-  end
-end

data/spec/integration/schema/params/explicit_types_spec.rb

@@ -1,195 +0,0 @@
-RSpec.describe Dry::Validation::Schema::Params, 'explicit types' do
-  context 'single type spec without rules' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-        required(:age, :integer)
-      end
-    end
-
-    it 'uses params coercion' do
-      expect(schema.('age' => '19').to_h).to eql(age: 19)
-    end
-  end
-
-  context 'integer' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-        required(:age, :integer)
-      end
-    end
-
-    it 'uses params coercion' do
-      expect(schema.('age' => '19').to_h).to eql(age: 19)
-    end
-  end
-
-  context 'single type spec with rules' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-        required(:age, :integer).value(:int?, gt?: 18)
-      end
-    end
-
-    it 'applies rules to coerced value' do
-      expect(schema.(age: 19).messages).to be_empty
-      expect(schema.(age: 18).messages).to eql(age: ['must be greater than 18'])
-    end
-  end
-
-  context 'single type spec with an array' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-        required(:nums, [:integer])
-      end
-    end
-
-    it 'uses params coercion' do
-      expect(schema.(nums: %w(1 2 3)).to_h).to eql(nums: [1, 2, 3])
-    end
-  end
-
-  context 'sum type spec without rules' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-        required(:age, [:nil, :integer])
-      end
-    end
-
-    it 'uses params coercion' do
-      expect(schema.('age' => '19').to_h).to eql(age: 19)
-      expect(schema.('age' => '').to_h).to eql(age: nil)
-    end
-  end
-
-  context 'sum type spec with rules' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-        required(:age, [:nil, :integer]).maybe(:int?, gt?: 18)
-      end
-    end
-
-    it 'applies rules to coerced value' do
-      expect(schema.(age: nil).messages).to be_empty
-      expect(schema.(age: 19).messages).to be_empty
-      expect(schema.(age: 18).messages).to eql(age: ['must be greater than 18'])
-    end
-  end
-
-  context 'using a type object' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-        required(:age, Types::Params::Nil | Types::Params::Integer)
-      end
-    end
-
-    it 'uses params coercion' do
-      expect(schema.('age' => '').to_h).to eql(age: nil)
-      expect(schema.('age' => '19').to_h).to eql(age: 19)
-    end
-  end
-
-  context 'nested schema' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-
-        required(:user).schema do
-          required(:email, :string)
-          required(:age, :integer)
-
-          required(:address).schema do
-            required(:street, :string)
-            required(:city, :string)
-            required(:zipcode, :string)
-
-            required(:location).schema do
-              required(:lat, :float)
-              required(:lng, :float)
-            end
-          end
-        end
-      end
-    end
-
-    it 'uses params coercion for nested input' do
-      input = {
-        'user' => {
-          'email' => 'jane@doe.org',
-          'age' => '21',
-          'address' => {
-            'street' => 'Street 1',
-            'city' => 'NYC',
-            'zipcode' => '1234',
-            'location' => { 'lat' => '1.23', 'lng' => '4.56' }
-          }
-        }
-      }
-
-      expect(schema.(input).to_h).to eql(
-        user:  {
-          email: 'jane@doe.org',
-          age: 21,
-          address: {
-            street: 'Street 1',
-            city: 'NYC',
-            zipcode:  '1234',
-            location: { lat: 1.23, lng: 4.56 }
-          }
-        }
-      )
-    end
-  end
-
-  context 'nested schema with arrays' do
-    subject(:schema) do
-      Dry::Validation.Params do
-        configure { config.type_specs = true }
-
-        required(:song).schema do
-          required(:title, :string)
-
-          required(:tags).each do
-            schema do
-              required(:name, :string)
-            end
-          end
-        end
-      end
-    end
-
-    it 'fails to coerce gracefuly' do
-      result = schema.(song: nil)
-
-      expect(result.messages).to eql(song: ['must be a hash'])
-      expect(result.to_h).to eql(song: nil)
-
-      result = schema.(song: { tags: nil })
-
-      expect(result.messages).to eql(song: { tags: ['must be an array'] })
-      expect(result.to_h).to eql(song: { tags: nil })
-    end
-
-    it 'uses params coercion for nested input' do
-      input = {
-        'song' => {
-          'title' => 'dry-rb is awesome lala',
-          'tags' => [{ 'name' => 'red' }, { 'name' => 'blue' }]
-        }
-      }
-
-      expect(schema.(input).to_h).to eql(
-        song: {
-          title: 'dry-rb is awesome lala',
-          tags: [{ name: 'red' }, { name: 'blue' }]
-        }
-      )
-    end
-  end
-end