joi 4.6.2 → 4.9.0

package/test/string.js

@@ -1,6 +1,7 @@
 // Load modules
 
 var Lab = require('lab');
+var Code = require('code');
 var Joi = require('../lib');
 var Helper = require('./helper');
 
@@ -12,11 +13,12 @@ var internals = {};
 
 // Test shortcuts
 
-var expect = Lab.expect;
-var before = Lab.before;
-var after = Lab.after;
-var describe = Lab.experiment;
-var it = Lab.test;
+var lab = exports.lab = Lab.script();
+var before = lab.before;
+var after = lab.after;
+var describe = lab.describe;
+var it = lab.it;
+var expect = Code.expect;
 
 
 describe('string', function () {
@@ -185,6 +187,43 @@ describe('string', function () {
         });
     });
 
+    describe('#creditCard', function () {
+
+        it('should validate credit card', function (done) {
+
+            var t = Joi.string().creditCard();
+            t.validate('4111111111111112', function (err, value) {
+
+                expect(err.message).to.equal('value must be a credit card');
+
+                Helper.validate(t, [
+                    ['378734493671000', true],  // american express
+                    ['371449635398431', true],  // american express
+                    ['378282246310005', true],  // american express
+                    ['341111111111111', true],  // american express
+                    ['5610591081018250', true], // australian bank
+                    ['5019717010103742', true], // dankort pbs
+                    ['38520000023237', true],   // diners club
+                    ['30569309025904', true],   // diners club
+                    ['6011000990139424', true], // discover
+                    ['6011111111111117', true], // discover
+                    ['6011601160116611', true], // discover
+                    ['3566002020360505', true], // jbc
+                    ['3530111333300000', true], // jbc
+                    ['5105105105105100', true], // mastercard
+                    ['5555555555554444', true], // mastercard
+                    ['5431111111111111', true], // mastercard
+                    ['6331101999990016', true], // switch/solo paymentech
+                    ['4222222222222', true],    // visa
+                    ['4012888888881881', true], // visa
+                    ['4111111111111111', true], // visa
+                    ['4111111111111112', false],
+                    [null, false],
+                ], done);
+            });
+        });
+    });
+
     describe('#length', function () {
 
         it('throws when limit is not a number', function (done) {
@@ -256,7 +295,7 @@ describe('string', function () {
             var schema = Joi.string().lowercase();
             schema.validate('UPPER TO LOWER', function (err, value) {
 
-                expect(err).to.not.exist;
+                expect(err).to.not.exist();
                 expect(value).to.equal('upper to lower');
                 done();
             });
@@ -294,7 +333,7 @@ describe('string', function () {
             var schema = Joi.string().uppercase();
             schema.validate('lower to upper', function (err, value) {
 
-                expect(err).to.not.exist;
+                expect(err).to.not.exist();
                 expect(value).to.equal('LOWER TO UPPER');
                 done();
             });
@@ -331,7 +370,7 @@ describe('string', function () {
             var schema = Joi.string().trim();
             schema.validate(' trim this ', function (err, value) {
 
-                expect(err).to.not.exist;
+                expect(err).to.not.exist();
                 expect(value).to.equal('trim this');
                 done();
             });
@@ -342,7 +381,7 @@ describe('string', function () {
             var schema = Joi.string().trim().allow('');
             schema.validate('     ', function (err, value) {
 
-                expect(err).to.not.exist;
+                expect(err).to.not.exist();
                 expect(value).to.equal('');
                 done();
             });
@@ -389,6 +428,29 @@ describe('string', function () {
         });
     });
 
+    describe('#regex', function () {
+
+        it('should not include a pattern name by default', function (done) {
+
+            var schema = Joi.string().regex(/[a-z]+/).regex(/[0-9]+/);
+            schema.validate('abcd', function (err, value) {
+
+                expect(err.message).to.contain('required pattern');
+                done();
+            });
+        });
+
+        it('should include a pattern name if specified', function (done) {
+
+            var schema = Joi.string().regex(/[a-z]+/, 'letters').regex(/[0-9]+/, 'numbers');
+            schema.validate('abcd', function (err, value) {
+
+                expect(err.message).to.contain('numbers pattern');
+                done();
+            });
+        });
+    });
+
     describe('#validate', function () {
 
         it('should, by default, allow undefined, deny empty string', function (done) {
@@ -427,7 +489,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate invalid values', function (done) {
+        it('validates invalid values', function (done) {
 
             var schema = Joi.string().invalid('a', 'b', 'c');
             Helper.validate(schema, [
@@ -447,7 +509,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle array arguments correctly', function (done) {
+        it('validates array arguments correctly', function (done) {
 
             var schema = Joi.string().valid(['a', 'b', 'c']);
             Helper.validate(schema, [
@@ -457,7 +519,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate minimum length when min is used', function (done) {
+        it('validates minimum length when min is used', function (done) {
 
             var schema = Joi.string().min(3);
             Helper.validate(schema, [
@@ -467,7 +529,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate minimum length when min is 0', function (done) {
+        it('validates minimum length when min is 0', function (done) {
 
             var schema = Joi.string().min(0).required();
             Helper.validate(schema, [
@@ -493,7 +555,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate maximum length when max is used', function (done) {
+        it('validates maximum length when max is used', function (done) {
 
             var schema = Joi.string().max(3);
             Helper.validate(schema, [
@@ -522,7 +584,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate regex', function (done) {
+        it('validates regex', function (done) {
 
             var schema = Joi.string().regex(/^[0-9][-][a-z]+$/);
             Helper.validate(schema, [
@@ -531,6 +593,15 @@ describe('string', function () {
             ], done);
         });
 
+        it('validates regex (ignoring global flag)', function (done) {
+
+            var schema = Joi.string().regex(/a/g);
+            Helper.validate(schema, [
+                ['ab', true],
+                ['ac', true]
+            ], done);
+        });
+
         it('validates token', function (done) {
 
             var schema = Joi.string().token();
@@ -551,7 +622,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate email', function (done) {
+        it('validates email', function (done) {
 
             var schema = Joi.string().email();
             Helper.validate(schema, [
@@ -564,7 +635,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate email with a friendly error message', function (done) {
+        it('validates email with a friendly error message', function (done) {
 
             var schema = { item: Joi.string().email() };
             Joi.compile(schema).validate({ item: 'something' }, function (err, value) {
@@ -579,7 +650,7 @@ describe('string', function () {
             var text = Joi.string().invalid('joi');
             text.validate('joi', function (err, value) {
 
-                expect(err).to.exist;
+                expect(err).to.exist();
                 done();
             });
         });
@@ -589,44 +660,44 @@ describe('string', function () {
             var text = Joi.string().allow('hapi');
             text.validate('result', function (err, value) {
 
-                expect(err).to.not.exist;
+                expect(err).to.not.exist();
                 done();
             });
         });
 
-        it('should validate with one validator (min)', function (done) {
+        it('validates with one validator (min)', function (done) {
 
             var text = Joi.string().min(3);
             text.validate('joi', function (err, value) {
 
-                expect(err).to.not.exist;
+                expect(err).to.not.exist();
                 done();
             });
         });
 
-        it('should validate with two validators (min, required)', function (done) {
+        it('validates with two validators (min, required)', function (done) {
 
             var text = Joi.string().min(3).required();
             text.validate('joi', function (err, value) {
 
-                expect(err).to.not.exist;
+                expect(err).to.not.exist();
 
                 text.validate('', function (err, value) {
 
-                    expect(err).to.exist;
+                    expect(err).to.exist();
                     done();
                 });
             });
         });
 
-        it('should validate null with allow(null)', function (done) {
+        it('validates null with allow(null)', function (done) {
 
             Helper.validate(Joi.string().allow(null), [
                 [null, true]
             ], done);
         });
 
-        it('should validate "" (empty string) with allow(\'\')', function (done) {
+        it('validates "" (empty string) with allow(\'\')', function (done) {
 
             Helper.validate(Joi.string().allow(''), [
                 ['', true],
@@ -634,7 +705,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of required and min', function (done) {
+        it('validates combination of required and min', function (done) {
 
             var rule = Joi.string().required().min(3);
             Helper.validate(rule, [
@@ -645,7 +716,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of required and max', function (done) {
+        it('validates combination of required and max', function (done) {
 
             var rule = Joi.string().required().max(3);
             Helper.validate(rule, [
@@ -657,7 +728,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of allow(\'\') and min', function (done) {
+        it('validates combination of allow(\'\') and min', function (done) {
 
             var rule = Joi.string().allow('').min(3);
             Helper.validate(rule, [
@@ -669,7 +740,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of allow(\'\') and max', function (done) {
+        it('validates combination of allow(\'\') and max', function (done) {
 
             var rule = Joi.string().allow('').max(3);
             Helper.validate(rule, [
@@ -681,7 +752,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of null allowed and max', function (done) {
+        it('validates combination of null allowed and max', function (done) {
             var rule = Joi.string().allow(null).max(3);
             Helper.validate(rule, [
                 ['x', true],
@@ -692,7 +763,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min and max', function (done) {
+        it('validates combination of min and max', function (done) {
 
             var rule = Joi.string().min(2).max(3);
             Helper.validate(rule, [
@@ -705,7 +776,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, and allow(\'\')', function (done) {
+        it('validates combination of min, max, and allow(\'\')', function (done) {
 
             var rule = Joi.string().min(2).max(3).allow('');
             Helper.validate(rule, [
@@ -718,7 +789,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, and required', function (done) {
+        it('validates combination of min, max, and required', function (done) {
 
             var rule = Joi.string().min(2).max(3).required();
             Helper.validate(rule, [
@@ -731,7 +802,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, and regex', function (done) {
+        it('validates combination of min, max, and regex', function (done) {
 
             var rule = Joi.string().min(2).max(3).regex(/^a/);
             Helper.validate(rule, [
@@ -747,7 +818,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, regex, and allow(\'\')', function (done) {
+        it('validates combination of min, max, regex, and allow(\'\')', function (done) {
 
             var rule = Joi.string().min(2).max(3).regex(/^a/).allow('');
             Helper.validate(rule, [
@@ -763,7 +834,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, regex, and required', function (done) {
+        it('validates combination of min, max, regex, and required', function (done) {
 
             var rule = Joi.string().min(2).max(3).regex(/^a/).required();
             Helper.validate(rule, [
@@ -779,7 +850,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, and alphanum', function (done) {
+        it('validates combination of min, max, and alphanum', function (done) {
 
             var rule = Joi.string().min(2).max(3).alphanum();
             Helper.validate(rule, [
@@ -796,7 +867,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, alphanum, and allow(\'\')', function (done) {
+        it('validates combination of min, max, alphanum, and allow(\'\')', function (done) {
 
             var rule = Joi.string().min(2).max(3).alphanum().allow('');
             Helper.validate(rule, [
@@ -813,7 +884,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, alphanum, and required', function (done) {
+        it('validates combination of min, max, alphanum, and required', function (done) {
 
             var rule = Joi.string().min(2).max(3).alphanum().required();
             Helper.validate(rule, [
@@ -830,7 +901,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, alphanum, and regex', function (done) {
+        it('validates combination of min, max, alphanum, and regex', function (done) {
 
             var rule = Joi.string().min(2).max(3).alphanum().regex(/^a/);
             Helper.validate(rule, [
@@ -848,7 +919,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, alphanum, required, and regex', function (done) {
+        it('validates combination of min, max, alphanum, required, and regex', function (done) {
 
             var rule = Joi.string().min(2).max(3).alphanum().required().regex(/^a/);
             Helper.validate(rule, [
@@ -866,7 +937,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of min, max, alphanum, allow(\'\'), and regex', function (done) {
+        it('validates combination of min, max, alphanum, allow(\'\'), and regex', function (done) {
 
             var rule = Joi.string().min(2).max(3).alphanum().allow('').regex(/^a/);
             Helper.validate(rule, [
@@ -884,7 +955,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email and min', function (done) {
+        it('validates combination of email and min', function (done) {
 
             var rule = Joi.string().email().min(8);
             Helper.validate(rule, [
@@ -895,7 +966,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, and max', function (done) {
+        it('validates combination of email, min, and max', function (done) {
 
             var rule = Joi.string().email().min(8).max(10);
             Helper.validate(rule, [
@@ -908,7 +979,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, and invalid', function (done) {
+        it('validates combination of email, min, max, and invalid', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).invalid('123@x.com');
             Helper.validate(rule, [
@@ -921,7 +992,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, and allow', function (done) {
+        it('validates combination of email, min, max, and allow', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).allow('x@x.com');
             Helper.validate(rule, [
@@ -934,7 +1005,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, allow, and invalid', function (done) {
+        it('validates combination of email, min, max, allow, and invalid', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com');
             Helper.validate(rule, [
@@ -947,7 +1018,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, allow, invalid, and allow(\'\')', function (done) {
+        it('validates combination of email, min, max, allow, invalid, and allow(\'\')', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').allow('');
             Helper.validate(rule, [
@@ -960,7 +1031,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, allow, and allow(\'\')', function (done) {
+        it('validates combination of email, min, max, allow, and allow(\'\')', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).allow('x@x.com').allow('');
             Helper.validate(rule, [
@@ -973,7 +1044,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, allow, invalid, and regex', function (done) {
+        it('validates combination of email, min, max, allow, invalid, and regex', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').regex(/^1/);
             Helper.validate(rule, [
@@ -986,7 +1057,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, allow, invalid, regex, and allow(\'\')', function (done) {
+        it('validates combination of email, min, max, allow, invalid, regex, and allow(\'\')', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').regex(/^1/).allow('');
             Helper.validate(rule, [
@@ -999,7 +1070,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, and allow(\'\')', function (done) {
+        it('validates combination of email, min, max, and allow(\'\')', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).allow('');
             Helper.validate(rule, [
@@ -1012,7 +1083,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, and regex', function (done) {
+        it('validates combination of email, min, max, and regex', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).regex(/^1234/);
             Helper.validate(rule, [
@@ -1025,7 +1096,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, regex, and allow(\'\')', function (done) {
+        it('validates combination of email, min, max, regex, and allow(\'\')', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).regex(/^1234/).allow('');
             Helper.validate(rule, [
@@ -1038,7 +1109,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of email, min, max, regex, and required', function (done) {
+        it('validates combination of email, min, max, regex, and required', function (done) {
 
             var rule = Joi.string().email().min(8).max(10).regex(/^1234/).required();
             Helper.validate(rule, [
@@ -1051,24 +1122,31 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate isoDate', function (done) {
+        it('validates isoDate', function (done) {
 
             Helper.validate(Joi.string().isoDate(), [
                 ['2013-06-07T14:21:46.295Z', true],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', true],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', true],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', true],
                 ['2013-06-07T14:21:46-07:00', true],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', true],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', true],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', true],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false]
             ], done);
         });
 
-        it('should validate isoDate with a friendly error message', function (done) {
+        it('validates isoDate with a friendly error message', function (done) {
 
             var schema = { item: Joi.string().isoDate() };
             Joi.compile(schema).validate({ item: 'something' }, function (err, value) {
@@ -1078,287 +1156,358 @@ describe('string', function () {
             });
         });
 
-        it('should handle combination of isoDate and min', function (done) {
+        it('validates combination of isoDate and min', function (done) {
 
             var rule = Joi.string().isoDate().min(23);
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', true],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', true],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', true],
                 ['2013-06-07T14:21:46Z', false],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', true],
                 ['2013-06-07T14:21:46-07:00', true],
                 ['2013-06-07T14:21Z', false],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', false],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min and max', function (done) {
-
-            var rule = Joi.string().isoDate().min(17).max(23);
-            Helper.validate(rule, [
-                ['2013-06-07T14:21:46.295Z', false],
-                ['2013-06-07T14:21:46.295+07:00', false],
-                ['2013-06-07T14:21:46.295-07:00', false],
-                ['2013-06-07T14:21:46Z', true],
-                ['2013-06-07T14:21:46+07:00', false],
-                ['2013-06-07T14:21:46-07:00', false],
-                ['2013-06-07T14:21Z', true],
-                ['2013-06-07T14:21+07:00', true],
-                ['2013-06-07T14:21-07:00', true],
-                ['2013-06-07T14:21Z+7:00', false],
-                ['1-1-2013', false],
-                ['', false],
-                [null, false]
-            ], done);
-        });
-
-        it('should handle combination of isoDate, min and max', function (done) {
+        it('validates combination of isoDate, min and max', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23);
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', false],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', true],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', true],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max and invalid', function (done) {
+        it('validates combination of isoDate, min, max and invalid', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).invalid('2013-06-07T14:21+07:00');
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', false],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', true],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max and allow', function (done) {
+        it('validates combination of isoDate, min, max and allow', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).allow('2013-06-07T14:21:46.295+07:00');
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', true],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', true],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', true],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max, allow and invalid', function (done) {
+        it('validates combination of isoDate, min, max, allow and invalid', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).allow('2013-06-07T14:21:46.295+07:00').invalid('2013-06-07T14:21+07:00');
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', true],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', true],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max, allow, invalid and allow(\'\')', function (done) {
+        it('validates combination of isoDate, min, max, allow, invalid and allow(\'\')', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).allow('2013-06-07T14:21:46.295+07:00').invalid('2013-06-07T14:21+07:00').allow('');
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', true],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', true],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', true],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max, allow, invalid and allow(\'\')', function (done) {
+        it('validates combination of isoDate, min, max, allow, invalid and allow(\'\')', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).allow('2013-06-07T14:21:46.295+07:00').allow('');
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', true],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', true],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', true],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', true],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max, allow, invalid and regex', function (done) {
+        it('validates combination of isoDate, min, max, allow, invalid and regex', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).allow('2013-06-07T14:21:46.295+07:00').invalid('2013-06-07T14:21Z').regex(/Z$/);
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', true],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', false],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', false],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max, allow, invalid, regex and allow(\'\')', function (done) {
+        it('validates combination of isoDate, min, max, allow, invalid, regex and allow(\'\')', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).allow('2013-06-07T14:21:46.295+07:00').invalid('2013-06-07T14:21Z').regex(/Z$/).allow('');
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', true],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', false],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', false],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', true],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max and allow(\'\')', function (done) {
+        it('validates combination of isoDate, min, max and allow(\'\')', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).allow('');
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', false],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', true],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', true],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', true],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max and regex', function (done) {
+        it('validates combination of isoDate, min, max and regex', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).regex(/Z$/);
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', false],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', false],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max, regex and allow(\'\')', function (done) {
+        it('validates combination of isoDate, min, max, regex and allow(\'\')', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).regex(/Z$/).allow('');
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', false],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', false],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', true],
                 [null, false]
             ], done);
         });
 
-        it('should handle combination of isoDate, min, max, regex and required', function (done) {
+        it('validates combination of isoDate, min, max, regex and required', function (done) {
 
             var rule = Joi.string().isoDate().min(17).max(23).regex(/Z$/).required();
             Helper.validate(rule, [
                 ['2013-06-07T14:21:46.295Z', false],
+                ['2013-06-07T14:21:46.295Z0', false],
                 ['2013-06-07T14:21:46.295+07:00', false],
+                ['2013-06-07T14:21:46.295+07:000', false],
                 ['2013-06-07T14:21:46.295-07:00', false],
                 ['2013-06-07T14:21:46Z', true],
+                ['2013-06-07T14:21:46Z0', false],
                 ['2013-06-07T14:21:46+07:00', false],
                 ['2013-06-07T14:21:46-07:00', false],
                 ['2013-06-07T14:21Z', true],
                 ['2013-06-07T14:21+07:00', false],
+                ['2013-06-07T14:21+07:000', false],
                 ['2013-06-07T14:21-07:00', false],
                 ['2013-06-07T14:21Z+7:00', false],
+                ['2013-06-07', false],
+                ['2013-06-07T', false],
+                ['2013-06-07T14:21', false],
                 ['1-1-2013', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('should validate guid', function (done) {
+        it('validates guid', function (done) {
 
             Helper.validate(Joi.string().guid(), [
                 ['{D1A5279D-B27D-4CD4-A05E-EFDD53D08E8D}', true],
@@ -1375,7 +1524,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should validate guid with a friendly error message', function (done) {
+        it('validates guid with a friendly error message', function (done) {
 
             var schema = { item: Joi.string().guid() };
             Joi.compile(schema).validate({ item: 'something' }, function (err, value) {
@@ -1385,7 +1534,7 @@ describe('string', function () {
             });
         });
 
-        it('should handle combination of guid and min', function (done) {
+        it('validates combination of guid and min', function (done) {
 
             var rule = Joi.string().guid().min(36);
             Helper.validate(rule, [
@@ -1405,7 +1554,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min and max', function (done) {
+        it('validates combination of guid, min and max', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34);
             Helper.validate(rule, [
@@ -1425,7 +1574,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max and invalid', function (done) {
+        it('validates combination of guid, min, max and invalid', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).invalid('b4b2fb69c6244e5eb0698e0c6ec66618');
             Helper.validate(rule, [
@@ -1445,7 +1594,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max and allow', function (done) {
+        it('validates combination of guid, min, max and allow', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).allow('{D1A5279D-B27D-4CD4-A05E-EFDD53D08E8D');
             Helper.validate(rule, [
@@ -1465,7 +1614,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max, allow and invalid', function (done) {
+        it('validates combination of guid, min, max, allow and invalid', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).allow('{D1A5279D-B27D-4CD4-A05E-EFDD53D08E8D').invalid('b4b2fb69c6244e5eb0698e0c6ec66618');
             Helper.validate(rule, [
@@ -1485,7 +1634,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max, allow, invalid and allow(\'\')', function (done) {
+        it('validates combination of guid, min, max, allow, invalid and allow(\'\')', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).allow('{D1A5279D-B27D-4CD4-A05E-EFDD53D08E8D').invalid('b4b2fb69c6244e5eb0698e0c6ec66618').allow('');
             Helper.validate(rule, [
@@ -1505,7 +1654,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max, allow and allow(\'\')', function (done) {
+        it('validates combination of guid, min, max, allow and allow(\'\')', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).allow('{D1A5279D-B27D-4CD4-A05E-EFDD53D08E8D').allow('');
             Helper.validate(rule, [
@@ -1525,7 +1674,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max, allow, invalid and regex', function (done) {
+        it('validates combination of guid, min, max, allow, invalid and regex', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).allow('{D1A5279D-B27D-4CD4-A05E-EFDD53D08').invalid('b4b2fb69c6244e5eb0698e0c6ec66618').regex(/^{7e908/);
             Helper.validate(rule, [
@@ -1545,7 +1694,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max, allow, invalid, regex and allow(\'\')', function (done) {
+        it('validates combination of guid, min, max, allow, invalid, regex and allow(\'\')', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).allow('{D1A5279D-B27D-4CD4-A05E-EFDD53D08').invalid('b4b2fb69c6244e5eb0698e0c6ec66618').regex(/^{7e908/).allow('');
             Helper.validate(rule, [
@@ -1565,7 +1714,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max and allow(\'\')', function (done) {
+        it('validates combination of guid, min, max and allow(\'\')', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).allow('');
             Helper.validate(rule, [
@@ -1585,7 +1734,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max and regex', function (done) {
+        it('validates combination of guid, min, max and regex', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).regex(/^{7e9081/i);
             Helper.validate(rule, [
@@ -1605,7 +1754,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max, regex and allow(\'\')', function (done) {
+        it('validates combination of guid, min, max, regex and allow(\'\')', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).regex(/^{7e9081/i).allow('');
             Helper.validate(rule, [
@@ -1625,7 +1774,7 @@ describe('string', function () {
             ], done);
         });
 
-        it('should handle combination of guid, min, max, regex and required', function (done) {
+        it('validates combination of guid, min, max, regex and required', function (done) {
 
             var rule = Joi.string().guid().min(32).max(34).regex(/^{7e9081/i).required();
             Helper.validate(rule, [