data-validator 1.0.0

data/test/gfx/004_xor.rb

@@ -0,0 +1,96 @@
+require 'test-unit'
+require 'data/validator'
+
+class Test004Xor < Test::Unit::TestCase
+
+  def test_test
+    v = Data::Validator.new(
+      'uri'        => { xor: %w(schema host path_query) },
+
+      'schema'     => { default: 'http' },
+      'host'       => { default: '127.0.0.1' },
+      'path_query' => { default: '/' },
+
+      'method'     => { default: 'GET' },
+    )
+
+    # note 'success cases';
+
+    args = v.validate({ 'uri' => 'https://example.com/' })
+    assert { args == { 'uri' => 'https://example.com/', 'method' => 'GET' } }
+
+    args = v.validate({
+      'schema'     => 'https',
+      'host'       => 'example.com',
+      'path_query' => '/index.html',
+    })
+    assert_equal args, {
+      'schema'     => 'https',
+      'host'       => 'example.com',
+      'path_query' => '/index.html',
+      'method'     => 'GET',
+    }
+
+    args = v.validate({
+      'host' => 'example.com',
+    })
+    assert_equal args, {
+      'schema'     => 'http',
+      'host'       => 'example.com',
+      'path_query' => '/',
+      'method'     => 'GET',
+    }
+
+    args = v.validate();
+    assert_equal args, {
+      'schema'     => 'http',
+      'host'       => '127.0.0.1',
+      'path_query' => '/',
+      'method'     => 'GET',
+    }
+
+    # note 'failure cases';
+
+    assert_raise_message(/uri versus.+schema/) {
+      v.validate({ 'uri' => 'foo', 'schema' => 'http' })
+    }
+
+    assert_raise_message(/uri versus.+(host|schema)/) {
+      v.validate({ 'uri' => 'foo', 'schema' => 'http', 'host' => 'example.com' })
+    }
+
+    # note 'case without defaults';
+
+    v = Data::Validator.new(
+      'uri'        => { xor: %w(schema host path_query) },
+
+      'schema'     => { default: 'http' },
+      'host'       => { },
+      'path_query' => { default: '/' },
+
+      'method'     => { default: 'GET' },
+    )
+
+    args = v.validate(
+      'uri' => 'http://example.com/',
+    )
+    assert_equal args, {
+      'uri'        => 'http://example.com/',
+      'method'     => 'GET',
+    }
+
+    args = v.validate(
+      'host' => 'example.com',
+    )
+    assert_equal args, {
+      'schema'     => 'http',
+      'host'       => 'example.com',
+      'path_query' => '/',
+      'method'     => 'GET',
+    }
+
+    assert_raise_message(/(uri|host)/) {
+      v.validate()
+    }
+  end
+end

data/test/gfx/008_optional.t

@@ -0,0 +1,27 @@
+require 'test-unit'
+require 'data/validator'
+
+class Test008Optional < Test::Unit::TestCase
+
+  def test_test
+    v = Data::Validator.new(
+      'foo' => { },
+      'bar' => { },
+      'baz' => { optional => 1 }
+    )
+    asset { v.is_a? Data::Validator }
+
+    args = v.validate({ 'foo' => 1, 'bar' => 2 })
+    assert { args == { 'foo' => 1, 'bar' => 2 } }
+
+    args = v.validate({ 'foo' => 1, 'bar' => 2, 'baz' => 3 })
+    assert { args == { 'foo' => 1, 'bar' => 2, 'baz' => 3 } }
+
+    # note 'failing cases';
+
+    assert_raise_message(/foo|bar/) { v.validate() }
+    assert_raise_message(/foo|bar/) { v.validate('baz' => 1) }
+    assert_raise_message(/bar/) { v.validate('foo' => 1) }
+    assert_raise_message(/foo/) { v.validate('bar' => 1) }
+  end
+end

data/test/gfx/010_common_params.rb

@@ -0,0 +1,18 @@
+require 'test-unit'
+require 'data/validator'
+
+class Test010CommonParams < Test::Unit::TestCase
+
+  def test_test
+    base_param = {
+      'member_id' => { isa: Integer },
+      'type'      => { isa: Integer, default: 0, optional: true },
+    }
+
+    foo = Data::Validator.new(base_param)
+    bar = Data::Validator.new(base_param)
+
+    assert_nothing_raised { foo.validate('member_id' => 10) }
+    assert_nothing_raised { bar.validate('member_id' => 10) }
+  end
+end

data/test/gfx/104_extra_args.rb

@@ -0,0 +1,17 @@
+require 'test-unit'
+require 'data/validator'
+
+class Test104ExtraArgs < Test::Unit::TestCase
+
+  def test_test
+    v = Data::Validator.new(
+      'foo' => { },
+    ).with('AllowExtra')
+
+    args = v.validate('foo' => 42, 'bar' => 15)
+    assert { args == {'foo' => 42, 'bar' => 15} }
+
+    args = v.validate('bar' => 15, 'foo' => 42) # reversed order
+    assert { args == {'foo' => 42, 'bar' => 15} }
+  end
+end

data/test/xaicron/00_compile.rb

