joi 6.8.1 → 6.10.1

package/.travis.yml

@@ -4,5 +4,6 @@ node_js:
   - "0.10"
   - "4.0"
   - "4"
+  - "5"
 
 sudo: false

package/API.md

@@ -1,5 +1,5 @@
 <!-- version -->
-# 6.8.1 API Reference
+# 6.10.1 API Reference
 <!-- versionstop -->
 
 <img src="https://raw.github.com/hapijs/joi/master/images/validation.png" align="right" />
@@ -38,6 +38,7 @@
     - [`array.sparse(enabled)`](#arraysparseenabled)
     - [`array.single(enabled)`](#arraysingleenabled)
     - [`array.items(type)`](#arrayitemstype)
+    - [`array.ordered(type)`](#arrayorderedtype)
     - [`array.min(limit)`](#arrayminlimit)
     - [`array.max(limit)`](#arraymaxlimit)
     - [`array.length(limit)`](#arraylengthlimit)
@@ -109,6 +110,7 @@
     - [`alternatives.try(schemas)`](#alternativestryschemas)
     - [`alternatives.when(ref, options)`](#alternativeswhenref-options)
   - [`ref(key, [options])`](#refkey-options)
+- [Errors](#errors)
 
 <!-- tocstop -->
 
@@ -132,9 +134,9 @@ Validates a value using the given schema and options where:
     `validate()` and not using `any.options()`.
   - `noDefaults` - when `true`, do not apply default values. Defaults to `false`.
 - `callback` - the optional synchronous callback method using the signature `function(err, value)` where:
-  - `err` - if validation failed, the error reason, otherwise `null`.
+  - `err` - if validation failed, the [error](#errors) reason, otherwise `null`.
   - `value` - the validated value with any type conversions and other modifiers applied (the input is left unchanged). `value` can be
-    incomplete if validation failed and `abortEarly` is `true`. If callback is not provided, then returns an object with error
+    incomplete if validation failed and `abortEarly` is `true`. If callback is not provided, then returns an object with [error](#errors)
     and value properties.
 
 ```javascript
@@ -182,7 +184,7 @@ var schema = Joi.alternatives().try([
 
 ### `assert(value, schema, [message])`
 
-Validates a value against a schema and throws if validation fails where:
+Validates a value against a schema and [throws](#errors) if validation fails where:
 - `value` - the value to validate.
 - `schema` - the schema object.
 - `message` - optional message string prefix added in front of the error message. may also be an Error object.
@@ -193,7 +195,7 @@ Joi.assert('x', Joi.number());
 
 ### `attempt(value, schema, [message])`
 
-Validates a value against a schema, returns valid object, and throws if validation fails where:
+Validates a value against a schema, returns valid object, and [throws](#errors) if validation fails where:
 - `value` - the value to validate.
 - `schema` - the schema object.
 - `message` - optional message string prefix added in front of the error message. may also be an Error object.
@@ -547,6 +549,20 @@ var schema = Joi.array().items(Joi.string().valid('not allowed').forbidden(), Jo
 var schema = Joi.array().items(Joi.string().label('My string').required(), Joi.number().required()); // If this fails it can result in `[ValidationError: "value" does not contain [My string] and 1 other required value(s)]`
 ```
 
+#### `array.ordered(type)`
+
+List the types in sequence order for the array values where:
+- `type` - a **joi** schema object to validate against each array item in sequence order. `type` can be an array of values, or multiple values can be passed as individual arguments.
+
+If a given type is `.required()` then there must be a matching item with the same index position in the array.
+Errors will contain the number of items that didn't match. Any unmatched item having a [label](#anylabelname) will be mentioned explicitly.
+
+```javascript
+var schema = Joi.array().ordered(Joi.string().required(), Joi.number().required()); // array must have first item as string and second item as number
+var schema = Joi.array().ordered(Joi.string().required()).items(Joi.number().required()); // array must have first item as string and 1 or more subsequent items as number
+var schema = Joi.array().ordered(Joi.string().required(), Joi.number()); // array must have first item as string and optionally second item as number
+```
+
 #### `array.min(limit)`
 
 Specifies the minimum number of items in the array where:
@@ -1484,4 +1500,16 @@ var schema = Joi.object().keys({
 });
 
 Joi.validate({ a: 5, b: { c: 5 } }, schema, { context: { x: 5 } }, function (err, value) {});
-```
+```
+
+## Errors
+
+Joi throws classical javascript `Error`s containing :
+- `name` - `ValidationError`.
+- `details` - an array of errors :
+    - `message` - string with a description of the error.
+    - `path` - dotted path to the key where the error happened.
+    - `type` - type of the error.
+    - `context` - object providing context of the error.
+- `annotate` - function that returns a string with an annotated version of the object pointing at the places where errors occured.
+- `_object` - the original object to validate.

package/lib/any.js

@@ -256,6 +256,8 @@ internals.Any.prototype._allow = function () {
     var values = Hoek.flatten(Array.prototype.slice.call(arguments));
     for (var i = 0, il = values.length; i < il; ++i) {
         var value = values[i];
+
+        Hoek.assert(value !== undefined, 'Cannot call allow/valid/invalid with undefined');
         this._invalids.remove(value);
         this._valids.add(value, this._refs);
     }
@@ -286,6 +288,8 @@ internals.Any.prototype.invalid = internals.Any.prototype.disallow = internals.A
     var values = Hoek.flatten(Array.prototype.slice.call(arguments));
     for (var i = 0, il = values.length; i < il; ++i) {
         value = values[i];
+
+        Hoek.assert(value !== undefined, 'Cannot call allow/valid/invalid with undefined');
         obj._valids.remove(value);
         obj._invalids.add(value, this._refs);
     }
@@ -526,7 +530,7 @@ internals.Any.prototype._validate = function (value, state, options, reference)
                 }
             }
             else {
-                finalValue = self._flags.default;
+                finalValue = Hoek.clone(self._flags.default);
             }
         }
 

package/lib/array.js

@@ -29,6 +29,7 @@ internals.Array = function () {
     Any.call(this);
     this._type = 'array';
     this._inner.items = [];
+    this._inner.ordereds = [];
     this._inner.inclusions = [];
     this._inner.exclusions = [];
     this._inner.requireds = [];
@@ -106,6 +107,7 @@ internals.checkItems = function (items, wasArray, state, options) {
     var errored;
 
     var requireds = this._inner.requireds.slice();
+    var ordereds = this._inner.ordereds.slice();
     var inclusions = this._inner.inclusions.concat(requireds);
 
     for (var v = 0, vl = items.length; v < vl; ++v) {
@@ -131,6 +133,7 @@ internals.checkItems = function (items, wasArray, state, options) {
 
         for (var i = 0, il = this._inner.exclusions.length; i < il; ++i) {
             res = this._inner.exclusions[i]._validate(item, localState, {});                // Not passing options to use defaults
+
             if (!res.errors) {
                 errors.push(Errors.create(wasArray ? 'array.excludes' : 'array.excludesSingle', { pos: v, value: item }, { key: state.key, path: localState.path }, options));
                 errored = true;
@@ -147,6 +150,38 @@ internals.checkItems = function (items, wasArray, state, options) {
             continue;
         }
 
+        // Ordered
+        if (this._inner.ordereds.length) {
+            if (ordereds.length > 0) {
+                var ordered = ordereds.shift();
+                res = ordered._validate(item, localState, options);
+                if (!res.errors) {
+                    if (ordered._flags.strip) {
+                        internals.fastSplice(items, v);
+                        --v;
+                        --vl;
+                    }
+                    else {
+                        items[v] = res.value;
+                    }
+                }
+                else {
+                    errors.push(Errors.create('array.ordered', { pos: v, reason: res.errors, value: item }, { key: state.key, path: localState.path }, options));
+                    if (options.abortEarly) {
+                        return errors;
+                    }
+                }
+                continue;
+            }
+            else if (!this._inner.items.length) {
+                errors.push(Errors.create('array.orderedLength', { pos: v, limit: this._inner.ordereds.length }, { key: state.key, path: localState.path }, options));
+                if (options.abortEarly) {
+                    return errors;
+                }
+                continue;
+            }
+        }
+
         // Requireds
 
         var requiredChecks = [];
@@ -238,10 +273,13 @@ internals.checkItems = function (items, wasArray, state, options) {
         internals.fillMissedErrors(errors, requireds, state, options);
     }
 
+    if (ordereds.length) {
+        internals.fillOrderedErrors(errors, ordereds, state, options);
+    }
+
     return errors.length ? errors : null;
 };
 
-
 internals.fillMissedErrors = function (errors, requireds, state, options) {
 
     var knownMisses = [];
@@ -269,11 +307,34 @@ internals.fillMissedErrors = function (errors, requireds, state, options) {
     }
 };
 
+internals.fillOrderedErrors = function (errors, ordereds, state, options) {
+
+    var requiredOrdereds = [];
+
+    for (var i = 0, il = ordereds.length; i < il; ++i) {
+        var presence = Hoek.reach(ordereds[i], '_flags.presence');
+        if (presence === 'required') {
+            requiredOrdereds.push(ordereds[i]);
+        }
+    }
+
+    if (requiredOrdereds.length) {
+        internals.fillMissedErrors(errors, requiredOrdereds, state, options);
+    }
+};
 
 internals.Array.prototype.describe = function () {
 
     var description = Any.prototype.describe.call(this);
 
+    if (this._inner.ordereds.length) {
+        description.orderedItems = [];
+
+        for (var o = 0, ol = this._inner.ordereds.length; o < ol; ++o) {
+            description.orderedItems.push(this._inner.ordereds[o].describe());
+        }
+    }
+
     if (this._inner.items.length) {
         description.items = [];
 
@@ -290,9 +351,22 @@ internals.Array.prototype.items = function () {
 
     var obj = this.clone();
 
-    Hoek.flatten(Array.prototype.slice.call(arguments)).forEach(function (type) {
+    Hoek.flatten(Array.prototype.slice.call(arguments)).forEach(function (type, index) {
+
+        try {
+            type = Cast.schema(type);
+        }
+        catch (castErr) {
+            if (castErr.hasOwnProperty('path')) {
+                castErr.path = index + '.' + castErr.path;
+            }
+            else {
+                castErr.path = index;
+            }
+            castErr.message += '(' + castErr.path + ')';
+            throw castErr;
+        }
 
-        type = Cast.schema(type);
         obj._inner.items.push(type);
 
         if (type._flags.presence === 'required') {
@@ -310,6 +384,32 @@ internals.Array.prototype.items = function () {
 };
 
 
+internals.Array.prototype.ordered = function () {
+
+    var obj = this.clone();
+
+    Hoek.flatten(Array.prototype.slice.call(arguments)).forEach(function (type, index) {
+
+        try {
+            type = Cast.schema(type);
+        }
+        catch (castErr) {
+            if (castErr.hasOwnProperty('path')) {
+                castErr.path = index + '.' + castErr.path;
+            }
+            else {
+                castErr.path = index;
+            }
+            castErr.message += '(' + castErr.path + ')';
+            throw castErr;
+        }
+        obj._inner.ordereds.push(type);
+    });
+
+    return obj;
+};
+
+
 internals.Array.prototype.min = function (limit) {
 
     Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');

package/lib/index.js

@@ -95,20 +95,28 @@ internals.root = function () {
         }
 
         var options = count === 3 ? arguments[2] : {};
-        var schema = Cast.schema(arguments[1]);
+        var schema = root.compile(arguments[1]);
 
         return schema._validateWithOptions(value, options, callback);
     };
 
     root.describe = function () {
 
-        var schema = arguments.length ? Cast.schema(arguments[0]) : any;
+        var schema = arguments.length ? root.compile(arguments[0]) : any;
         return schema.describe();
     };
 
     root.compile = function (schema) {
 
-        return Cast.schema(schema);
+        try {
+            return Cast.schema(schema);
+        }
+        catch (err) {
+            if (err.hasOwnProperty('path')) {
+                err.message += '(' + err.path + ')';
+            }
+            throw err;
+        }
     };
 
     root.assert = function (value, schema, message) {
@@ -122,11 +130,13 @@ internals.root = function () {
         var error = result.error;
         if (error) {
             if (!message) {
-                throw new Error(error.annotate());
+                error.message = error.annotate();
+                throw error;
             }
 
             if (!(message instanceof Error)) {
-                throw new Error(message + ' ' + error.annotate());
+                error.message = message + ' ' + error.annotate();
+                throw error;
             }
 
             throw message;

package/lib/language.js

@@ -37,6 +37,8 @@ exports.errors = {
         min: 'must contain at least {{limit}} items',
         max: 'must contain less than or equal to {{limit}} items',
         length: 'must contain {{limit}} items',
+        ordered: 'at position {{pos}} fails because {{reason}}',
+        orderedLength: 'at position {{pos}} fails because array must contain at most {{limit}} items',
         sparse: 'must not be a sparse array',
         unique: 'position {{pos}} contains a duplicate value'
     },

package/lib/object.js

@@ -231,7 +231,7 @@ internals.Object.prototype._base = function (value, state, options) {
             (this._flags.allowUnknown !== undefined ? !this._flags.allowUnknown : !options.allowUnknown)) {
 
             for (var e = 0, el = unprocessedKeys.length; e < el; ++e) {
-                errors.push(Errors.create('object.allowUnknown', null, { key: unprocessedKeys[e], path: state.path + '.' + unprocessedKeys[e] }, options));
+                errors.push(Errors.create('object.allowUnknown', null, { key: unprocessedKeys[e], path: state.path + (state.path ? '.' : '') + unprocessedKeys[e] }, options));
             }
         }
     }
@@ -296,8 +296,19 @@ internals.Object.prototype.keys = function (schema) {
     for (var c = 0, cl = children.length; c < cl; ++c) {
         var key = children[c];
         child = schema[key];
-        var cast = Cast.schema(child);
-        topo.add({ key: key, schema: cast }, { after: cast._refs, group: key });
+        try {
+            var cast = Cast.schema(child);
+            topo.add({ key: key, schema: cast }, { after: cast._refs, group: key });
+        }
+        catch (castErr) {
+            if (castErr.hasOwnProperty('path')) {
+                castErr.path = key + '.' + castErr.path;
+            }
+            else {
+                castErr.path = key;
+            }
+            throw castErr;
+        }
     }
 
     obj._inner.children = topo.nodes;
@@ -366,8 +377,20 @@ internals.Object.prototype.pattern = function (pattern, schema) {
 
     pattern = new RegExp(pattern.source, pattern.ignoreCase ? 'i' : undefined);         // Future version should break this and forbid unsupported regex flags
 
+    try {
+        schema = Cast.schema(schema);
+    }
+    catch (castErr) {
+        if (castErr.hasOwnProperty('path')) {
+            castErr.message += '(' + castErr.path + ')';
+        }
+
+        throw castErr;
+    }
+
+
     var obj = this.clone();
-    obj._inner.patterns.push({ regex: pattern, rule: Cast.schema(schema) });
+    obj._inner.patterns.push({ regex: pattern, rule: schema });
     return obj;
 };
 
@@ -682,7 +705,18 @@ internals.Object.prototype.assert = function (ref, schema, message) {
     Hoek.assert(ref.isContext || ref.depth > 1, 'Cannot use assertions for root level references - use direct key rules instead');
     message = message || 'pass the assertion test';
 
-    var cast = Cast.schema(schema);
+    var cast;
+    try {
+        cast = Cast.schema(schema);
+    }
+    catch (castErr) {
+        if (castErr.hasOwnProperty('path')) {
+            castErr.message += '(' + castErr.path + ')';
+        }
+
+        throw castErr;
+    }
+
     var key = ref.path[ref.path.length - 1];
     var path = ref.path.join('.');
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "joi",
   "description": "Object schema validation",
-  "version": "6.8.1",
+  "version": "6.10.1",
   "repository": "git://github.com/hapijs/joi",
   "main": "lib/index.js",
   "keywords": [

package/test/any.js

@@ -552,6 +552,31 @@ describe('any', function () {
             ], done);
         });
 
+        it('should set default value as a clone', function (done) {
+
+            var defaultValue = { bar: 'val' };
+            var schema = Joi.object({ foo: Joi.object().default(defaultValue) });
+            var input = {};
+
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value.foo).to.not.equal(defaultValue);
+                expect(value.foo).to.only.deep.include({ bar: 'val' });
+
+                value.foo.bar = 'mutated';
+
+                schema.validate(input, function (err2, value2) {
+
+                    expect(err2).to.not.exist();
+                    expect(value2.foo).to.not.equal(defaultValue);
+                    expect(value2.foo).to.only.deep.include({ bar: 'val' });
+
+                    done();
+                });
+            });
+        });
+
         it('should not apply default values if the noDefaults option is enquire', function (done) {
 
             var schema = Joi.object({
@@ -1497,8 +1522,72 @@ describe('any', function () {
 
             it('strips undefined', function (done) {
 
-                var b = Joi.any().allow(undefined);
-                expect(b._valids.values({ stripUndefined: true })).to.not.include(undefined);
+                var any = Joi.any().clone();
+                any._valids.add(undefined);
+                expect(any._valids.values({ stripUndefined: true })).to.not.include(undefined);
+                done();
+            });
+        });
+
+        describe('#allow', function () {
+
+            it('allows valid values to be set', function (done) {
+
+                expect(function () {
+
+                    Joi.any().allow(true, 1, 'hello', new Date());
+                }).not.to.throw();
+                done();
+            });
+
+            it('throws when passed undefined', function (done) {
+
+                expect(function () {
+
+                    Joi.any().allow(undefined);
+                }).to.throw(Error, 'Cannot call allow/valid/invalid with undefined');
+                done();
+            });
+        });
+
+        describe('#valid', function () {
+
+            it('allows valid values to be set', function (done) {
+
+                expect(function () {
+
+                    Joi.any().valid(true, 1, 'hello', new Date());
+                }).not.to.throw();
+                done();
+            });
+
+            it('throws when passed undefined', function (done) {
+
+                expect(function () {
+
+                    Joi.any().valid(undefined);
+                }).to.throw(Error, 'Cannot call allow/valid/invalid with undefined');
+                done();
+            });
+        });
+
+        describe('#invalid', function () {
+
+            it('allows invalid values to be set', function (done) {
+
+                expect(function () {
+
+                    Joi.any().valid(true, 1, 'hello', new Date());
+                }).not.to.throw();
+                done();
+            });
+
+            it('throws when passed undefined', function (done) {
+
+                expect(function () {
+
+                    Joi.any().invalid(undefined);
+                }).to.throw('Cannot call allow/valid/invalid with undefined');
                 done();
             });
         });

package/test/array.js

@@ -85,6 +85,29 @@ describe('array', function () {
             });
         });
 
+        it('shows path to errors in array items', function (done) {
+
+            expect(function () {
+
+                Joi.array().items({
+                    a: {
+                        b: {
+                            c: {
+                                d: undefined
+                            }
+                        }
+                    }
+                });
+            }).to.throw(Error, 'Invalid schema content: (0.a.b.c.d)');
+
+            expect(function () {
+
+                Joi.array().items({ foo: 'bar' }, undefined);
+            }).to.throw(Error, 'Invalid schema content: (1)');
+
+            done();
+        });
+
         it('allows zero size', function (done) {
 
             var schema = Joi.object({
@@ -569,7 +592,7 @@ describe('array', function () {
             done();
         });
 
-        it('returns an includes array only if includes are specified', function (done) {
+        it('returns an items array only if items are specified', function (done) {
 
             var schema = Joi.array().items().max(5);
             var desc = schema.describe();
@@ -577,14 +600,19 @@ describe('array', function () {
             done();
         });
 
-        it('returns a recursively defined array of includes when specified', function (done) {
+        it('returns a recursively defined array of items when specified', function (done) {
 
-            var schema = Joi.array().items(Joi.number(), Joi.string()).items(Joi.boolean().forbidden());
+            var schema = Joi.array()
+                .items(Joi.number(), Joi.string())
+                .items(Joi.boolean().forbidden())
+                .ordered(Joi.number(), Joi.string())
+                .ordered(Joi.string().required());
             var desc = schema.describe();
             expect(desc.items).to.have.length(3);
             expect(desc).to.deep.equal({
                 type: 'array',
                 flags: { sparse: false },
+                orderedItems: [{ type: 'number', invalids: [Infinity, -Infinity] }, { type: 'string', invalids: [''] }, { type: 'string', invalids: [''], flags: { presence: 'required' } }],
                 items: [{ type: 'number', invalids: [Infinity, -Infinity] }, { type: 'string', invalids: [''] }, { type: 'boolean', flags: { presence: 'forbidden' } }]
             });
 
@@ -793,4 +821,229 @@ describe('array', function () {
             });
         });
     });
+
+    describe('#ordered', function () {
+
+        it('shows path to errors in array ordered items', function (done) {
+
+            expect(function () {
+
+                Joi.array().ordered({
+                    a: {
+                        b: {
+                            c: {
+                                d: undefined
+                            }
+                        }
+                    }
+                });
+            }).to.throw(Error, 'Invalid schema content: (0.a.b.c.d)');
+
+            expect(function () {
+
+                Joi.array().ordered({ foo: 'bar' }, undefined);
+            }).to.throw(Error, 'Invalid schema content: (1)');
+
+            done();
+        });
+
+        it('validates input against items in order', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().required(), Joi.number().required()]);
+            var input = ['s1', 2];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal(['s1', 2]);
+                done();
+            });
+        });
+
+        it('validates input with optional item', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().required(), Joi.number().required(), Joi.number()]);
+            var input = ['s1', 2, 3];
+
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal(['s1', 2, 3]);
+                done();
+            });
+        });
+
+        it('validates input without optional item', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().required(), Joi.number().required(), Joi.number()]);
+            var input = ['s1', 2];
+
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal(['s1', 2]);
+                done();
+            });
+        });
+
+        it('validates input without optional item', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().required(), Joi.number().required(), Joi.number()]).sparse(true);
+            var input = ['s1', 2, undefined];
+
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal(['s1', 2, undefined]);
+                done();
+            });
+        });
+
+        it('validates input without optional item in a sparse array', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().required(), Joi.number(), Joi.number().required()]).sparse(true);
+            var input = ['s1', undefined, 3];
+
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal(['s1', undefined, 3]);
+                done();
+            });
+        });
+
+        it('validates when input matches ordered items and matches regular items', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().required(), Joi.number().required()]).items(Joi.number());
+            var input = ['s1', 2, 3, 4, 5];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal(['s1', 2, 3, 4, 5]);
+                done();
+            });
+        });
+
+        it('errors when input does not match ordered items', function (done) {
+
+            var schema = Joi.array().ordered([Joi.number().required(), Joi.string().required()]);
+            var input = ['s1', 2];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" at position 0 fails because ["0" must be a number]');
+                done();
+            });
+        });
+
+        it('errors when input has more items than ordered items', function (done) {
+
+            var schema = Joi.array().ordered([Joi.number().required(), Joi.string().required()]);
+            var input = [1, 's2', 3];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" at position 2 fails because array must contain at most 2 items');
+                done();
+            });
+        });
+
+        it('errors when input has more items than ordered items with abortEarly = false', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string(), Joi.number()]).options({ abortEarly: false });
+            var input = [1, 2, 3, 4, 5];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" at position 0 fails because ["0" must be a string]. "value" at position 2 fails because array must contain at most 2 items. "value" at position 3 fails because array must contain at most 2 items. "value" at position 4 fails because array must contain at most 2 items');
+                expect(err.details).to.have.length(4);
+                done();
+            });
+        });
+
+        it('errors when input has less items than ordered items', function (done) {
+
+            var schema = Joi.array().ordered([Joi.number().required(), Joi.string().required()]);
+            var input = [1];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" does not contain 1 required value(s)');
+                done();
+            });
+        });
+
+        it('errors when input matches ordered items but not matches regular items', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().required(), Joi.number().required()]).items(Joi.number()).options({ abortEarly: false });
+            var input = ['s1', 2, 3, 4, 's5'];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" at position 4 fails because ["4" must be a number]');
+                done();
+            });
+        });
+
+        it('errors when input does not match ordered items but matches regular items', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string(), Joi.number()]).items(Joi.number()).options({ abortEarly: false });
+            var input = [1, 2, 3, 4, 5];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" at position 0 fails because ["0" must be a string]');
+                done();
+            });
+        });
+
+        it('errors when input does not match ordered items not matches regular items', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string(), Joi.number()]).items(Joi.string()).options({ abortEarly: false });
+            var input = [1, 2, 3, 4, 5];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" at position 0 fails because ["0" must be a string]. "value" at position 2 fails because ["2" must be a string]. "value" at position 3 fails because ["3" must be a string]. "value" at position 4 fails because ["4" must be a string]');
+                expect(err.details).to.have.length(4);
+                done();
+            });
+        });
+
+        it('errors but continues when abortEarly is set to false', function (done) {
+
+            var schema = Joi.array().ordered([Joi.number().required(), Joi.string().required()]).options({ abortEarly: false });
+            var input = ['s1', 2];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" at position 0 fails because ["0" must be a number]. "value" at position 1 fails because ["1" must be a string]');
+                expect(err.details).to.have.length(2);
+                done();
+            });
+        });
+
+        it('strips item', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().required(), Joi.number().strip(), Joi.number().required()]);
+            var input = ['s1', 2, 3];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal(['s1', 3]);
+                done();
+            });
+        });
+
+        it('strips multiple items', function (done) {
+
+            var schema = Joi.array().ordered([Joi.string().strip(), Joi.number(), Joi.number().strip()]);
+            var input = ['s1', 2, 3];
+            schema.validate(input, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal([2]);
+                done();
+            });
+        });
+    });
 });

