@digitraffic/common 2022.10.28-2 → 2022.10.31-1

package/test/secrets/secret-holder.test.ts

@@ -0,0 +1,143 @@
+import { mockSecret, stubSecretsManager } from "../../src/test/secrets-manager";
+
+import * as sinon from "sinon";
+
+const SECRET_WITH_PREFIX = {
+    "prefix.value": "value",
+    "prefix.name": "name",
+    "wrong.value": "value",
+    username: "DB_USER",
+};
+const SECRET_EMPTY = {};
+
+const stubSM = stubSecretsManager();
+
+import { SecretHolder } from "../../src/aws/runtime/secrets/secret-holder";
+import { DatabaseEnvironmentKeys } from "../../src/aws/runtime/secrets/dbsecret";
+
+describe("SecretHolder - tests", () => {
+    beforeEach(() => {
+        process.env["SECRET_ID"] = "test-id";
+    });
+
+    afterEach(() => {
+        sinon.restore();
+        sinon.reset();
+        delete process.env[DatabaseEnvironmentKeys.DB_USER];
+    });
+
+    test("get - no secret", async () => {
+        mockSecret(null);
+
+        const holder = SecretHolder.create();
+        await expect(async () => {
+            await holder.get();
+        }).rejects.toThrowError("No secret found!");
+    });
+
+    test("get - empty secret", async () => {
+        mockSecret(SECRET_EMPTY);
+
+        const holder = SecretHolder.create();
+        const secret = await holder.get();
+
+        expect(secret).toEqual(SECRET_EMPTY);
+    });
+
+    test("get - no prefix", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        const holder = SecretHolder.create();
+        const secret = await holder.get();
+
+        expect(secret).toEqual(SECRET_WITH_PREFIX);
+    });
+
+    test("get - check keys - not found", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        const holder = SecretHolder.create("", ["not_found"]);
+        await expect(async () => {
+            await holder.get();
+        }).rejects.toThrow();
+    });
+
+    test("get - check keys - found", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        const holder = SecretHolder.create("", ["prefix.value", "username"]);
+
+        await holder.get();
+    });
+
+    test("setDatabaseCredentials - no prefix", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        const holder = SecretHolder.create();
+        expect(process.env[DatabaseEnvironmentKeys.DB_USER]).toBeUndefined();
+
+        await holder.setDatabaseCredentials();
+        expect(process.env[DatabaseEnvironmentKeys.DB_USER]).toEqual(
+            SECRET_WITH_PREFIX.username
+        );
+    });
+
+    test("setDatabaseCredentials - with prefix", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        const holder = SecretHolder.create("prefix");
+        expect(process.env[DatabaseEnvironmentKeys.DB_USER]).toBeUndefined();
+
+        await holder.setDatabaseCredentials();
+        expect(process.env[DatabaseEnvironmentKeys.DB_USER]).toEqual(
+            SECRET_WITH_PREFIX.username
+        );
+    });
+
+    test("getSecret - with prefix", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        const holder = SecretHolder.create("prefix");
+        const secret = await holder.get();
+
+        expect(secret).toEqual({
+            value: "value",
+            name: "name",
+        });
+    });
+
+    test("get - ttl - do not fetch", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        const holder = SecretHolder.create();
+
+        const callCount = stubSM.callCount;
+
+        await holder.get();
+        expect(stubSM.callCount).toEqual(callCount + 1);
+
+        // gets cached secret
+        await holder.get();
+        expect(stubSM.callCount).toEqual(callCount + 1);
+    });
+
+    test("get - ttl - fetch", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        const holder = new SecretHolder("", "", [], {
+            ttl: 1,
+        });
+
+        const callCount = stubSM.callCount;
+
+        await holder.get();
+        expect(stubSM.callCount).toEqual(callCount + 1);
+
+        // cache expires, fetches secret again
+        const start = Date.now();
+        while (Date.now() < start + 2000);
+
+        await holder.get();
+        expect(stubSM.callCount).toEqual(callCount + 2);
+    });
+});

package/test/secrets/secret.test.ts

@@ -0,0 +1,49 @@
+import {mockSecret, stubSecretsManager} from "../../src/test/secrets-manager";
+
+import * as sinon from 'sinon';
+
+const SECRET_ID = "test_secret";
+const SECRET_WITH_PREFIX = {
+    "prefix.value" : "value",
+    "prefix.name" : "name",
+    "wrong.value" : "value",
+};
+const SECRET_EMPTY = {};
+
+stubSecretsManager();
+
+import {getSecret} from "../../src/aws/runtime/secrets/secret";
+
+describe('secret - test', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    test('getSecret - no secret', async () => {
+        mockSecret(null);
+        await expect(async () => {
+            await getSecret(SECRET_ID, '');
+        }).rejects.toThrowError("No secret found!");
+    });
+
+    test('getSecret - empty secret', async () => {
+        mockSecret(SECRET_EMPTY);
+        const secret = await getSecret(SECRET_ID, '');
+        expect(secret).toEqual(SECRET_EMPTY);
+    });
+
+    test('getSecret - no prefix', async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const secret = await getSecret(SECRET_ID, '');
+        expect(secret).toEqual(SECRET_WITH_PREFIX);
+    });
+
+    test('getSecret - with prefix', async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const secret = await getSecret(SECRET_ID, 'prefix');
+        expect(secret).toEqual({
+            value: "value",
+            name: "name",
+        });
+    });
+});