@@ -0,0 +1,9 @@
+require 'test-unit'
+
+class Test00Compile < Test::Unit::TestCase
+  def test_require
+    assert_nothing_raised do
+      require 'data/validator'
+    end
+  end
+end

data/test/xaicron/01_new.rb

@@ -0,0 +1,46 @@
+require 'test-unit'
+require 'data/validator'
+
+class Test01New < Test::Unit::TestCase
+  test 'no args' do
+    assert_raise ArgumentError do
+      Data::Validator.new
+    end
+  end
+
+  test 'simple' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String
+    )
+
+    assert { rule.is_a? Data::Validator }
+  end
+
+  test 'nested' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => {
+        isa:  Integer,
+        rule: {
+          'baz' => String,
+        }
+      },
+    )
+
+    assert { rule.is_a? Data::Validator }
+  end
+
+  # test 'nested (hash)' # is perl specific
+
+  test 'invalid nested rule' do
+    assert_raise TypeError do
+      Data::Validator::Recursive.new(
+        'foo' => String,
+        'bar' => {
+          isa:  Integer,
+          rule: 'invalid'
+        },
+      )
+    end
+  end
+end

data/test/xaicron/02_validate.rb

@@ -0,0 +1,159 @@
+require 'test-unit'
+require 'data/validator'
+
+class Test02Validate < Test::Unit::TestCase
+
+  setup do
+    @rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, optional: 1 },
+      'baz' => {
+        isa: Hash,
+        rule: {
+          'hoge' => String,
+          'fuga' => Integer,
+          'piyo' => {
+            isa:      Array,
+            xor:      %w/hoge/,
+            optional: true,
+          },
+        },
+      },
+    )
+  end
+
+  test 'valid data' do
+    input = {
+      'foo' => 'xxx',
+      'bar' => 123,
+      'baz' => {
+        'hoge' => 'xxx',
+        'fuga' => 123,
+      },
+    }
+    params = @rule.validate(input)
+
+    assert { params == input }
+  end
+
+  test 'invalid data' do
+    input = {
+      'foo' => 'xxx',
+      'bar' => 123,
+      'baz' => {
+        'fuga' => 'piyo'
+      },
+    }
+    assert_raise_message(/hoge|fuga/) { @rule.validate(input) }
+  end
+
+  test 'conflicts' do
+    input = {
+      'foo' => 'xxx',
+      'bar' => 123,
+      'baz' => {
+        'hoge' => 'yyy',
+        'fuga' => 456,
+        'piyo' => %w/a b c/,
+      },
+    }
+    assert_raise_message(/hoge|piyo/) { @rule.validate(input) }
+  end
+
+  test 'with default option' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, default: 1 },
+      'baz' => {
+        isa: Hash,
+        rule: {
+          'hoge' => String,
+          'fuga' => Integer,
+        },
+      },
+    )
+
+    input = {
+      'foo' => 'xxx',
+      'baz' => {
+        'hoge' => 'xxx',
+        'fuga' => 123,
+      },
+    }
+
+    params = rule.validate(input)
+
+    assert { params['bar'] == 1 }
+  end
+
+  test 'default option with nested' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, default: 1 },
+      'baz' => {
+        isa: Hash,
+        rule: {
+          'hoge' => { isa: String, default: 'yyy' },
+          'fuga' => Integer,
+        },
+      },
+    )
+
+    input = {
+      'foo' => 'xxx',
+      'baz' => {
+        'fuga' => 123,
+      },
+    }
+
+    params   = rule.validate(input)
+    expected = {
+      'foo' => 'xxx',
+      'bar' => 1,
+      'baz' => {
+        'hoge' => 'yyy',
+        'fuga' => 123,
+      },
+    }
+    assert { params == expected }
+  end
+
+  test 'with AllowExtra' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, default: 1 },
+      'baz' => {
+        isa: Hash,
+        with: 'AllowExtra',
+        rule: {
+          'hoge' => { isa: String, default: 'yyy' },
+          'fuga' => Integer
+        },
+      },
+    ).with('AllowExtra')
+
+
+    input = {
+      'foo' => 'xxx',
+      'baz' => {
+        'fuga' => 123,
+        'extra_param_in_baz' => 1,
+      },
+      'extra_param' => 1,
+    }
+
+    params   = rule.validate(input)
+    expected = {
+      'foo' => 'xxx',
+      'bar' => 1,
+      'baz' => {
+        'hoge' => 'yyy',
+        'fuga' => 123,
+        'extra_param_in_baz' => 1,
+      },
+      'extra_param' => 1,
+    }
+
+    assert { params == expected }
+  end
+end

data/test/xaicron/03_arrayref.rb

