dry-validation 0.4.1 → 0.5.0

data/spec/unit/predicates/size_spec.rb

@@ -1,55 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#size?' do
-    let(:predicate_name) { :size? }
-
-    context 'when value size is equal to n' do
-      let(:arguments_list) do
-        [
-          [[8], 2],
-          [4, 'Jill'],
-          [2, { 1 => 'st', 2 => 'nd' }],
-          [8, 8],
-          [1..8, 5]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'when value size is greater than n' do
-      let(:arguments_list) do
-        [
-          [[1, 2], 3],
-          [5, 'Jill'],
-          [3, { 1 => 'st', 2 => 'nd' }],
-          [1, 9],
-          [1..5, 6]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-
-    context 'with value size is less than n' do
-      let(:arguments_list) do
-        [
-          [[1, 2], 1],
-          [3, 'Jill'],
-          [1, { 1 => 'st', 2 => 'nd' }],
-          [1, 7],
-          [1..5, 4]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-
-    context 'with an unsupported size' do
-      it 'raises an error' do
-        expect { Predicates[:size?].call('oops', 1) }.to raise_error(ArgumentError, /oops/)
-      end
-    end
-  end
-end

data/spec/unit/predicates/str_spec.rb

@@ -1,32 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#str?' do
-    let(:predicate_name) { :str? }
-
-    context 'when value is a string' do
-      let(:arguments_list) do
-        [
-          [''],
-          ['John']
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is not a string' do
-      let(:arguments_list) do
-        [
-          [[]],
-          [{}],
-          [nil],
-          [:symbol],
-          [String]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/time_spec.rb

@@ -1,31 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#time?' do
-    let(:predicate_name) { :time? }
-
-    context 'when value is a date' do
-      let(:arguments_list) do
-        [[Time.now]]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is not an integer' do
-      let(:arguments_list) do
-        [
-          [''],
-          [[]],
-          [{}],
-          [nil],
-          [:symbol],
-          [String],
-          [1]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/rule/check_spec.rb

@@ -1,29 +0,0 @@
-RSpec.describe Rule::Check do
-  subject(:rule) { Rule::Check.new(:name, other.(input).curry(predicate)) }
-
-  include_context 'predicates'
-
-  let(:other) do
-    Rule::Value.new(:name, none?).or(Rule::Value.new(:name, filled?))
-  end
-
-  describe '#call' do
-    context 'when a given predicate passed' do
-      let(:input) { 'Jane' }
-      let(:predicate) { :filled? }
-
-      it 'returns a success' do
-        expect(rule.()).to be_success
-      end
-    end
-
-    context 'when a given predicate did not pass' do
-      let(:input) { nil }
-      let(:predicate) { :filled? }
-
-      it 'returns a failure' do
-        expect(rule.()).to be_failure
-      end
-    end
-  end
-end

data/spec/unit/rule/conjunction_spec.rb

@@ -1,28 +0,0 @@
-RSpec.describe Rule::Composite::Conjunction do
-  subject(:rule) { Rule::Composite::Conjunction.new(left, right) }
-
-  let(:left) { Rule::Value.new(:age, Predicates[:int?]) }
-  let(:right) { Rule::Value.new(:age, Predicates[:gt?].curry(18)) }
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(rule.(18)).to be_failure
-    end
-  end
-
-  describe '#and' do
-    let(:other) { Rule::Value.new(:age, Predicates[:lt?].curry(30)) }
-
-    it 'creates conjunction with the other' do
-      expect(rule.and(other).(31)).to be_failure
-    end
-  end
-
-  describe '#or' do
-    let(:other) { Rule::Value.new(:age, Predicates[:lt?].curry(14)) }
-
-    it 'creates disjunction with the other' do
-      expect(rule.or(other).(13)).to be_success
-    end
-  end
-end

data/spec/unit/rule/disjunction_spec.rb

@@ -1,36 +0,0 @@
-RSpec.describe Rule::Composite::Disjunction do
-  subject(:rule) { Rule::Composite::Disjunction.new(left, right) }
-
-  let(:left) { Rule::Value.new(:age, Predicates[:none?]) }
-  let(:right) { Rule::Value.new(:age, Predicates[:gt?].curry(18)) }
-
-  let(:other) do
-    Rule::Value.new(:age, Predicates[:int?]) & Rule::Value.new(:age, Predicates[:lt?].curry(14))
-  end
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(rule.(nil)).to be_success
-      expect(rule.(19)).to be_success
-      expect(rule.(18)).to be_failure
-    end
-  end
-
-  describe '#and' do
-    it 'creates conjunction with the other' do
-      expect(rule.and(other).(nil)).to be_failure
-      expect(rule.and(other).(19)).to be_failure
-      expect(rule.and(other).(13)).to be_failure
-      expect(rule.and(other).(14)).to be_failure
-    end
-  end
-
-  describe '#or' do
-    it 'creates disjunction with the other' do
-      expect(rule.or(other).(nil)).to be_success
-      expect(rule.or(other).(19)).to be_success
-      expect(rule.or(other).(13)).to be_success
-      expect(rule.or(other).(14)).to be_failure
-    end
-  end
-end

data/spec/unit/rule/each_spec.rb

@@ -1,20 +0,0 @@
-require 'dry/validation/rule'
-
-RSpec.describe Dry::Validation::Rule::Each do
-  include_context 'predicates'
-
-  subject(:address_rule) do
-    Dry::Validation::Rule::Each.new(:name, is_string)
-  end
-
-  let(:is_string) { Dry::Validation::Rule::Value.new(:name, str?) }
-
-  describe '#call' do
-    it 'applies its rules to all elements in the input' do
-      expect(address_rule.(['Address'])).to be_success
-
-      expect(address_rule.([nil, 'Address'])).to be_failure
-      expect(address_rule.([:Address, 'Address'])).to be_failure
-    end
-  end
-end

data/spec/unit/rule/group_spec.rb

@@ -1,12 +0,0 @@
-RSpec.describe Rule::Group do
-  include_context 'predicates'
-
-  subject(:rule) { Rule::Group.new([:pass, :pass_confirm], eql?) }
-
-  describe '#call' do
-    it 'calls predicate with result values' do
-      expect(rule.('foo', 'foo')).to be_success
-      expect(rule.('foo', 'bar')).to be_failure
-    end
-  end
-end

data/spec/unit/rule/implication_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Rule::Composite::Implication do
-  subject(:rule) { Rule::Composite::Implication.new(left, right) }
-
-  let(:left) { Rule::Value.new(:age, Predicates[:int?]) }
-  let(:right) { Rule::Value.new(:age, Predicates[:gt?].curry(18)) }
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(rule.('19')).to be_success
-      expect(rule.(19)).to be_success
-      expect(rule.(18)).to be_failure
-    end
-  end
-end

data/spec/unit/rule/key_spec.rb

@@ -1,27 +0,0 @@
-require 'dry/validation/rule'
-
-RSpec.describe Dry::Validation::Rule::Key do
-  include_context 'predicates'
-
-  subject(:rule) { Dry::Validation::Rule::Key.new(:name, key?) }
-
-  describe '#call' do
-    it 'applies predicate to the value' do
-      expect(rule.(name: 'Jane')).to be_success
-      expect(rule.({})).to be_failure
-    end
-  end
-
-  describe '#and' do
-    let(:other) { Dry::Validation::Rule::Value.new(:name, str?) }
-
-    it 'returns conjunction rule where value is passed to the right' do
-      present_and_string = rule.and(other)
-
-      expect(present_and_string.(name: 'Jane')).to be_success
-
-      expect(present_and_string.({})).to be_failure
-      expect(present_and_string.(name: 1)).to be_failure
-    end
-  end
-end

data/spec/unit/rule/set_spec.rb

@@ -1,32 +0,0 @@
-require 'dry/validation/rule'
-
-RSpec.describe Dry::Validation::Rule::Set do
-  include_context 'predicates'
-
-  subject(:rule) do
-    Dry::Validation::Rule::Set.new(:address, [is_string, min_size.curry(6)])
-  end
-
-  let(:is_string) { Dry::Validation::Rule::Value.new(:name, str?) }
-  let(:min_size) { Dry::Validation::Rule::Value.new(:name, min_size?) }
-
-  describe '#call' do
-    it 'applies its rules to the input' do
-      expect(rule.('Address')).to be_success
-      expect(rule.('Addr')).to be_failure
-    end
-  end
-
-  describe '#to_ary' do
-    it 'returns an array representation' do
-      expect(rule).to match_array([
-        :set, [
-          :address, [
-            [:val, [:name, [:predicate, [:str?, []]]]],
-            [:val, [:name, [:predicate, [:min_size?, [6]]]]]
-          ]
-        ]
-      ])
-    end
-  end
-end

data/spec/unit/rule/value_spec.rb

@@ -1,42 +0,0 @@
-require 'dry/validation/rule'
-
-RSpec.describe Dry::Validation::Rule::Value do
-  include_context 'predicates'
-
-  let(:is_nil) { Dry::Validation::Rule::Value.new(:name, none?) }
-
-  let(:is_string) { Dry::Validation::Rule::Value.new(:name, str?) }
-
-  let(:min_size) { Dry::Validation::Rule::Value.new(:name, min_size?) }
-
-  describe '#call' do
-    it 'returns result of a predicate' do
-      expect(is_string.(1)).to be_failure
-      expect(is_string.('1')).to be_success
-    end
-  end
-
-  describe '#and' do
-    it 'returns a conjunction' do
-      string_and_min_size = is_string.and(min_size.curry(3))
-
-      expect(string_and_min_size.('abc')).to be_success
-      expect(string_and_min_size.('abcd')).to be_success
-
-      expect(string_and_min_size.(1)).to be_failure
-      expect(string_and_min_size.('ab')).to be_failure
-    end
-  end
-
-  describe '#or' do
-    it 'returns a disjunction' do
-      nil_or_string = is_nil.or(is_string)
-
-      expect(nil_or_string.(nil)).to be_success
-      expect(nil_or_string.('abcd')).to be_success
-
-      expect(nil_or_string.(true)).to be_failure
-      expect(nil_or_string.(1)).to be_failure
-    end
-  end
-end

data/spec/unit/rule_compiler_spec.rb

@@ -1,123 +0,0 @@
-require 'dry/validation/rule_compiler'
-
-RSpec.describe Dry::Validation::RuleCompiler, '#call' do
-  subject(:compiler) { RuleCompiler.new(predicates) }
-
-  let(:predicates) {
-    { key?: predicate,
-      filled?: predicate,
-      email: val_rule.('email').curry(:filled?) }
-  }
-
-  let(:predicate) { double(:predicate).as_null_object }
-
-  let(:key_rule) { Rule::Key.new(:email, predicate) }
-  let(:not_key_rule) { Rule::Key.new(:email, predicate).negation }
-  let(:val_rule) { Rule::Value.new(:email, predicate) }
-  let(:check_rule) { Rule::Check.new(:email, predicates[:email]) }
-  let(:and_rule) { key_rule & val_rule }
-  let(:or_rule) { key_rule | val_rule }
-  let(:xor_rule) { key_rule ^ val_rule }
-  let(:set_rule) { Rule::Set.new(:email, [val_rule]) }
-  let(:each_rule) { Rule::Each.new(:email, val_rule) }
-
-  it 'compiles key rules' do
-    ast = [[:key, [:email, [:predicate, [:key?, predicate]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([key_rule])
-  end
-
-  it 'compiles check rules' do
-    ast = [[:check, [:email, [:predicate, [:email, [:filled?]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([check_rule])
-  end
-
-
-  it 'compiles negated rules' do
-    ast = [[:not, [:key, [:email, [:predicate, [:key?, predicate]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([not_key_rule])
-  end
-
-  it 'compiles conjunction rules' do
-    ast = [
-      [
-        :and, [
-          [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:email, [:predicate, [:filled?, []]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([and_rule])
-  end
-
-  it 'compiles disjunction rules' do
-    ast = [
-      [
-        :or, [
-          [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:email, [:predicate, [:filled?, []]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([or_rule])
-  end
-
-  it 'compiles exclusive disjunction rules' do
-    ast = [
-      [
-        :xor, [
-          [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:email, [:predicate, [:filled?, []]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([xor_rule])
-  end
-
-  it 'compiles set rules' do
-    ast = [
-      [
-        :set, [
-          :email, [
-            [:val, [:email, [:predicate, [:filled?, []]]]]
-          ]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([set_rule])
-  end
-
-  it 'compiles each rules' do
-    ast = [
-      [
-        :each, [
-          :email, [:val, [:email, [:predicate, [:filled?, []]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([each_rule])
-  end
-end