package/test/test/httpserver.test.ts

@@ -0,0 +1,128 @@
+import {
+    TestHttpServer,
+    ListenProperties,
+    ERROR_NO_MATCH,
+    ERRORCODE_NOT_FOUND,
+} from "../../src/test/httpserver";
+import { IncomingMessage } from "http";
+import http = require("http");
+
+const DEFAULT_PATH = "/";
+const PORT = 8091;
+
+const DEFAULT_PROPS = {
+    "/": () => "",
+};
+
+describe("TestHttpServer - test", () => {
+    async function withServer(
+        fn: (server: TestHttpServer) => Promise<void>,
+        props: ListenProperties = DEFAULT_PROPS,
+        statusCode = 200
+    ) {
+        const server = new TestHttpServer();
+
+        server.listen(PORT, props, false, statusCode);
+
+        try {
+            await fn(server);
+        } finally {
+            server.close();
+        }
+    }
+
+    function sendGetRequest(path = DEFAULT_PATH): Promise<IncomingMessage> {
+        return sendRequest("GET", path);
+    }
+
+    function sendPostRequest(
+        path = DEFAULT_PATH,
+        body: string
+    ): Promise<IncomingMessage> {
+        return sendRequest("POST", path, body);
+    }
+
+    function sendRequest(
+        method: string,
+        path: string,
+        body?: string
+    ): Promise<IncomingMessage> {
+        return new Promise((resolve, reject) => {
+            const request = http.request(
+                {
+                    path,
+                    port: PORT,
+                    method,
+                },
+                (response: IncomingMessage) => {
+                    response.on("data", () => {
+                        // do nothing
+                    });
+
+                    //the whole response has been received, so we just print it out here
+                    response.on("end", () => {
+                        resolve(response);
+                    });
+
+                    response.on("error", (error: Error) => {
+                        reject(error);
+                    });
+                }
+            );
+
+            if (method === "POST") {
+                request.write(body);
+            }
+            request.end();
+        });
+    }
+
+    test("no calls", () => {
+        return withServer(async (server: TestHttpServer) => {
+            await expect(server.getCallCount()).toEqual(0);
+        });
+    });
+
+    test("one get", async () => {
+        await withServer(async (server: TestHttpServer) => {
+            await sendGetRequest();
+
+            expect(server.getCallCount()).toEqual(1);
+        });
+    });
+
+    test("one get - no MATCH", async () => {
+        await withServer(async (server: TestHttpServer) => {
+            const response = await sendGetRequest("/no-match");
+
+            expect(server.getCallCount()).toEqual(1);
+            expect(server.getRequestBody(0)).toEqual(ERROR_NO_MATCH);
+            expect(response.statusCode).toEqual(ERRORCODE_NOT_FOUND);
+        });
+    });
+
+    test("get - error 405", async () => {
+        const ERROR_CODE = 405;
+
+        await withServer(
+            async (server: TestHttpServer) => {
+                const response = await sendGetRequest();
+
+                expect(server.getCallCount()).toEqual(1);
+                expect(response.statusCode).toEqual(ERROR_CODE);
+            },
+            DEFAULT_PROPS,
+            ERROR_CODE
+        );
+    });
+
+    test("one post", async () => {
+        await withServer(async (server: TestHttpServer) => {
+            const testBody = "Testing123!";
+            await sendPostRequest(DEFAULT_PATH, testBody);
+
+            expect(server.getCallCount()).toEqual(1);
+            expect(server.getRequestBody(0)).toEqual(testBody);
+        });
+    });
+});

package/test/utils/date-utils.test.ts

@@ -0,0 +1,28 @@
+import moment from "moment";
+import * as CommonDateUtils from "../../src/utils/date-utils";
+
+const ISO = "2022-01-02T01:02:03.004Z";
+
+describe('CommonDateUtilsTest', () => {
+
+    test('dateFromIsoString', () => {
+        const parsed = CommonDateUtils.dateFromIsoString(ISO);
+        expect(parsed.toISOString()).toEqual(ISO);
+    });
+
+    test('dateFromIsoString fails', () => {
+        expect(() => CommonDateUtils.dateFromIsoString(ISO + "foobar")).toThrowError();
+    });
+
+    test('countDiffMs', () => {
+        const start = new Date();
+        const end = moment(start).add(1234, 'milliseconds').toDate();
+        expect (CommonDateUtils.countDiffMs(start, end)).toEqual(1234);
+    });
+
+    test('countDiffMs', () => {
+        const start = new Date();
+        const end = moment(start).add(1234, 'seconds').toDate();
+        expect (CommonDateUtils.countDiffInSeconds(start, end)).toEqual(1234);
+    });
+});

package/test/utils/geometry.test.ts

