ruby-livr 2.0.0

data/ruby-livr.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |gem|
+  gem.name        = "ruby-livr"
+  gem.version     = "2.0.0"
+  gem.date        = "2017-12-22"
+  gem.summary     = "Implementation of LIVR v2.0"
+  gem.description = "Language Independent Validation Rules. Implements 2.0 specification"
+  gem.authors     = ["Vitaliy Yanchuk"]
+  gem.email       = 'fuksito@gmail.com'
+  gem.homepage    = "https://github.com/fuksito/ruby-livr"
+  gem.license     = "MIT"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "activesupport", '~> 5'
+  gem.add_development_dependency "rspec", "3.7"
+end

data/spec/01-test_suite_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper.rb'
+
+def read_file(dir, filename)
+  data = File.read dir.join("#{filename}.json")
+  JSON.parse(data)
+end
+
+RSpec.describe "test_suite " do
+
+  %w[ positive negative ].each do |spec_dir|
+    context spec_dir do
+      dirs = Pathname.new("#{SPEC_ROOT}/test_suite/#{spec_dir}").children.select(&:directory?)
+      dirs.each do |dir|
+        it dir.basename do
+          rules = read_file(dir, "rules")
+          input = read_file(dir, "input")
+
+          validator = LIVR::Validator.new(rules)
+          result = validator.validate(input)
+          errors = validator.get_errors
+
+          if spec_dir == 'positive'
+            expected_result = read_file(dir, "output")
+            expect(result).to eq(expected_result)
+          else
+            expected_errors = read_file(dir, "errors")
+            expect(errors).to eq(expected_errors)
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/02-aliases_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper.rb'
+
+RSpec.describe "aliases" do
+
+  it "Validates with aliased rules" do
+    validator = LIVR::Validator.new({
+        "password" => ["required", "strong_password"]
+      })
+    validator.register_aliased_rule({
+      "name" => 'strong_password',
+      "rules" => { "min_length" => 6 },
+      "error" => 'WEAK_PASSWORD'
+    })
+
+
+    output = validator.validate({ "password" => "abc" })
+    expect(output).to eq(false)
+    expect(validator.get_errors).to eq({"password" => "WEAK_PASSWORD"})
+  end
+
+end

data/spec/03-auto_trim_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper.rb'
+
+RSpec.describe "auto_trim" do
+
+  let(:validator) do
+    LIVR::Validator.new({
+      code: "required",
+      password: [ "required", { "min_length" => 3 }],
+      address:  { "nested_object" => {
+          street: { "min_length" => 5 },
+        }
+      }
+    }, true)
+  end
+
+  it "NEGATIVE: Validate data with automatic trim" do
+    output = validator.validate({
+        code: '  ',
+        password: ' 12  ',
+        address: {
+            street: '  hell '
+        }
+      })
+    # expect(output).to eq(false), 'should return false due to validation errors fot trimmed values'
+    expect(output).to eq(false)
+
+    expect(validator.get_errors).to eq({
+                                        code: 'REQUIRED',
+                                        password: 'TOO_SHORT',
+                                        address: {
+                                          street: 'TOO_SHORT',
+                                        }
+                                      })
+
+  end
+
+  it "POSITIVE: Validate data with automatic trim" do
+    clean_data = validator.validate({
+        code: ' A ',
+        password: ' 123  ',
+        address: {
+            street: '  hello '
+        }
+    })
+
+    expect(clean_data).to be_truthy, 'should return clean data'
+    expect(clean_data).to eq({
+                              code: 'A',
+                              password: '123',
+                              address: {
+                                street: 'hello',
+                              }
+                             }), 'Should contain error codes'
+  end
+
+end

