Fixed issue where deprecated params were reported missing even for includeDeprecated=false

Author: VShingala

libV2/validationUtils.js

@@ -1130,7 +1130,8 @@ function resolveFormParamSchema (schema, schemaKey, encodingObj, requestParams,
     in: 'query', // serialization follows same behaviour as query params
     description: _.get(schema, 'description', _.get(metaInfo, 'description', '')),
     pathPrefix: _.get(metaInfo, 'pathPrefix'),
-    isComposite: _.get(metaInfo, 'isComposite', false)
+    isComposite: _.get(metaInfo, 'isComposite', false),
+    deprecated: _.get(schema, 'deprecated', _.get(metaInfo, 'deprecated'))
   };
   encodingValue = _.get(encodingObj, schemaKey);
 
@@ -1167,7 +1168,8 @@ function resolveFormParamSchema (schema, schemaKey, encodingObj, requestParams,
           in: 'query', // serialization follows same behaviour as query params
           description: _.get(propSchema, 'description') || _.get(metaInfo, 'description') || '',
           required: _.get(metaInfo, 'required'),
-          isComposite: _.get(metaInfo, 'isComposite', false)
+          isComposite: _.get(metaInfo, 'isComposite', false),
+          deprecated: _.get(propSchema, 'deprecated') || _.get(metaInfo, 'deprecated')
         },
         parentPropName = resolvedPropName.indexOf('[') === -1 ? resolvedPropName :
           resolvedPropName.slice(0, resolvedPropName.indexOf('[')),
@@ -1184,6 +1186,10 @@ function resolveFormParamSchema (schema, schemaKey, encodingObj, requestParams,
         resolvedProp.required = true;
       }
 
+      if (_.isUndefined(metaInfo.required) && _.includes(_.get(schema, 'required'), propName)) {
+        resolvedProp.required = true;
+      }
+
       pSerialisationInfo = getParamSerialisationInfo(resolvedProp, PARAMETER_SOURCE.REQUEST,
         components, options);
       isPropSeparable = _.includes(['form', 'deepObject'], pSerialisationInfo.style);
@@ -1217,7 +1223,8 @@ function resolveFormParamSchema (schema, schemaKey, encodingObj, requestParams,
       else if (isPropSeparable && propSchema.type === 'object' && pSerialisationInfo.explode) {
         let localMetaInfo = _.isEmpty(metaInfo) ? (metaInfo = {
             required: resolvedProp.required,
-            description: resolvedProp.description
+            description: resolvedProp.description,
+            deprecated: _.get(resolvedProp, 'deprecated')
           }) : metaInfo,
           nextSchemaKey = _.isEmpty(schemaKey) ? propName : `${schemaKey}[${propName}]`;
 
@@ -1235,7 +1242,8 @@ function resolveFormParamSchema (schema, schemaKey, encodingObj, requestParams,
               isResolvedParam: true,
               required: resolvedProp.required,
               description: resolvedProp.description,
-              isComposite: _.get(metaInfo, 'isComposite', false)
+              isComposite: _.get(metaInfo, 'isComposite', false),
+              deprecated: _.get(resolvedProp, 'deprecated') || _.get(metaInfo, 'deprecated')
             });
           });
         }
@@ -1288,7 +1296,8 @@ function resolveFormParamSchema (schema, schemaKey, encodingObj, requestParams,
             description: _.get(additionalPropSchema, 'description') || _.get(metaInfo, 'description') || '',
             required: false,
             isResolvedParam: true,
-            isComposite: true
+            isComposite: true,
+            deprecated: _.get(additionalPropSchema, 'deprecated') || _.get(metaInfo, 'deprecated')
           });
         }
       });
