validator.test.js

var node_validator = require('../lib'),
    Validator = new node_validator.Validator(),
    assert = require('assert');

function dateFixture() {
    var d = new Date();
    var Y = d.getFullYear();
    var M = d.getMonth() + 1; // 0-index
    var D = d.getDate();
    return {
        tomorrow: Y + '-' + M + '-' + (D + 1), // YYYY-MM-DD
        yesterday: Y + '-' + M + '-' + (D - 1) // YYYY-MM-DD
    };
}

module.exports = {
    'test #isEmail()': function () {
        //Try some invalid emails
        var invalid = [
            'invalidemail@',
            'invalid.com',
            '@invalid.com'
        ];
        invalid.forEach(function(email) {
            try {
                Validator.check(email, 'Invalid').isEmail();
                assert.ok(false, 'Invalid email ('+email+') passed validation');
            } catch(e) {
                assert.equal('Invalid', e.message);
            }
        });

        //Now try some valid ones
        var valid = [
            'foo@bar.com',
            'x@x.x',
            'foo@bar.com.au',
            'foo+bar@bar.com'
        ];
        try {
            valid.forEach(function(email) {
                Validator.check(email).isEmail();
            });
        } catch(e) {
            assert.ok(false, 'A valid email did not pass validation');
        }
    },

    'test #isUrl()': function () {
        //Try some invalid URLs
        var invalid = [
            'xyz://foobar.com', //Only http, https and ftp are valid
            'invalid/',
            'invalid.x',
            'invalid.',
            '.com',
            'http://com/',
            'http://300.0.0.1/'
        ];
        invalid.forEach(function(url) {
            try {
                Validator.check(url, 'Invalid').isUrl();
                assert.ok(false, 'Invalid url ('+url+') passed validation');
            } catch(e) {
                assert.equal('Invalid', e.message);
            }
        });

        //Now try some valid ones
        var valid = [
            'foobar.com',
            'www.foobar.com',
            'foobar.com/',
            'valid.au',
            'http://www.foobar.com/',
            'https://www.foobar.com/',
            'ftp://www.foobar.com/',
            'http://www.foobar.com/~foobar',
            'http://user:pass@www.foobar.com/',
            'http://127.0.0.1/',
            'http://255.255.255.255/',
            'http://duckduckgo.com/?q=%2F'
        ];
        try {
            valid.forEach(function(url) {
                Validator.check(url).isUrl();
            });
        } catch(e) {
            assert.ok(false, 'A valid url did not pass validation');
        }
    },

    'test #isIP()': function () {
        //Try some invalid IPs
        var invalid = [
            'abc',
            '256.0.0.0',
            '0.0.0.256'
        ];
        invalid.forEach(function(ip) {
            try {
                Validator.check(ip, 'Invalid').isIP();
                assert.ok(false, 'Invalid IP ('+ip+') passed validation');
            } catch(e) {
                assert.equal('Invalid', e.message);
            }
        });

        //Now try some valid ones
        var valid = [
            '127.0.0.1',
            '0.0.0.0',
            '255.255.255.255',
            '1.2.3.4'
        ];
        try {
            valid.forEach(function(ip) {
                Validator.check(ip).isIP();
            });
        } catch(e) {
            assert.ok(false, 'A valid IP did not pass validation');
        }
    },

    'test #isAlpha()': function () {
        assert.ok(Validator.check('abc').isAlpha());
        assert.ok(Validator.check('ABC').isAlpha());
        assert.ok(Validator.check('FoObAr').isAlpha());

        ['123',123,'abc123','  ',''].forEach(function(str) {
            try {
                Validator.check(str).isAlpha();
                assert.ok(false, 'isAlpha failed');
            } catch (e) {}
        });
    },

    'test #isAlphanumeric()': function () {
        assert.ok(Validator.check('abc13').isAlphanumeric());
        assert.ok(Validator.check('123').isAlphanumeric());
        assert.ok(Validator.check('F1oO3bAr').isAlphanumeric());

        ['(*&ASD','  ','.',''].forEach(function(str) {
            try {
                Validator.check(str).isAlphanumeric();
                assert.ok(false, 'isAlphanumeric failed');
            } catch (e) {}
        });
    },

    'test #isNumeric()': function () {
        assert.ok(Validator.check('123').isNumeric());
        assert.ok(Validator.check('00123').isNumeric());
        assert.ok(Validator.check('-00123').isNumeric());
        assert.ok(Validator.check('0').isNumeric());
        assert.ok(Validator.check('-0').isNumeric());

        ['123.123','  ','.',''].forEach(function(str) {
            try {
                Validator.check(str).isNumeric();
                assert.ok(false, 'isNumeric failed');
            } catch (e) {}
        });
    },

    'test #isLowercase()': function () {
        assert.ok(Validator.check('abc').isLowercase());
        assert.ok(Validator.check('foobar').isLowercase());
        assert.ok(Validator.check('a').isLowercase());
        assert.ok(Validator.check('123').isLowercase());
        assert.ok(Validator.check('abc123').isLowercase());

        ['123A','ABC','.',''].forEach(function(str) {
            try {
                Validator.check(str).isLowercase();
                assert.ok(false, 'isLowercase failed');
            } catch (e) {}
        });
    },

    'test #isUppercase()': function () {
        assert.ok(Validator.check('FOOBAR').isUppercase());
        assert.ok(Validator.check('A').isUppercase());
        assert.ok(Validator.check('123').isUppercase());
        assert.ok(Validator.check('ABC123').isUppercase());

        ['abc','123aBC','.',''].forEach(function(str) {
            try {
                Validator.check(str).isUppercase();
                assert.ok(false, 'isUpper failed');
            } catch (e) {}
        });
    },

    'test #isInt()': function () {
        assert.ok(Validator.check('13').isInt());
        assert.ok(Validator.check('123').isInt());
        assert.ok(Validator.check('0').isInt());
        assert.ok(Validator.check(0).isInt());
        assert.ok(Validator.check(123).isInt());
        assert.ok(Validator.check('-0').isInt());
        assert.ok(Validator.check('01').isInt());
        assert.ok(Validator.check('-01').isInt());
        assert.ok(Validator.check('000').isInt());

        ['123.123','  ',''].forEach(function(str) {
            try {
                Validator.check(str).isInt();
                assert.ok(false, 'falsepositive');
            } catch (e) {
              if (e.message == 'falsepositive') {
                e.message = 'isInt had a false positive: ' + str;
                throw e;
              }
            }
        });
    },

    'test #isDecimal()': function () {
        assert.ok(Validator.check('123').isDecimal());
        assert.ok(Validator.check('123.').isDecimal());
        assert.ok(Validator.check('123.123').isDecimal());
        assert.ok(Validator.check('-123.123').isDecimal());
        assert.ok(Validator.check('0.123').isDecimal());
        assert.ok(Validator.check('.123').isDecimal());
        assert.ok(Validator.check('.0').isDecimal());
        assert.ok(Validator.check('0').isDecimal());
        assert.ok(Validator.check('-0').isDecimal());
        assert.ok(Validator.check('01.123').isDecimal());

        assert.ok(Validator.check('2.2250738585072011e-308').isDecimal());
        assert.ok(Validator.check('-0.22250738585072011e-307').isDecimal());
        assert.ok(Validator.check('-0.22250738585072011E-307').isDecimal());

        ['-.123','  ',''].forEach(function(str) {
            try {
                Validator.check(str).isDecimal();
                assert.ok(false, 'falsepositive');
            } catch (e) {
              if (e.message == 'falsepositive') {
                e.message = 'isDecimal had a false positive: ' + str;
                throw e;
              }
            }
        });
    },

    //Alias for isDecimal()
    'test #isFloat()': function () {
        assert.ok(Validator.check('0.5').isFloat());
    },

    'test #isNull()': function () {
        assert.ok(Validator.check('').isNull());
        assert.ok(Validator.check().isNull());

        ['  ','123','abc'].forEach(function(str) {
            try {
                Validator.check(str).isNull();
                assert.ok(false, 'isNull failed');
            } catch (e) {}
        });
    },

    'test #notNull()': function () {
        assert.ok(Validator.check('abc').notNull());
        assert.ok(Validator.check('123').notNull());
        assert.ok(Validator.check('   ').notNull());

        [false,''].forEach(function(str) {
            try {
                Validator.check(str).notNull();
                assert.ok(false, 'notNull failed');
            } catch (e) {}
        });
    },

    'test #notEmpty()': function () {
        assert.ok(Validator.check('abc').notEmpty());
        assert.ok(Validator.check('123').notEmpty());
        assert.ok(Validator.check('   123   ').notEmpty());

        [false,'  ','\r\n','	','', NaN].forEach(function(str) {
            try {
                Validator.check(str).notEmpty();
                assert.ok(false, 'notEmpty failed');
            } catch (e) {}
        });
    },

    'test #equals()': function () {
        assert.ok(Validator.check('abc').equals('abc'));
        assert.ok(Validator.check('123').equals(123));
        assert.ok(Validator.check('   ').equals('   '));
        assert.ok(Validator.check().equals(''));

        try {
            Validator.check(123).equals('abc');
            assert.ok(false, 'equals failed');
        } catch (e) {}

        try {
            Validator.check('').equals('   ');
            assert.ok(false, 'equals failed');
        } catch (e) {}
    },

    'test #contains()': function () {
        assert.ok(Validator.check('abc').contains('abc'));
        assert.ok(Validator.check('foobar').contains('oo'));
        assert.ok(Validator.check('abc').contains('a'));
        assert.ok(Validator.check('  ').contains(' '));
        assert.ok(Validator.check('abc').contains(''));

        try {
            Validator.check(123).contains('abc');
            assert.ok(false, 'contains failed');
        } catch (e) {}

        try {
            Validator.check('\t').contains('\t\t');
            assert.ok(false, 'contains failed');
        } catch (e) {}
    },

    'test #notContains()': function () {
        assert.ok(Validator.check('abc').notContains('a '));
        assert.ok(Validator.check('foobar').notContains('foobars'));
        assert.ok(Validator.check('abc').notContains('123'));

        try {
            Validator.check(123).notContains(1);
            assert.ok(false, 'notContains failed');
        } catch (e) {}

        try {
            Validator.check(' ').contains('');
            assert.ok(false, 'notContains failed');
        } catch (e) {}
    },

    'test #regex()': function () {
        assert.ok(Validator.check('abc').regex(/a/));
        assert.ok(Validator.check('abc').regex(/^abc$/));
        assert.ok(Validator.check('abc').regex('abc'));
        assert.ok(Validator.check('ABC').regex(/^abc$/i));
        assert.ok(Validator.check('ABC').regex('abc', 'i'));
        assert.ok(Validator.check(12390947686129).regex(/^[0-9]+$/));

        //Check the is() alias
        assert.ok(Validator.check(12390947686129).is(/^[0-9]+$/));

        try {
            Validator.check(123).regex(/^1234$/);
            assert.ok(false, 'regex failed');
        } catch (e) {}
    },

    'test #notRegex()': function () {
        assert.ok(Validator.check('foobar').notRegex(/e/));
        assert.ok(Validator.check('ABC').notRegex('abc'));
        assert.ok(Validator.check(12390947686129).notRegex(/a/));

        //Check the not() alias
        assert.ok(Validator.check(12390947686129).not(/^[a-z]+$/));

        try {
            Validator.check(123).notRegex(/123/);
            assert.ok(false, 'regex failed');
        } catch (e) {}
    },

    'test #len()': function () {
        assert.ok(Validator.check('a').len(1));
        assert.ok(Validator.check(123).len(2));
        assert.ok(Validator.check(123).len(2, 4));
        assert.ok(Validator.check(12).len(2,2));
        assert.ok(Validator.check([1, 2]).len(2,2));
        assert.ok(Validator.check([1, 2, 3]).len(2,4));

        try {
            Validator.check('abc').len(4);
            assert.ok(false, 'len failed');
        } catch (e) {}
        try {
            Validator.check('abcd').len(1, 3);
            assert.ok(false, 'len failed');
        } catch (e) {}
    },

    'test #isUUID()': function () {
        ////xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

        assert.ok(Validator.check('A987FBC9-4BED-3078-CF07-9141BA07C9F3').isUUID());
        assert.ok(Validator.check('A987FBC9-4BED-3078-CF07-9141BA07C9F3').isUUID(1));
        assert.ok(Validator.check('A987FBC9-4BED-3078-CF07-9141BA07C9F3').isUUID(2));
        assert.ok(Validator.check('A987FBC9-4BED-3078-CF07-9141BA07C9F3').isUUID(3));
        assert.ok(Validator.check('A987FBC9-4BED-4078-8F07-9141BA07C9F3').isUUID(4));

        try {
            Validator.check('A987FBC9-4BED-3078-CF07-9141BA07C9F3').isUUID(4);
            assert.ok(false, 'isUUID failed');
        } catch (e) {}

        try {
            Validator.check('A987FBC9-4BED-4078-0F07-9141BA07C9F3').isUUID(4);
            assert.ok(false, 'isUUID failed');
        } catch (e) {}

        try {
            Validator.check('abc').isUUID();
            assert.ok(false, 'isUUID failed');
        } catch (e) {}

        try {
            Validator.check('A987FBC932-4BED-3078-CF07-9141BA07C9').isUUID();
            assert.ok(false, 'isUUID failed');
        } catch (e) {}

        try {
            Validator.check('A987FBG9-4BED-3078-CF07-9141BA07C9DE').isUUID();
            assert.ok(false, 'isUUID failed');
        } catch (e) {}

    },

    'test #isIn(options)': function () {

        assert.ok(Validator.check('foo').isIn('foobar'));
        assert.ok(Validator.check('foo').isIn('I love football'));

        assert.ok(Validator.check('foo').isIn(['foo', 'bar', 'baz']));

        assert.throws(function() {
            Validator.check('foo').isIn(['bar', 'baz']);
          }, /unexpected/i
        );

        assert.throws(function() {
            Validator.check('foo').isIn('bar, baz');
          }, /unexpected/i
        );

        assert.throws(function() {
            Validator.check('foo').isIn(1234567);
          }, /invalid/i
        );

        assert.throws(function() {
            Validator.check('foo').isIn({foo:"foo",bar:"bar"});
          }, /invalid/i
        );
    },

    'test #notIn(options)': function () {

        assert.ok(Validator.check('foo').notIn('bar'));
        assert.ok(Validator.check('foo').notIn('awesome'));

        assert.ok(Validator.check('foo').notIn(['foobar', 'bar', 'baz']));

        assert.throws(function() {
            Validator.check('foo').notIn(['foo', 'bar', 'baz']);
          }, /unexpected/i
        );

        assert.throws(function() {
            Validator.check('foo').notIn('foobar');
          }, /unexpected/i
        );

        assert.throws(function() {
            Validator.check('foo').notIn(1234567);
          }, /invalid/i
        );

        assert.throws(function() {
            Validator.check('foo').notIn({foo:"foo",bar:"bar"});
          }, /invalid/i
        );
    },
    
    'test #isDate()': function() {
        assert.ok(Validator.check('2011-08-04').isDate());
        assert.ok(Validator.check('04. 08. 2011.').isDate());
        assert.ok(Validator.check('08/04/2011').isDate());
        assert.ok(Validator.check('2011.08.04').isDate());
        assert.ok(Validator.check('4. 8. 2011. GMT').isDate());
        assert.ok(Validator.check('2011-08-04 12:00').isDate());

        assert.throws(Validator.check('foo').isDate);
        assert.throws(Validator.check('2011-foo-04').isDate);
        assert.throws(Validator.check('GMT').isDate);
    },

    'test #min()': function() {
        assert.ok(Validator.check('4').min(2));
        assert.ok(Validator.check('5').min(5));
        assert.ok(Validator.check('3.2').min(3));
        assert.ok(Validator.check('4.2').min(4.2));

        assert.throws(function() {
            Validator.check('5').min(10);
        });
        assert.throws(function() {
            Validator.check('5.1').min(5.11);
        });
    },

    'test #max()': function() {
        assert.ok(Validator.check('4').max(5));
        assert.ok(Validator.check('7').max(7));
        assert.ok(Validator.check('6.3').max(7));
        assert.ok(Validator.check('2.9').max(2.9));

        assert.throws(function() {
            Validator.check('5').max(2);
        });
        assert.throws(function() {
            Validator.check('4.9').max(4.2);
        });
    },

    'test #isArray()': function () {
        assert.ok(Validator.check(new Array()).isArray());
        assert.ok(Validator.check([]).isArray());
        assert.ok(Validator.check([1, 2]).isArray());
        assert.ok(Validator.check(['a', 'b', 'c']).isArray());
        assert.ok(Validator.check([{}, {}]).isArray());

        try {
            assert.ok(Validator.check('a').isArray());
            assert.ok(false, 'len failed');
        } catch (e) {}
        try {
            assert.ok(Validator.check({}).isArray());
            assert.ok(false, 'len failed');
        } catch (e) {}
        try {
            assert.ok(Validator.check({a: 1, b: 2}).isArray());
            assert.ok(false, 'len failed');
        } catch (e) {}
        try {
            assert.ok(Validator.check(new Object()).isArray());
            assert.ok(false, 'len failed');
        } catch (e) {}
    },

    'test #isDate()': function() {
        assert.ok(Validator.check('2011-08-04').isDate());
        assert.ok(Validator.check('04. 08. 2011.').isDate());
        assert.ok(Validator.check('08/04/2011').isDate());
        assert.ok(Validator.check('2011.08.04').isDate());
        assert.ok(Validator.check('4. 8. 2011. GMT').isDate());
        assert.ok(Validator.check('2011-08-04 12:00').isDate());

        assert.throws(Validator.check('foo').isDate);
        assert.throws(Validator.check('2011-foo-04').isDate);
        assert.throws(Validator.check('GMT').isDate);
    },

    'test #isAfter()': function() {
        var f = dateFixture();

        assert.ok(Validator.check('2011-08-04').isAfter('2011-08-03'));
        assert.ok(Validator.check('08. 04. 2011.').isAfter(new Date('2011-08-04')));
        assert.ok(Validator.check(f.tomorrow).isAfter());
        
        assert.throws(function() {
            Validator.check('08/04/2011').isAfter('2011-09-01');
        });
        assert.throws(function() {
            Validator.check(f.yesterday).isAfter();
        });
    },

    'test #isBefore()': function() {
        var f = dateFixture();

        assert.ok(Validator.check('2011-08-04').isBefore('2011-08-06'));
        assert.ok(Validator.check('08. 04. 2011.').isBefore(new Date('2011-08-04')));
        assert.ok(Validator.check(f.yesterday).isBefore());
        
        assert.throws(function() {
            Validator.check('08/04/2011').isBefore('2011-07-01');
        });
        assert.throws(function() {
            Validator.check(f.tomorrow).isBefore();
        });
    },

    'test #isDivisibleBy()': function() {
        assert.ok(Validator.check('10').isDivisibleBy(2));
        assert.ok(Validator.check('6').isDivisibleBy(3));
        
        assert.throws(function() {
            Validator.check('5').isDivisibleBy(2);
        });

        assert.throws(function() {
            Validator.check('6.7').isDivisibleBy(3);
        });
    }
}