legacy/routes/complex.js

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

var complex = function (coverage) {
  /**
   * Put and get for basic complex classes.
   */
  router.put("/basic/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      if (_.isEqual(req.body, { id: 2, name: "abc", color: "Magenta" })) {
        coverage["putComplexBasicValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like valid req " + util.inspect(req.body));
      }
    } else {
      utils.send400(res, next, 'Must specify scenario either "valid" or "empty"');
    }
  });

  router.get("/basic/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      coverage["getComplexBasicValid"]++;
      res.status(200).type("json").end('{ "id": 2, "name": "abc", "color": "YELLOW" }');
    } else if (req.params.scenario === "empty") {
      coverage["getComplexBasicEmpty"]++;
      res.status(200).type("json").end("{ }");
    } else if (req.params.scenario === "notprovided") {
      coverage["getComplexBasicNotProvided"]++;
      res.status(200).end();
    } else if (req.params.scenario === "null") {
      coverage["getComplexBasicNull"]++;
      res.status(200).type("json").end('{ "id": null, "name": null }');
    } else if (req.params.scenario === "invalid") {
      coverage["getComplexBasicInvalid"]++;
      res.status(200).type("json").end('{ "id": "a", "name": "abc" }');
    } else {
      res.status(400).send("Request scenario must be valid, empty, null, notprovided, or invalid.");
    }
  });

  /**
   * Put and get for primitive
   */
  var intBody = { field1: -1, field2: 2 };
  var longBody = { field1: 1099511627775, field2: -999511627788 };
  var floatBody = { field1: 1.05, field2: -0.003 };
  var doubleBody = {
    field1: 3e-100,
    field_56_zeros_after_the_dot_and_negative_zero_before_dot_and_this_is_a_long_field_name_on_purpose:
      -0.000000000000000000000000000000000000000000000000000000005,
  };
  var doubleBodyInbound = {
    field1: 3e-100,
    field_56_zeros_after_the_dot_and_negative_zero_before_dot_and_this_is_a_long_field_name_on_purpose: -5e-57,
  };
  var boolBody = { field_true: true, field_false: false };
  var stringBody = { field: "goodrequest", empty: "", null: null };
  var stringBodyInbound = { field: "goodrequest", empty: "" };
  var dateBody = { field: "0001-01-01", leap: "2016-02-29" };
  var datetimeBody = { field: "0001-01-01T00:00:00Z", now: "2015-05-18T18:38:00Z" };
  var datetimeRfc1123Body = { field: "Mon, 01 Jan 0001 00:00:00 GMT", now: "Mon, 18 May 2015 11:38:00 GMT" };
  var datetimeRfc1123BodyAlternate = { field: "Mon, 01 Jan 1 00:00:00 GMT", now: "Mon, 18 May 2015 11:38:00 GMT" };
  var datetimeRfc1123BodyAlternateWithSpaces = {
    field: "Mon, 01 Jan    1 00:00:00 GMT",
    now: "Mon, 18 May 2015 11:38:00 GMT",
  };
  var durationBody = { field: "P123DT22H14M12.011S" };
  var durationBodyAlternate = { field: "P123DT22H14M12.010999999998603S" };
  var byteString = new Buffer([255, 254, 253, 252, 0, 250, 249, 248, 247, 246]).toString("base64");
  var byteBody = '{"field":"' + byteString + '"}';
  router.put("/primitive/:scenario", function (req, res, next) {
    if (req.params.scenario === "integer") {
      if (_.isEqual(req.body, intBody)) {
        coverage["putComplexPrimitiveInteger"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like integer req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "long") {
      if (_.isEqual(req.body, longBody)) {
        coverage["putComplexPrimitiveLong"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like long req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "float") {
      if (_.isEqual(req.body, floatBody)) {
        coverage["putComplexPrimitiveFloat"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like float req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "double") {
      if (_.isEqual(req.body, doubleBodyInbound)) {
        coverage["putComplexPrimitiveDouble"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like double req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "bool") {
      if (_.isEqual(req.body, boolBody)) {
        coverage["putComplexPrimitiveBool"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like bool req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "string") {
      console.log(JSON.stringify(req.body));
      if (_.isEqual(req.body, stringBody) || _.isEqual(req.body, stringBodyInbound)) {
        coverage["putComplexPrimitiveString"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like string req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "date") {
      if (_.isEqual(req.body, dateBody)) {
        coverage["putComplexPrimitiveDate"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like date req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "datetime") {
      if (_.isEqual(utils.coerceDate(req.body), datetimeBody)) {
        coverage["putComplexPrimitiveDateTime"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like datetime req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "datetimerfc1123") {
      if (
        _.isEqual(req.body, datetimeRfc1123Body) ||
        _.isEqual(req.body, datetimeRfc1123BodyAlternate) ||
        _.isEqual(req.body, datetimeRfc1123BodyAlternateWithSpaces)
      ) {
        coverage["putComplexPrimitiveDateTimeRfc1123"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like datetimerfc1123 req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "duration") {
      if (_.isEqual(req.body, durationBody) || _.isEqual(req.body, durationBodyAlternate)) {
        coverage["putComplexPrimitiveDuration"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like duration req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "byte") {
      if (JSON.stringify(req.body) === byteBody) {
        coverage["putComplexPrimitiveByte"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like byte req " + util.inspect(req.body));
      }
    } else {
      utils.send400(res, next, "Must provide a valid primitive type.");
    }
  });

  router.get("/primitive/:scenario", function (req, res, next) {
    if (req.params.scenario === "integer") {
      coverage["getComplexPrimitiveInteger"]++;
      res.status(200).json(intBody);
    } else if (req.params.scenario === "long") {
      coverage["getComplexPrimitiveLong"]++;
      res.status(200).json(longBody);
    } else if (req.params.scenario === "float") {
      coverage["getComplexPrimitiveFloat"]++;
      res.status(200).json(floatBody);
    } else if (req.params.scenario === "double") {
      coverage["getComplexPrimitiveDouble"]++;
      res.status(200).json(doubleBody);
    } else if (req.params.scenario === "bool") {
      coverage["getComplexPrimitiveBool"]++;
      res.status(200).json(boolBody);
    } else if (req.params.scenario === "string") {
      coverage["getComplexPrimitiveString"]++;
      res.status(200).json(stringBody);
    } else if (req.params.scenario === "date") {
      coverage["getComplexPrimitiveDate"]++;
      res.status(200).json(dateBody);
    } else if (req.params.scenario === "datetime") {
      coverage["getComplexPrimitiveDateTime"]++;
      res.status(200).json(datetimeBody);
    } else if (req.params.scenario === "datetimerfc1123") {
      coverage["getComplexPrimitiveDateTimeRfc1123"]++;
      res.status(200).json(datetimeRfc1123Body);
    } else if (req.params.scenario === "duration") {
      coverage["getComplexPrimitiveDuration"]++;
      res.status(200).json(durationBody);
    } else if (req.params.scenario === "byte") {
      coverage["getComplexPrimitiveByte"]++;
      res.status(200).type("json").end(byteBody);
    } else {
      utils.send400(res, next, "Must provide a valid primitive type scenario.");
    }
  });

  /**
   * Put and get for array properties.
   */
  var arrayValidBody = '{"array":["1, 2, 3, 4","",null,"&S#$(*Y","The quick brown fox jumps over the lazy dog"]}';
  router.put("/array/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      if (JSON.stringify(req.body) === arrayValidBody) {
        coverage["putComplexArrayValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like complex array req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "empty") {
      if (JSON.stringify(req.body) === '{"array":[]}') {
        coverage["putComplexArrayEmpty"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like complex array req " + util.inspect(req.body));
      }
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  router.get("/array/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      coverage["getComplexArrayValid"]++;
      res.status(200).type("json").end(arrayValidBody);
    } else if (req.params.scenario === "empty") {
      coverage["getComplexArrayEmpty"]++;
      res.status(200).type("json").end('{"array":[]}');
    } else if (req.params.scenario === "notprovided") {
      coverage["getComplexArrayNotProvided"]++;
      res.status(200).type("json").end("{}");
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  /**
   * Put and get for typed dictionary properties.
   */
  var dictionaryValidBody = '{"defaultProgram":{"txt":"notepad","bmp":"mspaint","xls":"excel","exe":"","":null}}';
  router.put("/dictionary/typed/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      if (_.isEqual(req.body, JSON.parse(dictionaryValidBody))) {
        coverage["putComplexDictionaryValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like complex dictionary req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "empty") {
      if (JSON.stringify(req.body) === '{"defaultProgram":{}}') {
        coverage["putComplexDictionaryEmpty"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like complex array req " + util.inspect(req.body));
      }
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  router.get("/dictionary/typed/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      coverage["getComplexDictionaryValid"]++;
      res.status(200).type("json").end(dictionaryValidBody);
    } else if (req.params.scenario === "empty") {
      coverage["getComplexDictionaryEmpty"]++;
      res.status(200).type("json").end('{"defaultProgram":{}}');
    } else if (req.params.scenario === "null") {
      coverage["getComplexDictionaryNull"]++;
      res.status(200).type("json").end('{"defaultProgram":null}');
    } else if (req.params.scenario === "notprovided") {
      coverage["getComplexDictionaryNotProvided"]++;
      res.status(200).type("json").end("{}");
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  /**
   * Put and get for untyped dictionary properties.
   */
  router.put("/dictionary/untyped/:scenario", function (req, res, next) {
    res.status(501).end("Untyped dictionaries are not supported for now.");
  });

  router.get("/dictionary/untyped/:scenario", function (req, res, next) {
    res.status(501).end("Untyped dictionaries are not supported for now.");
  });

  /**
   * Put and get for inhertiance.
   */
  var siamese =
    '{"breed":"persian","color":"green","hates":[{"food":"tomato","id":1,"name":"Potato"},{"food":"french fries","id":-1,"name":"Tomato"}],"id":2,"name":"Siameeee"}';

  router.put("/inheritance/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      if (_.isEqual(req.body, JSON.parse(siamese))) {
        coverage["putComplexInheritanceValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like complex inheritance req " + util.inspect(req.body));
      }
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  router.get("/inheritance/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      coverage["getComplexInheritanceValid"]++;
      res.status(200).type("json").end(siamese);
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  /**
   * Put and get for polymorphism.
   */
  var rawFish = {
    fishtype: "salmon",
    location: "alaska",
    iswild: true,
    species: "king",
    length: 1.0,
    siblings: [
      {
        fishtype: "shark",
        age: 6,
        birthday: "2012-01-05T01:00:00Z",
        length: 20.0,
        species: "predator",
      },
      {
        fishtype: "sawshark",
        age: 105,
        birthday: "1900-01-05T01:00:00Z",
        length: 10.0,
        picture: new Buffer([255, 255, 255, 255, 254]).toString("base64"),
        species: "dangerous",
      },
      {
        fishtype: "goblin",
        age: 1,
        birthday: "2015-08-08T00:00:00Z",
        length: 30.0,
        species: "scary",
        jawsize: 5,
        // Intentionally requiring a value not defined in the enum, since
        // such values should be allowed to be sent to/received from the server
        color: "pinkish-gray",
      },
    ],
  };
  var rawSalmon = {
    fishtype: "smart_salmon",
    location: "alaska",
    iswild: true,
    species: "king",
    additionalProperty1: 1,
    additionalProperty2: false,
    additionalProperty3: "hello",
    additionalProperty4: { a: 1, b: 2 },
    additionalProperty5: [1, 3],
    length: 1.0,
    siblings: [
      {
        fishtype: "shark",
        age: 6,
        birthday: "2012-01-05T01:00:00Z",
        length: 20.0,
        species: "predator",
      },
      {
        fishtype: "sawshark",
        age: 105,
        birthday: "1900-01-05T01:00:00Z",
        length: 10.0,
        picture: new Buffer([255, 255, 255, 255, 254]).toString("base64"),
        species: "dangerous",
      },
      {
        fishtype: "goblin",
        age: 1,
        birthday: "2015-08-08T00:00:00Z",
        length: 30.0,
        species: "scary",
        jawsize: 5,
        color: "pinkish-gray",
      },
    ],
  };

  var regularSalmon = {
    fishtype: "salmon",
    location: "alaska",
    iswild: true,
    species: "king",
    length: 1.0,
    siblings: [
      {
        fishtype: "shark",
        age: 6,
        birthday: "2012-01-05T01:00:00Z",
        length: 20.0,
        species: "predator",
      },
      {
        fishtype: "sawshark",
        age: 105,
        birthday: "1900-01-05T01:00:00Z",
        length: 10.0,
        picture: new Buffer([255, 255, 255, 255, 254]).toString("base64"),
        species: "dangerous",
      },
      {
        fishtype: "goblin",
        age: 1,
        birthday: "2015-08-08T00:00:00Z",
        length: 30.0,
        species: "scary",
        jawsize: 5,
        color: "pinkish-gray",
      },
    ],
  };

  var regularSalmonWithoutDiscriminator = {
    location: "alaska",
    iswild: true,
    species: "king",
    length: 1.0,
    siblings: [
      {
        fishtype: "shark",
        age: 6,
        birthday: "2012-01-05T01:00:00Z",
        length: 20.0,
        species: "predator",
      },
      {
        fishtype: "sawshark",
        age: 105,
        birthday: "1900-01-05T01:00:00Z",
        length: 10.0,
        picture: new Buffer([255, 255, 255, 255, 254]).toString("base64"),
        species: "dangerous",
      },
      {
        fishtype: "goblin",
        age: 1,
        birthday: "2015-08-08T00:00:00Z",
        length: 30.0,
        species: "scary",
        jawsize: 5,
        color: "pinkish-gray",
      },
    ],
  };

  var dotSalmon = {
    "fish.type": "DotSalmon",
    "location": "sweden",
    "iswild": true,
    "species": "king",
  };

  var dotFishMarketWithDiscriminator = {
    sampleSalmon: {
      "fish.type": "DotSalmon",
      "location": "sweden",
      "iswild": false,
      "species": "king",
    },
    salmons: [
      {
        "fish.type": "DotSalmon",
        "location": "sweden",
        "iswild": false,
        "species": "king",
      },
      {
        "fish.type": "DotSalmon",
        "location": "atlantic",
        "iswild": true,
        "species": "king",
      },
    ],
    sampleFish: {
      "fish.type": "DotSalmon",
      "location": "australia",
      "iswild": false,
      "species": "king",
    },
    fishes: [
      {
        "fish.type": "DotSalmon",
        "location": "australia",
        "iswild": false,
        "species": "king",
      },
      {
        "fish.type": "DotSalmon",
        "location": "canada",
        "iswild": true,
        "species": "king",
      },
    ],
  };

  var dotFishMarketWithoutDiscriminator = {
    sampleSalmon: {
      location: "sweden",
      iswild: false,
      species: "king",
    },
    salmons: [
      {
        location: "sweden",
        iswild: false,
        species: "king",
      },
      {
        location: "atlantic",
        iswild: true,
        species: "king",
      },
    ],
    sampleFish: {
      location: "australia",
      iswild: false,
      species: "king",
    },
    fishes: [
      {
        location: "australia",
        iswild: false,
        species: "king",
      },
      {
        location: "canada",
        iswild: true,
        species: "king",
      },
    ],
  };

  coverage["getComplexPolymorphismDotSyntax"] = 0;
  router.get("/polymorphism/dotsyntax", function (req, res, next) {
    coverage["getComplexPolymorphismDotSyntax"]++;
    res.status(200).json(dotSalmon);
  });

  coverage["getComposedWithDiscriminator"] = 0;
  router.get("/polymorphism/composedWithDiscriminator", function (req, res, next) {
    coverage["getComposedWithDiscriminator"]++;
    res.status(200).json(dotFishMarketWithDiscriminator);
  });

  coverage["getComposedWithoutDiscriminator"] = 0;
  router.get("/polymorphism/composedWithoutDiscriminator", function (req, res, next) {
    coverage["getComposedWithoutDiscriminator"]++;
    res.status(200).json(dotFishMarketWithoutDiscriminator);
  });

  router.put("/polymorphism/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      console.log(JSON.stringify(req.body, null, 4));
      console.log(JSON.stringify(rawFish, null, 4));
      if (_.isEqual(utils.coerceDate(req.body), rawFish)) {
        coverage["putComplexPolymorphismValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like complex polymorphism req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "complicated") {
      console.log(JSON.stringify(req.body, null, 4));
      console.log(JSON.stringify(rawSalmon, null, 4));
      if (_.isEqual(utils.coerceDate(req.body), rawSalmon)) {
        coverage["putComplexPolymorphismComplicated"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like complex polymorphism req " + util.inspect(req.body));
      }
    } else if (req.params.scenario === "missingdiscriminator") {
      console.log(JSON.stringify(req.body, null, 4));
      console.log(JSON.stringify(regularSalmon, null, 4));
      if (_.isEqual(utils.coerceDate(req.body), regularSalmon)) {
        coverage["putComplexPolymorphismNoDiscriminator"]++;
        res.status(200).json(regularSalmonWithoutDiscriminator);
      } else {
        utils.send400(res, next, "Did not like complex polymorphism req " + util.inspect(req.body));
      }
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  router.get("/polymorphism/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      coverage["getComplexPolymorphismValid"]++;
      res.status(200).json(rawFish);
    } else if (req.params.scenario === "complicated") {
      coverage["getComplexPolymorphismComplicated"]++;
      res.status(200).json(rawSalmon);
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  router.put("/polymorphism/missingrequired/invalid", function (req, res, next) {
    utils.send400(
      res,
      next,
      "Reached server in scenario: /complex/polymorphism/missingrequired/invalid, and should not have - since required fields are missing from the request, the client should not be able to send it.",
    );
  });

  /**
   * Put and get for recursive reference.
   */
  var bigfishRaw = {
    fishtype: "salmon",
    location: "alaska",
    iswild: true,
    species: "king",
    length: 1,
    siblings: [
      {
        fishtype: "shark",
        age: 6,
        birthday: "2012-01-05T01:00:00Z",
        species: "predator",
        length: 20,
        siblings: [
          {
            fishtype: "salmon",
            location: "atlantic",
            iswild: true,
            species: "coho",
            length: 2,
            siblings: [
              {
                fishtype: "shark",
                age: 6,
                birthday: "2012-01-05T01:00:00Z",
                species: "predator",
                length: 20,
              },
              {
                fishtype: "sawshark",
                age: 105,
                birthday: "1900-01-05T01:00:00Z",
                picture: new Buffer([255, 255, 255, 255, 254]).toString("base64"),
                species: "dangerous",
                length: 10,
              },
            ],
          },
          {
            fishtype: "sawshark",
            age: 105,
            birthday: "1900-01-05T01:00:00Z",
            picture: new Buffer([255, 255, 255, 255, 254]).toString("base64"),
            species: "dangerous",
            length: 10,
            siblings: [],
          },
        ],
      },
      {
        fishtype: "sawshark",
        age: 105,
        birthday: "1900-01-05T01:00:00Z",
        picture: new Buffer([255, 255, 255, 255, 254]).toString("base64"),
        species: "dangerous",
        length: 10,
        siblings: [],
      },
    ],
  };

  router.put("/polymorphicrecursive/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      console.log(JSON.stringify(req.body, null, 4));
      console.log(JSON.stringify(bigfishRaw, null, 4));
      if (_.isEqual(utils.coerceDate(req.body), bigfishRaw)) {
        coverage["putComplexPolymorphicRecursiveValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "Did not like complex polymorphic recursive req " + util.inspect(req.body));
      }
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  router.get("/polymorphicrecursive/:scenario", function (req, res, next) {
    if (req.params.scenario === "valid") {
      coverage["getComplexPolymorphicRecursiveValid"]++;
      res.status(200).json(bigfishRaw);
    } else {
      utils.send400(res, next, "Must provide a valid scenario.");
    }
  });

  router.get("/readonlyproperty/valid", function (req, res, next) {
    coverage["getComplexReadOnlyPropertyValid"]++;
    res.status(200).json({ id: "1234", size: 2 });
  });

  router.put("/readonlyproperty/valid", function (req, res, next) {
    if (req.body) {
      if (typeof req.body.id == "undefined") {
        coverage["putComplexReadOnlyPropertyValid"]++;
        res.status(200).end();
      } else {
        utils.send400(res, next, "id is readonly");
      }
    }
  });
};

complex.prototype.router = router;

module.exports = complex;