@@ -0,0 +1,29 @@
+import {Asserter} from "../../src/test/asserter";
+import * as Geometry from '../../src/utils/geometry';
+
+const TAMPERE_WGS84_X = 23.761290078;
+const TAMPERE_WGS84_Y = 61.497742570;
+
+const KUOPIO_WGS84_X = 27.688935;
+const KUOPIO_WGS84_Y = 62.892983;
+const TAMPERE_KUOPIO_DISTANCE_KM = 255.8;
+
+describe('CommonGeometryTest', () => {
+
+    test('distanceBetweenWGS84PointsInKm', () => {
+        Asserter.assertToBeCloseTo(Geometry.distanceBetweenPositionsInKm([TAMPERE_WGS84_X, TAMPERE_WGS84_Y], [KUOPIO_WGS84_X, KUOPIO_WGS84_Y]),TAMPERE_KUOPIO_DISTANCE_KM, 0.5);
+        console.info(Geometry.distanceBetweenPositionsInKm([TAMPERE_WGS84_X, TAMPERE_WGS84_Y], [KUOPIO_WGS84_X, KUOPIO_WGS84_Y]));
+    });
+
+    test('distanceBetweenWGS84PointsInKm', () => {
+        Asserter.assertToBeCloseTo(Geometry.distanceBetweenPositionsInM([TAMPERE_WGS84_X, TAMPERE_WGS84_Y], [KUOPIO_WGS84_X, KUOPIO_WGS84_Y]),TAMPERE_KUOPIO_DISTANCE_KM*1000, 500);
+        console.info(Geometry.distanceBetweenPositionsInM([TAMPERE_WGS84_X, TAMPERE_WGS84_Y], [KUOPIO_WGS84_X, KUOPIO_WGS84_Y]));
+    });
+
+    test('areDistinctPositions', () => {
+        expect(Geometry.areDistinctPositions([1,2],[1,2])).toBe(false);
+        expect(Geometry.areDistinctPositions([1.1,2.2],[1.1,2.2])).toBe(false);
+        expect(Geometry.areDistinctPositions([1,2.1],[1,2])).toBe(true);
+        expect(Geometry.areDistinctPositions([1,2],[1,2.000000000000001])).toBe(true);
+    });
+});

package/test/utils/utils.test.ts

@@ -0,0 +1,64 @@
+import * as ArrayUtils from "../../src/utils/utils";
+
+describe("ArrayUtils", () => {
+    test("bothArraysHasSameValues", () => {
+        expect(ArrayUtils.bothArraysHasSameValues([], [])).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(["a"], ["a"])).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(["a"], ["a", "a"])).toEqual(
+            true
+        );
+        expect(
+            ArrayUtils.bothArraysHasSameValues(["a", "a"], ["a", "a"])
+        ).toEqual(true);
+
+        expect(ArrayUtils.bothArraysHasSameValues(null, null)).toEqual(true);
+        expect(
+            ArrayUtils.bothArraysHasSameValues(undefined, undefined)
+        ).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(null, undefined)).toEqual(
+            true
+        );
+        expect(ArrayUtils.bothArraysHasSameValues(["a"], undefined)).toEqual(
+            false
+        );
+        expect(ArrayUtils.bothArraysHasSameValues(["a"], null)).toEqual(false);
+        /* eslint-enable */
+        expect(
+            ArrayUtils.bothArraysHasSameValues(["a", "b"], ["a", "a"])
+        ).toEqual(false);
+        expect(
+            ArrayUtils.bothArraysHasSameValues(["a", "a", "a"], ["a", "b", "c"])
+        ).toEqual(false);
+
+        const o1 = { a: 1, b: 2 };
+        const o2 = { a: 1, b: 2 };
+        // Objects are references to same
+        expect(ArrayUtils.bothArraysHasSameValues([o1], [o1])).toEqual(true);
+        // Object's are not the same but the contents are the same
+        expect(ArrayUtils.bothArraysHasSameValues([o1], [o2])).toEqual(false);
+    });
+
+    test("getFirst - empty throws", () => {
+        expect(() => {
+            ArrayUtils.getFirst([]);
+        }).toThrow();
+    });
+
+    test("getFirst - two objects", () => {
+        expect(ArrayUtils.getFirst([1, 2])).toEqual(1);
+    });
+
+    test("getFirst - two objects with sort function", () => {
+        expect(ArrayUtils.getFirst([1, 2], (a) => -a)).toEqual(2);
+    });
+
+    test("getLast - empty throws", () => {
+        expect(() => {
+            ArrayUtils.getLast([]);
+        }).toThrow();
+    });
+
+    test("getLast - two objects", () => {
+        expect(ArrayUtils.getLast([1, 2])).toEqual(2);
+    });
+});

package/tsconfig.eslint.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*.ts", "test/**/*.ts"],
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["es2020"],
+    "outDir": "dist",
+    "declaration": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "strict": true,
+    "exactOptionalPropertyTypes": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "experimentalDecorators": true
+  },
+  "include": ["src/**/*.ts"],
+  "$schema": "https://json.schemastore.org/tsconfig"
+}