legacy/routes/queries.js

var express = require("express");
var router = express.Router();
var util = require("util");
var constants = require("../util/constants");
var utils = require("../util/utils");

var scenarioMap = {
  "true": "True",
  "false": "False",
  "1000000": "Positive",
  "-1000000": "Negative",
  "10000000000": "Positive",
  "-10000000000": "Negative",
  "1.034E+20": "Positive",
  "-1.034E-20": "Negative",
  "9999999.999": "Positive",
  "-9999999.999": "Negative",
  "begin!*'();:@ &=+$,/?#[]end": "UrlEncoded",
  "multibyte": "MultiByte",
  "empty": "Empty",
  "null": "Null",
  "2012-01-01": "Valid",
  "2012-01-01T01:01:01Z": "Valid",
  "green color": "Valid",
  "unicode": "Unicode",
};

var typeMap = {
  bool: "Bool",
  int: "Int",
  long: "Long",
  float: "Float",
  double: "Double",
  string: "String",
  byte: "Byte",
  date: "Date",
  datetime: "DateTime",
  enum: "Enum",
};

var queryParameterMap = {
  bool: "boolQuery",
  int: "intQuery",
  long: "longQuery",
  float: "floatQuery",
  double: "doubleQuery",
  string: "stringQuery",
  byte: "byteQuery",
  date: "dateQuery",
  datetime: "dateTimeQuery",
  enum: "enumQuery",
};

var getScenarioName = function (type, scenario) {
  console.log('received type "' + type + '" and scenario "' + scenario + '"\n');
  var parsedType = typeMap[type];
  var parsedScenario = scenarioMap[scenario];
  if (!parsedScenario || !parsedType) {
    return null;
  }

  console.log('Got parsed type "' + parsedType + '" and parsed scenario "' + parsedScenario + '"\n');
  return "" + parsedType + parsedScenario;
};

var getQueryParameterName = function (type) {
  console.log('received type "' + type + '"\n');
  var queryParam = queryParameterMap[type];

  if (!queryParam) {
    return null;
  }

  console.log('Got parsed query parameter name "' + queryParam + "\n");
  return "" + queryParam;
};

var validateArrayQuery = function (arrayValue, separator) {
  var testValue = arrayValue;
  if (Array.isArray(arrayValue)) {
    if (arrayValue.length != 4) {
      return false;
    }
    testValue = arrayValue.toString();
  }
  console.log('received array value "' + testValue + '" separator "' + separator + '"');
  return testValue === "ArrayQuery1" + separator + "begin!*'();:@ &=+$,/?#[]end" + separator + separator;
};

