template: Show all validation errors

Also parse validation errors to provide a more user-friendly message.

Author: mstokes-f5

lib/template.js

@@ -733,7 +733,8 @@ class Template {
         const ajv = new Ajv({
             loadSchema,
             unknownFormats: 'ignore',
-            useDefaults: true
+            useDefaults: true,
+            allErrors: true
         });
         ajv.addFormat('text', /.*/);
         ajv.addFormat('hidden', /.*/);
@@ -1067,6 +1068,28 @@ class Template {
         return Object.assign(defaults, mathExprResults);
     }
 
+    _parseValidationErrors(errors) {
+        return errors.map((error) => {
+            const param = error.dataPath
+                .replace('.', ''); // strip leading dot
+            let message = (param !== '') ? `parameter ${param} ${error.message}` : error.message;
+
+            if (error.keyword === 'type') {
+                const typeStr = error.params.type;
+                message = `parameter ${param} should be of type ${typeStr}`;
+            }
+
+            if (error.keyword === 'enum') {
+                const allowedValues = error.params.allowedValues;
+                message = `${message}: ${allowedValues.join(', ')}`;
+            }
+
+            return {
+                message
+            };
+        });
+    }
+
     /**
      * Validate the supplied parameters object against the template's parameter schema
      *
@@ -1075,7 +1098,7 @@ class Template {
     validateParameters(parameters) {
         const combParams = this.getCombinedParameters(parameters);
         if (!this._parametersValidator(combParams)) {
-            const validationErrors = this._parametersValidator.errors;
+            const validationErrors = this._parseValidationErrors(this._parametersValidator.errors);
             const err = Error('paramters failed validation');
             err.validationErrors = validationErrors;
             err.parameters = combParams;

test/template.js

@@ -1318,4 +1318,122 @@ describe('Template class tests', function () {
                 assert.strictEqual(rendered, reference);
             });
     });
+    it('validate_bad_type', function () {
+        const yamldata = `
+            parameters:
+                foo: 1
+                fooArray: [1, 2]
+                fooEnum: baz
+            definitions:
+                fooArray:
+                    type: array
+                    items:
+                        type: string
+                fooEnum:
+                    type: string
+                    enum:
+                        - foo
+                        - bar
+            template: |-
+                {{foo}}{{fooArray}}{{fooEnum}}
+        `;
+
+        return Template.loadYaml(yamldata)
+            .then((tmpl) => {
+                assert.throws(() => tmpl.validateParameters(), {
+                    validationErrors: [
+                        {
+                            message: 'parameter fooArray[0] should be of type string'
+                        },
+                        {
+                            message: 'parameter fooArray[1] should be of type string'
+                        },
+                        {
+                            message: 'parameter fooEnum should be equal to one of the allowed values: foo, bar'
+                        },
+                        {
+                            message: 'parameter foo should be of type string'
+                        }
+                    ]
+                });
+            });
+    });
+    it('validate_bad_min_max', function () {
+        const yamldata = `
+            parameters:
+                minval: 1
+                maxval: 10
+                minlength: too short
+                maxlength: too long
+                minitems: []
+                maxitems: [1, 2]
+            definitions:
+                minval:
+                    type: number
+                    minimum: 2
+                maxval:
+                    type: number
+                    maximum: 1
+                minlength:
+                    type: string
+                    minLength: 10
+                maxlength:
+                    type: string
+                    maxLength: 1
+                minitems:
+                    type: array
+                    minItems: 1
+                maxitems:
+                    type: array
+                    maxItems: 1
+            template: |-
+                {{minval}}{{maxval}}{{minlength}}{{maxlength}}
+                {{minitems}}{{maxitems}}
+        `;
+
+        return Template.loadYaml(yamldata)
+            .then((tmpl) => {
+                console.log(tmpl.getParametersSchema());
+                assert.throws(() => tmpl.validateParameters(), {
+                    validationErrors: [
+                        {
+                            message: 'parameter minval should be >= 2'
+                        },
+                        {
+                            message: 'parameter maxval should be <= 1'
+                        },
+                        {
+                            message: 'parameter minlength should NOT be shorter than 10 characters'
+                        },
+                        {
+                            message: 'parameter maxlength should NOT be longer than 1 characters'
+                        },
+                        {
+                            message: 'parameter minitems should NOT have fewer than 1 items'
+                        },
+                        {
+                            message: 'parameter maxitems should NOT have more than 1 items'
+                        }
+                    ]
+                });
+            });
+    });
+    it('validate_missing_required', function () {
+        const yamldata = `
+            parameters:
+            template: |-
+                {{foo}}
+        `;
+
+        return Template.loadYaml(yamldata)
+            .then((tmpl) => {
+                assert.throws(() => tmpl.validateParameters(), {
+                    validationErrors: [
+                        {
+                            message: "should have required property 'foo'"
+                        }
+                    ]
+                });
+            });
+    });
 });