Added support for Auth params in response/example. (#286)

* Added support for correct auth params in original request of response

* Updated collection json schema to latest

* Added tests for feature - response auth params support

* Moved auth params in response behind an option

* Updated option name and description to follow consistent casing

* Updated option id for including auth params in response to be more suitable

Co-authored-by: Vishal Shingala <vishalkumar.shingala@postman.com>

Author: VShingala

lib/options.js

@@ -116,6 +116,15 @@ module.exports = {
         external: false,
         usage: ['CONVERSION']
       },
+      {
+        name: 'Include auth info in example requests',
+        id: 'includeAuthInfoInExample',
+        type: 'boolean',
+        default: true,
+        description: 'Select whether to include authentication parameters in the example request',
+        external: true,
+        usage: ['CONVERSION']
+      },
       {
         name: 'Short error messages during request <> schema validation',
         id: 'shortValidationErrors',

lib/schemaUtils.js

@@ -1007,13 +1007,45 @@ module.exports = {
 
     securitySet.forEach((security) => {
       securityDef = openapi.securityDefs[Object.keys(security)[0]];
-      if (!securityDef) {
-        return false;
+      if (!_.isObject(securityDef)) {
+        return;
       }
       else if (securityDef.type === 'http') {
-        helper = {
-          type: securityDef.scheme
-        };
+        if (_.toLower(securityDef.scheme) === 'basic') {
+          helper = {
+            type: 'basic',
+            basic: [
+              { key: 'username', value: '<Basic Auth Username>' },
+              { key: 'password', value: '<Basic Auth Password>' }
+            ]
+          };
+        }
+        else if (_.toLower(securityDef.scheme) === 'bearer') {
+          helper = {
+            type: 'bearer',
+            bearer: [{ key: 'token', value: '<Bearer Token>' }]
+          };
+        }
+        else if (_.toLower(securityDef.scheme) === 'digest') {
+          helper = {
+            type: 'digest',
+            digest: [
+              { key: 'username', value: '<Digest Auth Username>' },
+              { key: 'password', value: '<Digest Auth Password>' },
+              { key: 'realm', value: '<realm>' }
+            ]
+          };
+        }
+        else if (_.toLower(securityDef.scheme) === 'oauth' || _.toLower(securityDef.scheme) === 'oauth1') {
+          helper = {
+            type: 'oauth1',
+            oauth1: [
+              { key: 'consumerSecret', value: '<OAuth 1.0 Consumer Key>' },
+              { key: 'consumerKey', value: '<OAuth 1.0 Consumer Secret>' },
+              { key: 'addParamsToHeader', value: true }
+            ]
+          };
+        }
       }
       else if (securityDef.type === 'oauth2') {
         helper = {
@@ -1022,15 +1054,103 @@ module.exports = {
       }
       else if (securityDef.type === 'apiKey') {
         helper = {
-          type: 'api-key',
-          properties: securityDef
+          type: 'apikey',
+          apikey: [
+            {
+              key: 'key',
+              value: _.isString(securityDef.name) ? securityDef.name : '<API Key Name>'
+            },
+            { key: 'value', value: true },
+            {
+              key: 'in',
+              value: _.includes(['query', 'header'], securityDef.in) ? securityDef.in : 'header'
+            }
+          ]
         };
       }
-      return false;
+
+      // stop searching for helper if valid auth scheme is found
+      if (!_.isEmpty(helper)) {
+        return false;
+      }
     });
     return helper;
   },
 
+  /**
+   * Generates Auth helper for response, params (query, headers) in helper object is added in
+   * request (originalRequest) part of example.
+   *
+   * @param {*} requestAuthHelper - Auth helper object of corresponding request
+   * @returns {Object} - Response Auth helper object containing params to be added
+   */
+  getResponseAuthHelper: function (requestAuthHelper) {
+    var responseAuthHelper = {
+        query: [],
+        header: []
+      },
+      getValueFromHelper = function (authParams, keyName) {
+        return _.find(authParams, { key: keyName }).value;
+      },
+      paramLocation,
+      description;
+
+    if (!_.isObject(requestAuthHelper)) {
+      return responseAuthHelper;
+    }
+    description = 'Added as a part of security scheme: ' + requestAuthHelper.type;
+
+    switch (requestAuthHelper.type) {
+      case 'apikey':
+        // find location of parameter from auth helper
+        paramLocation = getValueFromHelper(requestAuthHelper.apikey, 'in');
+        responseAuthHelper[paramLocation].push({
+          key: getValueFromHelper(requestAuthHelper.apikey, 'key'),
+          value: '<API Key>',
+          description
+        });
+        break;
+      case 'basic':
+        responseAuthHelper.header.push({
+          key: 'Authorization',
+          value: 'Basic <credentials>',
+          description
+        });
+        break;
+      case 'bearer':
+        responseAuthHelper.header.push({
+          key: 'Authorization',
+          value: 'Bearer <token>',
+          description
+        });
+        break;
+      case 'digest':
+        responseAuthHelper.header.push({
+          key: 'Authorization',
+          value: 'Digest <credentials>',
+          description
+        });
+        break;
+      case 'oauth1':
+        responseAuthHelper.header.push({
+          key: 'Authorization',
+          value: 'OAuth <credentials>',
+          description
+        });
+        break;
+      case 'oauth2':
+        responseAuthHelper.header.push({
+          key: 'Authorization',
+          value: '<token>',
+          description
+        });
+        break;
+      default:
+        break;
+    }
+    return responseAuthHelper;
+  },
+
   /**
    * Converts a 'content' object into Postman response body. Any content-type header determined
    * from the body is returned as well
@@ -2077,25 +2197,6 @@ module.exports = {
       thisAuthObject[authMap[authMeta.currentHelper]] = authMeta.helperAttributes;
       item.request.auth = new sdk.RequestAuth(thisAuthObject);
     }
-    // TODO: Figure out what happens if type!=api-key
-    else if (authHelper && authHelper.type === 'api-key') {
-      if (authHelper.properties.in === 'header') {
-        item.request.addHeader(this.convertToPmHeader(authHelper.properties,
-          REQUEST_TYPE.ROOT, PARAMETER_SOURCE.REQUEST, components, options, schemaCache));
-        item.request.auth = {
-          type: 'noauth'
-        };
-      }
-      else if (authHelper.properties.in === 'query') {
-        this.convertToPmQueryParameters(authHelper.properties, REQUEST_TYPE.ROOT,
-          components, options, schemaCache).forEach((pmParam) => {
-          item.request.url.addQueryParams(pmParam);
-        });
-        item.request.auth = {
-          type: 'noauth'
-        };
-      }
-    }
     else {
       item.request.auth = authHelper;
     }
@@ -2162,27 +2263,57 @@ module.exports = {
     // adding responses to request item
     if (operation.responses) {
       let thisOriginalRequest = {},
+        responseAuthHelper,
+        authQueryParams,
         convertedResponse;
+
+      if (options.includeAuthInfoInExample) {
+        responseAuthHelper = this.getResponseAuthHelper(authHelper);
+
+        // override auth helper with global security definition if no operation security definition found
+        if (_.isEmpty(authHelper)) {
+          responseAuthHelper = this.getResponseAuthHelper(this.getAuthHelper(openapi, openapi.security));
+        }
+
+        authQueryParams = _.map(responseAuthHelper.query, (queryParam) => {
+          // key-value pair will be added as transformed query string
+          return queryParam.key + '=' + queryParam.value;
+        });
+      }
+
       _.forOwn(operation.responses, (response, code) => {
-        let originalRequestHeaders = [];
+        let originalRequestHeaders = [],
+          originalRequestQueryParams = this.convertToPmQueryArray(reqParams, REQUEST_TYPE.EXAMPLE,
+            components, options, schemaCache);
+
         swagResponse = response;
         if (response.$ref) {
           swagResponse = this.getRefObject(response.$ref, components, options);
         }
 
+        if (options.includeAuthInfoInExample) {
+          // add Authorization params if present
+          originalRequestQueryParams = _.concat(originalRequestQueryParams, authQueryParams);
+          originalRequestHeaders = _.concat(originalRequestHeaders, responseAuthHelper.header);
+        }
+
         // Try and set fields for originalRequest (example.request)
         thisOriginalRequest.method = item.request.method;
         // setting URL
         thisOriginalRequest.url = displayUrl;
+
         // setting query params
-        thisOriginalRequest.url += '?';
-        thisOriginalRequest.url += this.convertToPmQueryArray(reqParams, REQUEST_TYPE.EXAMPLE, components,
-          options, schemaCache).join('&');
+        if (originalRequestQueryParams.length) {
+          thisOriginalRequest.url += '?';
+          thisOriginalRequest.url += originalRequestQueryParams.join('&');
+        }
+
         // setting headers
         _.forEach(reqParams.header, (header) => {
           originalRequestHeaders.push(this.convertToPmHeader(header, REQUEST_TYPE.EXAMPLE,
             PARAMETER_SOURCE.REQUEST, components, options, schemaCache));
         });
+
         thisOriginalRequest.header = originalRequestHeaders;
         // setting request body
         try {

lib/schemapack.js

@@ -266,15 +266,6 @@ class SchemaPack {
     if (openapi.security) {
       authHelper = schemaUtils.getAuthHelper(openapi, openapi.security);
       if (authHelper) {
-        if (authHelper.type === 'api-key') {
-          // if authHelper has type apikey and has properties in header or query
-          // we override authHelper to 'noauth'
-          if (authHelper.properties.in === 'header' || authHelper.properties.in === 'query') {
-            authHelper = {
-              type: 'noauth'
-            };
-          }
-        }
         generatedStore.collection.auth = authHelper;
       }
     }