Merge branch 'develop' into fix/fixAllOfValidationIssue597

Author: erfemega

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/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

@@ -28,6 +28,7 @@ const { formatDataPath, checkIsCorrectType, isKnownType } = require('./common/sc
   APP_JSON = 'application/json',
   APP_JS = 'application/javascript',
   TEXT_XML = 'text/xml',
+  APP_XML = 'application/xml',
   TEXT_PLAIN = 'text/plain',
   TEXT_HTML = 'text/html',
   FORM_DATA = 'multipart/form-data',
@@ -1914,6 +1915,7 @@ module.exports = {
       else if (contentObj.hasOwnProperty(APP_JSON)) { bodyType = APP_JSON; }
       else if (contentObj.hasOwnProperty(TEXT_HTML)) { bodyType = TEXT_HTML; }
       else if (contentObj.hasOwnProperty(TEXT_PLAIN)) { bodyType = TEXT_PLAIN; }
+      else if (contentObj.hasOwnProperty(APP_XML)) { bodyType = APP_XML; }
       else if (contentObj.hasOwnProperty(TEXT_XML)) { bodyType = TEXT_XML; }
       else {
         // take the first property it has
@@ -1934,12 +1936,29 @@ module.exports = {
         };
       }
       else {
+        let getXmlVersionContent = (bodyContent) => {
+          const regExp = new RegExp('([<\\?xml]+[\\s{1,}]+[version="\\d.\\d"]+[\\sencoding="]+.{1,15}"\\?>)');
+          let xmlBody = bodyContent;
+
+          if (!bodyContent.match(regExp)) {
+            const versionContent = '<?xml version="1.0" encoding="UTF-8"?>\n';
+            xmlBody = versionContent + xmlBody;
+          }
+          return xmlBody;
+        };
+
         bodyData = this.convertToPmBodyData(contentObj[bodyType], requestType, bodyType,
           PARAMETER_SOURCE.REQUEST, options.indentCharacter, components, options, schemaCache);
 
+        bodyData = (bodyType === TEXT_XML || bodyType === APP_XML) ?
+          getXmlVersionContent(bodyData) :
+          bodyData;
+
         updateOptions = {
           mode: rDataMode,
-          raw: JSON.stringify(bodyData, null, options.indentCharacter)
+          raw: bodyType !== APP_JSON ?
+            bodyData.toString() :
+            JSON.stringify(bodyData, null, options.indentCharacter)
         };
       }
 
@@ -2611,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(
@@ -2654,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;
@@ -3322,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
@@ -3333,7 +3363,7 @@ module.exports = {
    * @returns {array} mismatches (in the callback)
    */
   checkPathVariables: function (
-    determinedPathVariables,
+    matchedPathData,
     transactionPathPrefix,
     schemaPath,
     components,
@@ -3347,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, []);
@@ -3413,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);
@@ -3432,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,
@@ -4439,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) {

lib/swaggerUtils/inputValidationSwagger.js

@@ -1,4 +1,3 @@
-
 const _ = require('lodash');
 module.exports = {