Fixed issue causing incorrect suggested fixes for validation

Author: Vishal Shingala

Diff for: lib/schemaUtils.js

@@ -310,7 +310,7 @@ module.exports = {
     // {{text}} will not be converted
     // https://regex101.com/r/9N1520/1
     return url
-      .replace(/(\{[^\/\{\}]+\})(?!\})/g, '{$1}');
+      .replace(/(\{[^\/\{\}]+\})/g, '{$1}');
   },
 
   /**
@@ -2810,6 +2810,43 @@ module.exports = {
     return jsonContentType;
   },
 
+  /**
+   * Converts existing JSON values of mismatch objects to serialised value based on
+   * serilasation params defined in schema.
+   *
+   * @param {Array} mismatches - Array of mismatch objects
+   * @param {Array} resolvedSchemaParams - All resolved schema params
+   * @param {Object} components - Components in the spec that the schema might refer to
+   * @param {Object} schemaCache - object storing schemaFaker and schmeResolution caches
+   * @param {Object} options - Global options
+   * @returns {Array} - Array of mismatch objects with updated value
+   */
+  convertToSerialisedValues: function (mismatches, resolvedSchemaParams, components, schemaCache, options) {
+    // fetches property name from schem path
+    let getPropNameFromSchemPath = (schemaPath) => {
+      let regex = /\.properties\[(.+)\]/gm;
+      return _.last(regex.exec(schemaPath));
+    };
+
+    return _.map(mismatches, (mismatchObj) => {
+      if (!_.isEmpty(mismatchObj)) {
+        let propertyName = getPropNameFromSchemPath(mismatchObj.schemaJsonPath),
+          schemaParam = _.find(resolvedSchemaParams, (param) => { return param.name === propertyName; }),
+          serializedParamValue;
+
+        if (schemaParam) {
+          // serialize param value (to be used in suggested value)
+          serializedParamValue = _.get(this.convertParamsWithStyle(schemaParam, _.get(mismatchObj,
+            'suggestedFix.suggestedValue'), PARAMETER_SOURCE.REQUEST, components, schemaCache, options),
+          '[0].value');
+          _.set(mismatchObj, 'suggestedFix.actualValue', schemaParam.actualValue);
+          _.set(mismatchObj, 'suggestedFix.suggestedValue', serializedParamValue);
+        }
+      }
+      return mismatchObj;
+    });
+  },
+
   /**
    *
    * @param {String} property - one of QUERYPARAM, PATHVARIABLE, HEADER, BODY, RESPONSE_HEADER, RESPONSE_BODY
@@ -3355,7 +3392,8 @@ module.exports = {
           resolvedSchemaParams.push({
             name: propName,
             schema: propSchema,
-            isResolvedParam: true,
+            required: param.required || false, // treat exploded param as required if parent param is required
+            isResolvedParam: !_.includes(['array', 'object'], _.get(propSchema, 'type')),
             pathPrefix
           });
         });
@@ -3389,10 +3427,21 @@ module.exports = {
       // assign parameter example(s) as schema examples;
       this.assignParameterExamples(schemaParam);
 
-      if (!schemaParam.isResolvedParam) {
+      if (schemaParam.isResolvedParam === false) {
+        // simply parse value which will be not serialised and is stringified
+        try {
+          resolvedParamValue = JSON.parse(pQuery.value);
+        }
+        catch (err) {
+          console.warn(`Unable to parse value for parameter ${schemaParam.name}`);
+        }
+      }
+      else if (!schemaParam.isResolvedParam) {
         resolvedParamValue = this.deserialiseParamValue(schemaParam, pQuery.value, PARAMETER_SOURCE.REQUEST,
           components, schemaCache);
       }
+      // store existing value to be used in mismatch object
+      schemaParam.actualValue = pQuery.value;
 
       // query found in spec. check query's schema
       setTimeout(() => {
@@ -3414,7 +3463,7 @@ module.exports = {
       let mismatches = [],
         mismatchObj;
 
-      _.each(_.filter(schemaParams, (q) => { return q.required; }), (qp) => {
+      _.each(_.filter(resolvedSchemaParams, (q) => { return q.required; }), (qp) => {
         if (!_.find(requestQueryParams, (param) => { return param.key === qp.name; })) {
 
           // assign parameter example(s) as schema examples;
@@ -3443,7 +3492,11 @@ module.exports = {
           mismatches.push(mismatchObj);
         }
       });
-      return callback(null, _.concat(_.flatten(res), mismatches));
+
+      mismatches = this.convertToSerialisedValues(_.concat(_.flatten(res), mismatches), resolvedSchemaParams,
+        components, schemaCache, options);
+
+      return callback(null, mismatches);
     });
   },
 
@@ -3864,7 +3917,8 @@ module.exports = {
             resolvedSchemaParams.push({
               name: key,
               schema: value,
-              isResolvedParam: true
+              required: resolvedProp.required || false, // treat exploded param as required if parent param is required
+              isResolvedParam: !_.includes(['array', 'object'], _.get(propSchema, 'type'))
             });
           });
         }
@@ -3894,7 +3948,16 @@ module.exports = {
           return cb(null, mismatches);
         }
 
-        if (!schemaParam.isResolvedParam) {
+        if (schemaParam.isResolvedParam === false) {
+          // simply parse value which will be not serialised and is stringified
+          try {
+            resolvedParamValue = JSON.parse(uParam.value);
+          }
+          catch (err) {
+            console.warn(`Unable to parse value for parameter ${schemaParam.name}`);
+          }
+        }
+        else if (!schemaParam.isResolvedParam) {
           resolvedParamValue = this.deserialiseParamValue(schemaParam, uParam.value, PARAMETER_SOURCE.REQUEST,
             components, schemaCache);
         }
@@ -3919,30 +3982,7 @@ module.exports = {
         }, 0);
       }, (err, res) => {
         let mismatches = [],
-          mismatchObj,
-          // fetches property name from schem path
-          getPropNameFromSchemPath = (schemaPath) => {
-            let regex = /\.properties\[(.+)\]/gm;
-            return _.last(regex.exec(schemaPath));
-          };
-
-        // update actual value and suggested value from JSON to serialized strings
-        _.forEach(_.flatten(res), (mismatchObj) => {
-          if (!_.isEmpty(mismatchObj)) {
-            let propertyName = getPropNameFromSchemPath(mismatchObj.schemaJsonPath),
-              schemaParam = _.find(resolvedSchemaParams, (param) => { return param.name === propertyName; }),
-              serializedParamValue;
-
-            if (schemaParam) {
-              // serialize param value (to be used in suggested value)
-              serializedParamValue = _.get(this.convertParamsWithStyle(schemaParam, _.get(mismatchObj,
-                'suggestedFix.suggestedValue'), PARAMETER_SOURCE.REQUEST, components, schemaCache, options),
-              '[0].value');
-              _.set(mismatchObj, 'suggestedFix.actualValue', schemaParam.actualValue);
-              _.set(mismatchObj, 'suggestedFix.suggestedValue', serializedParamValue);
-            }
-          }
-        });
+          mismatchObj;
 
         _.each(resolvedSchemaParams, (uParam) => {
           // report mismatches only for reuired properties
@@ -3970,7 +4010,12 @@ module.exports = {
             mismatches.push(mismatchObj);
           }
         });
-        return callback(null, _.concat(_.flatten(res), mismatches));
+
+        // update actual value and suggested value from JSON to serialized strings
+        mismatches = this.convertToSerialisedValues(_.concat(_.flatten(res), mismatches), resolvedSchemaParams,
+          components, schemaCache, options);
+
+        return callback(null, mismatches);
       });
     }
     else {