joi 7.2.3 → 7.3.0

package/test/string.js

@@ -34,24 +34,6 @@ describe('string', () => {
 
     describe('valid()', () => {
 
-        it('should throw error on input not matching type', (done) => {
-
-            expect(() => {
-
-                Joi.string().valid({});
-            }).to.throw();
-            done();
-        });
-
-        it('should not throw on input matching type', (done) => {
-
-            expect(() => {
-
-                Joi.string().valid('joi');
-            }).to.not.throw();
-            done();
-        });
-
         it('validates case sensitive values', (done) => {
 
             Helper.validate(Joi.string().valid('a', 'b'), [
@@ -88,24 +70,6 @@ describe('string', () => {
 
     describe('invalid()', () => {
 
-        it('should throw error on input not matching type', (done) => {
-
-            expect(() => {
-
-                Joi.string().invalid({});
-            }).to.throw();
-            done();
-        });
-
-        it('should not throw on input matching type', (done) => {
-
-            expect(() => {
-
-                Joi.string().invalid('joi');
-            }).to.not.throw();
-            done();
-        });
-
         it('invalidates case sensitive values', (done) => {
 
             Helper.validate(Joi.string().invalid('a', 'b'), [
@@ -496,6 +460,89 @@ describe('string', () => {
             }).to.not.throw();
             done();
         });
+
+        it('validates email', (done) => {
+
+            const schema = Joi.string().email();
+            Helper.validate(schema, [
+                ['joe@example.com', true],
+                ['"joe"@example.com', true],
+                ['@iaminvalid.com', false],
+                ['joe@[IPv6:2a00:1450:4001:c02::1b]', true],
+                ['12345678901234567890123456789012345678901234567890123456789012345@walmartlabs.com', false],
+                ['123456789012345678901234567890123456789012345678901234567890@12345678901234567890123456789012345678901234567890123456789.12345678901234567890123456789012345678901234567890123456789.12345678901234567890123456789012345678901234567890123456789.12345.toolong.com', false]
+            ], done);
+        });
+
+        it('validates email with tldWhitelist as array', (done) => {
+
+            const schema = Joi.string().email({ tldWhitelist: ['com', 'org'] });
+            Helper.validate(schema, [
+                ['joe@example.com', true],
+                ['joe@example.org', true],
+                ['joe@example.edu', false]
+            ], done);
+        });
+
+        it('validates email with tldWhitelist as object', (done) => {
+
+            const schema = Joi.string().email({ tldWhitelist: { com: true, org: true } });
+            Helper.validate(schema, [
+                ['joe@example.com', true],
+                ['joe@example.org', true],
+                ['joe@example.edu', false]
+            ], done);
+        });
+
+        it('validates email with minDomainAtoms', (done) => {
+
+            const schema = Joi.string().email({ minDomainAtoms: 4 });
+            Helper.validate(schema, [
+                ['joe@example.com', false],
+                ['joe@www.example.com', false],
+                ['joe@sub.www.example.com', true]
+            ], done);
+        });
+
+        it('validates email with errorLevel as boolean', (done) => {
+
+            let schema = Joi.string().email({ errorLevel: false });
+            Helper.validate(schema, [
+                ['joe@example.com', true],
+                ['joe@www.example.com', true],
+                ['joe@localhost', true],
+                ['joe', false]
+            ]);
+
+            schema = Joi.string().email({ errorLevel: true });
+            Helper.validate(schema, [
+                ['joe@example.com', true],
+                ['joe@www.example.com', true],
+                ['joe@localhost', false],
+                ['joe', false]
+            ], done);
+        });
+
+        it('validates email with errorLevel as integer', (done) => {
+
+            const schema = Joi.string().email({ errorLevel: 10 });
+            Helper.validate(schema, [
+                ['joe@example.com', true],
+                ['joe@www.example.com', true],
+                ['joe@localhost', true],
+                ['joe', false]
+            ], done);
+        });
+
+        it('validates email with a friendly error message', (done) => {
+
+            const schema = { item: Joi.string().email() };
+            Joi.compile(schema).validate({ item: 'something' }, (err, value) => {
+
+                expect(err.message).to.contain('must be a valid email');
+                done();
+            });
+        });
     });
 
     describe('hostname()', () => {
@@ -1329,520 +1376,725 @@ describe('string', () => {
         });
     });
 
-    describe('validate()', () => {
+    describe('uri()', () => {
 
-        it('should, by default, allow undefined, deny empty string', (done) => {
+        it('validates uri', (done) => {
 
-            Helper.validate(Joi.string(), [
-                [undefined, true],
-                ['', false]
+            // Handful of tests taken from Node: https://github.com/joyent/node/blob/cfcb1de130867197cbc9c6012b7e84e08e53d032/test/simple/test-url.js
+            // Also includes examples from RFC 8936: http://tools.ietf.org/html/rfc3986#page-7
+            const schema = Joi.string().uri();
+
+            Helper.validate(schema, [
+                ['foo://example.com:8042/over/there?name=ferret#nose', true],
+                ['urn:example:animal:ferret:nose', true],
+                ['ftp://ftp.is.co.za/rfc/rfc1808.txt', true],
+                ['http://www.ietf.org/rfc/rfc2396.txt', true],
+                ['ldap://[2001:db8::7]/c=GB?objectClass?one', true],
+                ['mailto:John.Doe@example.com', true],
+                ['news:comp.infosystems.www.servers.unix', true],
+                ['tel:+1-816-555-1212', true],
+                ['telnet://192.0.2.16:80/', true],
+                ['urn:oasis:names:specification:docbook:dtd:xml:4.1.2', true],
+                ['file:///example.txt', true],
+                ['http://asdf:qw%20er@localhost:8000?asdf=12345&asda=fc%2F#bacon', true],
+                ['http://asdf@localhost:8000', true],
+                ['http://[v1.09azAZ-._~!$&\'()*+,;=:]', true],
+                ['http://[a:b:c:d:e::1.2.3.4]', true],
+                ['coap://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]', true],
+                ['http://[1080:0:0:0:8:800:200C:417A]', true],
+                ['http://127.0.0.1:8000/foo?bar', true],
+                ['http://asdf:qwer@localhost:8000', true],
+                ['http://user:pass%3A@localhost:80', true],
+                ['http://localhost:123', true],
+                ['https://localhost:123', true],
+                ['file:///whatever', true],
+                ['mailto:asdf@asdf.com', true],
+                ['ftp://www.example.com', true],
+                ['javascript:alert(\'hello\');', true], // eslint-disable-line no-script-url
+                ['xmpp:isaacschlueter@jabber.org', true],
+                ['f://some.host/path', true],
+                ['http://localhost:18/asdf', true],
+                ['http://localhost:42/asdf?qwer=zxcv', true],
+                ['HTTP://www.example.com/', true],
+                ['HTTP://www.example.com', true],
+                ['http://www.ExAmPlE.com/', true],
+                ['http://user:pw@www.ExAmPlE.com/', true],
+                ['http://USER:PW@www.ExAmPlE.com/', true],
+                ['http://user@www.example.com/', true],
+                ['http://user%3Apw@www.example.com/', true],
+                ['http://x.com/path?that%27s#all,%20folks', true],
+                ['HTTP://X.COM/Y', true],
+                ['http://www.narwhaljs.org/blog/categories?id=news', true],
+                ['http://mt0.google.com/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s=', true],
+                ['http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=', true],
+                ['http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=', true],
+                ['http://_jabber._tcp.google.com:80/test', true],
+                ['http://user:pass@_jabber._tcp.google.com:80/test', true],
+                ['http://[fe80::1]/a/b?a=b#abc', true],
+                ['http://user:password@[3ffe:2a00:100:7031::1]:8080', true],
+                ['coap://[1080:0:0:0:8:800:200C:417A]:61616/', true],
+                ['git+http://github.com/joyent/node.git', true],
+                ['http://bucket_name.s3.amazonaws.com/image.jpg', true],
+                ['dot.test://foo/bar', true],
+                ['svn+ssh://foo/bar', true],
+                ['dash-test://foo/bar', true],
+                ['xmpp:isaacschlueter@jabber.org', true],
+                ['http://atpass:foo%40bar@127.0.0.1:8080/path?search=foo#bar', true],
+                ['javascript:alert(\'hello\');', true], // eslint-disable-line no-script-url
+                ['file://localhost/etc/node/', true],
+                ['file:///etc/node/', true],
+                ['http://USER:PW@www.ExAmPlE.com/', true],
+                ['mailto:local1@domain1?query1', true],
+                ['http://example/a/b?c/../d', true],
+                ['http://example/x%2Fabc', true],
+                ['http://a/b/c/d;p=1/g;x=1/y', true],
+                ['http://a/b/c/g#s/../x', true],
+                ['http://a/b/c/.foo', true],
+                ['http://example.com/b//c//d;p?q#blarg', true],
+                ['g:h', true],
+                ['http://a/b/c/g', true],
+                ['http://a/b/c/g/', true],
+                ['http://a/g', true],
+                ['http://g', true],
+                ['http://a/b/c/d;p?y', true],
+                ['http://a/b/c/g?y', true],
+                ['http://a/b/c/d;p?q#s', true],
+                ['http://a/b/c/g#s', true],
+                ['http://a/b/c/g?y#s', true],
+                ['http://a/b/c/;x', true],
+                ['http://a/b/c/g;x', true],
+                ['http://a/b/c/g;x?y#s', true],
+                ['http://a/b/c/d;p?q', true],
+                ['http://a/b/c/', true],
+                ['http://a/b/', true],
+                ['http://a/b/g', true],
+                ['http://a/', true],
+                ['http://a/g', true],
+                ['http://a/g', true],
+                ['file:/asda', true],
+                ['qwerty', false],
+                ['invalid uri', false],
+                ['1http://google.com', false],
+                ['http://testdomain`,.<>/?\'";{}][++\\|~!@#$%^&*().org', false],
+                ['', false],
+                ['(╯°□°)╯︵ ┻━┻', false],
+                ['one/two/three?value=abc&value2=123#david-rules', false],
+                ['//username:password@test.example.com/one/two/three?value=abc&value2=123#david-rules', false],
+                ['http://a\r" \t\n<\'b:b@c\r\nd/e?f', false],
+                ['/absolute', false]
             ], done);
         });
 
-        it('should, when .required(), deny undefined, deny empty string', (done) => {
+        it('validates uri with a single scheme provided', (done) => {
 
-            Helper.validate(Joi.string().required(), [
-                [undefined, false],
-                ['', false]
+            const schema = Joi.string().uri({
+                scheme: 'http'
+            });
+
+            Helper.validate(schema, [
+                ['http://google.com', true],
+                ['https://google.com', false],
+                ['ftp://google.com', false],
+                ['file:/asdf', false],
+                ['/path?query=value#hash', false]
             ], done);
         });
 
-        it('should, when .required(), print a friend error message for an empty string', (done) => {
-
-            const schema = Joi.string().required();
-            Joi.compile(schema).validate('', (err, value) => {
+        it('validates uri with a single regex scheme provided', (done) => {
 
-                expect(err.message).to.contain('be empty');
-                done();
+            const schema = Joi.string().uri({
+                scheme: /https?/
             });
-        });
 
-        it('should, when .required(), validate non-empty strings', (done) => {
-
-            const schema = Joi.string().required();
             Helper.validate(schema, [
-                ['test', true],
-                ['0', true],
-                [null, false]
+                ['http://google.com', true],
+                ['https://google.com', true],
+                ['ftp://google.com', false],
+                ['file:/asdf', false],
+                ['/path?query=value#hash', false]
             ], done);
         });
 
-        it('validates invalid values', (done) => {
+        it('validates uri with multiple schemes provided', (done) => {
 
-            const schema = Joi.string().invalid('a', 'b', 'c');
-            Helper.validate(schema, [
-                ['x', true],
-                ['a', false],
-                ['c', false]
-            ], done);
-        });
-
-        it('should invalidate invalid values', (done) => {
+            const schema = Joi.string().uri({
+                scheme: [/https?/, 'ftp', 'file', 'git+http']
+            });
 
-            const schema = Joi.string().valid('a', 'b', 'c');
             Helper.validate(schema, [
-                ['x', false],
-                ['a', true],
-                ['c', true]
+                ['http://google.com', true],
+                ['https://google.com', true],
+                ['ftp://google.com', true],
+                ['file:/asdf', true],
+                ['git+http://github.com/hapijs/joi', true],
+                ['/path?query=value#hash', false]
             ], done);
         });
 
-        it('validates array arguments correctly', (done) => {
+        it('validates uri with a friendly error message', (done) => {
 
-            const schema = Joi.string().valid(['a', 'b', 'c']);
-            Helper.validate(schema, [
-                ['x', false],
-                ['a', true],
-                ['c', true]
-            ], done);
-        });
+            const schema = { item: Joi.string().uri() };
 
-        it('validates minimum length when min is used', (done) => {
+            Joi.compile(schema).validate({ item: 'something invalid' }, (err, value) => {
 
-            const schema = Joi.string().min(3);
-            Helper.validate(schema, [
-                ['test', true],
-                ['0', false],
-                [null, false]
-            ], done);
+                expect(err.message).to.contain('must be a valid uri');
+                done();
+            });
         });
 
-        it('validates minimum length when min is 0', (done) => {
+        it('validates uri with a custom scheme with a friendly error message', (done) => {
 
-            const schema = Joi.string().min(0).required();
-            Helper.validate(schema, [
-                ['0', true],
-                [null, false],
-                [undefined, false]
-            ], done);
-        });
+            const schema = {
+                item: Joi.string().uri({
+                    scheme: 'http'
+                })
+            };
 
-        it('should return false with minimum length and a null value passed in', (done) => {
+            Joi.compile(schema).validate({ item: 'something invalid' }, (err, value) => {
 
-            const schema = Joi.string().min(3);
-            Helper.validate(schema, [
-                [null, false]
-            ], done);
+                expect(err.message).to.contain('must be a valid uri with a scheme matching the http pattern');
+                done();
+            });
         });
 
-        it('null allowed overrides min length requirement', (done) => {
+        it('validates uri with a custom array of schemes with a friendly error message', (done) => {
 
-            const schema = Joi.string().min(3).allow(null);
-            Helper.validate(schema, [
-                [null, true]
-            ], done);
-        });
+            const schema = {
+                item: Joi.string().uri({
+                    scheme: ['http', /https?/]
+                })
+            };
 
-        it('validates maximum length when max is used', (done) => {
+            Joi.compile(schema).validate({ item: 'something invalid' }, (err, value) => {
 
-            const schema = Joi.string().max(3);
-            Helper.validate(schema, [
-                ['test', false],
-                ['0', true],
-                [null, false]
-            ], done);
+                expect(err.message).to.contain('must be a valid uri with a scheme matching the http|https? pattern');
+                done();
+            });
         });
 
-        it('should return true with max and not required when value is undefined', (done) => {
+        it('validates uri treats scheme as optional', (done) => {
 
-            const schema = Joi.string().max(3);
-            Helper.validate(schema, [
-                [undefined, true]
-            ], done);
-        });
+            expect(() => {
 
-        it('validates length requirements', (done) => {
+                Joi.string().uri({});
+            }).to.not.throw();
 
-            const schema = Joi.string().length(3);
-            Helper.validate(schema, [
-                ['test', false],
-                ['0', false],
-                [null, false],
-                ['abc', true]
-            ], done);
+            done();
         });
 
-        it('validates regex', (done) => {
+        it('validates uri requires uriOptions as an object with a friendly error message', (done) => {
 
-            const schema = Joi.string().regex(/^[0-9][-][a-z]+$/);
-            Helper.validate(schema, [
-                ['van', false],
-                ['0-www', true]
-            ], done);
-        });
+            expect(() => {
 
-        it('validates regex (ignoring global flag)', (done) => {
+                Joi.string().uri('http');
+            }).to.throw(Error, 'options must be an object');
 
-            const schema = Joi.string().regex(/a/g);
-            Helper.validate(schema, [
-                ['ab', true],
-                ['ac', true]
-            ], done);
+            done();
         });
 
-        it('validates token', (done) => {
+        it('validates uri requires scheme to be a RegExp, String, or Array with a friendly error message', (done) => {
 
-            const schema = Joi.string().token();
-            Helper.validate(schema, [
-                ['w0rld_of_w4lm4rtl4bs', true],
-                ['w0rld of_w4lm4rtl4bs', false],
-                ['abcd#f?h1j orly?', false]
-            ], done);
-        });
+            expect(() => {
 
-        it('validates alphanum', (done) => {
+                Joi.string().uri({
+                    scheme: {}
+                });
+            }).to.throw(Error, 'scheme must be a RegExp, String, or Array');
 
-            const schema = Joi.string().alphanum();
-            Helper.validate(schema, [
-                ['w0rld of w4lm4rtl4bs', false],
-                ['w0rldofw4lm4rtl4bs', true],
-                ['abcd#f?h1j orly?', false]
-            ], done);
+            done();
         });
 
-        it('validates email', (done) => {
+        it('validates uri requires scheme to not be an empty array', (done) => {
 
-            const schema = Joi.string().email();
-            Helper.validate(schema, [
-                ['joe@example.com', true],
-                ['"joe"@example.com', true],
-                ['@iaminvalid.com', false],
-                ['joe@[IPv6:2a00:1450:4001:c02::1b]', true],
-                ['12345678901234567890123456789012345678901234567890123456789012345@walmartlabs.com', false],
-                ['123456789012345678901234567890123456789012345678901234567890@12345678901234567890123456789012345678901234567890123456789.12345678901234567890123456789012345678901234567890123456789.12345678901234567890123456789012345678901234567890123456789.12345.toolong.com', false]
-            ], done);
-        });
+            expect(() => {
 
-        it('validates email with tldWhitelist as array', (done) => {
+                Joi.string().uri({
+                    scheme: []
+                });
+            }).to.throw(Error, 'scheme must have at least 1 scheme specified');
 
-            const schema = Joi.string().email({ tldWhitelist: ['com', 'org'] });
-            Helper.validate(schema, [
-                ['joe@example.com', true],
-                ['joe@example.org', true],
-                ['joe@example.edu', false]
-            ], done);
+            done();
         });
 
-        it('validates email with tldWhitelist as object', (done) => {
+        it('validates uri requires scheme to be an Array of schemes to all be valid schemes with a friendly error message', (done) => {
 
-            const schema = Joi.string().email({ tldWhitelist: { com: true, org: true } });
-            Helper.validate(schema, [
-                ['joe@example.com', true],
-                ['joe@example.org', true],
-                ['joe@example.edu', false]
-            ], done);
-        });
+            expect(() => {
 
-        it('validates email with minDomainAtoms', (done) => {
+                Joi.string().uri({
+                    scheme: [
+                        'http',
+                        '~!@#$%^&*()_'
+                    ]
+                });
+            }).to.throw(Error, 'scheme at position 1 must be a valid scheme');
 
-            const schema = Joi.string().email({ minDomainAtoms: 4 });
-            Helper.validate(schema, [
-                ['joe@example.com', false],
-                ['joe@www.example.com', false],
-                ['joe@sub.www.example.com', true]
-            ], done);
+            done();
         });
 
-        it('validates email with errorLevel as boolean', (done) => {
-
-            let schema = Joi.string().email({ errorLevel: false });
-            Helper.validate(schema, [
-                ['joe@example.com', true],
-                ['joe@www.example.com', true],
-                ['joe@localhost', true],
-                ['joe', false]
-            ]);
+        it('validates uri requires scheme to be an Array of schemes to be strings or RegExp', (done) => {
 
-            schema = Joi.string().email({ errorLevel: true });
-            Helper.validate(schema, [
-                ['joe@example.com', true],
-                ['joe@www.example.com', true],
-                ['joe@localhost', false],
-                ['joe', false]
-            ], done);
-        });
+            expect(() => {
 
-        it('validates email with errorLevel as integer', (done) => {
+                Joi.string().uri({
+                    scheme: [
+                        'http',
+                        {}
+                    ]
+                });
+            }).to.throw(Error, 'scheme at position 1 must be a RegExp or String');
 
-            const schema = Joi.string().email({ errorLevel: 10 });
-            Helper.validate(schema, [
-                ['joe@example.com', true],
-                ['joe@www.example.com', true],
-                ['joe@localhost', true],
-                ['joe', false]
-            ], done);
+            done();
         });
 
-        it('validates email with a friendly error message', (done) => {
-
-            const schema = { item: Joi.string().email() };
-            Joi.compile(schema).validate({ item: 'something' }, (err, value) => {
-
-                expect(err.message).to.contain('must be a valid email');
-                done();
-            });
-        });
+        it('validates uri requires scheme to be a valid String scheme with a friendly error message', (done) => {
 
-        it('should return false for denied value', (done) => {
+            expect(() => {
 
-            const text = Joi.string().invalid('joi');
-            text.validate('joi', (err, value) => {
+                Joi.string().uri({
+                    scheme: '~!@#$%^&*()_'
+                });
+            }).to.throw(Error, 'scheme at position 0 must be a valid scheme');
 
-                expect(err).to.exist();
-                done();
-            });
+            done();
         });
 
-        it('should return true for allowed value', (done) => {
-
-            const text = Joi.string().allow('hapi');
-            text.validate('result', (err, value) => {
+        it('validates relative uri', (done) => {
 
-                expect(err).to.not.exist();
-                done();
-            });
+            const schema = Joi.string().uri({ allowRelative: true });
+            Helper.validate(schema, [
+                ['foo://example.com:8042/over/there?name=ferret#nose', true],
+                ['urn:example:animal:ferret:nose', true],
+                ['ftp://ftp.is.co.za/rfc/rfc1808.txt', true],
+                ['http://www.ietf.org/rfc/rfc2396.txt', true],
+                ['ldap://[2001:db8::7]/c=GB?objectClass?one', true],
+                ['mailto:John.Doe@example.com', true],
+                ['news:comp.infosystems.www.servers.unix', true],
+                ['tel:+1-816-555-1212', true],
+                ['telnet://192.0.2.16:80/', true],
+                ['urn:oasis:names:specification:docbook:dtd:xml:4.1.2', true],
+                ['file:///example.txt', true],
+                ['http://asdf:qw%20er@localhost:8000?asdf=12345&asda=fc%2F#bacon', true],
+                ['http://asdf@localhost:8000', true],
+                ['http://[v1.09azAZ-._~!$&\'()*+,;=:]', true],
+                ['http://[a:b:c:d:e::1.2.3.4]', true],
+                ['coap://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]', true],
+                ['http://[1080:0:0:0:8:800:200C:417A]', true],
+                ['http://127.0.0.1:8000/foo?bar', true],
+                ['http://asdf:qwer@localhost:8000', true],
+                ['http://user:pass%3A@localhost:80', true],
+                ['http://localhost:123', true],
+                ['https://localhost:123', true],
+                ['file:///whatever', true],
+                ['mailto:asdf@asdf.com', true],
+                ['ftp://www.example.com', true],
+                ['javascript:alert(\'hello\');', true], // eslint-disable-line no-script-url
+                ['xmpp:isaacschlueter@jabber.org', true],
+                ['f://some.host/path', true],
+                ['http://localhost:18/asdf', true],
+                ['http://localhost:42/asdf?qwer=zxcv', true],
+                ['HTTP://www.example.com/', true],
+                ['HTTP://www.example.com', true],
+                ['http://www.ExAmPlE.com/', true],
+                ['http://user:pw@www.ExAmPlE.com/', true],
+                ['http://USER:PW@www.ExAmPlE.com/', true],
+                ['http://user@www.example.com/', true],
+                ['http://user%3Apw@www.example.com/', true],
+                ['http://x.com/path?that%27s#all,%20folks', true],
+                ['HTTP://X.COM/Y', true],
+                ['http://www.narwhaljs.org/blog/categories?id=news', true],
+                ['http://mt0.google.com/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s=', true],
+                ['http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=', true],
+                ['http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=', true],
+                ['http://_jabber._tcp.google.com:80/test', true],
+                ['http://user:pass@_jabber._tcp.google.com:80/test', true],
+                ['http://[fe80::1]/a/b?a=b#abc', true],
+                ['http://user:password@[3ffe:2a00:100:7031::1]:8080', true],
+                ['coap://[1080:0:0:0:8:800:200C:417A]:61616/', true],
+                ['git+http://github.com/joyent/node.git', true],
+                ['http://bucket_name.s3.amazonaws.com/image.jpg', true],
+                ['dot.test://foo/bar', true],
+                ['svn+ssh://foo/bar', true],
+                ['dash-test://foo/bar', true],
+                ['xmpp:isaacschlueter@jabber.org', true],
+                ['http://atpass:foo%40bar@127.0.0.1:8080/path?search=foo#bar', true],
+                ['javascript:alert(\'hello\');', true], // eslint-disable-line no-script-url
+                ['file://localhost/etc/node/', true],
+                ['file:///etc/node/', true],
+                ['http://USER:PW@www.ExAmPlE.com/', true],
+                ['mailto:local1@domain1?query1', true],
+                ['http://example/a/b?c/../d', true],
+                ['http://example/x%2Fabc', true],
+                ['http://a/b/c/d;p=1/g;x=1/y', true],
+                ['http://a/b/c/g#s/../x', true],
+                ['http://a/b/c/.foo', true],
+                ['http://example.com/b//c//d;p?q#blarg', true],
+                ['g:h', true],
+                ['http://a/b/c/g', true],
+                ['http://a/b/c/g/', true],
+                ['http://a/g', true],
+                ['http://g', true],
+                ['http://a/b/c/d;p?y', true],
+                ['http://a/b/c/g?y', true],
+                ['http://a/b/c/d;p?q#s', true],
+                ['http://a/b/c/g#s', true],
+                ['http://a/b/c/g?y#s', true],
+                ['http://a/b/c/;x', true],
+                ['http://a/b/c/g;x', true],
+                ['http://a/b/c/g;x?y#s', true],
+                ['http://a/b/c/d;p?q', true],
+                ['http://a/b/c/', true],
+                ['http://a/b/', true],
+                ['http://a/b/g', true],
+                ['http://a/', true],
+                ['http://a/g', true],
+                ['http://a/g', true],
+                ['file:/asda', true],
+                ['qwerty', true],
+                ['invalid uri', false],
+                ['1http://google.com', false],
+                ['http://testdomain`,.<>/?\'";{}][++\\|~!@#$%^&*().org', false],
+                ['', false],
+                ['(╯°□°)╯︵ ┻━┻', false],
+                ['one/two/three?value=abc&value2=123#david-rules', true],
+                ['//username:password@test.example.com/one/two/three?value=abc&value2=123#david-rules', true],
+                ['http://a\r" \t\n<\'b:b@c\r\nd/e?f', false],
+                ['/absolute', true]
+            ], done);
         });
+    });
 
-        it('validates with one validator (min)', (done) => {
+    describe('validate()', () => {
 
-            const text = Joi.string().min(3);
-            text.validate('joi', (err, value) => {
+        it('should, by default, allow undefined, deny empty string', (done) => {
 
-                expect(err).to.not.exist();
-                done();
-            });
+            Helper.validate(Joi.string(), [
+                [undefined, true],
+                ['', false]
+            ], done);
         });
 
-        it('validates with two validators (min, required)', (done) => {
+        it('should, when .required(), deny undefined, deny empty string', (done) => {
 
-            const text = Joi.string().min(3).required();
-            text.validate('joi', (err, value) => {
+            Helper.validate(Joi.string().required(), [
+                [undefined, false],
+                ['', false]
+            ], done);
+        });
 
-                expect(err).to.not.exist();
+        it('should, when .required(), print a friend error message for an empty string', (done) => {
 
-                text.validate('', (err2, value2) => {
+            const schema = Joi.string().required();
+            Joi.compile(schema).validate('', (err, value) => {
 
-                    expect(err2).to.exist();
-                    done();
-                });
+                expect(err.message).to.contain('be empty');
+                done();
             });
         });
 
-        it('validates null with allow(null)', (done) => {
+        it('should, when .required(), validate non-empty strings', (done) => {
 
-            Helper.validate(Joi.string().allow(null), [
-                [null, true]
+            const schema = Joi.string().required();
+            Helper.validate(schema, [
+                ['test', true],
+                ['0', true],
+                [null, false]
             ], done);
         });
 
-        it('validates "" (empty string) with allow(\'\')', (done) => {
+        it('validates invalid values', (done) => {
 
-            Helper.validate(Joi.string().allow(''), [
-                ['', true],
-                ['', true]
+            const schema = Joi.string().invalid('a', 'b', 'c');
+            Helper.validate(schema, [
+                ['x', true],
+                ['a', false],
+                ['c', false]
             ], done);
         });
 
-        it('validates combination of required and min', (done) => {
+        it('should invalidate invalid values', (done) => {
 
-            const rule = Joi.string().required().min(3);
-            Helper.validate(rule, [
+            const schema = Joi.string().valid('a', 'b', 'c');
+            Helper.validate(schema, [
                 ['x', false],
-                ['123', true],
-                ['', false],
-                [null, false]
+                ['a', true],
+                ['c', true]
             ], done);
         });
 
-        it('validates combination of required and max', (done) => {
+        it('validates array arguments correctly', (done) => {
 
-            const rule = Joi.string().required().max(3);
-            Helper.validate(rule, [
-                ['x', true],
-                ['123', true],
-                ['1234', false],
-                ['', false],
-                [null, false]
+            const schema = Joi.string().valid(['a', 'b', 'c']);
+            Helper.validate(schema, [
+                ['x', false],
+                ['a', true],
+                ['c', true]
             ], done);
         });
 
-        it('validates combination of allow(\'\') and min', (done) => {
+        it('validates minimum length when min is used', (done) => {
 
-            const rule = Joi.string().allow('').min(3);
-            Helper.validate(rule, [
-                ['x', false],
-                ['123', true],
-                ['1234', true],
-                ['', true],
+            const schema = Joi.string().min(3);
+            Helper.validate(schema, [
+                ['test', true],
+                ['0', false],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of allow(\'\') and max', (done) => {
+        it('validates minimum length when min is 0', (done) => {
 
-            const rule = Joi.string().allow('').max(3);
-            Helper.validate(rule, [
-                ['x', true],
-                ['123', true],
-                ['1234', false],
-                ['', true],
-                [null, false]
+            const schema = Joi.string().min(0).required();
+            Helper.validate(schema, [
+                ['0', true],
+                [null, false],
+                [undefined, false]
             ], done);
         });
 
-        it('validates combination of null allowed and max', (done) => {
+        it('should return false with minimum length and a null value passed in', (done) => {
 
-            const rule = Joi.string().allow(null).max(3);
-            Helper.validate(rule, [
-                ['x', true],
-                ['123', true],
-                ['1234', false],
-                ['', false],
-                [null, true]
+            const schema = Joi.string().min(3);
+            Helper.validate(schema, [
+                [null, false]
             ], done);
         });
 
-        it('validates combination of min and max', (done) => {
+        it('null allowed overrides min length requirement', (done) => {
 
-            const rule = Joi.string().min(2).max(3);
-            Helper.validate(rule, [
-                ['x', false],
-                ['123', true],
-                ['1234', false],
-                ['12', true],
-                ['', false],
-                [null, false]
+            const schema = Joi.string().min(3).allow(null);
+            Helper.validate(schema, [
+                [null, true]
             ], done);
         });
 
-        it('validates combination of min, max, and allow(\'\')', (done) => {
+        it('validates maximum length when max is used', (done) => {
 
-            const rule = Joi.string().min(2).max(3).allow('');
-            Helper.validate(rule, [
-                ['x', false],
-                ['123', true],
-                ['1234', false],
-                ['12', true],
-                ['', true],
+            const schema = Joi.string().max(3);
+            Helper.validate(schema, [
+                ['test', false],
+                ['0', true],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of min, max, and required', (done) => {
+        it('should return true with max and not required when value is undefined', (done) => {
 
-            const rule = Joi.string().min(2).max(3).required();
-            Helper.validate(rule, [
-                ['x', false],
-                ['123', true],
-                ['1234', false],
-                ['12', true],
-                ['', false],
-                [null, false]
+            const schema = Joi.string().max(3);
+            Helper.validate(schema, [
+                [undefined, true]
             ], done);
         });
 
-        it('validates combination of min, max, and regex', (done) => {
+        it('validates length requirements', (done) => {
 
-            const rule = Joi.string().min(2).max(3).regex(/^a/);
-            Helper.validate(rule, [
-                ['x', false],
-                ['123', false],
-                ['1234', false],
-                ['12', false],
+            const schema = Joi.string().length(3);
+            Helper.validate(schema, [
+                ['test', false],
+                ['0', false],
+                [null, false],
+                ['abc', true]
+            ], done);
+        });
+
+        it('validates regex', (done) => {
+
+            const schema = Joi.string().regex(/^[0-9][-][a-z]+$/);
+            Helper.validate(schema, [
+                ['van', false],
+                ['0-www', true]
+            ], done);
+        });
+
+        it('validates regex (ignoring global flag)', (done) => {
+
+            const schema = Joi.string().regex(/a/g);
+            Helper.validate(schema, [
                 ['ab', true],
-                ['abc', true],
-                ['abcd', false],
+                ['ac', true]
+            ], done);
+        });
+
+        it('validates token', (done) => {
+
+            const schema = Joi.string().token();
+            Helper.validate(schema, [
+                ['w0rld_of_w4lm4rtl4bs', true],
+                ['w0rld of_w4lm4rtl4bs', false],
+                ['abcd#f?h1j orly?', false]
+            ], done);
+        });
+
+        it('validates alphanum', (done) => {
+
+            const schema = Joi.string().alphanum();
+            Helper.validate(schema, [
+                ['w0rld of w4lm4rtl4bs', false],
+                ['w0rldofw4lm4rtl4bs', true],
+                ['abcd#f?h1j orly?', false]
+            ], done);
+        });
+
+        it('should return false for denied value', (done) => {
+
+            const text = Joi.string().invalid('joi');
+            text.validate('joi', (err, value) => {
+
+                expect(err).to.exist();
+                done();
+            });
+        });
+
+        it('should return true for allowed value', (done) => {
+
+            const text = Joi.string().allow('hapi');
+            text.validate('result', (err, value) => {
+
+                expect(err).to.not.exist();
+                done();
+            });
+        });
+
+        it('validates with one validator (min)', (done) => {
+
+            const text = Joi.string().min(3);
+            text.validate('joi', (err, value) => {
+
+                expect(err).to.not.exist();
+                done();
+            });
+        });
+
+        it('validates with two validators (min, required)', (done) => {
+
+            const text = Joi.string().min(3).required();
+            text.validate('joi', (err, value) => {
+
+                expect(err).to.not.exist();
+
+                text.validate('', (err2, value2) => {
+
+                    expect(err2).to.exist();
+                    done();
+                });
+            });
+        });
+
+        it('validates null with allow(null)', (done) => {
+
+            Helper.validate(Joi.string().allow(null), [
+                [null, true]
+            ], done);
+        });
+
+        it('validates "" (empty string) with allow(\'\')', (done) => {
+
+            Helper.validate(Joi.string().allow(''), [
+                ['', true],
+                ['', true]
+            ], done);
+        });
+
+        it('validates combination of required and min', (done) => {
+
+            const rule = Joi.string().required().min(3);
+            Helper.validate(rule, [
+                ['x', false],
+                ['123', true],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of min, max, regex, and allow(\'\')', (done) => {
+        it('validates combination of required and max', (done) => {
 
-            const rule = Joi.string().min(2).max(3).regex(/^a/).allow('');
+            const rule = Joi.string().required().max(3);
+            Helper.validate(rule, [
+                ['x', true],
+                ['123', true],
+                ['1234', false],
+                ['', false],
+                [null, false]
+            ], done);
+        });
+
+        it('validates combination of allow(\'\') and min', (done) => {
+
+            const rule = Joi.string().allow('').min(3);
             Helper.validate(rule, [
                 ['x', false],
-                ['123', false],
+                ['123', true],
+                ['1234', true],
+                ['', true],
+                [null, false]
+            ], done);
+        });
+
+        it('validates combination of allow(\'\') and max', (done) => {
+
+            const rule = Joi.string().allow('').max(3);
+            Helper.validate(rule, [
+                ['x', true],
+                ['123', true],
                 ['1234', false],
-                ['12', false],
-                ['ab', true],
-                ['abc', true],
-                ['abcd', false],
                 ['', true],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of min, max, regex, and required', (done) => {
+        it('validates combination of null allowed and max', (done) => {
 
-            const rule = Joi.string().min(2).max(3).regex(/^a/).required();
+            const rule = Joi.string().allow(null).max(3);
             Helper.validate(rule, [
-                ['x', false],
-                ['123', false],
+                ['x', true],
+                ['123', true],
                 ['1234', false],
-                ['12', false],
-                ['ab', true],
-                ['abc', true],
-                ['abcd', false],
                 ['', false],
-                [null, false]
+                [null, true]
             ], done);
         });
 
-        it('validates combination of min, max, and alphanum', (done) => {
+        it('validates combination of min and max', (done) => {
 
-            const rule = Joi.string().min(2).max(3).alphanum();
+            const rule = Joi.string().min(2).max(3);
             Helper.validate(rule, [
                 ['x', false],
                 ['123', true],
                 ['1234', false],
                 ['12', true],
-                ['ab', true],
-                ['abc', true],
-                ['abcd', false],
-                ['*ab', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of min, max, alphanum, and allow(\'\')', (done) => {
+        it('validates combination of min, max, and allow(\'\')', (done) => {
 
-            const rule = Joi.string().min(2).max(3).alphanum().allow('');
+            const rule = Joi.string().min(2).max(3).allow('');
             Helper.validate(rule, [
                 ['x', false],
                 ['123', true],
                 ['1234', false],
                 ['12', true],
-                ['ab', true],
-                ['abc', true],
-                ['abcd', false],
-                ['*ab', false],
                 ['', true],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of min, max, alphanum, and required', (done) => {
+        it('validates combination of min, max, and required', (done) => {
 
-            const rule = Joi.string().min(2).max(3).alphanum().required();
+            const rule = Joi.string().min(2).max(3).required();
             Helper.validate(rule, [
                 ['x', false],
                 ['123', true],
                 ['1234', false],
                 ['12', true],
-                ['ab', true],
-                ['abc', true],
-                ['abcd', false],
-                ['*ab', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of min, max, alphanum, and regex', (done) => {
+        it('validates combination of min, max, and regex', (done) => {
 
-            const rule = Joi.string().min(2).max(3).alphanum().regex(/^a/);
+            const rule = Joi.string().min(2).max(3).regex(/^a/);
             Helper.validate(rule, [
                 ['x', false],
                 ['123', false],
@@ -1850,17 +2102,15 @@ describe('string', () => {
                 ['12', false],
                 ['ab', true],
                 ['abc', true],
-                ['a2c', true],
                 ['abcd', false],
-                ['*ab', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of min, max, alphanum, required, and regex', (done) => {
+        it('validates combination of min, max, regex, and allow(\'\')', (done) => {
 
-            const rule = Joi.string().min(2).max(3).alphanum().required().regex(/^a/);
+            const rule = Joi.string().min(2).max(3).regex(/^a/).allow('');
             Helper.validate(rule, [
                 ['x', false],
                 ['123', false],
@@ -1868,17 +2118,15 @@ describe('string', () => {
                 ['12', false],
                 ['ab', true],
                 ['abc', true],
-                ['a2c', true],
                 ['abcd', false],
-                ['*ab', false],
-                ['', false],
+                ['', true],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of min, max, alphanum, allow(\'\'), and regex', (done) => {
+        it('validates combination of min, max, regex, and required', (done) => {
 
-            const rule = Joi.string().min(2).max(3).alphanum().allow('').regex(/^a/);
+            const rule = Joi.string().min(2).max(3).regex(/^a/).required();
             Helper.validate(rule, [
                 ['x', false],
                 ['123', false],
@@ -1886,458 +2134,282 @@ describe('string', () => {
                 ['12', false],
                 ['ab', true],
                 ['abc', true],
-                ['a2c', true],
                 ['abcd', false],
-                ['*ab', false],
-                ['', true],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email and min', (done) => {
-
-            const rule = Joi.string().email().min(8);
-            Helper.validate(rule, [
-                ['x@x.com', false],
-                ['123@x.com', true],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of email, min, and max', (done) => {
+        it('validates combination of min, max, and alphanum', (done) => {
 
-            const rule = Joi.string().email().min(8).max(10);
+            const rule = Joi.string().min(2).max(3).alphanum();
             Helper.validate(rule, [
-                ['x@x.com', false],
-                ['123@x.com', true],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
+                ['x', false],
+                ['123', true],
+                ['1234', false],
+                ['12', true],
+                ['ab', true],
+                ['abc', true],
+                ['abcd', false],
+                ['*ab', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of email, min, max, and invalid', (done) => {
+        it('validates combination of min, max, alphanum, and allow(\'\')', (done) => {
 
-            const rule = Joi.string().email().min(8).max(10).invalid('123@x.com');
+            const rule = Joi.string().min(2).max(3).alphanum().allow('');
             Helper.validate(rule, [
-                ['x@x.com', false],
-                ['123@x.com', false],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', false],
+                ['x', false],
+                ['123', true],
+                ['1234', false],
+                ['12', true],
+                ['ab', true],
+                ['abc', true],
+                ['abcd', false],
+                ['*ab', false],
+                ['', true],
                 [null, false]
             ], done);
         });
 
-        it('validates combination of email, min, max, and allow', (done) => {
+        it('validates combination of min, max, alphanum, and required', (done) => {
 
-            const rule = Joi.string().email().min(8).max(10).allow('x@x.com');
-            Helper.validate(rule, [
-                ['x@x.com', true],
-                ['123@x.com', true],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', false],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, allow, and invalid', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com');
-            Helper.validate(rule, [
-                ['x@x.com', true],
-                ['123@x.com', false],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', false],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, allow, invalid, and allow(\'\')', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').allow('');
-            Helper.validate(rule, [
-                ['x@x.com', true],
-                ['123@x.com', false],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', true],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, allow, and allow(\'\')', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').allow('');
-            Helper.validate(rule, [
-                ['x@x.com', true],
-                ['123@x.com', true],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', true],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, allow, invalid, and regex', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').regex(/^1/);
-            Helper.validate(rule, [
-                ['x@x.com', true],
-                ['123@x.com', false],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', false],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, allow, invalid, regex, and allow(\'\')', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').regex(/^1/).allow('');
-            Helper.validate(rule, [
-                ['x@x.com', true],
-                ['123@x.com', false],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', true],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, and allow(\'\')', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).allow('');
-            Helper.validate(rule, [
-                ['x@x.com', false],
-                ['123@x.com', true],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', true],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, and regex', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).regex(/^1234/);
-            Helper.validate(rule, [
-                ['x@x.com', false],
-                ['123@x.com', false],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', false],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, regex, and allow(\'\')', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).regex(/^1234/).allow('');
-            Helper.validate(rule, [
-                ['x@x.com', false],
-                ['123@x.com', false],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
-                ['', true],
-                [null, false]
-            ], done);
-        });
-
-        it('validates combination of email, min, max, regex, and required', (done) => {
-
-            const rule = Joi.string().email().min(8).max(10).regex(/^1234/).required();
+            const rule = Joi.string().min(2).max(3).alphanum().required();
             Helper.validate(rule, [
-                ['x@x.com', false],
-                ['123@x.com', false],
-                ['1234@x.com', true],
-                ['12345@x.com', false],
+                ['x', false],
+                ['123', true],
+                ['1234', false],
+                ['12', true],
+                ['ab', true],
+                ['abc', true],
+                ['abcd', false],
+                ['*ab', false],
                 ['', false],
                 [null, false]
             ], done);
         });
 
-        it('validates uri', (done) => {
-
-            // Handful of tests taken from Node: https://github.com/joyent/node/blob/cfcb1de130867197cbc9c6012b7e84e08e53d032/test/simple/test-url.js
-            // Also includes examples from RFC 8936: http://tools.ietf.org/html/rfc3986#page-7
-            const schema = Joi.string().uri();
-
-            Helper.validate(schema, [
-                ['foo://example.com:8042/over/there?name=ferret#nose', true],
-                ['urn:example:animal:ferret:nose', true],
-                ['ftp://ftp.is.co.za/rfc/rfc1808.txt', true],
-                ['http://www.ietf.org/rfc/rfc2396.txt', true],
-                ['ldap://[2001:db8::7]/c=GB?objectClass?one', true],
-                ['mailto:John.Doe@example.com', true],
-                ['news:comp.infosystems.www.servers.unix', true],
-                ['tel:+1-816-555-1212', true],
-                ['telnet://192.0.2.16:80/', true],
-                ['urn:oasis:names:specification:docbook:dtd:xml:4.1.2', true],
-                ['file:///example.txt', true],
-                ['http://asdf:qw%20er@localhost:8000?asdf=12345&asda=fc%2F#bacon', true],
-                ['http://asdf@localhost:8000', true],
-                ['http://[v1.09azAZ-._~!$&\'()*+,;=:]', true],
-                ['http://[a:b:c:d:e::1.2.3.4]', true],
-                ['coap://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]', true],
-                ['http://[1080:0:0:0:8:800:200C:417A]', true],
-                ['http://127.0.0.1:8000/foo?bar', true],
-                ['http://asdf:qwer@localhost:8000', true],
-                ['http://user:pass%3A@localhost:80', true],
-                ['http://localhost:123', true],
-                ['https://localhost:123', true],
-                ['file:///whatever', true],
-                ['mailto:asdf@asdf.com', true],
-                ['ftp://www.example.com', true],
-                ['javascript:alert(\'hello\');', true], // eslint-disable-line no-script-url
-                ['xmpp:isaacschlueter@jabber.org', true],
-                ['f://some.host/path', true],
-                ['http://localhost:18/asdf', true],
-                ['http://localhost:42/asdf?qwer=zxcv', true],
-                ['HTTP://www.example.com/', true],
-                ['HTTP://www.example.com', true],
-                ['http://www.ExAmPlE.com/', true],
-                ['http://user:pw@www.ExAmPlE.com/', true],
-                ['http://USER:PW@www.ExAmPlE.com/', true],
-                ['http://user@www.example.com/', true],
-                ['http://user%3Apw@www.example.com/', true],
-                ['http://x.com/path?that%27s#all,%20folks', true],
-                ['HTTP://X.COM/Y', true],
-                ['http://www.narwhaljs.org/blog/categories?id=news', true],
-                ['http://mt0.google.com/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s=', true],
-                ['http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=', true],
-                ['http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=', true],
-                ['http://_jabber._tcp.google.com:80/test', true],
-                ['http://user:pass@_jabber._tcp.google.com:80/test', true],
-                ['http://[fe80::1]/a/b?a=b#abc', true],
-                ['http://user:password@[3ffe:2a00:100:7031::1]:8080', true],
-                ['coap://[1080:0:0:0:8:800:200C:417A]:61616/', true],
-                ['git+http://github.com/joyent/node.git', true],
-                ['http://bucket_name.s3.amazonaws.com/image.jpg', true],
-                ['dot.test://foo/bar', true],
-                ['svn+ssh://foo/bar', true],
-                ['dash-test://foo/bar', true],
-                ['xmpp:isaacschlueter@jabber.org', true],
-                ['http://atpass:foo%40bar@127.0.0.1:8080/path?search=foo#bar', true],
-                ['javascript:alert(\'hello\');', true], // eslint-disable-line no-script-url
-                ['file://localhost/etc/node/', true],
-                ['file:///etc/node/', true],
-                ['http://USER:PW@www.ExAmPlE.com/', true],
-                ['mailto:local1@domain1?query1', true],
-                ['http://example/a/b?c/../d', true],
-                ['http://example/x%2Fabc', true],
-                ['http://a/b/c/d;p=1/g;x=1/y', true],
-                ['http://a/b/c/g#s/../x', true],
-                ['http://a/b/c/.foo', true],
-                ['http://example.com/b//c//d;p?q#blarg', true],
-                ['g:h', true],
-                ['http://a/b/c/g', true],
-                ['http://a/b/c/g/', true],
-                ['http://a/g', true],
-                ['http://g', true],
-                ['http://a/b/c/d;p?y', true],
-                ['http://a/b/c/g?y', true],
-                ['http://a/b/c/d;p?q#s', true],
-                ['http://a/b/c/g#s', true],
-                ['http://a/b/c/g?y#s', true],
-                ['http://a/b/c/;x', true],
-                ['http://a/b/c/g;x', true],
-                ['http://a/b/c/g;x?y#s', true],
-                ['http://a/b/c/d;p?q', true],
-                ['http://a/b/c/', true],
-                ['http://a/b/', true],
-                ['http://a/b/g', true],
-                ['http://a/', true],
-                ['http://a/g', true],
-                ['http://a/g', true],
-                ['file:/asda', true],
-                ['qwerty', false],
-                ['invalid uri', false],
-                ['1http://google.com', false],
-                ['http://testdomain`,.<>/?\'";{}][++\\|~!@#$%^&*().org', false],
-                ['', false],
-                ['(╯°□°)╯︵ ┻━┻', false],
-                ['one/two/three?value=abc&value2=123#david-rules', false],
-                ['//username:password@test.example.com/one/two/three?value=abc&value2=123#david-rules', false],
-                ['http://a\r" \t\n<\'b:b@c\r\nd/e?f', false]
-            ], done);
-        });
-
-        it('validates uri with a single scheme provided', (done) => {
-
-            const schema = Joi.string().uri({
-                scheme: 'http'
-            });
-
-            Helper.validate(schema, [
-                ['http://google.com', true],
-                ['https://google.com', false],
-                ['ftp://google.com', false],
-                ['file:/asdf', false],
-                ['/path?query=value#hash', false]
-            ], done);
-        });
-
-        it('validates uri with a single regex scheme provided', (done) => {
-
-            const schema = Joi.string().uri({
-                scheme: /https?/
-            });
-
-            Helper.validate(schema, [
-                ['http://google.com', true],
-                ['https://google.com', true],
-                ['ftp://google.com', false],
-                ['file:/asdf', false],
-                ['/path?query=value#hash', false]
-            ], done);
-        });
-
-        it('validates uri with multiple schemes provided', (done) => {
-
-            const schema = Joi.string().uri({
-                scheme: [/https?/, 'ftp', 'file', 'git+http']
-            });
-
-            Helper.validate(schema, [
-                ['http://google.com', true],
-                ['https://google.com', true],
-                ['ftp://google.com', true],
-                ['file:/asdf', true],
-                ['git+http://github.com/hapijs/joi', true],
-                ['/path?query=value#hash', false]
-            ], done);
-        });
-
-        it('validates uri with a friendly error message', (done) => {
-
-            const schema = { item: Joi.string().uri() };
-
-            Joi.compile(schema).validate({ item: 'something invalid' }, (err, value) => {
-
-                expect(err.message).to.contain('must be a valid uri');
-                done();
-            });
-        });
-
-        it('validates uri with a custom scheme with a friendly error message', (done) => {
-
-            const schema = {
-                item: Joi.string().uri({
-                    scheme: 'http'
-                })
-            };
-
-            Joi.compile(schema).validate({ item: 'something invalid' }, (err, value) => {
-
-                expect(err.message).to.contain('must be a valid uri with a scheme matching the http pattern');
-                done();
-            });
-        });
-
-        it('validates uri with a custom array of schemes with a friendly error message', (done) => {
+        it('validates combination of min, max, alphanum, and regex', (done) => {
 
-            const schema = {
-                item: Joi.string().uri({
-                    scheme: ['http', /https?/]
-                })
-            };
+            const rule = Joi.string().min(2).max(3).alphanum().regex(/^a/);
+            Helper.validate(rule, [
+                ['x', false],
+                ['123', false],
+                ['1234', false],
+                ['12', false],
+                ['ab', true],
+                ['abc', true],
+                ['a2c', true],
+                ['abcd', false],
+                ['*ab', false],
+                ['', false],
+                [null, false]
+            ], done);
+        });
 
-            Joi.compile(schema).validate({ item: 'something invalid' }, (err, value) => {
+        it('validates combination of min, max, alphanum, required, and regex', (done) => {
 
-                expect(err.message).to.contain('must be a valid uri with a scheme matching the http|https? pattern');
-                done();
-            });
+            const rule = Joi.string().min(2).max(3).alphanum().required().regex(/^a/);
+            Helper.validate(rule, [
+                ['x', false],
+                ['123', false],
+                ['1234', false],
+                ['12', false],
+                ['ab', true],
+                ['abc', true],
+                ['a2c', true],
+                ['abcd', false],
+                ['*ab', false],
+                ['', false],
+                [null, false]
+            ], done);
         });
 
-        it('validates uri treats scheme as optional', (done) => {
+        it('validates combination of min, max, alphanum, allow(\'\'), and regex', (done) => {
 
-            expect(() => {
+            const rule = Joi.string().min(2).max(3).alphanum().allow('').regex(/^a/);
+            Helper.validate(rule, [
+                ['x', false],
+                ['123', false],
+                ['1234', false],
+                ['12', false],
+                ['ab', true],
+                ['abc', true],
+                ['a2c', true],
+                ['abcd', false],
+                ['*ab', false],
+                ['', true],
+                [null, false]
+            ], done);
+        });
 
-                Joi.string().uri({});
-            }).to.not.throw();
+        it('validates combination of email and min', (done) => {
 
-            done();
+            const rule = Joi.string().email().min(8);
+            Helper.validate(rule, [
+                ['x@x.com', false],
+                ['123@x.com', true],
+                ['', false],
+                [null, false]
+            ], done);
         });
 
-        it('validates uri requires uriOptions as an object with a friendly error message', (done) => {
+        it('validates combination of email, min, and max', (done) => {
 
-            expect(() => {
+            const rule = Joi.string().email().min(8).max(10);
+            Helper.validate(rule, [
+                ['x@x.com', false],
+                ['123@x.com', true],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', false],
+                [null, false]
+            ], done);
+        });
 
-                Joi.string().uri('http');
-            }).to.throw(Error, 'options must be an object');
+        it('validates combination of email, min, max, and invalid', (done) => {
 
-            done();
+            const rule = Joi.string().email().min(8).max(10).invalid('123@x.com');
+            Helper.validate(rule, [
+                ['x@x.com', false],
+                ['123@x.com', false],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', false],
+                [null, false]
+            ], done);
         });
 
-        it('validates uri requires scheme to be a RegExp, String, or Array with a friendly error message', (done) => {
+        it('validates combination of email, min, max, and allow', (done) => {
 
-            expect(() => {
+            const rule = Joi.string().email().min(8).max(10).allow('x@x.com');
+            Helper.validate(rule, [
+                ['x@x.com', true],
+                ['123@x.com', true],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', false],
+                [null, false]
+            ], done);
+        });
 
-                Joi.string().uri({
-                    scheme: {}
-                });
-            }).to.throw(Error, 'scheme must be a RegExp, String, or Array');
+        it('validates combination of email, min, max, allow, and invalid', (done) => {
 
-            done();
+            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com');
+            Helper.validate(rule, [
+                ['x@x.com', true],
+                ['123@x.com', false],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', false],
+                [null, false]
+            ], done);
         });
 
-        it('validates uri requires scheme to not be an empty array', (done) => {
+        it('validates combination of email, min, max, allow, invalid, and allow(\'\')', (done) => {
 
-            expect(() => {
+            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').allow('');
+            Helper.validate(rule, [
+                ['x@x.com', true],
+                ['123@x.com', false],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', true],
+                [null, false]
+            ], done);
+        });
 
-                Joi.string().uri({
-                    scheme: []
-                });
-            }).to.throw(Error, 'scheme must have at least 1 scheme specified');
+        it('validates combination of email, min, max, allow, and allow(\'\')', (done) => {
 
-            done();
+            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').allow('');
+            Helper.validate(rule, [
+                ['x@x.com', true],
+                ['123@x.com', true],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', true],
+                [null, false]
+            ], done);
         });
 
-        it('validates uri requires scheme to be an Array of schemes to all be valid schemes with a friendly error message', (done) => {
+        it('validates combination of email, min, max, allow, invalid, and regex', (done) => {
 
-            expect(() => {
+            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').regex(/^1/);
+            Helper.validate(rule, [
+                ['x@x.com', true],
+                ['123@x.com', false],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', false],
+                [null, false]
+            ], done);
+        });
 
-                Joi.string().uri({
-                    scheme: [
-                        'http',
-                        '~!@#$%^&*()_'
-                    ]
-                });
-            }).to.throw(Error, 'scheme at position 1 must be a valid scheme');
+        it('validates combination of email, min, max, allow, invalid, regex, and allow(\'\')', (done) => {
 
-            done();
+            const rule = Joi.string().email().min(8).max(10).allow('x@x.com').invalid('123@x.com').regex(/^1/).allow('');
+            Helper.validate(rule, [
+                ['x@x.com', true],
+                ['123@x.com', false],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', true],
+                [null, false]
+            ], done);
         });
 
-        it('validates uri requires scheme to be an Array of schemes to be strings or RegExp', (done) => {
+        it('validates combination of email, min, max, and allow(\'\')', (done) => {
 
-            expect(() => {
+            const rule = Joi.string().email().min(8).max(10).allow('');
+            Helper.validate(rule, [
+                ['x@x.com', false],
+                ['123@x.com', true],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', true],
+                [null, false]
+            ], done);
+        });
 
-                Joi.string().uri({
-                    scheme: [
-                        'http',
-                        {}
-                    ]
-                });
-            }).to.throw(Error, 'scheme at position 1 must be a RegExp or String');
+        it('validates combination of email, min, max, and regex', (done) => {
 
-            done();
+            const rule = Joi.string().email().min(8).max(10).regex(/^1234/);
+            Helper.validate(rule, [
+                ['x@x.com', false],
+                ['123@x.com', false],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', false],
+                [null, false]
+            ], done);
         });
 
-        it('validates uri requires scheme to be a valid String scheme with a friendly error message', (done) => {
+        it('validates combination of email, min, max, regex, and allow(\'\')', (done) => {
 
-            expect(() => {
+            const rule = Joi.string().email().min(8).max(10).regex(/^1234/).allow('');
+            Helper.validate(rule, [
+                ['x@x.com', false],
+                ['123@x.com', false],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', true],
+                [null, false]
+            ], done);
+        });
 
-                Joi.string().uri({
-                    scheme: '~!@#$%^&*()_'
-                });
-            }).to.throw(Error, 'scheme at position 0 must be a valid scheme');
+        it('validates combination of email, min, max, regex, and required', (done) => {
 
-            done();
+            const rule = Joi.string().email().min(8).max(10).regex(/^1234/).required();
+            Helper.validate(rule, [
+                ['x@x.com', false],
+                ['123@x.com', false],
+                ['1234@x.com', true],
+                ['12345@x.com', false],
+                ['', false],
+                [null, false]
+            ], done);
         });
 
         it('validates isoDate', (done) => {
@@ -3042,5 +3114,28 @@ describe('string', () => {
                 ['123afg', false, null, '"value" must only contain hexadecimal characters']
             ], done);
         });
+
+        it('validates combination of uppercase, min, max, alphanum and valid', (done) => {
+
+            const rule = Joi.string().uppercase().min(2).max(3).alphanum().valid('AB', 'BC');
+            Helper.validate(rule, [
+                ['x', false],
+                ['123', false],
+                ['1234', false],
+                ['12', false],
+                ['ab', true],
+                ['abc', false],
+                ['a2c', false],
+                ['abcd', false],
+                ['*ab', false],
+                ['', false],
+                ['bc', true],
+                ['BC', true],
+                ['de', false],
+                ['ABc', false],
+                ['AB', true],
+                [null, false]
+            ], done);
+        });
     });
 });