dry-validation 0.12.0 → 1.6.0

data/spec/integration/schema/validate_spec.rb

@@ -1,120 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'arbitrary validation blocks' do
-  context 'with a single value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          option :email_regex, /@/
-
-          def self.messages
-            super.merge(en: { errors: { email?: '%{value} looks like an invalid email' } })
-          end
-        end
-
-        required(:email).filled
-
-        validate(email?: :email) do |value|
-          email_regex.match(value)
-        end
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(email: 'jane@doe.org')).to be_success
-    end
-
-    it 'returns failure for invalid input' do
-      expect(schema.(email: 'jane')).to be_failure
-    end
-
-    it 'adds correct error message' do
-      expect(schema.(email: 'jane').messages).to eql(
-        email: ['jane looks like an invalid email']
-      )
-    end
-
-    it 'is not executed when deps are invalid' do
-      expect(schema.(email: nil)).to be_failure
-    end
-  end
-
-  context 'with more than one value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def self.messages
-            super.merge(en: { errors: { email_required: 'provide email' }})
-          end
-        end
-
-        required(:email).maybe(:str?)
-        required(:newsletter).value(:bool?)
-
-        validate(email_required: %i[newsletter email]) do |newsletter, email|
-          if newsletter == true
-            !email.nil?
-          else
-            true
-          end
-        end
-      end
-    end
-
-    it 'returns success for valid input' do
-      expect(schema.(newsletter: false, email: nil)).to be_success
-      expect(schema.(newsletter: true, email: 'jane@doe.org')).to be_success
-    end
-
-    it 'returns failure for invalid input' do
-      expect(schema.(newsletter: true, email: nil)).to be_failure
-    end
-
-    it 'adds correct error message' do
-      expect(schema.(newsletter: true, email: nil).errors).to eql(
-        email_required: ['provide email']
-      )
-    end
-
-    it 'is not executed when deps are invalid' do
-      expect(schema.(newsletter: 'oops', email: '').errors).to eql(
-        newsletter: ['must be boolean']
-      )
-    end
-  end
-
-  context 'with more than one validation' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          option :email_regex, /@/
-
-          def self.messages
-            super.merge(en: {
-              errors: {
-                email?:        '%{value} looks like an invalid email',
-                google_email?: '%{value} is not a google email'
-              } })
-          end
-        end
-
-        required(:email).filled
-
-        validate(email?: :email) do |value|
-          email_regex.match(value)
-        end
-
-        validate(google_email?: :email) do |value|
-          value.end_with?('@google.com')
-        end
-      end
-    end
-
-    it 'returns errors message for both validate' do
-      expect(schema.(email: 'jane').messages).to eql(
-        email: [
-          'jane looks like an invalid email',
-          'jane is not a google email'
-        ]
-      )
-    end
-  end
-end

data/spec/integration/schema/xor_spec.rb

@@ -1,35 +0,0 @@
-RSpec.describe 'Schema with xor 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
-
-      required(:eat_cake).filled
-
-      required(:have_cake).filled
-
-      rule(be_reasonable: %i[eat_cake have_cake]) do |ec, hc|
-        ec.eql?('yes!') ^ hc.eql?('yes!')
-      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
-      expect(schema.(eat_cake: 'yes!', have_cake: 'yes!').messages).to eql(
-        be_reasonable: ['you cannot eat cake and have cake!']
-      )
-    end
-  end
-end

data/spec/integration/schema_builders_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe 'Building schemas' do
-  describe 'Dry::Validation.Schema' do
-    it 'builds a schema class with custom predicate set' do
-      predicates = Module.new do
-        include Dry::Logic::Predicates
-
-        def zomg?(*)
-          true
-        end
-      end
-
-      schema = Dry::Validation.Schema(predicates: predicates, build: false)
-
-      expect(schema.predicates[:key?]).to be_a(Method)
-    end
-  end
-end

data/spec/integration/schema_spec.rb