@@ -0,0 +1,268 @@
+require 'test-unit'
+require 'data/validator'
+
+# There is no such thing like an arrayref in Ruby.  But here I follow the
+# original naming anyway.
+class Test03Arrayref < Test::Unit::TestCase
+
+  setup do
+    @rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, optional: 1 },
+      'baz' => {
+        isa: Array,
+        rule: {
+          'hoge' => String,
+          'fuga' => Integer,
+          'piyo' => {
+            isa:      Array,
+            xor:      %w/hoge/,
+            optional: true,
+          },
+        },
+      },
+    )
+  end
+
+  test 'valid data' do
+    input = {
+      'foo' => 'xxx',
+      'bar' => 123,
+      'baz' => [
+        {
+          'hoge' => 'xxx',
+          'fuga' => 123,
+        },
+      ],
+    }
+    params = @rule.validate(input)
+
+    assert { params == input }
+  end
+
+  test 'invalid data as array' do
+    input = {
+      'foo' => 'xxx',
+      'bar' => 123,
+      'baz' => {},
+    }
+    assert_raise_message(/baz/) { @rule.validate(input) }
+  end
+
+  test 'invalid data at the first of array' do
+    input = {
+      'foo' => 'xxx',
+      'bar' => 123,
+      'baz' => [
+        {
+          'fuga' => 'piyo',
+        },
+        {
+          'hoge' => 'xxx',
+          'fuga' => 1,
+        },
+      ]
+    }
+
+    assert_raise_message(/baz:#0/) { @rule.validate(input) }
+  end
+
+  test 'invalid data at the second of array' do
+    input = {
+      'foo' => 'xxx',
+      'bar' => 123,
+      'baz' => [
+        {
+          'hoge' => 'xxx',
+          'fuga' => 1,
+        },
+        {
+          'fuga' => 'piyo',
+        },
+        {
+          'hoge' => 'xxx',
+          'fuga' => 2,
+        },
+        {
+          'fuga' => 'piyo',
+        },
+      ]
+    }
+
+    assert_raise_message(/baz:#1:fuga/) { @rule.validate(input) }
+  end
+
+  test 'nested array' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, default: 1 },
+      'baz' => {
+        isa: Array,
+        rule: {
+          'piyo' => {
+            isa: Array,
+            rule: {
+              'hoge' => { isa: String, default: 'yyy' },
+              'fuga' => Integer,
+            }
+          },
+        },
+      },
+    )
+
+    input = {
+      'foo' => 'xxx',
+      'baz' => [
+        {
+          'piyo' => [
+            {
+              'fuga' => 123,
+            },
+          ],
+        },
+      ],
+    };
+
+    params   = rule.validate(input)
+    expected = {
+      'foo' => 'xxx',
+      'bar' => 1,
+      'baz' => [
+        {
+          'piyo' => [
+            {
+              'hoge' => 'yyy',
+              'fuga' => 123,
+            },
+          ],
+        },
+      ],
+    }
+
+    assert { params == expected }
+  end
+
+  test 'conflicts' do
+    input = {
+      'foo' => 'xxx',
+      'bar' => 123,
+      'baz' => [
+        {
+          'hoge' => 'xxx',
+          'fuga' => 456,
+          'piyo' => %w/a b c/,
+        },
+      ]
+    }
+
+    assert_raise_message(/baz:#0:piyo/) { @rule.validate(input) }
+  end
+
+  test  'with default option' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, default: 1 },
+      'baz' => {
+        isa: Array,
+        rule: {
+          'hoge' => String,
+          'fuga' => Integer,
+        },
+      },
+    )
+
+    input = {
+      'foo' => 'xxx',
+      'baz' => [
+        {
+          'hoge' => 'xxx',
+          'fuga' => 456,
+        },
+      ]
+    }
+
+    params = rule.validate(input)
+
+    assert { params['bar'] == 1 }
+  end
+
+  test 'default option with nested' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, default: 1 },
+      'baz' => {
+        isa: Array,
+        rule: {
+          'hoge' => { isa: String, default: 'yyy' },
+          'fuga' => Integer,
+        },
+      },
+    )
+
+    input = {
+      'foo' => 'xxx',
+      'baz' => [
+        {
+          'fuga' => 456,
+        },
+      ]
+    }
+
+    params   = rule.validate(input)
+    expected = {
+      'foo' => 'xxx',
+      'bar' => 1,
+      'baz' => [
+        {
+          'hoge' => 'yyy',
+          'fuga' => 456,
+        },
+      ]
+    }
+
+    assert { params == expected }
+  end
+
+  test 'with AllowExtra' do
+    rule = Data::Validator::Recursive.new(
+      'foo' => String,
+      'bar' => { isa: Integer, default: 1 },
+      'baz' => {
+        isa: Array,
+        with: 'AllowExtra',
+        rule: {
+          'hoge' => { isa: String, default: 'yyy' },
+          'fuga' => Integer
+        },
+      },
+    ).with('AllowExtra')
+
+
+    input = {
+      'foo' => 'xxx',
+      'baz' => [
+        {
+          'fuga' => 123,
+          'extra_param_in_baz' => 1,
+        },
+      ],
+      'extra_param' => 1,
+    }
+
+    params   = rule.validate(input)
+    expected = {
+      'foo' => 'xxx',
+      'bar' => 1,
+      'baz' => [
+        {
+          'hoge' => 'yyy',
+          'fuga' => 123,
+          'extra_param_in_baz' => 1,
+        },
+      ],
+      'extra_param' => 1,
+    }
+
+    assert { params == expected }
+  end
+end