checkMetadata(transaction, transactionPathPrefix, schemaPath, pathRoute, options, callback) {
    let expectedReqName,
      expectedReqDesc,
      reqNameMismatch,
      actualReqName = _.get(transaction, 'name'),
      trimmedReqName,
      actualReqDesc,
      mismatches = [],
      mismatchObj,
      reqUrl;

    if (!options.validateMetadata) {
      return callback(null, []);
    }

    // only validate string upto 255 character as longer name results in issues while updation
    trimmedReqName = utils.trimRequestName(actualReqName);

    // handling path templating in request url if any
    // convert all {anything} to {{anything}}
    reqUrl = this.fixPathVariablesInUrl(pathRoute.slice(pathRoute.indexOf('/')));

    // convert all /{{one}}/{{two}} to /:one/:two
    // Doesn't touch /{{file}}.{{format}}
    reqUrl = this.sanitizeUrlPathParams(reqUrl, []).url;

    // description can be one of following two
    actualReqDesc = _.isObject(_.get(transaction, 'request.description')) ?
      _.get(transaction, 'request.description.content') : _.get(transaction, 'request.description');
    expectedReqDesc = schemaPath.description;

    switch (options.requestNameSource) {
      case 'fallback' : {
        // operationId is usually camelcase or snake case
        expectedReqName = schemaPath.summary || utils.insertSpacesInName(schemaPath.operationId) || reqUrl;
        expectedReqName = utils.trimRequestName(expectedReqName);
        reqNameMismatch = (trimmedReqName !== expectedReqName);
        break;
      }
      case 'url' : {
        // actual value may differ in conversion as it uses local/global servers info to generate it
        // for now suggest actual path as request name
        expectedReqName = reqUrl;
        reqNameMismatch = !_.endsWith(actualReqName, reqUrl);
        break;
      }
      default : {
        expectedReqName = schemaPath[options.requestNameSource];
        expectedReqName = utils.trimRequestName(expectedReqName);
        reqNameMismatch = (trimmedReqName !== expectedReqName);
        break;
      }
    }

    if (reqNameMismatch) {
      mismatchObj = {
        property: 'REQUEST_NAME',
        transactionJsonPath: transactionPathPrefix + '.name',
        schemaJsonPath: null,
        reasonCode: 'INVALID_VALUE',
        reason: 'The request name didn\'t match with specified schema'
      };

      options.suggestAvailableFixes && (mismatchObj.suggestedFix = {
        key: 'name',
        actualValue: actualReqName || null,
        suggestedValue: expectedReqName
      });
      mismatches.push(mismatchObj);
    }

    /**
     * Collection stores empty description as null, while OpenAPI spec can have empty string as description.
     * Hence We need to treat null and empty string as match. So check first if both schema and collection description
     * are not empty. _.isEmpty() returns true for null/undefined/''(empty string)
     * i.e. collection desc = null and schema desc = '', for this case no mismatch will occurr
     */
    if ((!_.isEmpty(actualReqDesc) || !_.isEmpty(expectedReqDesc)) && (actualReqDesc !== expectedReqDesc)) {
      mismatchObj = {
        property: 'REQUEST_DESCRIPTION',
        transactionJsonPath: transactionPathPrefix + '.request.description',
        schemaJsonPath: null,
        reasonCode: 'INVALID_VALUE',
        reason: 'The request description didn\'t match with specified schema'
      };

      options.suggestAvailableFixes && (mismatchObj.suggestedFix = {
        key: 'description',
        actualValue: actualReqDesc || null,
        suggestedValue: expectedReqDesc
      });
      mismatches.push(mismatchObj);
    }
    return callback(null, mismatches);
  }
@param {*} transaction Transaction with which to compare
@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 {*} pathRoute Route to applicable pathItem (i.e. 'GET /users/{userID}')
@param {*} options OAS options
@param {*} callback Callback
@returns {array} mismatches (in the callback)