data/spec/04-custom_filters_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper.rb'
+
+RSpec.describe "custom_filters" do
+  class MyTrim < LIVR::Rule
+    def call(value, user_data, field_results)
+      return if is_no_value(value) || value.is_a?(Hash)
+      field_results << value.to_s.strip
+      return
+    end
+  end
+
+  class MyLc < LIVR::Rule
+    def call(value, user_data, field_results)
+      return if is_no_value(value) || value.is_a?(Hash)
+      field_results << value.to_s.downcase
+      return
+    end
+  end
+
+  class MyUcfirst < LIVR::Rule
+    def call(value, user_data, field_results)
+      return if is_no_value(value) || value.is_a?(Hash)
+      field_results << value[0].capitalize + value[1..-1]
+      return
+    end
+  end
+
+  LIVR::Validator.register_default_rules(
+      my_trim:    MyTrim,
+      my_lc:      MyLc,
+      my_ucfirst: MyUcfirst
+    )
+
+  it 'Validate data with registered rules' do
+    validator = LIVR::Validator.new(
+      "word1" => ['my_trim', 'my_lc', 'my_ucfirst'],
+      "word2" => ['my_trim', 'my_lc'],
+      "word3" => ['my_ucfirst'],
+    )
+
+    output = validator.validate(
+      "word1" => ' wordOne ',
+      "word2" => ' wordTwo ',
+      "word3" => 'wordThree ',
+      )
+
+    expect(output).to eq( "word1" => 'Wordone',
+                          "word2" => 'wordtwo',
+                          "word3" => 'WordThree ',
+                        )
+  end
+
+end
+

data/spec/05-rules_replacement_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper.rb'
+
+RSpec.describe "rules_replacement" do
+
+  class PatchedRule < LIVR::Rule
+
+    def initialize(rule_name, rule_builder)
+      @rule_name = rule_name
+      @rule_builder = rule_builder
+    end
+
+    def new(*args)
+      @rule_args = args
+      @rule_validator = @rule_builder.new(*args)
+      self
+    end
+
+    def call(*args)
+      error_code = @rule_validator.call(*args)
+      if error_code
+        return {
+          "code" => error_code,
+          "rule" => { @rule_name => @rule_args }
+        }
+      end
+    end
+  end
+
+  it 'Validate data with registered rules' do
+    # Patch rules
+    default_rules = LIVR::DEFAULT_RULES
+
+    original_rules = {}
+    new_rules      = {}
+    default_rules.each do |rule_name, rule_builder|
+      original_rules[rule_name] = rule_builder
+      new_rules[rule_name] = PatchedRule.new(rule_name, rule_builder)
+    end
+
+    LIVR::Validator.register_default_rules(new_rules)
+
+    # Test
+    validator = LIVR::Validator.new({
+        "name" =>  ['required'],
+        "phone" => { "max_length" => 10 }
+    })
+
+    output = validator.validate({
+        "phone" => '123456789123456'
+    })
+
+    expect(output).to eq(false)
+    expect(validator.get_errors).to eq({
+            "name" => {
+                "code" => 'REQUIRED',
+                "rule" => { "required" => [] },
+            },
+            "phone" => {
+                "code" => 'TOO_LONG',
+                "rule" => { "max_length" => [10] },
+            }
+      })
+
+     # Restore
+    LIVR::Validator.register_default_rules(original_rules)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+SPEC_ROOT = File.dirname(__FILE__)
+
+require_relative "../lib/livr.rb"

data/spec/test_suite/aliases_negative/01-adult_age/aliases.json

@@ -0,0 +1,12 @@
+[
+    {
+        "name": "adult_age",
+        "rules": ["positive_integer", {"min_number": 18}]
+    },
+
+    {
+        "name": "adult_age_with_custom_error",
+        "rules": ["positive_integer", {"min_number": 18}],
+        "error": "WRONG_AGE"
+    }
+]

data/spec/test_suite/aliases_negative/01-adult_age/errors.json

@@ -0,0 +1,6 @@
+{
+    "age3": "TOO_LOW",
+    "age4": "NOT_POSITIVE_INTEGER",
+    "age3_custom_error": "WRONG_AGE",
+    "age4_custom_error": "WRONG_AGE"
+}

data/spec/test_suite/aliases_negative/01-adult_age/input.json

@@ -0,0 +1,11 @@
+{
+    "age1": 32,
+    "age2": 33,
+    "age3": 15,
+    "age4": -20,
+    "age1_custom_error": 37,
+    "age2_custom_error": 38,
+    "age3_custom_error": 16,
+    "age4_custom_error": -10,
+    "extra_field": 12
+}

data/spec/test_suite/aliases_negative/01-adult_age/rules.json

@@ -0,0 +1,10 @@
+{
+    "age1": "adult_age",
+    "age2": ["adult_age"],
+    "age3": [ { "adult_age": [] } ],
+    "age4": { "adult_age": [] },
+    "age1_custom_error": "adult_age_with_custom_error",
+    "age2_custom_error": ["adult_age_with_custom_error"],
+    "age3_custom_error": [ { "adult_age_with_custom_error": [] } ],
+    "age4_custom_error": { "adult_age_with_custom_error": [] }
+}

