cranker-router/test.js

A cranker router in Javascript.

const express = require("express");
const connectToRouters = require("cranker-connector");
const httpClient = require("./http-client.js");
const crankerRouter = require("./server.js");
const bodyParser = require("body-parser");
const assert = require("assert");
const multer = require("multer");
const upload = multer();

function getRemoteAddr(request) {
    const ip = request.headers["x-forwarded-for"]
        || request.connection.remoteAddress
        || request.socket.remoteAddress
        || request.connection.socket.remoteAddress;
    const remotePort = request.connection.remotePort;
    const remoteAddr = ip + ":" + remotePort;
    return remoteAddr;
}

process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

const test = async function () {
    const suggestedRouterPort = 0;
    const routerObject = await crankerRouter(suggestedRouterPort);
    const routerPort = routerObject.getListener().address().port;
    const crankerPort = routerObject.getCrankerListener().address().port;
    console.log(">test router port", routerPort, "cranker port", crankerPort);

    // Now start a target
    const targetApp = express();
    targetApp.use(bodyParser.urlencoded({ extended: false }));

    targetApp.get("/test", function (req, res) {
        console.log(">test target server test called");
        res.send("<h1>Hello!</h1>");
    });

    // Add a POST test
    targetApp.post("/test", function (req, res) {
        console.log(">test target server test called", req.body, "<");
        const data = `<h1>${Object.values(req.body).join(" ")}</h1>`;
        res.send(data);
    });

    const targetListener = await new Promise((resolve, reject) => {
        const listener = targetApp.listen(0, _ => resolve(listener));
    });
    const targetPort = targetListener.address().port;
    console.log(">test target server listening on", targetPort);

    let crankerRoutes = routerObject.getCrankedRoutes();
    
    // Now connect to the router
    const routers = await connectToRouters(
        [`localhost:${crankerPort}`],
        "test",
        `http://localhost:${targetPort}`, {
            _do_untls: true,
            deferConnect: true
        }
    );

    routers.on("crankedPing", evt => console.log("crankedPing pong"));
    
    let crankerSockets = 0;
    const result = await new Promise((resolve, reject) => {
        routers.once("testsetup", async data => {
            console.log("> test got 2 crankers");
            const result = await httpClient.request(routerPort);
            resolve(result);
        });

        routers.on("crankerConnected", _ => {
            crankerSockets = crankerSockets + 1;
            if (crankerSockets === 2) {
                // We've reached limit
                routers.emit("testsetup");
            }
        });
        routers.on("crankerDisconnected", s => {
            crankerSockets = crankerSockets - 1;
        });

        routers.connect();
    });

    crankerRoutes = routerObject.getCrankedRoutes();
    console.log(">test cranker sockets count #1",
                crankerSockets,
                crankerRoutes["test"].length);

    const postResult = await new Promise(async (resolve, reject) => {
        const postData = {
            param1: "hello",
            param2: "world"
        };
        const result = await httpClient.request(routerPort, postData);
        resolve(result);
    });
    
    console.log(">test waiting for sockets maybe");

    await new Promise(
        (resolve, reject) => setTimeout(_ => resolve(), 3000)
    );
    
    crankerRoutes = routerObject.getCrankedRoutes();
    console.log("> test cranker sockets count #2",
                crankerSockets,
                crankerRoutes["test"].length,
                crankerRoutes["test"]);

    const grabbedRoutesLength = [crankerSockets, crankerRoutes["test"].length];

    // Before we close, everything is back to having the right number of sockets
    assert(crankerSockets === 2, "cranker sockets should be 2 because that's the limit.");
    assert(crankerRoutes["test"].length === 2, "the sockets attached to the routes should be 2 as well");
    
    // Close everything
    await routers.close();
    targetListener.close();
    routerObject.close();

    // Assert the GET
    assert.deepStrictEqual(result.statusCode, 200);
    assert.deepStrictEqual(result.chunkArray[0], new String("<h1>Hello!</h1>"));
    assert (crankerSockets == 0);

    // We have to wait 1/2 second for the closes to come up to the router object socket
    const crankerRoutesAfterClose = await new Promise((resolve, reject) => {
        setTimeout(_ => resolve(routerObject.getCrankedRoutes()), 500);
    });
    assert (crankerRoutesAfterClose["test"].length === 0, `routes length is not 0: ${Object.values(crankerRoutesAfterClose)}`);

    // Assert the POST
    console.log(">test postRestult", postResult);
    assert.deepStrictEqual(postResult.statusCode, 200);
    assert.deepStrictEqual(postResult.headers["content-length"], "20");
    assert.deepStrictEqual(postResult.chunkArray[0], new String("<h1>hello world</h1>"));

    return;
};

test().then(data => console.log("end", data));

// End