var queries = function (coverage) {
  router.get("/:type/empty", function (req, res, next) {
    console.log("inside router\n");
    var type = req.params.type;
    var scenario = "empty";
    var queryName = getQueryParameterName(type);

    var test = getScenarioName(type, scenario);
    var queryParamCount = Object.keys(req.query).length;
    if (test === null) {
      console.log("test was null\n");
      utils.send400(res, next, 'Unable to parse scenario "/paths/' + type + "/" + scenario + '"');
    } else if (scenario === "empty" && queryParamCount == 1 && req.query[queryName] === "") {
      console.log("in empty test\n");
      coverage["UrlQueries" + test]++;
      res.status(200).end();
    } else {
      console.log("Null Failure!\n");
      utils.send400(
        res,
        next,
        'Failed null test for type "' + type + '" received query parameter "' + util.inspect(req.query) + '"',
      );
    }
  });

  router.get("/:type/null", function (req, res, next) {
    console.log("inside router\n");
    var type = req.params.type;
    var scenario = "null";
    var queryName = getQueryParameterName(type);

    var test = getScenarioName(type, scenario);
    if (test === null) {
      console.log("test was null\n");
      utils.send400(res, next, 'Unable to parse scenario "/paths/' + type + "/" + scenario + '"');
    } else if (scenario === "null" && Object.keys(req.query).length == 0) {
      console.log("in null test\n");
      coverage["UrlQueries" + test]++;
      res.status(200).end();
    } else {
      console.log("Null Failure!\n");
      utils.send400(
        res,
        next,
        'Failed null test for type "' + type + '" received query parameter "' + util.inspect(req.query) + '"',
      );
    }
  });

  router.get("/array/:format/string/:scenario", function (req, res, next) {
    console.log("inside router\n");
    var type = req.params.type;
    var scenario = req.params.scenario;
    var format = req.params.format;

    var test = getScenarioName(type, scenario);
    if (format === "csv") {
      console.log("In csv test\n");
      if (scenario === "null" && Object.keys(req.query).length == 0) {
        coverage["UrlQueriesArrayCsvNull"]++;
        res.status(200).end();
      } else if (scenario === "empty" && Object.keys(req.query).length == 1 && req.query.arrayQuery === "") {
        coverage["UrlQueriesArrayCsvEmpty"]++;
        res.status(200).end();
      } else if (
        scenario === "valid" &&
        Object.keys(req.query).length == 1 &&
        validateArrayQuery(req.query.arrayQuery, ",")
      ) {
        coverage["UrlQueriesArrayCsvValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, 'Failed csv array scenario format "' + format + '", scenario "' + scenario + '"');
      }
    } else if (format === "multi") {
      console.log("In multi test\n");
      if (scenario === "null" && Object.keys(req.query).length == 0) {
        coverage["UrlQueriesArrayMultiNull"]++;
        res.status(200).end();
      } else if (scenario === "empty" && Object.keys(req.query).length == 0) {
        coverage["UrlQueriesArrayMultiEmpty"]++;
        res.status(200).end();
      } else if (
        scenario === "valid" &&
        Object.keys(req.query).length == 1 &&
        validateArrayQuery(req.query.arrayQuery, ",")
      ) {
        //Note: comma is used as a seperator to test multi format with becuase Array.toString returns comma seperated list
        coverage["UrlQueriesArrayMultiValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, 'Failed csv array scenario format "' + format + '", scenario "' + scenario + '"');
      }
    } else if (format === "ssv" && scenario === "valid") {
      console.log("in ssv test\n");
      if (scenario === "valid" && Object.keys(req.query).length == 1 && validateArrayQuery(req.query.arrayQuery, " ")) {
        coverage["UrlQueriesArraySsvValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, 'Failed ssv array scenario format "' + format + '", scenario "' + scenario + '"');
      }
    } else if (format === "tsv" && scenario === "valid") {
      console.log("in tsv test\n");
      if (
        scenario === "valid" &&
        Object.keys(req.query).length == 1 &&
        validateArrayQuery(req.query.arrayQuery, "\t")
      ) {
        coverage["UrlQueriesArrayTsvValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, 'Failed tsv array scenario format "' + format + '", scenario "' + scenario + '"');
      }
    } else if (format === "pipes" && scenario === "valid") {
      console.log("in pipes test\n");
      if (scenario === "valid" && Object.keys(req.query).length == 1 && validateArrayQuery(req.query.arrayQuery, "|")) {
        coverage["UrlQueriesArrayPipesValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, 'Failed pipes array scenario format "' + format + '", scenario "' + scenario + '"');
      }
    } else if (format == "none") {
      if (req.query.arrayQuery == "hello,nihao,bonjour") {
        coverage["UrlQueriesArrayNoCollectionFormatValid"]++;
        res.status(200).end();
      } else {
        utils.send400(
          res,
          next,
          "'arrayQuery' parameter must be of value 'hello,nihao,bonjour', not '" + req.query["arrayQuery"] + "'",
        );
      }
    } else {
      console.log("Array Failure!\n");
      utils.send400(
        res,
        next,
        'Unable to find matching Array scenario for format "' + format + '" scenario "' + scenario + '"',
      );
    }
  });

  router.get("/:type/:scenario", function (req, res, next) {
    var type = req.params.type;
    var scenario = req.params.scenario;
    var queryName = getQueryParameterName(type);
    var wireParameter = req.query[queryName];
    var test = getScenarioName(type, scenario);
    console.log(
      'inside main function with values type "' +
        type +
        '" scenario "' +
        scenario +
        '" queryName "' +
        queryName +
        '" wireParameter "' +
        wireParameter +
        '"\n',
    );
    var bytes = new Buffer(constants.MULTIBYTE_BUFFER);

    if (
      type === "enum" ||
      type === "date" ||
      type === "datetime" ||
      scenario === "multibyte" ||
      (type === "string" && scenario.indexOf("begin") === 0) ||
      scenario == "unicode"
    ) {
      scenario = '"' + scenario + '"';
      wireParameter = '"' + wireParameter + '"';
    }

    scenario = JSON.parse(scenario);
    wireParameter = JSON.parse(wireParameter);

    if (test === null) {
      console.log("test was null\n");
      utils.send400(res, next, 'Unable to parse scenario "/paths/' + type + "/" + scenario + '"');
    } else if (scenario === "null" && wireParameter) {
      console.log("in null test\n");
      utils.send400(res, next, 'Null scenario must have empty query parameter instead of "' + wireParameter + '"');
    } else if (scenario === "empty" && wireParameter !== "" && wireParameter !== null) {
      console.log("in empty test\n");
      utils.send400(res, next, 'Empty scenario must have empty parameter instead of "' + wireParameter + '"');
    } else if (type === "string" || type === "date" || type === "enum") {
      if (scenario === wireParameter || (scenario === "unicode" && wireParameter === "啊齄丂狛狜隣郎隣兀﨩")) {
        console.log("Success!\n");
        coverage["UrlQueries" + test]++;
        res.status(200).end();
      } else {
        utils.send400(
          res,
          next,
          "Failed " + type + ' scenario "' + scenario + '" does not match wire parameter "' + wireParameter + '"',
        );
      }
    } else if (type === "byte") {
      if (scenario === "multibyte" && wireParameter === bytes.toString("base64")) {
        console.log("Success!\n");
        coverage["UrlQueries" + test]++;
        res.status(200).end();
      } else {
        utils.send400(
          res,
          next,
          'Failed byte scenario "' +
            wireParameter +
            '" does not match expected encoded string "' +
            bytes.toString("base64") +
            '"',
        );
      }
    } else if (type === "datetime") {
      if (utils.coerceDate(wireParameter) === scenario) {
        console.log("Success!\n");
        coverage["UrlQueries" + test]++;
        res.status(200).end();
      } else {
        utils.send400(
          res,
          next,
          'Failed date-time scenario "' +
            utils.coerceDate(wireParameter) +
            '" does not match expected date string "' +
            scenario +
            '"',
        );
      }
    } else if (scenario === wireParameter) {
      console.log("Success!\n");
      coverage["UrlQueries" + test]++;
      res.status(200).end();
    } else {
      console.log("mismatched parameters\n");
      utils.send400(
        res,
        next,
        'Expected query parameter "' + scenario + '" does not match wire parameter "' + wireParameter + '"',
      );
    }
  });
};

queries.prototype.router = router;

module.exports = queries;