data/spec/test_suite/aliases_negative/02-address/aliases.json

@@ -0,0 +1,20 @@
+[
+    {
+        "name": "address",
+        "rules": { "nested_object":{
+            "street": "required",
+            "zip": ["required", "positive_integer"],
+            "city": {"one_of": ["Kiev", "Kharkiv"] }
+        }}
+    },
+
+    {
+        "name": "address_with_custom_error",
+        "rules": { "nested_object":{
+            "street": "required",
+            "zip": ["required", "positive_integer"],
+            "city": {"one_of": ["Kiev", "Kharkiv"] }
+        }},
+        "error": "WRONG_ADDRESS"
+    }
+]

data/spec/test_suite/aliases_negative/02-address/errors.json

@@ -0,0 +1,8 @@
+{
+    "address": {
+        "street": "REQUIRED",
+        "zip": "NOT_POSITIVE_INTEGER",
+        "city": "NOT_ALLOWED_VALUE"
+    },
+    "address_custom_error": "WRONG_ADDRESS"
+}

data/spec/test_suite/aliases_negative/02-address/input.json

@@ -0,0 +1,13 @@
+{
+    "address": {
+        "street": "",
+        "zip": -1232131,
+        "city": "Moscow"
+    },
+    "address_custom_error": {
+        "street": "My street",
+        "zip": "12312",
+        "city": "Moscow"
+    },
+    "extra_field": 12
+}

data/spec/test_suite/aliases_negative/02-address/rules.json

@@ -0,0 +1,4 @@
+{
+    "address": "address",
+    "address_custom_error": "address_with_custom_error"
+}

data/spec/test_suite/aliases_negative/03-adult_age_in_user/aliases.json

@@ -0,0 +1,31 @@
+[
+    {
+        "name": "adult_age",
+        "rules": ["positive_integer", {"min_number": 18}]
+    },
+
+    {
+        "name": "adult_age_with_custom_error",
+        "rules": ["positive_integer", {"min_number": 18}],
+        "error": "WRONG_AGE"
+    },
+
+    {
+        "name": "user",
+        "rules": { "nested_object":{
+            "name": "required",
+            "age1": "adult_age",
+            "age2": "adult_age_with_custom_error"
+        }}
+    },
+
+    {
+        "name": "user_with_custom_error",
+        "rules": { "nested_object":{
+            "name": "required",
+            "age1": "adult_age",
+            "age2": "adult_age_with_custom_error"
+        }},
+        "error": "WRONG_USER"
+    }
+]

data/spec/test_suite/aliases_negative/03-adult_age_in_user/errors.json

@@ -0,0 +1,8 @@
+{
+    "user": {
+        "name": "REQUIRED",
+        "age1": "TOO_LOW",
+        "age2": "WRONG_AGE"
+    },
+    "user_custom_error": "WRONG_USER"
+}

data/spec/test_suite/aliases_negative/03-adult_age_in_user/input.json

@@ -0,0 +1,14 @@
+{
+    "user": {
+        "name": "",
+        "age1": 15,
+        "age2": 15,
+        "extra_field": "som value"
+    },
+    "user_custom_error": {
+        "name": "koorchik",
+        "age1": 15,
+        "age2": 22
+    },
+    "extra_field": 12
+}

data/spec/test_suite/aliases_negative/03-adult_age_in_user/rules.json

@@ -0,0 +1,4 @@
+{
+    "user": "user",
+    "user_custom_error": ["user_with_custom_error"]
+}

data/spec/test_suite/aliases_positive/01-adult_age/aliases.json

@@ -0,0 +1,12 @@
+[
+    {
+        "name": "adult_age",
+        "rules": ["positive_integer", {"min_number": 18}]
+    },
+
+    {
+        "name": "adult_age_with_custom_error",
+        "rules": ["positive_integer", {"min_number": 18}],
+        "error": "WRONG_AGE"
+    }
+]

data/spec/test_suite/aliases_positive/01-adult_age/input.json

@@ -0,0 +1,11 @@
+{
+    "age1": 32,
+    "age2": 33,
+    "age3": 35,
+    "age4": 36,
+    "age1_custom_error": 37,
+    "age2_custom_error": 38,
+    "age3_custom_error": 100,
+    "age4_custom_error": 110,
+    "extra_field": 12
+}