Merge branch 'release/1.2.6'

Author: Vishal Shingala

CHANGELOG.md

@@ -1,4 +1,14 @@
 # OpenAPI-Postman Changelog
+#### v1.2.5 (July 21, 2020)
+* Fixed TypeError happening when null parameter value provided.
+* Fixed an issue where suggested value for mismatch did not fix corresponding mismatch upon applying.
+* Fixed issue where root path was not matched during validation.
+* Fixed an issue where transaction was not matching if path had segment with fix and variable parts during valiadtion.
+* Fixed issue where URL did not contain baseUrl as host when base url variables are present.
+* Fixed issue where collection variable generated for path variables had empty values.
+* Fixed issue where invalid deserialisation was happening for param style matrix.
+* Added validation tests to improve code coverage.
+
 #### v1.2.5 (July 21, 2020)
 * Fixed incorrect variable name in schemapack.js.
 

lib/schemaUtils.js

@@ -1815,6 +1815,50 @@ module.exports = {
     return path.match(/(\{\{[^\/\{\}]+\}\})/g);
   },
 
+  /**
+   * Finds all the possible path variables conversion from schema path,
+   * and excludes path variable that are converted to collection variable
+   * @param {string} path Path string
+   * @returns {array} Array of path variables.
+   */
+  findPathVariablesFromSchemaPath: function (path) {
+    // /{path}/{file}.{format}/{hello} return [ '/{path}', '/{hello}' ]
+    // https://regex101.com/r/aFRWQD/4
+    let matches = path.match(/(\/\{[^\/\{\}]+\}(?=[\/\0]|$))/g);
+
+    // remove leading '/' and starting and ending curly braces
+    return _.map(matches, (match) => { return match.slice(2, -1); });
+  },
+
+  /**
+   * Finds fixed parts present in path segment of collection or schema.
+   *
+   * @param {String} segment - Path segment
+   * @param {String} pathType - Path type (one of 'collection' / 'schema')
+   * @returns {Array} - Array of strings where each element is fixed part in order of their occurence
+   */
+  getFixedPartsFromPathSegment: function (segment, pathType = 'collection') {
+    var tempSegment = segment,
+      // collection is default
+      varMatches = segment.match(pathType === 'schema' ? /(\{[^\/\{\}]+\})/g : /(\{\{[^\/\{\}]+\}\})/g),
+      fixedParts = [];
+
+    _.forEach(varMatches, (match) => {
+      let matchedIndex = tempSegment.indexOf(match);
+
+      // push fixed part before collection variable if present
+      (matchedIndex !== 0) && (fixedParts.push(tempSegment.slice(0, matchedIndex)));
+
+      // substract starting fixed and variable part from tempSegment
+      tempSegment = tempSegment.substr(matchedIndex + match.length);
+    });
+
+    // add last fixed part if present
+    (tempSegment.length > 0) && (fixedParts.push(tempSegment));
+
+    return fixedParts;
+  },
+
   /** Separates out collection and path variables from the reqUrl
    *
    * @param {string} reqUrl Request Url
@@ -1874,7 +1918,7 @@ module.exports = {
       reqBody = operationItem.properties.requestBody,
       itemParams = operationItem.properties.parameters,
       reqParams = this.getParametersForPathItem(itemParams),
-      baseUrl = openapi.baseUrl,
+      baseUrl = '{{baseUrl}}',
       pathVarArray = [],
       authHelper,
       item,
@@ -1906,12 +1950,14 @@ module.exports = {
     // Add collection variables to the variableStore.
     sanitizeResult.collectionVars.forEach((element) => {
       if (!variableStore[element.name]) {
-        variableStore[element.name] = {
-          id: element.name,
-          value: element.default || '',
-          description: element.description,
-          type: 'collection'
-        };
+        let fakedData = options.schemaFaker ?
+            safeSchemaFaker(element.schema || {}, options.requestParametersResolution, PROCESSING_TYPE.CONVERSION,
+              PARAMETER_SOURCE.REQUEST, components, SCHEMA_FORMATS.DEFAULT, options.indentCharacter, schemaCache,
+              options.stackLimit) : '',
+          convertedPathVar = _.get(this.convertParamsWithStyle(element, fakedData, PARAMETER_SOURCE.REQUEST,
+            components, schemaCache), '[0]', {});
+
+        variableStore[element.name] = _.assign(convertedPathVar, { id: element.name, type: 'collection' });
       }
     });
     // accounting for the overriding of the root level and path level servers object if present at the operation level
@@ -2294,7 +2340,8 @@ module.exports = {
       retVal.push({
         // using path instead of operationId / sumamry since it's widely understood
         name: method + ' ' + path,
-        path: matchedPath,
+        // assign path as schemaPathName property to use path in path object
+        path: _.assign(matchedPath, { schemaPathName: path }),
         jsonPath: matchedPathJsonPath + '.' + method.toLowerCase(),
         pathVariables: pathVars,
         score: score
@@ -2410,8 +2457,8 @@ module.exports = {
     // decide explodable params, starting value and separators between key-value and properties for serialisation
     switch (style) {
       case 'matrix':
-        isExplodable = true;
-        startValue = ';' + (paramSchema.type === 'object' ? '' : (paramName + _.isEmpty(paramValue) ? '' : '='));
+        isExplodable = paramSchema.type === 'object' || explode;
+        startValue = ';' + ((paramSchema.type === 'object' && explode) ? '' : (paramName + '='));
         propSeparator = explode ? ';' : ',';
         keyValueSeparator = explode ? '=' : ',';
         break;
@@ -2475,7 +2522,7 @@ module.exports = {
       };
 
     // for invalid param object return null
-    if (!_.isObject(param)) {
+    if (!_.isObject(param) || !_.isString(paramValue)) {
       return null;
     }
 
@@ -2702,10 +2749,10 @@ module.exports = {
 
                   // for empty string _.set creates new key with empty string '', so separate handling
                   if (dataPath === '') {
-                    suggestedValue = this.getSuggestedValue(fakedValue, valueToUse, ajvError);
+                    suggestedValue = this.getSuggestedValue(fakedValue, suggestedValue, ajvError);
                   }
                   else {
-                    _.set(suggestedValue, dataPath, this.getSuggestedValue(fakedValue, valueToUse, ajvError));
+                    _.set(suggestedValue, dataPath, this.getSuggestedValue(fakedValue, suggestedValue, ajvError));
                   }
                 });
 
@@ -2794,14 +2841,18 @@ module.exports = {
     var mismatchProperty = 'PATHVARIABLE',
       // all path variables defined in this path. acc. to the spec, all path params are required
       schemaPathVariables,
+      pmPathVariables,
       schemaPathVar;
 
     if (options.validationPropertiesToIgnore.includes(mismatchProperty)) {
       return callback(null, []);
     }
 
+    // find all schema path variables that can be present as collection path variables
+    pmPathVariables = this.findPathVariablesFromSchemaPath(schemaPath.schemaPathName);
     schemaPathVariables = _.filter(schemaPath.parameters, (param) => {
-      return (param.in === 'path');
+      // exclude path variables stored as collection variable from being validated further
+      return (param.in === 'path' && _.includes(pmPathVariables, param.name));
     });
 
     async.map(determinedPathVariables, (pathVar, cb) => {
@@ -3413,6 +3464,10 @@ module.exports = {
           schemaPathPrefix + '.content', _.get(schemaResponse, 'content'), mismatchProperty, options);
 
       _.each(_.filter(schemaHeaders, (h, hName) => {
+        // exclude empty headers fron validation
+        if (_.isEmpty(h)) {
+          return false;
+        }
         h.name = hName;
         return h.required;
       }), (header) => {
@@ -3610,6 +3665,15 @@ module.exports = {
       }
     });
 
+    // handle root path '/'
+    if (postmanPath === '/' && schemaPath === '/') {
+      anyMatchFound = true;
+      maxScoreFound = 1; // assign max possible score
+      matchedPathVars = []; // no path variables present
+      fixedMatchedSegments = 0;
+      variableMatchedSegments = 0;
+    }
+
     if (anyMatchFound) {
       return {
         match: true,
@@ -3642,7 +3706,14 @@ module.exports = {
       // No. of fixed segment matches between schema and postman url path
       fixedMatchedSegments = 0,
       // No. of variable segment matches between schema and postman url path
-      variableMatchedSegments = 0;
+      variableMatchedSegments = 0,
+      // checks if schema segment provided is path variable
+      isSchemaSegmentPathVar = (segment) => {
+        return segment.startsWith('{') &&
+        segment.endsWith('}') &&
+        // check that only one path variable is present as collection path variable can contain only one var
+        segment.indexOf('}') === segment.lastIndexOf('}');
+      };
 
     if (options.strictRequestMatching && pmSuffix.length !== schemaPath.length) {
       return {
@@ -3656,28 +3727,31 @@ module.exports = {
     // segments match if the schemaPath segment is {..} or the postmanPathStr is :<anything> or {{anything}}
     // for (let i = pmSuffix.length - 1; i >= 0; i--) {
     for (let i = 0; i < minLength; i++) {
+      let schemaFixedParts = this.getFixedPartsFromPathSegment(schemaPath[sMax - i], 'schema'),
+        collectionFixedParts = this.getFixedPartsFromPathSegment(pmSuffix[pMax - i], 'collection');
+
       if (
-        (schemaPath[sMax - i] === pmSuffix[pMax - i]) || // exact match
-        (schemaPath[sMax - i].startsWith('{') && schemaPath[sMax - i].endsWith('}')) || // schema segment is a pathVar
+        (_.isEqual(schemaFixedParts, collectionFixedParts)) || // exact fixed parts match
+        (isSchemaSegmentPathVar(schemaPath[sMax - i])) || // schema segment is a pathVar
         (pmSuffix[pMax - i].startsWith(':')) || // postman segment is a pathVar
         (this.isPmVariable(pmSuffix[pMax - i])) // postman segment is an env/collection var
       ) {
 
         // for variable match increase variable matched segments count (used for determining order for multiple matches)
         if (
-          (schemaPath[sMax - i].startsWith('{') && schemaPath[sMax - i].endsWith('}')) && // schema segment is a pathVar
+          (isSchemaSegmentPathVar(schemaPath[sMax - i])) && // schema segment is a pathVar
           ((pmSuffix[pMax - i].startsWith(':')) || // postman segment is a pathVar
             (this.isPmVariable(pmSuffix[pMax - i]))) // postman segment is an env/collection var
         ) {
           variableMatchedSegments++;
         }
         // for exact match increase fix matched segments count (used for determining order for multiple matches)
-        else if (schemaPath[sMax - i] === pmSuffix[pMax - i]) {
+        else if (_.isEqual(schemaFixedParts, collectionFixedParts)) {
           fixedMatchedSegments++;
         }
 
-        // add a matched path variable only if the schema one was a pathVar
-        if (schemaPath[sMax - i].startsWith('{') && schemaPath[sMax - i].endsWith('}')) {
+        // add a matched path variable only if the schema one was a pathVar and only one path variable is in segment
+        if (isSchemaSegmentPathVar(schemaPath[sMax - i])) {
           variables.push({
             key: schemaPath[sMax - i].substring(1, schemaPath[sMax - i].length - 1),
             value: pmSuffix[pMax - i]
@@ -3859,7 +3933,7 @@ module.exports = {
               // Not adding colloection variables for now
               suggestedValue: {
                 request: convertedRequest,
-                variables
+                variables: _.values(variables)
               }
             };
           }

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "openapi-to-postmanv2",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Convert a given OpenAPI specification to Postman Collection v2.0",
   "homepage": "https://github.com/postmanlabs/openapi-to-postman",
   "bugs": "https://github.com/postmanlabs/openapi-to-postman/issues",
@@ -120,7 +120,7 @@
     "async": "3.1.0",
     "commander": "2.20.3",
     "js-yaml": "3.13.1",
-    "lodash": "4.17.13",
+    "lodash": "4.17.19",
     "oas-resolver-browser": "2.3.3",
     "path-browserify": "1.0.1",
     "postman-collection": "3.5.5",

package.json

@@ -57,7 +57,7 @@
 				]
 			}
     },
-    "/new/{path}.{new-path-variable}": {
+    "/new/{path}.{new-path-variable-1}": {
 			"get": {
 				"summary": "List all pets",
 				"operationId": "listPets",
@@ -72,19 +72,21 @@
 						"required": true,
 						"schema": {
 							"type": "string",
-              "pattern": "json|xml",
-              "example": "json"
+              "example": "send-email"
 						}
           },
           {
-						"name": "new-path-variable",
+						"name": "new-path-variable-1",
 						"in": "path",
 						"description": "description",
 						"required": true,
 						"schema": {
-							"type": "string",
-              "pattern": "json|xml",
-              "example": "json"
+							"type": "object",
+              "properties": {
+								"R": { "type": "integer", "example": 100 },
+								"G": { "type": "integer", "example": 200 },
+								"B": { "type": "integer", "example": 150 }
+							}
 						}
 					}
 				]
@@ -123,7 +125,7 @@
 				]
 			}
 		},
-		"/anotherpath/{path}/{new-path-variable}.{onemore}": {
+		"/anotherpath/{path}/{new-path-variable-2}.{onemore}": {
 			"get": {
 				"summary": "List all pets",
 				"operationId": "listPets",
@@ -143,14 +145,16 @@
 						}
           },
           {
-						"name": "new-path-variable",
+						"name": "new-path-variable-2",
 						"in": "path",
 						"description": "description",
 						"required": true,
 						"schema": {
-							"type": "string",
-              "pattern": "json|xml",
-              "example": "json"
+							"type": "array",
+              "items": {
+								"type": "string",
+								"example": "exampleString"
+							}
 						}
 					},
 					{

test/data/valid_openapi/issue#133.json

@@ -59,8 +59,8 @@
 		"schemas": {
 			"RequestBody": {
 				"required": [
-					"id",
-					"name"
+					"requestId",
+					"requestName"
 				],
 				"properties": {
 					"requestId": {
@@ -74,8 +74,8 @@
       },
       "ResponseBody": {
         "required": [
-          "id",
-          "name"
+          "responseId",
+          "responseName"
         ],
         "properties": {
           "responseId": {