dry-validation 0.1.0 → 0.2.0

data/spec/unit/input_type_compiler_spec.rb

@@ -0,0 +1,205 @@
+require 'dry/validation/input_type_compiler'
+
+RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
+  subject(:compiler) { Dry::Validation::InputTypeCompiler.new }
+
+  let(:rule_ast) do
+    [
+      [
+        :and, [
+          [:key, [:email, [:predicate, [:key?, [:email]]]]],
+          [
+            :and, [
+              [:val, [:email, [:predicate, [:str?, []]]]],
+              [:val, [:email, [:predicate, [:filled?, []]]]]
+            ]
+          ]
+        ]
+      ],
+      [
+        :and, [
+          [:key, [:age, [:predicate, [:key?, [:age]]]]],
+          [
+            :or, [
+              [:val, [:age, [:predicate, [:none?, []]]]],
+              [
+                :and, [
+                  [:val, [:age, [:predicate, [:int?, []]]]],
+                  [:val, [:age, [:predicate, [:filled?, []]]]]
+                ]
+              ]
+            ]
+          ]
+        ]
+      ],
+      [
+        :and, [
+          [:key, [:address, [:predicate, [:key?, [:address]]]]],
+          [:val, [:address, [:predicate, [:str?, []]]]]
+        ]
+      ]
+    ].map(&:to_ary)
+  end
+
+  let(:params) 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[params]
+
+    expect(result).to eql(email: 'jane@doe.org', age: 20, address: 'City, Street 1/2')
+  end
+
+  it 'supports int? => "form.int"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:age, [:predicate, [:key?, [:age]]]]],
+          [:val, [:age, [:predicate, [:int?, []]]]],
+        ]
+      ]
+    ]
+
+    input_type = compiler.(rule_ast)
+
+    expect(input_type['age' => '21']).to eql(age: 21)
+  end
+
+  it 'supports none? => "form.int"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:age, [:predicate, [:key?, [:age]]]]],
+          [
+            :or, [
+              [:val, [:age, [:predicate, [:none?, []]]]],
+              [:val, [:age, [:predicate, [: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? => "form.float"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:lat, [:predicate, [:key?, [:lat]]]]],
+          [:val, [:lat, [:predicate, [:float?, []]]]],
+        ]
+      ]
+    ]
+
+    input_type = compiler.(rule_ast)
+
+    expect(input_type['lat' => '21.12']).to eql(lat: 21.12)
+  end
+
+  it 'supports decimal? => "form.decimal"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:lat, [:predicate, [:key?, [:lat]]]]],
+          [:val, [:lat, [:predicate, [:decimal?, []]]]],
+        ]
+      ]
+    ]
+
+    input_type = compiler.(rule_ast)
+
+    expect(input_type['lat' => '21.12']).to eql(lat: 21.12.to_d)
+  end
+
+  it 'supports date? => "form.date"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:bday, [:predicate, [:key?, [:bday]]]]],
+          [:val, [:bday, [:predicate, [: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? => "form.date_time"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:bday, [:predicate, [:key?, [:bday]]]]],
+          [:val, [:bday, [:predicate, [: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? => "form.time"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:bday, [:predicate, [:key?, [:bday]]]]],
+          [:val, [:bday, [:predicate, [: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? => "form.bool"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:bday, [:predicate, [:key?, [:bday]]]]],
+          [:val, [:bday, [:predicate, [: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? => "form.time"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:key, [:admin, [:predicate, [:key?, [:admin]]]]],
+          [:val, [:admin, [:predicate, [: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
+end

data/spec/unit/predicates/bool_spec.rb

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

data/spec/unit/predicates/date_spec.rb

@@ -0,0 +1,31 @@
+require 'dry/validation/predicates'
+
+RSpec.describe Dry::Validation::Predicates do
+  describe '#date?' do
+    let(:predicate_name) { :date? }
+
+    context 'when value is a date' do
+      let(:arguments_list) do
+        [[Date.today]]
+      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/predicates/date_time_spec.rb

@@ -0,0 +1,31 @@
+require 'dry/validation/predicates'
+
+RSpec.describe Dry::Validation::Predicates do
+  describe '#date_time?' do
+    let(:predicate_name) { :date_time? }
+
+    context 'when value is a date' do
+      let(:arguments_list) do
+        [[DateTime.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/predicates/decimal_spec.rb

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

data/spec/unit/predicates/float_spec.rb

@@ -0,0 +1,31 @@
+require 'dry/validation/predicates'
+
+RSpec.describe Dry::Validation::Predicates do
+  describe '#float?' do
+    let(:predicate_name) { :float? }
+
+    context 'when value is a float' do
+      let(:arguments_list) do
+        [[1.0]]
+      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/predicates/{nil_spec.rb → none_spec.rb}

@@ -1,8 +1,8 @@
 require 'dry/validation/predicates'
 
 RSpec.describe Dry::Validation::Predicates do
-  describe '#nil?' do
-    let(:predicate_name) { :nil? }
+  describe '#none?' do
+    let(:predicate_name) { :none? }
 
     context 'when value is nil' do
       let(:arguments_list) { [[nil]] }

data/spec/unit/predicates/time_spec.rb

@@ -0,0 +1,31 @@
+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/conjunction_spec.rb

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,36 @@
+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