dry-validation 0.13.3 → 1.7.0

data/spec/unit/input_processor_compiler/params_spec.rb

@@ -1,328 +0,0 @@
-RSpec.describe Dry::Validation::InputProcessorCompiler::Params, '#call' do
-  subject(:compiler) { Dry::Validation::InputProcessorCompiler::Params.new }
-
-  include_context 'predicate helper'
-
-  let(:rule_ast) do
-    [
-      [
-        :and, [
-          p(:key?, :email),
-          [
-            :and, [
-              [:key, [:email, p(:str?)]],
-              [:key, [:email, p(:filled?)]]
-            ]
-          ]
-        ]
-      ],
-      [
-        :and, [
-          p(:key?, :age),
-          [
-            :or, [
-              [:key, [:age, p(:none?)]],
-              [
-                :and, [
-                  [:key, [:age, p(:int?)]],
-                  [:key, [:age, p(:filled?)]]
-                ]
-              ]
-            ]
-          ]
-        ]
-      ],
-      [
-        :and, [
-          p(:key?, :address),
-          [:key, [:address, p(:str?)]]
-        ]
-      ]
-    ]
-  end
-
-  let(:output) do
-    { 'email' => 'jane@doe.org', 'age' => '20', 'address' => 'City, Street 1/2' }
-  end
-
-  it 'builds an input dry-data type' do
-    input_type = compiler.(rule_ast)
-
-    result = input_type[output]
-
-    expect(result).to eql(email: 'jane@doe.org', age: 20, address: 'City, Street 1/2')
-  end
-
-  it 'supports arbitrary types via type?(const) => "params.const"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :age)],
-          [:key, [:age, p(:type?, Integer)]]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['age' => '21']).to eql(age: 21)
-  end
-
-  it 'supports arbitrary types via type?(conts)' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :admin)],
-          [:key, [:admin, p(:type?, 'Params::Bool')]]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['admin' => '0']).to eql(admin: false)
-  end
-
-  it 'supports int? => "params.integer"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :age)],
-          [:key, [:age, p(:int?)]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['age' => '21']).to eql(age: 21)
-  end
-
-  it 'supports none? => "params.integer"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :age)],
-          [
-            :or, [
-              [:key, [:age, p(:none?)]],
-              [:key, [:age, p(:int?)]],
-            ]
-          ]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['age' => '']).to eql(age: nil)
-    expect(input_type['age' => '21']).to eql(age: 21)
-  end
-
-  it 'supports float? => "params.float"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :lat)],
-          [:key, [:lat, p(:float?)]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['lat' => '21.12']).to eql(lat: 21.12)
-  end
-
-  it 'supports decimal? => "params.decimal"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :lat)],
-          [:key, [:lat, p(:decimal?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['lat' => '21.12']).to eql(lat: 21.12.to_d)
-  end
-
-  it 'supports date? => "params.date"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :bday)],
-          [:key, [:bday, p(:date?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['bday' => '2012-01-23']).to eql(bday: Date.new(2012, 1, 23))
-  end
-
-  it 'supports date_time? => "params.date_time"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :bday)],
-          [:key, [:bday, p(:date_time?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['bday' => '2012-01-23 11:07']).to eql(bday: DateTime.new(2012, 1, 23, 11, 7))
-  end
-
-  it 'supports time? => "params.time"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :bday)],
-          [:key, [:bday, p(:time?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['bday' => '2012-01-23 11:07']).to eql(bday: Time.new(2012, 1, 23, 11, 7))
-  end
-
-  it 'supports time? => "params.time"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :bday)],
-          [:key, [:bday, p(:time?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['bday' => '2012-01-23 11:07']).to eql(bday: Time.new(2012, 1, 23, 11, 7))
-  end
-
-  it 'supports bool? => "params.bool"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :admin)],
-          [:key, [:admin, p(:bool?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['admin' => 'true']).to eql(admin: true)
-    expect(input_type['admin' => 'false']).to eql(admin: false)
-  end
-
-  it 'supports each rule' do
-    rule_ast = [
-      [
-        :and, [
-          [:val, p(:key?, :author)],
-          [:set, [
-            [:and, [
-              [:val, p(:key?, :books)],
-              [
-                :each, [
-                  :set, [
-                    [
-                      :and, [
-                        [:val, p(:key?, :published)],
-                        [:key, [:published, p(:bool?, [])]]
-                      ]
-                    ]
-                  ]
-                ]
-              ]
-            ]]
-          ]]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['author' => { 'books' => [{ 'published' => 'true' }] }]).to eql(
-      author: { books: [published: true] }
-    )
-
-    expect(input_type['author' => { 'books' => [{ 'published' => 'false' }] }]).to eql(
-      author: { books: [published: false] }
-    )
-  end
-
-  it 'supports array? with an each rule' do
-    rule_ast = [
-      [
-        :and, [
-          [:val, p(:key?, :ids)],
-          [:and, [
-            [:key, [:ids, p(:array?, [])]],
-            [:each, [:val, p(:int?, [])]]
-          ]]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type.('ids' => 'oops')).to eql(ids: 'oops')
-
-    expect(input_type.('ids' => %w(1 2 3))).to eql(ids: [1, 2, 3])
-  end
-
-  it 'supports hash? with a set rule' do
-    rule_ast = [
-      [
-        :and, [
-          [:val, p(:key?, :address)],
-          [
-            :and, [
-              [:key, [:address, p(:hash?, [])]],
-              [
-                :set, [
-                  [
-                    :and, [
-                      [:val, p(:key?, :street)],
-                      [:key, [:street, p(:filled?, [])]]
-                    ]
-                  ]
-                ]
-              ]
-            ]
-          ]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type.('address' => 'oops')).to eql(address: 'oops')
-
-    expect(input_type.('address' => { 'street' => 'ok' })).to eql(
-      address: { street: 'ok' }
-    )
-  end
-end

data/spec/unit/message_compiler/visit_failure_spec.rb

@@ -1,38 +0,0 @@
-RSpec.describe Dry::Validation::MessageCompiler, '#visit_failure' do
-  include_context :message_compiler
-
-  let(:visitor) { :visit_failure }
-
-  context 'with :int? predicate' do
-    let(:node) do
-      [:age, [:key, [:age, [:predicate, [:int?, [[:input, '17']]]]]]]
-    end
-
-    it 'returns a message for :int? failure with :rule name inferred from key-rule' do
-      expect(result.rule).to be(:age)
-      expect(result.path).to eql([:age])
-      expect(result).to eql('must be an integer')
-    end
-  end
-
-  context 'with set failure and :int? predicate' do
-    let(:node) do
-      [:items, [:key, [:items, [:set, [
-        [:key, [0, [:predicate, [:int?, [[:input, 'foo']]]]]],
-        [:key, [2, [:predicate, [:int?, [[:input, 'bar']]]]]]
-      ]]]]]
-    end
-
-    it 'returns a message for the first element that failed' do
-      expect(result[0].rule).to be(:items)
-      expect(result[0].path).to eql([:items, 0])
-      expect(result[0]).to eql('must be an integer')
-    end
-
-    it 'returns a message for the third element that failed' do
-      expect(result[1].rule).to be(:items)
-      expect(result[1].path).to eql([:items, 2])
-      expect(result[1]).to eql('must be an integer')
-    end
-  end
-end

data/spec/unit/message_compiler/visit_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe Dry::Validation::MessageCompiler, '#visit' do
-  include_context :message_compiler
-
-  let(:visitor) { :visit }
-
-  context 'with an anonymous :failure' do
-    let(:node) do
-      [:failure, [:age, [:key, [:age, [:predicate, [:int?, [[:input, '17']]]]]]]]
-    end
-
-    it 'returns a message for :int? failure with :rule name inferred from key-rule' do
-      expect(result.rule).to be(:age)
-      expect(result).to eql('must be an integer')
-    end
-  end
-end

data/spec/unit/message_compiler_spec.rb

@@ -1,7 +0,0 @@
-RSpec.describe MessageCompiler, '#call' do
-  subject(:message_compiler) { MessageCompiler.new( Messages.default ) }
-
-  it 'returns an empty hash when there are no errors' do
-    expect(message_compiler.([])).to be_empty
-  end
-end

data/spec/unit/predicate_registry_spec.rb

@@ -1,34 +0,0 @@
-require 'dry/validation/predicate_registry'
-
-RSpec.describe PredicateRegistry do
-  subject!(:predicate_registry) { schema_class.registry }
-
-  let(:schema_class) { Class.new(Schema) }
-  let(:schema) { schema_class.new }
-
-  before do
-    schema_class.class_eval { def dis_ok?; true; end }
-  end
-
-  describe '.[]' do
-    it 'returns a registry which collects predicate methods' do
-      expect(predicate_registry[:dis_ok?]).to be_instance_of(UnboundMethod)
-    end
-  end
-
-  describe '#[]' do
-    it 'gives access to built-in predicates' do
-      expect(predicate_registry[:filled?].("sutin")).to be(true)
-    end
-  end
-
-  describe '#bind' do
-    it 'binds unbound predicates and return finalized registry' do
-      registry = predicate_registry.bind(schema)
-
-      expect(registry).to be_frozen
-      expect(registry[:dis_ok?]).to be_a(Method)
-      expect(registry[:dis_ok?].()).to be(true)
-    end
-  end
-end

data/spec/unit/schema/key_spec.rb

@@ -1,38 +0,0 @@
-RSpec.describe Schema::Key do
-  include_context 'predicate helper'
-
-  let(:registry) { PredicateRegistry.new(predicates) }
-
-  describe '#str?' do
-    subject(:user) { Schema::Key[:user, registry: registry] }
-
-    it 'returns a key rule' do
-      expect(user.str?.to_ast).to eql(
-        [:rule, [:user, [:key, [:user, [:predicate, [:str?, [[:input, Undefined]]]]]]]]
-      )
-    end
-
-    it 'returns a key rule & disjunction rule created within the block' do
-      user.hash? do
-        required(:email) { none? | filled? }
-      end
-
-      expect(user.to_ast).to eql(
-        [:key, [:user, [:rule, [:user,
-          [:and, [
-            [:rule, [:user, [:predicate, [:hash?, [[:input, Undefined]]]]]],
-            [:rule, [:user, [:key, [:user, [:rule, [:email,
-              [:and, [
-                [:rule, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-                [:rule, [:user, [:rule, [:email,
-                  [:or, [
-                    [:rule, [:email, [:key, [:email, [:predicate, [:none?, [[:input, Undefined]]]]]]]],
-                    [:rule, [:email, [:key, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-                  ]]]]]]
-              ]]]]]]]
-            ]]]
-        ]]]]
-      )
-    end
-  end
-end

data/spec/unit/schema/rule_spec.rb

@@ -1,42 +0,0 @@
-RSpec.describe Schema::Rule do
-  include_context 'predicate helper'
-
-  let(:filled) { p(:filled?) }
-  let(:format) { p(:format?, /regex/) }
-
-  let(:left) { Schema::Rule.new(filled, name: :email, target: target) }
-  let(:right) { Schema::Rule.new(format, name: :email, target: target) }
-  let(:target) { double(:target, id: :user) }
-
-  describe '#and' do
-    it 'returns a conjunction' do
-      expect(left.and(right).to_ast).to match_array(
-        [:rule, [:email, [:and, [[:rule, [:email, filled]], [:rule, [:email, format]]]]]]
-      )
-    end
-  end
-
-  describe '#or' do
-    it 'returns a disjunction' do
-      expect(left.or(right).to_ast).to match_array(
-        [:rule, [:email, [:or, [[:rule, [:email, filled]], [:rule, [:email, format]]]]]]
-      )
-    end
-  end
-
-  describe '#xor' do
-    it 'returns an exclusive disjunction' do
-      expect(left.xor(right).to_ast).to match_array(
-        [:rule, [:email, [:xor, [[:rule, [:email, filled]], [:rule, [:email, format]]]]]]
-      )
-    end
-  end
-
-  describe '#then' do
-    it 'returns an implication' do
-      expect(left.then(right).to_ast).to match_array(
-        [:rule, [:email, [:implication, [[:rule, [:email, filled]], [:rule, [:email, format]]]]]]
-      )
-    end
-  end
-end

data/spec/unit/schema/value_spec.rb

@@ -1,131 +0,0 @@
-RSpec.describe Schema::Value do
-  include_context 'rule compiler'
-  include_context 'predicate helper'
-
-  let(:registry) { PredicateRegistry.new(predicates) }
-
-  describe '#required' do
-    subject(:value) { Schema::Value.new(registry: registry) }
-
-    let(:expected_ast) do
-      [:rule, [:address, [:and, [
-        [:rule, [:address, [:predicate, [:key?, [[:name, :address], [:input, Undefined]]]]]],
-        [:rule, [:address, [:key, [:address, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-      ]]]]
-    end
-
-    it 'creates a rule for a specified key using a block' do
-      rule = value.required(:address, &:filled?)
-      expect(rule.to_ast).to eql(expected_ast)
-    end
-
-    it 'creates a rule for a specified key using a macro' do
-      rule = value.required(:address).filled
-      expect(rule.to_ast).to eql(expected_ast)
-    end
-  end
-
-  describe '#each' do
-    subject(:value) { Schema::Value.new(registry: registry) }
-
-    it 'creates an each rule with another rule returned from the block' do
-      rule = value.each { key?(:method) }
-
-      expect(rule.to_ast).to eql(
-        [:and, [
-          [:predicate, [:array?, [[:input, Undefined]]]],
-          [:each, [:predicate, [:key?, [[:name, :method], [:input, Undefined]]]]]
-        ]]
-      )
-    end
-
-    it 'creates an each rule with other rules returned from the block' do
-      rule = value.each do
-        required(:method) { str? }
-        required(:amount) { float? }
-      end
-
-      expect(rule.to_ast).to eql(
-        [:and, [
-          [:predicate, [:array?, [[:input, Undefined]]]],
-          [:each, [:set, [
-            [:rule, [:method, [:and, [
-              [:rule, [:method, [:predicate, [:key?, [[:name, :method], [:input, Undefined]]]]]],
-              [:rule, [:method, [:key, [:method, [:predicate, [:str?, [[:input, Undefined]]]]]]]]]
-            ]]],
-            [:rule, [:amount, [:and, [
-              [:rule, [:amount, [:predicate, [:key?, [[:name, :amount], [:input, Undefined]]]]]],
-              [:rule, [:amount, [:key, [:amount, [:predicate, [:float?, [[:input, Undefined]]]]]]]]
-            ]]]]
-          ]]]
-        ]]
-      )
-    end
-  end
-
-  describe '#hash? with block' do
-    subject(:user) { Schema::Value.new(registry: registry) }
-
-    it 'builds hash? & rule created within the block' do
-      rule = user.hash? { required(:email).filled }
-
-      expect(rule.to_ast).to eql(
-        [:and, [
-          [:predicate, [:hash?, [[:input, Undefined]]]],
-          [:rule, [:email, [:and, [
-            [:rule, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-            [:rule, [:email, [:key, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-          ]]]]
-        ]]
-      )
-    end
-
-    it 'builds hash? & rule created within the block with deep nesting' do
-      rule = user.hash? do
-        required(:address) do
-          hash? do
-            required(:city).filled
-            required(:zipcode).filled
-          end
-        end
-      end
-
-      expect(rule.to_ast).to eql(
-        [:and, [
-          [:predicate, [:hash?, [[:input, Undefined]]]],
-          [:rule, [:address, [:and, [
-            [:rule, [:address, [:predicate, [:key?, [[:name, :address], [:input, Undefined]]]]]],
-            [:rule, [:address, [:and, [
-              [:rule, [:address, [:predicate, [:hash?, [[:input, Undefined]]]]]],
-              [:rule, [:address, [:key, [:address, [:set, [
-                [:rule, [:city, [:and, [
-                  [:rule, [:city, [:predicate, [:key?, [[:name, :city], [:input, Undefined]]]]]],
-                  [:rule, [:city, [:key, [:city, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-                ]]]],
-                [:rule, [:zipcode, [:and, [
-                  [:rule, [:zipcode, [:predicate, [:key?, [[:name, :zipcode], [:input, Undefined]]]]]],
-                  [:rule, [:zipcode, [:key, [:zipcode, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-                ]]]]
-              ]]]]]]
-            ]]]]
-          ]]]]
-        ]]
-      )
-    end
-  end
-
-  describe '#not' do
-    subject(:user) { Schema::Value.new(registry: registry) }
-
-    it 'builds a negated rule' do
-      not_email = user.required(:email) { str?.not }
-
-      expect(not_email.to_ast).to eql(
-        [:rule, [:email, [:and, [
-          [:rule, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-          [:rule, [:email, [:not, [:key, [:email, [:predicate, [:str?, [[:input, Undefined]]]]]]]]]]
-        ]]]
-      )
-    end
-  end
-end

data/spec/unit/schema_spec.rb

@@ -1,35 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe Schema do
-  describe '.messages' do
-    context 'with default setting' do
-      let(:schema) do
-        Class.new(Schema)
-      end
-
-      it 'returns default yaml messages' do
-        expect(schema.messages).to be_instance_of(Messages::YAML)
-      end
-    end
-
-    context 'with i18n setting' do
-      let(:schema) do
-        Class.new(Schema) { configure { config.messages = :i18n } }
-      end
-
-      it 'returns default i18n messages' do
-        expect(schema.messages).to be_instance_of(Messages::I18n)
-      end
-    end
-
-    context 'with an invalid setting' do
-      let(:schema) do
-        Class.new(Schema) { configure { config.messages = :oops } }
-      end
-
-      it 'returns default i18n messages' do
-        expect { schema.messages }.to raise_error(RuntimeError, /oops/)
-      end
-    end
-  end
-end