Merge branch 'develop' of github.com:postmanlabs/openapi-to-postman into fix496/validateWithServers

Author: Vishal Shingala

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

@@ -3333,7 +3333,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
@@ -3344,7 +3344,7 @@ module.exports = {
    * @returns {array} mismatches (in the callback)
    */
   checkPathVariables: function (
-    determinedPathVariables,
+    matchedPathData,
     transactionPathPrefix,
     schemaPath,
     components,
@@ -3358,7 +3358,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, []);
@@ -3424,17 +3426,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);
@@ -3443,14 +3469,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,

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) {

package-lock.json

@@ -118,22 +118,22 @@
   "dependencies": {
     "ajv": "8.1.0",
     "ajv-formats": "2.1.1",
-    "async": "3.2.3",
+    "async": "3.2.4",
     "commander": "2.20.3",
     "js-yaml": "3.14.1",
     "json-schema-merge-allof": "0.8.1",
     "lodash": "4.17.21",
     "oas-resolver-browser": "2.5.6",
     "path-browserify": "1.0.1",
-    "postman-collection": "4.0.0",
+    "postman-collection": "4.1.4",
     "swagger2openapi": "7.0.8",
     "traverse": "0.6.6",
     "yaml": "1.10.2"
   },
   "author": "Postman Labs <help@getpostman.com>",
   "license": "Apache-2.0",
   "devDependencies": {
-    "chai": "4.3.4",
+    "chai": "4.3.6",
     "editorconfig": "0.15.3",
     "eslint": "5.16.0",
     "eslint-plugin-jsdoc": "3.8.0",