@veecode-platform/backstage-plugin-about-backend-dynamic 1.0.1

package/node_modules/express-promise-router/test/express-promise-router.test.js

@@ -0,0 +1,401 @@
+"use strict";
+
+var assert = require("chai").assert;
+var sinon = require("sinon");
+var express = require("express");
+var GET = require("./util/http-utils").GET;
+
+var delay = function (method, payload) {
+  setTimeout(function () {
+    method(payload);
+  }, 10);
+};
+
+var PromiseRouter = require("../lib/express-promise-router.js");
+
+describe("express-promise-router", function () {
+  var app;
+  var serverListening;
+  var server;
+  var router;
+
+  var bootstrap = function (router) {
+    app = express();
+    app.use("/", router);
+
+    if (serverListening) {
+      throw "already bootstrapped";
+    }
+
+    serverListening = new Promise(function (resolve, reject) {
+      server = app.listen(12345, function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+
+    return serverListening;
+  };
+
+  beforeEach(function () {
+    router = new PromiseRouter();
+  });
+
+  afterEach(function () {
+    if (serverListening) {
+      return serverListening.then(function () {
+        server.close();
+        app = undefined;
+        server = undefined;
+        serverListening = undefined;
+      });
+    }
+  });
+
+  it("should call next with an error when a returned promise is rejected", function () {
+    var callback = sinon.spy();
+
+    router.use("/foo", function () {
+      return new Promise(function (resolve, reject) {
+        delay(reject, "some error");
+      });
+    });
+    router.use(function (err, req, res, next) {
+      assert.equal("some error", err);
+      callback();
+      res.send();
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(callback.calledOnce);
+      });
+  });
+
+  it('should call next without an error when a returned promise is resolved with "next"', function () {
+    var errorCallback = sinon.spy();
+    var nextCallback = sinon.spy();
+
+    router.use("/foo", function () {
+      return new Promise(function (resolve) {
+        delay(resolve, "next");
+      });
+    });
+    router.use("/foo", function (req, res) {
+      nextCallback();
+      res.send();
+    });
+    router.use(function (err, req, res, next) {
+      errorCallback();
+      next();
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(errorCallback.notCalled);
+        assert(nextCallback.calledOnce);
+      });
+  });
+
+  it('should not call next when a returned promise is resolved with anything other than "route" or "next"', function () {
+    var callback = sinon.spy();
+
+    router.get("/foo", function (req, res) {
+      return new Promise(function (resolve) {
+        res.send();
+        delay(resolve, "something");
+      });
+    });
+    router.get("/bar", function (req, res) {
+      return new Promise(function (resolve) {
+        res.send();
+        delay(resolve, {});
+      });
+    });
+    router.use(function (req, res) {
+      callback();
+      res.send(500);
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(callback.notCalled);
+        return GET("/bar");
+      })
+      .then(function () {
+        assert(callback.notCalled);
+      });
+  });
+
+  it("should move to the next middleware when next is called without an error", function () {
+    var callback = sinon.spy();
+
+    router.use("/foo", function (req, res, next) {
+      next();
+    });
+    router.use("/foo", function (req, res, next) {
+      callback();
+      res.send();
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(callback.calledOnce);
+      });
+  });
+
+  it("should move to the next error handler when next is called with an error", function () {
+    var callback = sinon.spy();
+    var errorCallback = sinon.spy();
+
+    router.use("/foo", function (req, res, next) {
+      next("an error");
+    });
+    router.use("/foo", function (req, res, next) {
+      callback();
+      next();
+    });
+    router.use(function (err, req, res, next) {
+      assert.equal("an error", err);
+      errorCallback();
+      res.send();
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(errorCallback.calledOnce);
+        assert(callback.notCalled);
+      });
+  });
+
+  it("should call chained handlers in the correct order", function () {
+    var fn2 = sinon.spy(function (req, res) {
+      res.send();
+    });
+    var fn1 = sinon.spy(function () {
+      assert(fn2.notCalled);
+      return Promise.resolve("next");
+    });
+
+    router.get("/foo", fn1, fn2);
+
+    return bootstrap(router).then(function () {
+      return GET("/foo");
+    });
+  });
+
+  it("should correctly call an array of handlers", function () {
+    var fn2 = sinon.spy(function (req, res) {
+      res.send();
+    });
+    var fn1 = sinon.spy(function () {
+      assert(fn2.notCalled);
+      return Promise.resolve("next");
+    });
+
+    router.get("/foo", [[fn1], [fn2]]);
+
+    return bootstrap(router).then(function () {
+      return GET("/foo");
+    });
+  });
+
+  it('should call next("route") if a returned promise is resolved with "route"', function () {
+    var fn1 = function () {
+      return Promise.resolve("route");
+    };
+    var fn2 = function () {
+      assert.fail();
+    };
+
+    router.get("/foo", fn1, fn2);
+    router.get("/foo", function (req, res) {
+      res.send();
+    });
+
+    return bootstrap(router).then(function () {
+      return GET("/foo");
+    });
+  });
+
+  it("should bind to RegExp routes", function () {
+    var fn1 = function (req, res) {
+      res.send();
+    };
+
+    router.get(/^\/foo/, fn1);
+
+    return bootstrap(router).then(function () {
+      return GET("/foo");
+    });
+  });
+
+  it('multiple calls to handlers that have used "next" should not interfere with each other', function () {
+    var fn = sinon.spy(function (req, res, next) {
+      if (fn.calledOnce) {
+        next("error");
+      } else {
+        setTimeout(function () {
+          res.status(200).send("ok");
+        }, 15);
+      }
+    });
+    var errHandler = function (err, req, res, next) {
+      if (err === "error") {
+        res.send("fail");
+      } else {
+        next(err);
+      }
+    };
+
+    router.get("/foo", fn, errHandler);
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "fail");
+        return GET("/foo");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "ok");
+      });
+  });
+
+  it("calls next if next is called even if the handler returns a promise", function () {
+    var fn = function (req, res, next) {
+      next();
+      return new Promise(function (resolve, reject) {});
+    };
+    var fn2 = function (req, res) {
+      res.send("ok");
+    };
+    var errHandler = function (err, req, res, next) {
+      res.send("error");
+    };
+
+    router.get("/foo", fn, fn2, errHandler);
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "ok");
+      });
+  });
+
+  it("calls next with an error if the returned promise is rejected with no reason", function () {
+    var fn = function () {
+      return new Promise(function (resolve, reject) {
+        delay(reject, null);
+      });
+    };
+    var errHandler = function (err, req, res, next) {
+      res.send("error");
+    };
+
+    router.get("/foo", fn, errHandler);
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "error");
+      });
+  });
+
+  it("should handle resolved promises returned in req.param() calls", function () {
+    router.param("id", function () {
+      return new Promise(function (resolve) {
+        delay(resolve, "next");
+      });
+    });
+    router.use("/foo/:id", function (req, res) {
+      res.send("done");
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo/1");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "done");
+      });
+  });
+
+  it("should call next with unresolved promises returned in req.param() calls", function () {
+    var assertOutput = "error in param";
+
+    router.param("id", function (req, res, next, id) {
+      return new Promise(function (resolve, reject) {
+        delay(reject, assertOutput);
+      });
+    });
+
+    var fn = function (req, res) {
+      res.send("done");
+    };
+
+    var errHandler = function (err, req, res, next) {
+      res.send(err);
+    };
+
+    router.use("/foo/:id", fn);
+
+    router.use(errHandler);
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo/1");
+      })
+      .then(function (res) {
+        assert.equal(res.body, assertOutput);
+      });
+  });
+
+  it("support array in routes values", function () {
+    router.use(["/", "/foo/:bar"], function (req, res) {
+      res.send("done");
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "done");
+
+        return GET("/foo/1");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "done");
+      });
+  });
+
+  it("should throw sensible errors when handler is not a function", function () {
+    assert.throws(function () {
+      router.use("/foo/:id", null);
+    }, /callback/);
+  });
+});

