Merge branch 'develop' into fix/formatingBodyRawOutputWhenIsNotAnObject

Author: VShingala

assets/json-schema-faker.js

@@ -23782,7 +23782,7 @@ function extend() {
                   var min = Math.max(params.minimum || 0, 0);
                   var max = Math.min(params.maximum || Infinity, Infinity);
                   min = handleExclusiveMinimum(schema, min);
-                  max = handleExclusiveMaximum(schema, min);
+                  max = handleExclusiveMaximum(schema, max);
                   // discard out-of-bounds enumerations
                   schema.enum = schema.enum.filter(function (x) {
                       if (x >= min && x <= max) {

lib/bundle.js

@@ -22,7 +22,7 @@ let path = require('path'),
   { DFS } = require('./dfs'),
   deref = require('./deref.js'),
   { isSwagger, getBundleRulesDataByVersion } = require('./common/versionUtils'),
-  CIRCULAR_REF_EXT_PROP = 'x-circularRef';
+  CIRCULAR_OR_REF_EXT_PROP = 'x-orRef';
 
 
 /**
@@ -481,6 +481,34 @@ function findReferenceByMainKeyInTraceFromContext(documentContext, mainKeyInTrac
   return relatedRef;
 }
 
+/**
+ * Verifies if a node has same content as one of the parents so it is a circular ref
+ * @param {function} traverseContext - The context of the traverse function
+ * @param {object} contentFromTrace -  The resolved content of the node to deref
+ * @returns {boolean} whether is circular reference or not.
+ */
+function isCircularReference(traverseContext, contentFromTrace) {
+  return traverseContext.parents.find((parent) => { return parent.node === contentFromTrace; }) !== undefined;
+}
+
+/**
+ * Modifies content of a node if it is circular reference.
+ *
+ * @param {function} traverseContext - The context of the traverse function
+ * @param {object} documentContext The document context from root
+ * @returns {undefined}  nothing
+ */
+function handleCircularReference(traverseContext, documentContext) {
+  let relatedRef = '';
+  if (traverseContext.circular) {
+    relatedRef = findReferenceByMainKeyInTraceFromContext(documentContext, traverseContext.circular.key);
+    traverseContext.update({ $ref: relatedRef });
+  }
+  if (traverseContext.keys && traverseContext.keys.includes(CIRCULAR_OR_REF_EXT_PROP)) {
+    traverseContext.update({ $ref: traverseContext.node[CIRCULAR_OR_REF_EXT_PROP] });
+  }
+}
+
 /**
  * Generates the components object from the documentContext data
  * @param {object} documentContext The document context from root
@@ -492,8 +520,9 @@ function findReferenceByMainKeyInTraceFromContext(documentContext, mainKeyInTrac
  */
 function generateComponentsObject (documentContext, rootContent, refTypeResolver, components, version) {
   let notInLine = Object.entries(documentContext.globalReferences).filter(([, value]) => {
-    return value.keyInComponents.length !== 0;
-  });
+      return value.keyInComponents.length !== 0;
+    }),
+    circularRefsSet = new Set();
   const { COMPONENTS_KEYS } = getBundleRulesDataByVersion(version);
   notInLine.forEach(([key, value]) => {
     let [, partial] = key.split(localPointer);
@@ -541,6 +570,17 @@ function generateComponentsObject (documentContext, rootContent, refTypeResolver
             if (!contentFromTrace) {
               refData.nodeContent = { $ref: `${localPointer + local}` };
             }
+            else if (isCircularReference(this, contentFromTrace)) {
+              if (refData.inline) {
+                refData.nodeContent = { [CIRCULAR_OR_REF_EXT_PROP]: tempRef };
+                circularRefsSet.add(tempRef);
+              }
+              else {
+                refData.node = { [CIRCULAR_OR_REF_EXT_PROP]: refData.reference };
+                refData.nodeContent = contentFromTrace;
+                circularRefsSet.add(refData.reference);
+              }
+            }
             else {
               refData.nodeContent = contentFromTrace;
             }
@@ -551,39 +591,30 @@ function generateComponentsObject (documentContext, rootContent, refTypeResolver
             refData.node = hasSiblings ?
               _.merge(referenceSiblings, refData.nodeContent) :
               refData.nodeContent;
-            documentContext.globalReferences[property.$ref].reference =
+            documentContext.globalReferences[tempRef].reference =
               resolveJsonPointerInlineNodes(this.parents, this.key);
           }
-          this.update(refData.node);
-          if (!refData.inline) {
-            if (documentContext.globalReferences[tempRef].refHasContent) {
-              setValueInComponents(
-                refData.keyInComponents,
-                components,
-                refData.nodeContent,
-                COMPONENTS_KEYS
-              );
-            }
+          else if (refData.refHasContent) {
+            setValueInComponents(
+              refData.keyInComponents,
+              components,
+              refData.nodeContent,
+              COMPONENTS_KEYS
+            );
           }
+          this.update(refData.node);
         }
       }
     });
   });
   return {
     resRoot: traverseUtility(rootContent).map(function () {
-      let relatedRef = '';
-      if (this.circular) {
-        relatedRef = findReferenceByMainKeyInTraceFromContext(documentContext, this.circular.key);
-        this.update({ $ref: relatedRef, [CIRCULAR_REF_EXT_PROP]: true });
-      }
+      handleCircularReference(this, documentContext);
     }),
     newComponents: traverseUtility(components).map(function () {
-      let relatedRef = '';
-      if (this.circular) {
-        relatedRef = findReferenceByMainKeyInTraceFromContext(documentContext, this.circular.key);
-        this.update({ $ref: relatedRef, [CIRCULAR_REF_EXT_PROP]: true });
-      }
-    })
+      handleCircularReference(this, documentContext);
+    }),
+    circularRefs: [...circularRefsSet]
   };
 }
 