@@ -1729,7 +1738,8 @@ function checkQueryParams (context, queryParams, transactionPathPrefix, schemaPa
   let schemaParams = _.filter(schemaPath.parameters, (param) => { return param.in === 'query'; }),
     requestQueryParams = [],
     resolvedSchemaParams = [],
-    mismatchProperty = 'QUERYPARAM';
+    mismatchProperty = 'QUERYPARAM',
+    { includeDeprecated } = context.computedOptions;
 
   if (options.validationPropertiesToIgnore.includes(mismatchProperty)) {
     return callback(null, []);
@@ -1755,6 +1765,7 @@ function checkQueryParams (context, queryParams, transactionPathPrefix, schemaPa
       metaInfo = {
         required: _.get(param, 'required') || false,
         description: _.get(param, 'description'),
+        deprecated: _.get(param, 'deprecated') || false,
         pathPrefix
       };
 
@@ -1826,6 +1837,10 @@ function checkQueryParams (context, queryParams, transactionPathPrefix, schemaPa
       });
 
     _.each(filteredSchemaParams, (qp) => {
+      if (qp.deprecated && !includeDeprecated) {
+        return;
+      }
+
       if (!_.find(requestQueryParams, (param) => {
         return param.key === qp.name;
       })) {
@@ -1876,7 +1891,8 @@ function checkRequestHeaders (context, headers, transactionPathPrefix, schemaPat
 
       return !_.includes(IMPLICIT_HEADERS, _.toLower(_.get(header, 'key')));
     }),
-    mismatchProperty = 'HEADER';
+    mismatchProperty = 'HEADER',
+    { includeDeprecated } = context.computedOptions;
 
   if (options.validationPropertiesToIgnore.includes(mismatchProperty)) {
     return callback(null, []);
@@ -1931,7 +1947,8 @@ function checkRequestHeaders (context, headers, transactionPathPrefix, schemaPat
     let mismatches = [],
       mismatchObj,
       reqBody = _.get(schemaPath, 'requestBody'),
-      contentHeaderMismatches = [];
+      contentHeaderMismatches = [],
+      filteredHeaders;
 
     // resolve $ref in request body if present
     if (reqBody) {
@@ -1943,17 +1960,24 @@ function checkRequestHeaders (context, headers, transactionPathPrefix, schemaPat
         schemaPathPrefix + '.requestBody.content', _.get(reqBody, 'content'),
         mismatchProperty, options);
     }
-    _.each(_.filter(schemaHeaders, (h) => {
+
+    filteredHeaders = _.filter(schemaHeaders, (h) => {
       // exclude non-required, non-composite and implicit header from further validation
       const isImplicitHeader = _.includes(IMPLICIT_HEADERS, _.toLower(h.name));
 
       if (VALIDATE_OPTIONAL_PARAMS) {
         return !h.isComposite && !isImplicitHeader;
       }
       return h.required && !h.isComposite && !isImplicitHeader;
-    }), (header) => {
+    });
+
+    _.each(filteredHeaders, (header) => {
       if (!_.find(reqHeaders, (param) => { return param.key === header.name; })) {
 
+        if (header.deprecated && !includeDeprecated) {
+          return;
+        }
+
         // assign parameter example(s) as schema examples;
         assignParameterExamples(header);
 
@@ -1998,7 +2022,8 @@ function checkResponseHeaders (context, schemaResponse, headers, transactionPath
 
       return !_.includes(IMPLICIT_HEADERS, _.toLower(_.get(header, 'key')));
     }),
-    mismatchProperty = 'RESPONSE_HEADER';
+    mismatchProperty = 'RESPONSE_HEADER',
+    { includeDeprecated } = context.computedOptions;
 
   if (options.validationPropertiesToIgnore.includes(mismatchProperty)) {
     return callback(null, []);
@@ -2055,23 +2080,28 @@ function checkResponseHeaders (context, schemaResponse, headers, transactionPath
     let mismatches = [],
       mismatchObj,
       contentHeaderMismatches = checkContentTypeHeader(headers, transactionPathPrefix,
-        schemaPathPrefix + '.content', _.get(schemaResponse, 'content'), mismatchProperty, options);
+        schemaPathPrefix + '.content', _.get(schemaResponse, 'content'), mismatchProperty, options),
+      filteredHeaders = _.filter(schemaHeaders, (h, hName) => {
+        // exclude empty headers from validation
+        if (_.isEmpty(h)) {
+          return false;
+        }
+        h.name = hName;
 
-    _.each(_.filter(schemaHeaders, (h, hName) => {
-      // exclude empty headers from validation
-      if (_.isEmpty(h)) {
-        return false;
-      }
-      h.name = hName;
+        // exclude non-required, non-composite and implicit header from further validation
+        const isImplicitHeader = _.includes(IMPLICIT_HEADERS, _.toLower(hName));
 
-      // exclude non-required, non-composite and implicit header from further validation
-      const isImplicitHeader = _.includes(IMPLICIT_HEADERS, _.toLower(hName));
+        if (VALIDATE_OPTIONAL_PARAMS) {
+          return !h.isComposite && !isImplicitHeader;
+        }
+        return h.required && !h.isComposite && !isImplicitHeader;
+      });
 
-      if (VALIDATE_OPTIONAL_PARAMS) {
-        return !h.isComposite && !isImplicitHeader;
+    _.each(filteredHeaders, (header) => {
+      if (header.deprecated && !includeDeprecated) {
+        return;
       }
-      return h.required && !h.isComposite && !isImplicitHeader;
-    }), (header) => {
+
       if (!_.find(resHeaders, (param) => { return param.key === header.name; })) {
 
         // assign parameter example(s) as schema examples;
@@ -2112,7 +2142,8 @@ function checkRequestBody (context, requestBody, transactionPathPrefix, schemaPa
   // check for body modes
   let jsonSchemaBody,
     jsonContentType,
-    mismatchProperty = 'BODY';
+    mismatchProperty = 'BODY',
+    { includeDeprecated } = context.computedOptions;
 
   if (options.validationPropertiesToIgnore.includes(mismatchProperty)) {
     return callback(null, []);
@@ -2247,6 +2278,10 @@ function checkRequestBody (context, requestBody, transactionPathPrefix, schemaPa
       });
 
       _.each(filteredSchemaParams, (uParam) => {
+        if (uParam.deprecated && !includeDeprecated) {
+          return;
+        }
+
         // report mismatches only for required properties
         if (!_.find(filteredUrlEncodedBody, (param) => { return param.key === uParam.name; })) {
           mismatchObj = {