exports['test_validate_ip_blacklist'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().isIP().notIpBlacklisted()
};
// positive case
var obj_ext = { a: '173.45.245.32', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'IP Blacklist test');
// negative case
var neg = { a: 'invalid/' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'IP blacklist test (negative case)');
neg = {a: '192.168.0.1' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'IP blacklist test (negative case 2)');
// IPv6
obj_ext = { a: '2001:db8::1:0:0:1'};
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'IPv6 blacklist test');
neg = {a: 'fc00:1:0:0:1' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'IPv6 blacklist test (negative case)');
test.finish();
};
exports['test_optional_fields'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().optional().range(1, 65535)
};
// positive case
var obj = { a: 500 };
var obj_ext = { a: 500, b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'optional fields');
assert.deepEqual(rv.cleaned, obj);
// positive case
var obj = { a: null };
var obj_ext = { a: null, b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'optional fields (optional)');
assert.deepEqual(rv.cleaned, obj);
// negative case
obj = { a: 65536 };
obj_ext = { a: 65536, b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === false, 'optional fields');
test.finish();
};
exports['test_validate_ip'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().isIP()
};
// positive case
var obj = { a: '192.168.0.1' };
var obj_ext = { a: '192.168.0.1', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'IP test');
assert.deepEqual(rv.cleaned, obj);
// negative case
var neg = { a: 'invalid/' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'IP test (negative case)');
neg = {a: '12345' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'IP test (negative case 2)');
// IPv6 normalization
obj_ext = { a: '2001:db8::1:0:0:1'};
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'IPv6 test and normalization');
assert.deepEqual(rv.cleaned.a, '2001:0db8:0000:0000:0001:0000:0000:0001');
test.finish();
};
exports['test_validate_url'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().isUrl()
};
// positive case
var obj = { a: 'http://www.cloudkick.com' };
var obj_ext = { a: 'http://www.cloudkick.com', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'url test');
assert.deepEqual(rv.cleaned, obj);
// negative case
var neg = { a: 'invalid/' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'url test (negative case)');
test.finish();
};
exports['test_validate_not_contains'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().notContains('abc')
};
// positive case
var obj = { a: '123'};
var obj_ext = { a: '123', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'not contains test');
assert.deepEqual(rv.cleaned, obj);
// negative case
var neg = { a: 'abc' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'not contains test (negative case)');
test.finish();
};
exports['test_validate_present'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().notEmpty()
};
// positive case
var obj = { a: 123};
var obj_ext = { a: 123, b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'validate present');
assert.deepEqual(rv.cleaned, obj);
// negative case
var neg = { b: 2 };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'validate (negative case)');
test.finish();
};
exports['test_validate_null'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().isNull()
};
// positive case
var obj = { a: null};
var obj_ext = { a: null, b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'null test');
assert.deepEqual(rv.cleaned, obj);
// negative case
var neg = { a: 'not null' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'null test (negative case)');
test.finish();
};
exports['test_validate_regex'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().regex('^a$')
};
// positive case
var obj = { a: 'a' };
var obj_ext = { a: 'a', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'regex test');
assert.deepEqual(rv.cleaned, obj);
// negative case
var neg = { a: 'b' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'regex test (negative case)');
test.finish();
};
exports['test_validate_float'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().isFloat()
};
// positive case
var obj = { a: 123.123 };
var obj_ext = { a: 123.123, b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'float test');
assert.deepEqual(rv.cleaned, obj);
// negative case
var neg = { a: 'ABCabc' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'float test (negative case)');
test.finish();
};
exports['test_validate_alphanumeric'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().isAlphanumeric()
};
// positive case
var obj = { a: 'ABC123' };
var obj_ext = { a: 'ABC123', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'alphanumeric test');
assert.deepEqual(rv.cleaned, obj);
// negative case
var neg = { a: 'invalid/' };
rv = swiz.check(schema, neg);
assert.ok(rv.is_valid === false, 'alphanumeric test (negative case)');
test.finish();
};
exports['test_validate_string'] = function(test, assert) {
var rv, obj, obj_ext;
var schema = {
a: new swiz.Valve().string()
};
// positive case
obj = { a: 'test' };
obj_ext = { a: 'test', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'string test');
assert.deepEqual(rv.cleaned, obj);
// negative case
obj = { a: 123 };
obj_ext = { a: 123, b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === false, 'string test (negative case)');
test.finish();
};
exports['test_validate_chain'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().len(1).isNumeric()
};
// positive case
var obj = { a: '1' };
var obj_ext = { a: '1', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'chain test');
assert.deepEqual(rv.cleaned, obj);
// negative case
rv = swiz.check(schema, { a: '' });
assert.ok(rv.is_valid === false, 'chain test (negative case)');
// negative case
rv = swiz.check(schema, { a: 'A' });
assert.ok(rv.is_valid === false, 'chain test (negative case)');
test.finish();
};
exports['test_validate_notregex'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().notRegex(/e/)
};
// positive case
var obj = { a: 'foobar' };
var obj_ext = { a: 'foobar', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'notregex test');
assert.deepEqual(rv.cleaned, obj);
test.finish();
};
exports['test_validate_enum'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().enumerated({inactive: 0, active: 1, full_no_new_checks: 2})
};
// positive case
var obj = { a: 2 };
var obj_ext = { a: 'full_no_new_checks', b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'enum test');
assert.deepEqual(rv.cleaned, obj);
test.finish();
};
exports['test_validate_nested_hash'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().hash(new swiz.Valve().string(), new swiz.Valve().string())
};
// positive case
var obj = { a: {'test' : 'test'} };
var obj_ext = { a: {'test' : 'test'}, b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'hash test');
assert.deepEqual(rv.cleaned, obj);
test.finish();
};
exports['test_validate_nested'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().array(new swiz.Valve().isInt().toInt())
};
// positive case
var obj = { a: [1] };
var obj_ext = { a: ['1'], b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'nested test');
assert.deepEqual(rv.cleaned, obj);
test.finish();
};
exports['test_validate_tofloat'] = function(test, assert) {
var rv;
var schema = {
a: new swiz.Valve().array(new swiz.Valve().toFloat())
};
// positive case
var obj = { a: [3.145] };
var obj_ext = { a: ['3.145'], b: 2 };
rv = swiz.check(schema, obj_ext);
assert.ok(rv.is_valid === true, 'tofloat test');
assert.ok(typeof rv.cleaned.a[0] === 'number', 'tofloat === number test');
assert.deepEqual(rv.cleaned, obj);
test.finish();
};
// and validation
var def = {
'Node': [
['key', {'val' : new V()}],
['ip_address_v4', {'val' : new V().isIP()}]
]};
var validity = validate.defToValve(def);
// Generic payload
var CreatePayload = {
key: '1234',
ip_address_v4: '1.2.0.4'
};
console.log('validate a payload:\n');
// Validate the generic payload
var rv = validate.check(validity['Node'], CreatePayload);
console.log(rv);
console.log('\n\nserialize an object\n');
var sw = new validate.Swiz(def);
var obj = rv.cleaned;
obj.getSerializerType = function() {return 'Node';};
sw.serialize(validate.SERIALIZATION.SERIALIZATION_JSON, 1, obj,
function(err, results) {
console.log(results);
});