package/node_modules/express-promise-router/test/test-resources/.eslintrc

@@ -0,0 +1,6 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 2015,
+    "sourceType": "module"
+  }
+}

package/node_modules/express-promise-router/test/test-resources/babel-base-case.js

@@ -0,0 +1,12 @@
+import express from "express";
+import Router from "../../lib/express-promise-router.js";
+const router = Router();
+
+router.get("/", function (req, res) {
+  res.send("Hi!");
+});
+
+const app = express();
+app.use(router);
+app.listen(12345);
+console.log("START");

package/node_modules/express-promise-router/test/test-resources/commonjs-base-case.js

@@ -0,0 +1,12 @@
+var express = require("express");
+var Router = require("../../lib/express-promise-router.js");
+var router = Router();
+
+router.get("/", function (req, res) {
+  res.send("Hi!");
+});
+
+var app = express();
+app.use(router);
+app.listen(12345);
+console.log("START");

package/node_modules/express-promise-router/test/test-resources/typescript-base-case.ts

@@ -0,0 +1,13 @@
+/// <reference path="../../index.d.ts"/>
+import * as express from "express";
+import Router from "../../lib/express-promise-router.js";
+const router = Router();
+
+router.get("/", function (req, res) {
+  res.send("Hi!");
+});
+
+const app = express();
+app.use(router);
+app.listen(12345);
+console.log("START");

