Merge branch 'release/4.9.0'

Author: VShingala

CHANGELOG.md

@@ -1,5 +1,10 @@
 # OpenAPI-Postman Changelog
 
+#### v4.9.0 (February 06, 2023)
+* Fixed issue [#660](https://github.com/postmanlabs/openapi-to-postman/issues/660) where for certain XML request bodies, conversion was failing with TypeError.
+* Fixed issue where for some definitions having non-string URLs were failing conversion with TypeErrors.
+* Fixed issue where a test in-consistently kept failing due to uncertainity of jsf library.
+
 #### v4.8.0 (January 24, 2023)
 * Added specifictionVersion field to validate result.
 

lib/31XUtils/schemaUtils31X.js

@@ -125,7 +125,7 @@ module.exports = {
       schema.items = this.fixExamplesByVersion(schema.items);
     }
     else if (hasProperties) {
-      const schemaProperties = Object.keys(schema.properties);
+      const schemaProperties = _.keys(schema.properties);
       schemaProperties.forEach((property) => {
         schema.properties[property] = this.fixExamplesByVersion(schema.properties[property]);
       });
@@ -141,7 +141,7 @@ module.exports = {
    * @returns {boolean} Returns true if content is a binary type
    */
   isBinaryContentType (bodyType, contentObj) {
-    return Object.keys(contentObj[bodyType]).length === 0 && fileUploadTypes.includes(bodyType);
+    return _.keys(contentObj[bodyType]).length === 0 && fileUploadTypes.includes(bodyType);
   },
 
   getOuterPropsIfIsSupported(schema) {
@@ -152,7 +152,7 @@ module.exports = {
 
   addOuterPropsToRefSchemaIfIsSupported(refSchema, outerProps) {
     const resolvedSchema = _.cloneDeep(refSchema),
-      outerKeys = Object.keys(outerProps);
+      outerKeys = _.keys(outerProps);
 
     if (_.isObject(resolvedSchema) && _.isObject(outerProps)) {
       outerKeys.forEach((key) => {

lib/schemaUtils.js

@@ -196,6 +196,13 @@ function safeSchemaFaker (oldSchema, resolveTo, resolveFor, parameterSourceOptio
     });
   }
 
+  if (schemaFormat === 'xml') {
+    key += ' schemaFormatXML';
+  }
+  else {
+    key += ' schemaFormatDEFAULT';
+  }
+
   key = hash(key);
   if (schemaFakerCache[key]) {
     return schemaFakerCache[key];
@@ -360,6 +367,11 @@ module.exports = {
   * @returns {string} string after replacing /{pet}/ with /:pet/
   */
   fixPathVariablesInUrl: function (url) {
+    // URL should always be string so update value if non-string value is found
+    if (typeof url !== 'string') {
+      return '';
+    }
+
     // All complicated logic removed
     // This simply replaces all instances of {text} with {{text}}
     // text cannot have any of these 3 chars: /{}
@@ -371,7 +383,7 @@ module.exports = {
       }
       return '{' + p1 + '}';
     };
-    return url.replace(/(\{[^\/\{\}]+\})/g, replacer);
+    return _.isString(url) ? url.replace(/(\{[^\/\{\}]+\})/g, replacer) : '';
   },
 
   /**
@@ -2797,7 +2809,7 @@ module.exports = {
   // also, any endpoint-level params are merged into the returned pathItemObject
   findMatchingRequestFromSchema: function (method, url, schema, options) {
     // first step - get array of requests from schema
-    let parsedUrl = require('url').parse(url),
+    let parsedUrl = require('url').parse(_.isString(url) ? url : ''),
       retVal = [],
       pathToMatch,
       matchedPath,

lib/xmlSchemaFaker.js

@@ -47,7 +47,7 @@ function convertSchemaToXML(name, schema, attribute, indentChar, indent) {
         attributes.push(`${key}="${propVal}"`);
       }
       else {
-        childNodes += propVal;
+        childNodes += _.isString(propVal) ? propVal : '';
       }
     });
     if (attributes.length > 0) {
@@ -66,7 +66,7 @@ function convertSchemaToXML(name, schema, attribute, indentChar, indent) {
       contents;
 
     schemaItemsWithXmlProps.xml = schema.xml;
-    contents = convertSchemaToXML(arrayElemName, schemaItemsWithXmlProps, false, indentChar, indent + extraIndent) + 
+    contents = convertSchemaToXML(arrayElemName, schemaItemsWithXmlProps, false, indentChar, indent + extraIndent) +
       convertSchemaToXML(arrayElemName, schemaItemsWithXmlProps, false, indentChar, indent + extraIndent);
     if (isWrapped) {
       return `\n${cIndent}<${tagPrefix}${name}>${contents}\n${cIndent}</${tagPrefix}${name}>`;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "openapi-to-postmanv2",
-  "version": "4.8.0",
+  "version": "4.9.0",
   "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",

package.json

@@ -624,6 +624,26 @@ describe('fixExamplesByVersion method', function() {
     expect(JSON.stringify(fixedSchemaWithExample)).to.be.equal(JSON.stringify(expectedSchemaAfterFix));
   });
 
+  it('Should correctly handle schema with properties defined as null', function() {
+    const providedSchema = {
+        required: [
+          'id',
+          'name'
+        ],
+        type: 'object',
+        properties: null
+      },
+      expectedSchemaAfterFix = {
+        required: [
+          'id',
+          'name'
+        ],
+        type: 'object',
+        properties: null
+      },
+      fixedSchemaWithExample = concreteUtils.fixExamplesByVersion(providedSchema);
+    expect(JSON.stringify(fixedSchemaWithExample)).to.be.equal(JSON.stringify(expectedSchemaAfterFix));
+  });
 });
 
 describe('isBinaryContentType method', function() {
@@ -651,6 +671,15 @@ describe('isBinaryContentType method', function() {
       isBinary = concreteUtils.isBinaryContentType(bodyType, contentObject);
     expect(isBinary).to.be.false;
   });
+
+  it('Should correctly handle null value for corresponding body', function() {
+    const bodyType = 'application/octet-stream',
+      contentObject = {
+        'application/octet-stream': null
+      },
+      isBinary = concreteUtils.isBinaryContentType(bodyType, contentObject);
+    expect(isBinary).to.be.true;
+  });
 });
 
 describe('getOuterPropsIfIsSupported method', function() {
@@ -704,6 +733,22 @@ describe('getOuterPropsIfIsSupported method', function() {
     expect(resolvedSchema.job).to.be.equal(outerProperties.job);
     expect(JSON.stringify(resolvedSchema.required)).to.be.equal(JSON.stringify(expectedRequiredValue));
   });
+
+  it('Should correctly handle if outer properties are defined as null', function() {
+    const referencedSchema = {
+        name: 'Test name',
+        age: '30',
+        required: [
+          'name'
+        ]
+      },
+      outerProperties = null,
+      expectedRequiredValue = ['name'],
+      resolvedSchema = concreteUtils.addOuterPropsToRefSchemaIfIsSupported(referencedSchema, outerProperties);
+    expect(resolvedSchema).to.be.an('object')
+      .nested.to.have.all.keys('name', 'age', 'required');
+    expect(JSON.stringify(resolvedSchema.required)).to.be.equal(JSON.stringify(expectedRequiredValue));
+  });
 });
 
 describe('findTypeByExample method', function () {

test/unit/31Xsupport/schemaUtils31X.test.js

@@ -1816,7 +1816,9 @@ describe('CONVERT FUNCTION TESTS ', function() {
           const responseBodyWithAdditionalProperties =
             JSON.parse(conversionResult.output[0].data.item[0].response[1].body);
           expect(responseBodyWithAdditionalProperties).to.include.keys('test1');
-          expect(Object.keys(responseBodyWithAdditionalProperties).length).to.be.greaterThan(1);
+
+          // json-schema-faker doesn't guarantee that there will always be additional properties generated
+          expect(Object.keys(responseBodyWithAdditionalProperties).length).to.be.greaterThanOrEqual(1);
           done();
         });
     });

test/unit/base.test.js

@@ -206,7 +206,7 @@ describe('SCHEMA UTILITY FUNCTION TESTS ', function () {
         schemaCache = {
           schemaFakerCache: {}
         },
-        key = hash('resolveToSchema ' + JSON.stringify(resolvedSchema)),
+        key = hash('resolveToSchema ' + JSON.stringify(resolvedSchema) + ' schemaFormatDEFAULT'),
         options = {
           indentCharacter: '  ',
           stackLimit: 10,
@@ -251,7 +251,7 @@ describe('SCHEMA UTILITY FUNCTION TESTS ', function () {
           { components, concreteUtils },
           { resolveFor, resolveTo }
         ),
-        key = hash('resolveToExample ' + JSON.stringify(resolvedSchema)),
+        key = hash('resolveToExample ' + JSON.stringify(resolvedSchema) + ' schemaFormatDEFAULT'),
         options = {
           indentCharacter: '  ',
           stackLimit: 10,
@@ -268,6 +268,60 @@ describe('SCHEMA UTILITY FUNCTION TESTS ', function () {
       done();
 
     });
+
+    it('should populate schemaFakerCache with distinct value when only the schemaFormat is different', function (done) {
+      var schema = {
+          $ref: '#/components/schema/request'
+        },
+        components = {
+          schema: {
+            request: {
+              properties: {
+                name: {
+                  type: 'string'
+                }
+              }
+            }
+          }
+        },
+        parameterSource = 'REQUEST',
+        resolveTo = 'schema',
+        resolveFor = 'CONVERSION',
+        resolvedSchema = deref.resolveRefs(schema,
+          parameterSource,
+          { components, concreteUtils },
+          { resolveFor, resolveTo }
+        ),
+        schemaCache = {
+          schemaFakerCache: {}
+        },
+        xml_key = hash('resolveToSchema ' + JSON.stringify(resolvedSchema) + ' schemaFormatXML'),
+        default_key = hash('resolveToSchema ' + JSON.stringify(resolvedSchema) + ' schemaFormatDEFAULT'),
+        options = {
+          indentCharacter: '  ',
+          stackLimit: 10,
+          includeDeprecated: true
+        },
+        fakedSchema_default = SchemaUtils.safeSchemaFaker(schema, resolveTo, resolveFor, parameterSource,
+          { components, concreteUtils }, 'default', schemaCache, options),
+        fakedSchema_xml = SchemaUtils.safeSchemaFaker(schema, resolveTo, resolveFor, parameterSource,
+          { components, concreteUtils }, 'xml', schemaCache, options);
+
+      expect(schemaCache.schemaFakerCache).to.have.property(default_key);
+      expect(schemaCache.schemaFakerCache[default_key]).to.equal(fakedSchema_default);
+      expect(fakedSchema_default).to.eql({
+        name: '<string>'
+      });
+
+      expect(schemaCache.schemaFakerCache).to.have.property(xml_key);
+      expect(schemaCache.schemaFakerCache[xml_key]).to.equal(fakedSchema_xml);
+      expect(fakedSchema_xml).to.eql(
+        '<element>\n  <name>(string)</name>\n</element>'
+      );
+
+      done();
+    });
+
   });
 
   describe('convertToPmCollectionVariables function', function() {
@@ -2577,6 +2631,13 @@ describe('SCHEMA UTILITY FUNCTION TESTS ', function () {
   });
 
   describe('fixPathVariablesInUrl function', function() {
+    it('should be able to handle incorrect urls', function(done) {
+      expect(SchemaUtils.fixPathVariablesInUrl({})).to.equal('');
+      expect(SchemaUtils.fixPathVariablesInUrl(null)).to.equal('');
+      expect(SchemaUtils.fixPathVariablesInUrl(undefined)).to.equal('');
+      done();
+    });
+
     it('should convert a url with scheme and path variables', function(done) {
       var convertedUrl = SchemaUtils.fixPathVariablesInUrl('{scheme}://developer.uspto.gov/{path0}/segment/{path1}');
       expect(convertedUrl).to.equal('{{scheme}}://developer.uspto.gov/{{path0}}/segment/{{path1}}');
@@ -2593,6 +2654,18 @@ describe('SCHEMA UTILITY FUNCTION TESTS ', function () {
 
       done();
     });
+
+    it('should correctly handle non string values', function(done) {
+      expect(SchemaUtils.fixPathVariablesInUrl(123)).to.equal('');
+
+      expect(SchemaUtils.fixPathVariablesInUrl([])).to.equal('');
+
+      expect(SchemaUtils.fixPathVariablesInUrl({})).to.equal('');
+
+      expect(SchemaUtils.fixPathVariablesInUrl(true)).to.equal('');
+
+      done();
+    });
   });
 
   describe('findPathVariablesFromPath function', function() {

test/unit/util.test.js

@@ -1404,6 +1404,23 @@ describe('VALIDATE FUNCTION TESTS ', function () {
       expect(result[1].name).to.eql('GET /lookups');
       done();
     });
+
+    it('should correctly handle non string URLs', function (done) {
+      let schema = {
+          paths: {
+            '/lookups': {
+              'get': { 'summary': 'Lookup Job Values' }
+            }
+          }
+        },
+        schemaPath = null,
+        result;
+
+      result = schemaUtils.findMatchingRequestFromSchema('GET', schemaPath, schema, { strictRequestMatching: true });
+
+      expect(result).to.have.lengthOf(0);
+      done();
+    });
   });
 });