@digitraffic/common 2022.10.31-2 → 2022.10.31-3

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"
+}