@@ -618,7 +649,7 @@ function generateComponentsWrapper(parsedOasObject, version, nodesContent = {})
 }
 
 /**
- * Generates a map of generated refernce to the original reference
+ * Generates a map of generated reference to the original reference
  *
  * @param {object} globalReferences - Global references present at each root file context
  * @returns {object} reference map
@@ -712,7 +743,8 @@ module.exports = {
       fileContent: finalElements.resRoot,
       components: finalElements.newComponents,
       fileName: specRoot.fileName,
-      referenceMap: getReferenceMap(rootContextData.globalReferences)
+      referenceMap: getReferenceMap(rootContextData.globalReferences),
+      circularRefs: finalElements.circularRefs
     };
   },
   getReferences,

lib/common/schemaUtilsCommon.js

@@ -345,5 +345,16 @@ module.exports = {
 
   isKnownType: function(schema) {
     return typeof schemaTypeToJsValidator[schema.type] === 'function';
+  },
+
+  getServersPathVars: function(servers) {
+    return servers.reduce((acc, current) => {
+      const newVarNames = current.hasOwnProperty('variables') ?
+        Object.keys(current.variables).filter((varName) => {
+          return !acc.includes(varName);
+        }) :
+        [];
+      return [...acc, ...newVarNames];
+    }, []);
   }
 };

lib/schemaUtils.js

@@ -1828,6 +1828,10 @@ module.exports = {
       bodyData = this.convertToPmBodyData(contentObj[FORM_DATA], requestType, FORM_DATA,
         PARAMETER_SOURCE.REQUEST, options.indentCharacter, components, options, schemaCache);
       encoding = contentObj[FORM_DATA].encoding ? contentObj[FORM_DATA].encoding : {};
+
+      if (contentObj[FORM_DATA].hasOwnProperty('schema') && contentObj[FORM_DATA].schema.hasOwnProperty('$ref')) {
+        contentObj[FORM_DATA].schema = this.getRefObject(contentObj[FORM_DATA].schema.$ref, components, options);
+      }
       // create the form parameters and add it to the request body object
       _.forOwn(bodyData, (value, key) => {
 
@@ -2626,11 +2630,15 @@ module.exports = {
       matchedPath,
       matchedPathJsonPath,
       schemaPathItems = schema.paths,
+      pathToMatchServer,
       filteredPathItemsArray = [];
 
     // Return no matches for invalid url (if unable to decode parsed url)
     try {
       pathToMatch = decodeURI(parsedUrl.pathname);
+      if (!_.isNil(parsedUrl.hash)) {
+        pathToMatch += parsedUrl.hash;
+      }
     }
     catch (e) {
       console.warn(
@@ -2669,9 +2677,16 @@ module.exports = {
         }
         return accumulator;
       }, []);
-
+      let schemaMatchResult = { match: false };
       // check if path and pathToMatch match (non-null)
-      let schemaMatchResult = this.getPostmanUrlSchemaMatchScore(pathToMatch, path, options);
+      // check in explicit (local defined) servers
+      if (pathItemObject[method.toLowerCase()].servers) {
+        pathToMatchServer = this.handleExplicitServersPathToMatch(pathToMatch, path);
+        schemaMatchResult = this.getPostmanUrlSchemaMatchScore(pathToMatchServer, path, options);
+      }
+      else {
+        schemaMatchResult = this.getPostmanUrlSchemaMatchScore(pathToMatch, path, options);
+      }
       if (!schemaMatchResult.match) {
         // there was no reasonable match b/w the postman path and this schema path
         return true;
@@ -3337,7 +3352,7 @@ module.exports = {
 
   /**
    *
-   * @param {*} determinedPathVariables the key/determined-value pairs of the path variables (from Postman)
+   * @param {*} matchedPathData the matchedPath data
    * @param {*} transactionPathPrefix the jsonpath for this validation (will be prepended to all identified mismatches)
    * @param {*} schemaPath the applicable pathItem defined at the schema level
    * @param {*} components the components + paths from the OAS spec that need to be used to resolve $refs
@@ -3348,7 +3363,7 @@ module.exports = {
    * @returns {array} mismatches (in the callback)
    */
   checkPathVariables: function (
-    determinedPathVariables,
+    matchedPathData,
     transactionPathPrefix,
     schemaPath,
     components,
@@ -3362,7 +3377,9 @@ module.exports = {
     var mismatchProperty = 'PATHVARIABLE',
       // all path variables defined in this path. acc. to the spec, all path params are required
       schemaPathVariables,
-      pmPathVariables;
+      pmPathVariables,
+      determinedPathVariables = matchedPathData.pathVariables,
+      unmatchedVariablesFromTransaction = matchedPathData.unmatchedVariablesFromTransaction;
 
     if (options.validationPropertiesToIgnore.includes(mismatchProperty)) {
       return callback(null, []);
@@ -3428,17 +3445,41 @@ module.exports = {
     }, (err, res) => {
       let mismatches = [],
         mismatchObj;
+      const unmatchedSchemaVariableNames = determinedPathVariables.filter((pathVariable) => {
+        return !pathVariable._varMatched;
+      }).map((schemaPathVar) => {
+        return schemaPathVar.key;
+      });
 
       if (err) {
         return callback(err);
       }
 
       // go through required schemaPathVariables, and params that aren't found in the given transaction are errors
-      _.each(schemaPathVariables, (pathVar) => {
+      _.each(schemaPathVariables, (pathVar, index) => {
         if (!_.find(determinedPathVariables, (param) => {
           // only consider variable matching if url path variables is not allowed
           return param.key === pathVar.name && (options.allowUrlPathVarMatching || param._varMatched);
         })) {
+          let reasonCode = 'MISSING_IN_REQUEST',
+            reason,
+            actualValue,
+            currentUnmatchedVariableInTransaction = unmatchedVariablesFromTransaction[index],
+            isInvalidValue = currentUnmatchedVariableInTransaction !== undefined;
+
+          if (unmatchedSchemaVariableNames.length > 0 && isInvalidValue) {
+            reason = `The ${currentUnmatchedVariableInTransaction.key} path variable does not match with ` +
+              `path variable expected (${unmatchedSchemaVariableNames[index]}) in the schema at this position`;
+            actualValue = {
+              key: currentUnmatchedVariableInTransaction.key,
+              description: this.getParameterDescription(currentUnmatchedVariableInTransaction),
+              value: currentUnmatchedVariableInTransaction.value
+            };
+          }
+          else {
+            reason = `The required path variable "${pathVar.name}" was not found in the transaction`;
+            actualValue = null;
+          }
 
           // assign parameter example(s) as schema examples;
           this.assignParameterExamples(pathVar);
@@ -3447,14 +3488,14 @@ module.exports = {
             property: mismatchProperty,
             transactionJsonPath: transactionPathPrefix,
             schemaJsonPath: pathVar.pathPrefix,
-            reasonCode: 'MISSING_IN_REQUEST',
-            reason: `The required path variable "${pathVar.name}" was not found in the transaction`
+            reasonCode,
+            reason
           };
 
           if (options.suggestAvailableFixes) {
             mismatchObj.suggestedFix = {
               key: pathVar.name,
-              actualValue: null,
+              actualValue,
               suggestedValue: {
                 key: pathVar.name,
                 value: safeSchemaFaker(pathVar.schema || {}, 'example', PROCESSING_TYPE.VALIDATION,
@@ -4454,6 +4495,32 @@ module.exports = {
     });
   },
 
+  /**
+   * Takes in the postman path and the schema path
+   * takes from the path the number of segments present in the schema path
+   * and returns the last segments from the path to match in an string format
+   *
+   * @param {string} pathToMatch - parsed path (exclude host and params) from the Postman request
+   * @param {string} schemaPath - schema path from the OAS spec (exclude servers object)
+   * @returns {string} only the selected segments from the pathToMatch
+   */
+  handleExplicitServersPathToMatch: function (pathToMatch, schemaPath) {
+    let pathTMatchSlice,
+      schemaPathArr = _.reject(schemaPath.split('/'), (segment) => {
+        return segment === '';
+      }),
+      schemaPathSegments = schemaPathArr.length,
+      pathToMatchArr = _.reject(pathToMatch.split('/'), (segment) => {
+        return segment === '';
+      }),
+      pathToMatchSegments = pathToMatchArr.length;
+    if (pathToMatchSegments < schemaPathSegments) {
+      return pathToMatch;
+    }
+    pathTMatchSlice = pathToMatchArr.slice(pathToMatchArr.length - schemaPathSegments, pathToMatchArr.length);
+    return pathTMatchSlice.join('/');
+  },
+
   /**
    * @param {string} postmanPath - parsed path (exclude host and params) from the Postman request
    * @param {string} schemaPath - schema path from the OAS spec (exclude servers object)

lib/schemapack.js

@@ -1,6 +1,5 @@
 'use strict';
 
-
 // This is the default collection name if one can't be inferred from the OpenAPI spec
 const COLLECTION_NAME = 'Imported from OpenAPI 3.0',
   { getConcreteSchemaUtils } = require('./common/versionUtils.js'),
@@ -26,7 +25,8 @@ const COLLECTION_NAME = 'Imported from OpenAPI 3.0',
   // This provides the base class for
   // errors with the input OpenAPI spec
   OpenApiErr = require('./error.js'),
-  schemaUtils = require('./schemaUtils');
+  schemaUtils = require('./schemaUtils'),
+  { getServersPathVars } = require('./common/schemaUtilsCommon.js');
 
 let path = require('path'),
   concreteUtils,
@@ -495,12 +495,29 @@ class SchemaPack {
         return setTimeout(() => {
           // 2. perform validation for each identified matchedPath (schema endpoint)
           return async.map(matchedPaths, (matchedPath, pathsCallback) => {
+            const transactionPathVariables = _.get(transaction, 'request.url.variable', []),
+              localServers = matchedPath.path.hasOwnProperty('servers') ?
+                matchedPath.path.servers :
+                [],
+              serversPathVars = [...getServersPathVars(localServers), ...getServersPathVars(schema.servers)],
+              isNotAServerPathVar = (pathVarName) => {
+                return !serversPathVars.includes(pathVarName);
+              };
 
+            matchedPath.unmatchedVariablesFromTransaction = [];
             // override path variable value with actual value present in transaction
             // as matched pathvariable contains key as value, as it is generated from url only
             _.forEach(matchedPath.pathVariables, (pathVar) => {
-              let mappedPathVar = _.find(_.get(transaction, 'request.url.variable', []), (transactionPathVar) => {
-                return transactionPathVar.key === pathVar.key;
+              const mappedPathVar = _.find(transactionPathVariables, (transactionPathVar) => {
+                let matched = transactionPathVar.key === pathVar.key;
+                if (
+                  !matched &&
+                  isNotAServerPathVar(transactionPathVar.key) &&
+                  !matchedPath.unmatchedVariablesFromTransaction.includes(transactionPathVar)
+                ) {
+                  matchedPath.unmatchedVariablesFromTransaction.push(transactionPathVar);
+                }
+                return matched;
               });
               pathVar.value = _.get(mappedPathVar, 'value', pathVar.value);
               // set _varMatched flag which represents if variable was found in transaction or not
@@ -522,7 +539,7 @@ class SchemaPack {
                 schemaUtils.checkMetadata(transaction, '$', matchedPath.path, matchedPath.name, options, cb);
               },
               path: function(cb) {
-                schemaUtils.checkPathVariables(matchedPath.pathVariables, '$.request.url.variable', matchedPath.path,
+                schemaUtils.checkPathVariables(matchedPath, '$.request.url.variable', matchedPath.path,
                   componentsAndPaths, options, schemaCache, jsonSchemaDialect, cb);
               },
               queryparams: function(cb) {