package/test/errors.js

@@ -233,6 +233,41 @@ describe('errors', function () {
         });
     });
 
+    it('has a name that is ValidationError', function (done) {
+
+        var schema = Joi.number();
+        schema.validate('a', function (validateErr) {
+
+            expect(validateErr).to.exist();
+            expect(validateErr.name).to.be.equal('ValidationError');
+
+            try {
+                Joi.assert('a', schema);
+                throw new Error('should not reach that');
+            }
+            catch (assertErr) {
+                expect(assertErr.name).to.be.equal('ValidationError');
+            }
+
+            try {
+                Joi.assert('a', schema, 'foo');
+                throw new Error('should not reach that');
+            }
+            catch (assertErr) {
+                expect(assertErr.name).to.be.equal('ValidationError');
+            }
+
+            try {
+                Joi.assert('a', schema, new Error('foo'));
+                throw new Error('should not reach that');
+            }
+            catch (assertErr) {
+                expect(assertErr.name).to.equal('Error');
+                done();
+            }
+        });
+    });
+
     describe('#annotate', function () {
 
         it('annotates error', function (done) {
@@ -287,7 +322,7 @@ describe('errors', function () {
         it('annotates error within array multiple times on the same element', function (done) {
 
             var object = {
-                a: [2, 3 , 4]
+                a: [2, 3, 4]
             };
 
             var schema = {
@@ -323,8 +358,8 @@ describe('errors', function () {
         it('annotates error within multiple arrays and multiple times on the same element', function (done) {
 
             var object = {
-                a: [2, 3 , 4],
-                b: [2, 3 , 4]
+                a: [2, 3, 4],
+                b: [2, 3, 4]
             };
 
             var schema = {

package/test/index.js

@@ -1658,4 +1658,35 @@ describe('Joi', function () {
             done();
         });
     });
+
+    describe('#compile', function () {
+
+        it('throws an error on invalid value', function (done) {
+
+            expect(function () {
+
+                Joi.compile(undefined);
+            }).to.throw(Error, 'Invalid schema content: ');
+            done();
+        });
+
+        it('shows path to errors in object', function (done) {
+
+            var schema = {
+                a: {
+                    b: {
+                        c: {
+                            d: undefined
+                        }
+                    }
+                }
+            };
+
+            expect(function () {
+
+                Joi.compile(schema);
+            }).to.throw(Error, 'Invalid schema content: (a.b.c.d)');
+            done();
+        });
+    });
 });

package/test/object.js

@@ -362,6 +362,17 @@ describe('object', function () {
         });
     });
 
+    it('errors on unknown nested keys with the correct path at the root level', function (done) {
+
+        var schema = Joi.object({ a: Joi.object().keys({}) });
+        var obj = { c: 'hello' };
+        schema.validate(obj, function (err, value) {
+
+            expect(err).to.exist();
+            expect(err.details[0].path).to.equal('c');
+            done();
+        });
+    });
 
     it('should work on prototype-less objects', function (done) {
 
@@ -881,6 +892,31 @@ describe('object', function () {
 
     describe('#pattern', function () {
 
+        it('shows path to errors in schema', function (done) {
+
+            expect(function () {
+
+                Joi.object().pattern(/.*/, {
+                    a: {
+                        b: {
+                            c: {
+                                d: undefined
+                            }
+                        }
+                    }
+                });
+            }).to.throw(Error, 'Invalid schema content: (a.b.c.d)');
+
+            expect(function () {
+
+                Joi.object().pattern(/.*/, function () {
+
+                });
+            }).to.throw(Error, 'Invalid schema content: ');
+
+            done();
+        });
+
         it('validates unknown keys using a pattern', function (done) {
 
             var schema = Joi.object({
@@ -1081,6 +1117,32 @@ describe('object', function () {
 
     describe('#assert', function () {
 
+        it('shows path to errors in schema', function (done) {
+
+            expect(function () {
+
+                Joi.object().assert('a.b', {
+                    a: {
+                        b: {
+                            c: {
+                                d: undefined
+                            }
+                        }
+                    }
+                });
+            }).to.throw(Error, 'Invalid schema content: (a.b.c.d)');
+            done();
+        });
+
+        it('shows errors in schema', function (done) {
+
+            expect(function () {
+
+                Joi.object().assert('a.b', undefined);
+            }).to.throw(Error, 'Invalid schema content: ');
+            done();
+        });
+
         it('validates upwards reference', function (done) {
 
             var schema = Joi.object({