Added support for option includeDeprecated in validateTransactionV2()

Author: VShingala

libV2/schemaUtils.js

@@ -539,7 +539,8 @@ let QUERYPARAM = 'query',
       concreteUtils.compareTypes(schema.type, SCHEMA_TYPES.object) ||
       schema.hasOwnProperty('properties')
     ) {
-      let resolvedSchemaProps = {};
+      let resolvedSchemaProps = {},
+        { includeDeprecated } = context.computedOptions;
 
       _.forOwn(schema.properties, (property, propertyName) => {
         if (
@@ -552,6 +553,11 @@ let QUERYPARAM = 'query',
           delete property.format;
         }
 
+        // Skip addition of deprecated properties based on provided options
+        if (!includeDeprecated && property.deprecated) {
+          return;
+        }
+
         resolvedSchemaProps[propertyName] = resolveSchema(context, property, stack, resolveFor, _.cloneDeep(seenRef));
       });
 
@@ -1421,14 +1427,15 @@ let QUERYPARAM = 'query',
 
   resolveQueryParamsForPostmanRequest = (context, operationItem, method) => {
     const params = resolvePathItemParams(context, operationItem[method].parameters, operationItem.parameters),
-      pmParams = [];
+      pmParams = [],
+      { includeDeprecated } = context.computedOptions;
 
     _.forEach(params, (param) => {
       if (_.has(param, '$ref')) {
         param = resolveSchema(context, param);
       }
 
-      if (param.in !== QUERYPARAM) {
+      if (param.in !== QUERYPARAM || (!includeDeprecated && param.deprecated)) {
         return;
       }
 
@@ -1509,14 +1516,14 @@ let QUERYPARAM = 'query',
   resolveHeadersForPostmanRequest = (context, operationItem, method) => {
     const params = resolvePathItemParams(context, operationItem[method].parameters, operationItem.parameters),
       pmParams = [],
-      { keepImplicitHeaders } = context.computedOptions;
+      { keepImplicitHeaders, includeDeprecated } = context.computedOptions;
 
     _.forEach(params, (param) => {
       if (_.has(param, '$ref')) {
         param = resolveSchema(context, param);
       }
 
-      if (param.in !== HEADER) {
+      if (param.in !== HEADER || (!includeDeprecated && param.deprecated)) {
         return;
       }
 
@@ -1585,13 +1592,18 @@ let QUERYPARAM = 'query',
   },
 
   resolveResponseHeaders = (context, responseHeaders) => {
-    const headers = [];
+    const headers = [],
+      { includeDeprecated } = context.computedOptions;
 
     if (_.has(responseHeaders, '$ref')) {
       responseHeaders = resolveSchema(context, responseHeaders);
     }
 
     _.forOwn(responseHeaders, (value, headerName) => {
+      if (!includeDeprecated && value.deprecated) {
+        return;
+      }
+
       let headerValue = resolveValueOfParameter(context, value);
 
       if (typeof headerValue === 'number' || typeof headerValue === 'boolean') {

libV2/validationUtils.js

@@ -22,7 +22,6 @@ const _ = require('lodash'),
     getServersPathVars } = require('../lib/common/schemaUtilsCommon.js'),
 
   { findMatchingRequestFromSchema, isPmVariable } = require('./requestMatchingUtils'),
-  traverseUtility = require('traverse'),
 
   // common global constants
   SCHEMA_FORMATS = {
@@ -114,22 +113,6 @@ function getDefaultContext (options, components = {}) {
   };
 }
 
-/**
- * Remove or keep the deprecated properties according to the option
- * @param {object} resolvedSchema - the schema to verify properties
- * @param {boolean} includeDeprecated - Whether to include the deprecated properties
- * @returns {undefined} undefined
- */
-function verifyDeprecatedProperties(resolvedSchema, includeDeprecated) {
-  traverseUtility(resolvedSchema.properties).forEach(function (property) {
-    if (property && typeof property === 'object') {
-      if (property.deprecated === true && includeDeprecated === false) {
-        this.delete();
-      }
-    }
-  });
-}
-
 /**
  * Verifies if the deprecated operations should be added
  *
@@ -167,8 +150,7 @@ function safeSchemaFaker (context, oldSchema, resolveTo, resolveFor, parameterSo
   let concreteUtils = components && components.hasOwnProperty('concreteUtils') ?
     components.concreteUtils :
     DEFAULT_SCHEMA_UTILS;
-  const indentCharacter = options.indentCharacter,
-    includeDeprecated = options.includeDeprecated;
+  const indentCharacter = options.indentCharacter;
 
   resolvedSchema = resolveSchema(context, oldSchema, 0, PROCESSING_TYPE.VALIDATION);
 
@@ -218,7 +200,6 @@ function safeSchemaFaker (context, oldSchema, resolveTo, resolveFor, parameterSo
         }
       }
     }
-    verifyDeprecatedProperties(resolvedSchema, includeDeprecated);
   }
 
   try {
@@ -646,26 +627,6 @@ function getSuggestedValue (fakedValue, actualValue, ajvValidationErrorObj) {
   return suggestedValue;
 }
 
-/**
- * Returns all security params that can be applied during converion.
- *
- * @param {Object} components - OpenAPI components
- * @param {String} location - location for which we want to get security params (i.e. 'header' | 'query')
- * @returns {Array} applicable security params
- */
-function getSecurityParams (components, location) {
-  let securityDefs = _.get(components, 'securitySchemes', {}),
-    securityParams = [];
-
-  _.forEach(securityDefs, (securityDef) => {
-    // Currently we only apply header and query for apiKey type of security param during conversion
-    if (_.get(securityDef, 'type') === 'apiKey' && _.get(securityDef, 'in') === location) {
-      securityParams.push(securityDef);
-    }
-  });
-  return securityParams;
-}
-
 /**
  * Tests whether given parameter is of complex array type from param key
  *
@@ -1762,22 +1723,19 @@ function checkQueryParams (context, queryParams, transactionPathPrefix, schemaPa
   let schemaParams = _.filter(schemaPath.parameters, (param) => { return param.in === 'query'; }),
     requestQueryParams = [],
     resolvedSchemaParams = [],
-    mismatchProperty = 'QUERYPARAM',
-    securityParams;
+    mismatchProperty = 'QUERYPARAM';
 
   if (options.validationPropertiesToIgnore.includes(mismatchProperty)) {
     return callback(null, []);
   }
 
-  // filter out query params added by security schemes
-  securityParams = _.map(getSecurityParams(_.get(components, 'components'), 'query'), 'name');
   requestQueryParams = _.filter(queryParams, (pQuery) => {
     // Ignoring the disabled query params
     if (pQuery.disabled === true) {
       return false;
     }
 
-    return !_.includes(securityParams, pQuery.key) && pQuery.value !== OAS_NOT_SUPPORTED;
+    return pQuery.value !== OAS_NOT_SUPPORTED;
   });
 
   // resolve schema params
@@ -1899,8 +1857,6 @@ function checkQueryParams (context, queryParams, transactionPathPrefix, schemaPa
 function checkRequestHeaders (context, headers, transactionPathPrefix, schemaPathPrefix, schemaPath,
   components, options, schemaCache, jsonSchemaDialect, callback) {
   let schemaHeaders = _.filter(schemaPath.parameters, (param) => { return param.in === 'header'; }),
-    // key name of headers which are added by security schemes
-    securityHeaders = _.map(getSecurityParams(_.get(components, 'components'), 'header'), 'name'),
     // filter out headers for following cases
     reqHeaders = _.filter(headers, (header) => {
       // 1. If header is disabled
@@ -1910,8 +1866,7 @@ function checkRequestHeaders (context, headers, transactionPathPrefix, schemaPat
         return !header.disabled;
       }
 
-      return !_.includes(IMPLICIT_HEADERS, _.toLower(_.get(header, 'key'))) &&
-        !_.includes(securityHeaders, header.key);
+      return !_.includes(IMPLICIT_HEADERS, _.toLower(_.get(header, 'key')));
     }),
     mismatchProperty = 'HEADER';
 

test/unit/convertV2.test.js

@@ -55,6 +55,9 @@ const expect = require('chai').expect,
   invalidNullInfoTitle = path.join(__dirname, INVALID_OPENAPI_PATH, '/invalid-info-null-title.json'),
   invalidNullInfoVersion = path.join(__dirname, INVALID_OPENAPI_PATH, '/invalid-info-null-version.json'),
   onlyOneOperationDeprecated = path.join(__dirname, VALID_OPENAPI_PATH, '/has_one_op_dep.json'),
+  someOperationOneDeprecated = path.join(__dirname, VALID_OPENAPI_PATH, '/has_some_op_dep.json'),
+  someOperationDeprecatedUsingTags =
+        path.join(__dirname, VALID_OPENAPI_PATH, '/has_some_op_dep_use_tags.json'),
   deprecatedParams =
     path.join(__dirname, VALID_OPENAPI_PATH, '/petstore_deprecated_param.json'),
   deprecatedProperty =
@@ -1164,31 +1167,68 @@ describe('The convert Function', function() {
       });
   });
 
-  it('Should convert and include deprecated operations when option is not present' +
-  '- has only one op and is deprecated', function () {
-    const fileData = fs.readFileSync(onlyOneOperationDeprecated, 'utf8');
-    Converter.convertV2({ type: 'string', data: fileData }, undefined,
-      (err, result) => {
-        expect(err).to.be.null;
-        expect(result.result).to.be.true;
-        expect(result.output[0].data.item.length).to.equal(1);
-      });
-  });
-
   // TODO: Handle deprecated property config option
-  describe.skip('Deprecated property', function () {
+  describe('Deprecated property', function () {
+    it('Should convert and exclude deprecated operations - has only one op and is deprecated', function () {
+      const fileData = fs.readFileSync(onlyOneOperationDeprecated, 'utf8');
+      Converter.convertV2({ type: 'string', data: fileData }, { includeDeprecated: false },
+        (err, result) => {
+          expect(err).to.be.null;
+          expect(result.result).to.be.true;
+          expect(result.output[0].data.item).to.be.empty;
+        });
+    });
+
+    it('Should convert and exclude deprecated operations - has some deprecated', function () {
+      const fileData = fs.readFileSync(someOperationOneDeprecated, 'utf8');
+      Converter.convertV2({ type: 'string', data: fileData },
+        { includeDeprecated: false },
+        (err, result) => {
+          expect(err).to.be.null;
+          expect(result.result).to.be.true;
+          expect(result.output[0].data.item.length).to.equal(1);
+        });
+    });
+
+    it('Should convert and exclude deprecated operations - has only one op and is deprecated' +
+      'using tags as folder strategy operation has not tag', function () {
+      const fileData = fs.readFileSync(onlyOneOperationDeprecated, 'utf8');
+      Converter.convertV2({ type: 'string', data: fileData },
+        { includeDeprecated: false, folderStrategy: 'tags' },
+        (err, result) => {
+          expect(err).to.be.null;
+          expect(result.result).to.be.true;
+          expect(result.output[0].data.item).to.be.empty;
+        });
+    });
+
+    it('Should convert and exclude deprecated operations - has some deprecated' +
+      'using tags as folder strategy', function () {
+      const fileData = fs.readFileSync(someOperationDeprecatedUsingTags, 'utf8');
+      Converter.convertV2({ type: 'string', data: fileData },
+        { includeDeprecated: false, folderStrategy: 'tags' },
+        (err, result) => {
+          expect(err).to.be.null;
+          expect(result.result).to.be.true;
+          expect(result.output[0].data.item.length).to.equal(1);
+          expect(result.output[0].data.item[0].name).to.equal('pets');
+        });
+    });
+
     it('Should convert and exclude deprecated params when option is set to false', function() {
       const fileData = fs.readFileSync(deprecatedParams, 'utf8');
       Converter.convertV2({ type: 'string', data: fileData },
         { includeDeprecated: false },
         (err, result) => {
+          const req1 = result.output[0].data.item[0],
+            req2 = result.output[0].data.item[1];
+
           expect(err).to.be.null;
-          expect(result.output[0].data.item[0].item[0].request.url.query.length).to.equal(1);
-          expect(result.output[0].data.item[0].item[0].request.url.query[0].key).to.equal('variable');
-          expect(result.output[0].data.item[0].item[0].request.header.length).to.equal(3);
-          expect(result.output[0].data.item[0].item[0].request.header[0].key).to.equal('limit');
-          expect(result.output[0].data.item[0].item[0].request.header[1].key).to.equal('limit_2');
-          expect(result.output[0].data.item[0].item[1].request.header[0].key).to.equal('limit_2');
+          expect(req1.request.url.query.length).to.equal(1);
+          expect(req1.request.url.query[0].key).to.equal('variable');
+          expect(req1.request.header[0].key).to.equal('limit');
+          expect(req1.request.header[1].key).to.equal('limit_2');
+          expect(req2.request.header[0].key).to.equal('limit_2');
         });
     });
 
@@ -1197,29 +1237,31 @@ describe('The convert Function', function() {
       Converter.convertV2({ type: 'string', data: fileData },
         { includeDeprecated: true },
         (err, result) => {
+          const req = result.output[0].data.item[0];
+
           expect(err).to.be.null;
-          expect(result.output[0].data.item[0].item[0].request.url.query.length).to.equal(2);
-          expect(result.output[0].data.item[0].item[0].request.url.query[0].key).to.equal('variable');
-          expect(result.output[0].data.item[0].item[0].request.url.query[1].key).to.equal('variable2');
-          expect(result.output[0].data.item[0].item[0].request.header.length).to.equal(4);
-          expect(result.output[0].data.item[0].item[0].request.header[0].key).to.equal('limit');
-          expect(result.output[0].data.item[0].item[0].request.header[1].key).to.equal('limit_2');
-          expect(result.output[0].data.item[0].item[0].request.header[2].key).to.equal('limit_Dep');
+          expect(req.request.url.query.length).to.equal(2);
+          expect(req.request.url.query[0].key).to.equal('variable');
+          expect(req.request.url.query[1].key).to.equal('variable2');
+          expect(req.request.header[0].key).to.equal('limit');
+          expect(req.request.header[1].key).to.equal('limit_2');
+          expect(req.request.header[2].key).to.equal('limit_Dep');
         });
     });
 
     it('Should convert and include deprecated params when option is not present', function() {
       const fileData = fs.readFileSync(deprecatedParams, 'utf8');
       Converter.convertV2({ type: 'string', data: fileData }, {},
         (err, result) => {
+          const req = result.output[0].data.item[0];
+
           expect(err).to.be.null;
-          expect(result.output[0].data.item[0].item[0].request.url.query.length).to.equal(2);
-          expect(result.output[0].data.item[0].item[0].request.url.query[0].key).to.equal('variable');
-          expect(result.output[0].data.item[0].item[0].request.url.query[1].key).to.equal('variable2');
-          expect(result.output[0].data.item[0].item[0].request.header.length).to.equal(4);
-          expect(result.output[0].data.item[0].item[0].request.header[0].key).to.equal('limit');
-          expect(result.output[0].data.item[0].item[0].request.header[1].key).to.equal('limit_2');
-          expect(result.output[0].data.item[0].item[0].request.header[2].key).to.equal('limit_Dep');
+          expect(req.request.url.query.length).to.equal(2);
+          expect(req.request.url.query[0].key).to.equal('variable');
+          expect(req.request.url.query[1].key).to.equal('variable2');
+          expect(req.request.header[0].key).to.equal('limit');
+          expect(req.request.header[1].key).to.equal('limit_2');
+          expect(req.request.header[2].key).to.equal('limit_Dep');
         });
     });
 
@@ -1257,8 +1299,6 @@ describe('The convert Function', function() {
             .to.equal('deprecated');
           expect(result.output[0].data.item[0].request.url.query[1].key)
             .to.equal('b');
-          expect(result.output[0].data.item[0].request.url.query[1].value)
-            .to.equal('{"c":"<string>","d":"<string>","deprecated":"<string>"}');
           expect(result.output[0].data.item[0].request.url.variable[0].value)
             .to.equal(';limitPath=deprecated,<boolean>,b,<string>');
           expect(result.output[0].data.item[0].request.header[0].value)
@@ -1276,8 +1316,6 @@ describe('The convert Function', function() {
             .to.equal('deprecated');
           expect(result.output[0].data.item[0].request.url.query[1].key)
             .to.equal('b');
-          expect(result.output[0].data.item[0].request.url.query[1].value)
-            .to.equal('{"d":"<string>","deprecated":"<string>"}');
           expect(result.output[0].data.item[0].request.url.variable[0].value)
             .to.equal(';limitPath=b,<string>');
           expect(result.output[0].data.item[0].request.header[0].value)