@@ -1,173 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'defining key-based schema' do
-  describe 'with a flat structure' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          config.input_processor = :params
-          config.type_specs = true
-        end
-
-        required(:email, :string).filled
-        required(:age, [:nil, :integer]) { none? | (int? & gt?(18)) }
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(email: 'jane@doe', age: 19)).to be_success
-      expect(schema.(email: 'jane@doe', age: nil)).to be_success
-    end
-
-    it 'fails when input is not valid' do
-      expect(schema.(email: 'jane@doe', age: 17)).to_not be_success
-    end
-
-    it 'returns result which quacks like hash' do
-      input = { email: 'jane@doe', age: 19 }
-      result = schema.(input)
-
-      expect(result[:email]).to eql('jane@doe')
-      expect(Hash[result]).to eql(input)
-
-      expect(result.to_a).to eql([[:email, 'jane@doe'], [:age, 19]])
-    end
-
-    describe '#type_map' do
-      it 'returns key=>type map' do
-        expect(schema.type_map).to eql(
-          email: Types::String, age: Types::Params::Nil | Types::Params::Integer
-        )
-      end
-
-      it 'uses type_map for input processor when it is not empty' do
-        expect(schema.(email: 'jane@doe.org', age: '18').to_h).to eql(
-          email: 'jane@doe.org', age: 18
-        )
-      end
-    end
-  end
-
-  describe 'with nested structures' do
-    subject(:schema) do
-      class Test::CountrySchema
-        def self.schema
-          Dry::Validation.Schema do
-            required(:name).filled
-            required(:code).filled
-          end
-        end
-      end
-
-      Dry::Validation.Schema do
-        required(:email).filled
-
-        required(:age).maybe(:int?, gt?: 18)
-
-        required(:address).schema do
-          required(:city).filled(min_size?: 3)
-
-          required(:street).filled
-
-          required(:country).schema(Test::CountrySchema)
-        end
-
-        required(:phone_numbers).each(:str?)
-      end
-    end
-
-    let(:input) do
-      {
-        email: 'jane@doe.org',
-        age: 19,
-        address: { city: 'NYC', street: 'Street 1/2', country: { code: 'US', name: 'USA' } },
-        phone_numbers: [
-          '123456', '234567'
-        ]
-      }.freeze
-    end
-
-    describe '#messages' do
-      it 'returns compiled error messages' do
-        expect(schema.(input.merge(email: '')).messages).to eql(
-          email: ['must be filled']
-        )
-      end
-    end
-
-    describe '#call' do
-      it 'passes when attributes are valid' do
-        expect(schema.(input)).to be_success
-      end
-
-      it 'validates presence of an email and min age value' do
-        expect(schema.(input.merge(email: '', age: 18)).messages).to eql(
-          email: ['must be filled'], age: ['must be greater than 18']
-        )
-      end
-
-      it 'validates presence of the email key and type of age value' do
-        attrs = {
-          name: 'Jane',
-          age: '18',
-          address: input[:address], phone_numbers: input[:phone_numbers]
-        }
-
-        expect(schema.(attrs).messages).to eql(
-          email: ['is missing'],
-          age: ['must be an integer', 'must be greater than 18']
-        )
-      end
-
-      it 'validates presence of the address and phone_number keys' do
-        attrs = { email: 'jane@doe.org', age: 19 }
-
-        expect(schema.(attrs).messages).to eql(
-          address: ['is missing'], phone_numbers: ['is missing']
-        )
-      end
-
-      it 'validates presence of keys under address and min size of the city value' do
-        attrs = input.merge(address: { city: 'NY' })
-
-        expect(schema.(attrs).messages).to eql(
-          address: {
-            street: ['is missing'],
-            country: ['is missing'],
-            city: ['size cannot be less than 3']
-          }
-        )
-      end
-
-      it 'validates address type' do
-        expect(schema.(input.merge(address: 'totally not a hash')).messages).to eql(
-          address: ['must be a hash']
-        )
-      end
-
-      it 'validates address code and name values' do
-        attrs = input.merge(
-          address: input[:address].merge(country: { code: 'US', name: '' })
-        )
-
-        expect(schema.(attrs).messages).to eql(
-          address: { country: { name: ['must be filled'] } }
-        )
-      end
-
-      it 'validates each phone number' do
-        attrs = input.merge(phone_numbers: ['123', 312])
-
-        expect(schema.(attrs).messages).to eql(
-          phone_numbers: { 1 => ['must be a string'] }
-        )
-      end
-    end
-  end
-
-  context 'nested keys' do
-    it 'raises error when defining nested keys without `schema` block`' do
-      expect {
-        Dry::Validation.Schema { required(:foo).value { required(:bar).value(:str?) } }
-      }.to raise_error(ArgumentError, /required/)
-    end
-  end
-end

data/spec/shared/message_compiler.rb

@@ -1,11 +0,0 @@
-RSpec.shared_context :message_compiler do
-  subject(:compiler) { Dry::Validation::MessageCompiler.new(messages) }
-
-  let(:messages) do
-    Dry::Validation::Messages.default
-  end
-
-  let(:result) do
-    compiler.public_send(visitor, node)
-  end
-end

data/spec/shared/predicate_helper.rb

@@ -1,15 +0,0 @@
-RSpec.shared_context 'predicate helper' do
-  def p(name, *args)
-    Dry::Logic::Rule::Predicate.new(predicates[name], args: args).to_ast
-  end
-
-  let!(:predicates) do
-    Module.new {
-      include Dry::Logic::Predicates
-
-      def self.email?(value)
-        true
-      end
-    }
-  end
-end

data/spec/shared/rule_compiler.rb

@@ -1,8 +0,0 @@
-require 'dry/logic/rule_compiler'
-require 'dry/logic/predicates'
-
-RSpec.shared_context 'rule compiler' do
-  let(:rule_compiler) do
-    Dry::Logic::RuleCompiler.new(Dry::Logic::Predicates)
-  end
-end

data/spec/spec_helper.rb

@@ -1,58 +0,0 @@
-if ENV['COVERAGE'] == 'true' && RUBY_ENGINE == 'ruby' && RUBY_VERSION == '2.3.1'
-  require "simplecov"
-  SimpleCov.start do
-    add_filter '/spec/'
-  end
-end
-
-begin
-  require 'pry'
-  require 'pry-byebug'
-rescue LoadError
-end
-
-require 'dry-validation'
-require 'dry/core/constants'
-require 'ostruct'
-
-SPEC_ROOT = Pathname(__dir__)
-
-Dir[SPEC_ROOT.join('shared/**/*.rb')].each(&method(:require))
-Dir[SPEC_ROOT.join('support/**/*.rb')].each(&method(:require))
-
-include Dry::Validation
-
-module Types
-  include Dry::Types.module
-end
-
-Dry::Validation::Deprecations.configure do |config|
-  config.logger = Logger.new(SPEC_ROOT.join('../log/deprecations.log'))
-end
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-  config.warnings = true
-
-  config.after do
-    if defined?(I18n)
-      I18n.load_path = Dry::Validation.messages_paths.dup
-      I18n.backend.reload!
-    end
-  end
-
-  config.include PredicatesIntegration
-
-  config.before do
-    module Test
-      def self.remove_constants
-        constants.each { |const| remove_const(const)  }
-        self
-      end
-    end
-  end
-
-  config.after do
-    Object.send(:remove_const, Test.remove_constants.name)
-  end
-end