package/node_modules/express-promise-router/test/tracing.test.js

@@ -0,0 +1,36 @@
+const Router = require("../lib/express-promise-router");
+const assert = require("chai").assert;
+
+describe("function name", function () {
+  it("uses the wrapped handler's name in a route handler", function () {
+    const router = Router();
+    router.get("/test-route", function actualHandler() {});
+
+    assert.equal(router.stack[0].route.stack[0].handle.name, "actualHandler");
+    assert.equal(router.stack[0].route.stack[0].name, "actualHandler");
+  });
+
+  it("uses the wrapped handler's name in a middleware handler", function () {
+    const router = Router();
+    router.use(function actualHandler(req, res, next) {});
+
+    assert.equal(router.stack[0].handle.name, "actualHandler");
+    assert.equal(router.stack[0].name, "actualHandler");
+  });
+
+  it("uses the wrapped handler's name in an error middleware", function () {
+    const router = Router();
+    router.use(function actualErrorHandler(err, req, res, next) {});
+
+    assert.equal(router.stack[0].handle.name, "actualErrorHandler");
+    assert.equal(router.stack[0].name, "actualErrorHandler");
+  });
+
+  it("empty name for anonymous middleware handler", function () {
+    const router = Router();
+    router.use((req, res, next) => {});
+
+    assert.equal(router.stack[0].handle.name, "");
+    assert.equal(router.stack[0].name, "<anonymous>");
+  });
+});

package/node_modules/express-promise-router/test/typescript.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var tt = require("@mormahr/typescript-definition-tester");
+var path = require("path");
+var resolve = require("path").resolve;
+var assert = require("chai").assert;
+var spawnTypeScript = require("./util/launch-utils").spawnTypeScript;
+var GET = require("./util/http-utils").GET;
+
+describe("TypeScript", function () {
+  it("should compile base-case successfully against index.d.ts", function (done) {
+    this.timeout(20000);
+    tt.compile(
+      [
+        path.resolve(
+          __dirname + "/typescript-resources/typescript-base-case.ts",
+        ),
+      ],
+      {},
+      done.bind(null),
+    );
+  });
+
+  it("should run the example and respond", function (done) {
+    this.timeout(5000);
+    var ts_file = resolve(
+      __dirname,
+      "./test-resources/typescript-base-case.ts",
+    );
+    var target = spawnTypeScript(ts_file);
+    var called = false;
+
+    target.stdout.on("data", function (data) {
+      if (data.toString().indexOf("START") === -1) {
+        return;
+      }
+
+      GET("/").then(function () {
+        called = true;
+        target.kill("SIGINT");
+      });
+    });
+
+    target.stderr.on("data", function (data) {
+      console.error(data.toString());
+    });
+
+    target.on("close", function () {
+      assert(called);
+      done();
+    });
+  });
+});

package/node_modules/express-promise-router/test/util/http-utils.js

@@ -0,0 +1,14 @@
+var request = require("request-promise");
+var assert = require("chai").assert;
+
+exports.GET = function (route) {
+  return request({
+    url: "http://localhost:12345" + route,
+    resolveWithFullResponse: true,
+  }).then(function (res) {
+    // Express sends 500 errors for uncaught exceptions (like failed assertions)
+    // Make sure to still fail the test if an assertion in middleware failed.
+    assert.equal(res.statusCode, 200);
+    return res;
+  });
+};

package/node_modules/express-promise-router/test/util/launch-utils.js

@@ -0,0 +1,40 @@
+var ts = require("typescript");
+var babel = require("@babel/core");
+var fs = require("fs");
+var spawn = require("child_process").spawn;
+var dirname = require("path").dirname;
+
+function spawnString(source, dir) {
+  return spawn("node", ["-e", source], {
+    cwd: dir,
+  });
+}
+
+// path has to be fully qualified
+exports.spawnTypeScript = function spawnTypeScript(path) {
+  var content = fs.readFileSync(path, "utf-8");
+
+  var compilerOptions = {
+    module: ts.ModuleKind.CommonJS,
+  };
+
+  var transpiled = ts.transpile(content, compilerOptions);
+
+  return spawnString(transpiled, dirname(path));
+};
+
+exports.spawnJavaScript = function spawnJavaScript(path) {
+  var content = fs.readFileSync(path, "utf-8");
+
+  return spawnString(content, dirname(path));
+};
+
+exports.spawnBabel = function spawnBabel(path) {
+  var content = fs.readFileSync(path, "utf-8");
+
+  var result = babel.transform(content, {
+    plugins: ["@babel/plugin-transform-modules-commonjs"],
+  });
+
+  return spawnString(result.code, dirname(path));
+};

package/node_modules/fecha/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Taylor Hakes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+