@everyonesoftware/common 1.0.0

package/tests/mutableConditionTests.ts

@@ -0,0 +1,273 @@
+
+
+import { EqualFunctions } from "../sources/equalFunctions";
+import { MutableCondition } from "../sources/mutableCondition";
+import { PreConditionError } from "../sources/preConditionError";
+import { join } from "../sources/strings";
+import { ToStringFunctions } from "../sources/toStringFunctions";
+import { isNumber, isString } from "../sources/types";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("mutableCondition.ts", () =>
+    {
+        runner.testType("MutableCondition", () =>
+        {
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const mc: MutableCondition = MutableCondition.create();
+                test.assertNotUndefinedAndNotNull(mc);
+            });
+
+            runner.testFunction("setToStringFunctions()", () =>
+            {
+                function setToStringFunctionsErrorTest(testName: string, toStringFunctions: ToStringFunctions, expected: Error): void
+                {
+                    runner.test(testName, (test: Test) =>
+                    {
+                        const mc: MutableCondition = MutableCondition.create();
+                        test.assertThrows(() => mc.setToStringFunctions(toStringFunctions), expected);
+                    });
+                }
+
+                setToStringFunctionsErrorTest("with undefined", undefined!, new PreConditionError(
+                    "Expression: toStringFunctions",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+                setToStringFunctionsErrorTest("with null", null!, new PreConditionError(
+                    "Expression: toStringFunctions",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+
+                runner.test("with valid value", (test: Test) =>
+                {
+                    const mc: MutableCondition = MutableCondition.create();
+                    test.assertEqual(`"hello"`, mc.toValueString("hello"));
+
+                    mc.setToStringFunctions(
+                        ToStringFunctions.create()
+                            .add(isString, (value: string) => `---${value}---`),
+                    );
+                    test.assertEqual(`---hello---`, mc.toValueString("hello"));
+                });
+            });
+
+            runner.testFunction("setEqualFunctions()", () =>
+            {
+                function setEqualFunctionsErrorTest(testName: string, equalFunctions: EqualFunctions, expected: Error): void
+                {
+                    runner.test(testName, (test: Test) =>
+                    {
+                        const mc: MutableCondition = MutableCondition.create();
+                        test.assertThrows(() => mc.setEqualFunctions(equalFunctions), expected);
+                    });
+                }
+
+                setEqualFunctionsErrorTest("with undefined", undefined!, new PreConditionError(
+                    "Expression: equalFunctions",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+                setEqualFunctionsErrorTest("with null", null!, new PreConditionError(
+                    "Expression: equalFunctions",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+
+                runner.test("with valid value", (test: Test) =>
+                {
+                    const mc: MutableCondition = MutableCondition.create();
+                    test.assertFalse(mc.areEqual(3, 5));
+                    test.assertFalse(mc.areEqual(3, 4));
+                    test.assertTrue(mc.areEqual(4, 4));
+
+                    mc.setEqualFunctions(
+                        EqualFunctions.create()
+                            .add((left: unknown, right: unknown) =>
+                            {
+                                return isNumber(left) && isNumber(right)
+                                    ? left % 2 === right % 2
+                                    : undefined;
+                            })
+                    )
+
+                    test.assertTrue(mc.areEqual(3, 5));
+                    test.assertFalse(mc.areEqual(3, 4));
+                    test.assertTrue(mc.areEqual(4, 4));
+                });
+            });
+
+            runner.testFunction("setCreateErrorFunction()", () =>
+            {
+                function setCreateErrorFunctionErrorTest(testName: string, createErrorFunction: ((message: string) => Error), expected: Error): void
+                {
+                    runner.test(testName, (test: Test) =>
+                    {
+                        const mc: MutableCondition = MutableCondition.create();
+                        test.assertThrows(() => mc.setCreateErrorFunction(createErrorFunction), expected);
+                    });
+                }
+
+                setCreateErrorFunctionErrorTest("with undefined", undefined!, new PreConditionError(
+                    "Expression: createErrorFunction",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+                setCreateErrorFunctionErrorTest("with null", null!, new PreConditionError(
+                    "Expression: createErrorFunction",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+
+                runner.test("with valid function", (test: Test) =>
+                {
+                    const mc: MutableCondition = MutableCondition.create();
+                    test.assertThrows(() => mc.assertEqual(1, 2));
+
+                    mc.setCreateErrorFunction((message: string) =>
+                    {
+                        return Error(`fake '${message}' fake`);
+                    });
+
+                    mc.setEqualFunctions(
+                        EqualFunctions.create()
+                            .add((left: unknown, right: unknown) =>
+                            {
+                                return isNumber(left) && isNumber(right)
+                                    ? left % 2 === right % 2
+                                    : undefined;
+                            })
+                    )
+
+                    test.assertTrue(mc.areEqual(3, 5));
+                    test.assertFalse(mc.areEqual(3, 4));
+                    test.assertTrue(mc.areEqual(4, 4));
+                });
+            });
+
+            runner.testFunction("assertUndefined()", () =>
+            {
+                runner.test("with undefined", (test: Test) =>
+                {
+                    const mc: MutableCondition = MutableCondition.create();
+                    mc.assertUndefined(undefined);
+                });
+
+                function assertUndefinedErrorTest(value: unknown, expected: Error): void
+                {
+                    runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                    {
+                        const mc: MutableCondition = MutableCondition.create();
+                        test.assertThrows(() => mc.assertUndefined(value), expected);
+                    });
+                }
+
+                assertUndefinedErrorTest(null, new Error(join("\n", [
+                    "Expected: undefined",
+                    "Actual: null",
+                ])));
+                assertUndefinedErrorTest(false, new Error(join("\n", [
+                    "Expected: undefined",
+                    "Actual: false",
+                ])));
+                assertUndefinedErrorTest("abc", new Error(join("\n", [
+                    "Expected: undefined",
+                    "Actual: \"abc\"",
+                ])));
+            });
+
+            runner.testFunction("assertNotUndefined()", () =>
+            {
+                runner.test("with undefined", (test: Test) =>
+                {
+                    const mc: MutableCondition = MutableCondition.create();
+                    test.assertThrows(
+                        () => mc.assertNotUndefined(undefined),
+                        new Error(join("\n", [
+                            "Expected: not undefined",
+                            "Actual: undefined",
+                        ])),
+                    );
+                });
+
+                function assertNotUndefinedTest(value: unknown): void
+                {
+                    runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                    {
+                        const mc: MutableCondition = MutableCondition.create();
+                        mc.assertNotUndefined(value);
+                    });
+                }
+
+                assertNotUndefinedTest(null);
+                assertNotUndefinedTest("");
+                assertNotUndefinedTest(false);
+            });
+
+            runner.testFunction("areEqual()", () =>
+            {
+                function areEqualTest(left: unknown, right: unknown, expected: boolean): void
+                {
+                    runner.test(`with ${runner.andList([left, right])}`, (test: Test) =>
+                    {
+                        const mc: MutableCondition = MutableCondition.create();
+                        test.assertEqual(mc.areEqual(left, right), expected);
+                    });
+                }
+
+                areEqualTest(undefined, undefined, true);
+                areEqualTest(5, 5, true);
+                areEqualTest(true, true, true);
+                areEqualTest({}, {}, true);
+
+                areEqualTest(undefined, "", false);
+                areEqualTest(1, 2, false);
+                areEqualTest(false, true, false);
+                areEqualTest({a:1}, {a:2}, false);
+            });
+
+            runner.testFunction("toValueString()", () =>
+            {
+                function toValueStringTest(value: unknown, expected: string): void
+                {
+                    runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                    {
+                        const mc: MutableCondition = MutableCondition.create();
+                        test.assertEqual(expected, mc.toValueString(value));
+                    });
+                }
+
+                toValueStringTest(undefined, "undefined");
+                toValueStringTest(null, "null");
+                toValueStringTest(0, "0");
+                toValueStringTest("abc", `"abc"`);
+                toValueStringTest({}, "{}");
+                toValueStringTest({a:"a"}, `{"a":"a"}`);
+            });
+
+            runner.testFunction("createError()", () =>
+            {
+                runner.test("with all properties", (test: Test) =>
+                {
+                    const mc: MutableCondition = MutableCondition.create();
+                    const error: Error = mc.createError({
+                        actual: "fake-actual",
+                        expected: "fake-expected",
+                        expression: "fake-expression",
+                        message: "fake-message",
+                    });
+                    test.assertEqual(error, new Error(join("\n", [
+                        "Message: fake-message",
+                        "Expression: fake-expression",
+                        "Expected: fake-expected",
+                        "Actual: fake-actual",
+                    ])));
+                });
+            });
+        });
+    });
+}

package/tests/mutableMapTests.ts

@@ -0,0 +1,154 @@
+import { Iterator } from "../sources/iterator";
+import { JavascriptIterable } from "../sources/javascript";
+import { isMap } from "../sources/map";
+import { MutableMap } from "../sources/mutableMap";
+import { NotFoundError } from "../sources/notFoundError";
+import { mapTests } from "./mapTests";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("mutableMap.ts", () =>
+    {
+        runner.testType("MutableMap<TKey,TValue>", () =>
+        {
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const map: MutableMap<number,string> = MutableMap.create();
+                test.assertSame(map.getCount().await(), 0);
+            });
+
+            mutableMapTests(runner, MutableMap.create);
+        });
+    });
+}
+
+export function mutableMapTests(runner: TestRunner, creator: () => MutableMap<number,string>): void
+{
+    runner.testType("MutableMap<TKey,TValue>", () =>
+    {
+        mapTests(runner, creator);
+
+        runner.testFunction("creator()", (test: Test) =>
+        {
+            test.assertNotUndefinedAndNotNull(creator);
+            
+            const map: MutableMap<number,string> = creator();
+            test.assertNotUndefinedAndNotNull(map);
+            test.assertEqual(map.getCount().await(), 0);
+            test.assertTrue(isMap(map));
+        });
+
+        runner.testFunction("containsKey(TKey)", () =>
+        {
+            runner.test("when it doesn't contain the key", (test: Test) =>
+            {
+                const map: MutableMap<number,string> = creator();
+
+                test.assertFalse(map.containsKey(50).await());
+            });
+
+            runner.test("when it contains the key", (test: Test) =>
+            {
+                const map: MutableMap<number,string> = creator().set(50, "fifty");
+
+                test.assertTrue(map.containsKey(50).await());
+            });
+        });
+
+        runner.testFunction("get(TKey)", () =>
+        {
+            runner.test("when it contains the key", (test: Test) =>
+            {
+                const map: MutableMap<number,string> = creator().set(1, "one");
+                test.assertEqual(map.getCount().await(), 1);
+                test.assertEqual(map.get(1).await(), "one");
+                test.assertEqual(map.getCount().await(), 1);
+            });
+
+            runner.test("when it doesn't contain the key", (test: Test) =>
+            {
+                const map: MutableMap<number,string> = creator();
+
+                test.assertThrows(() => map.get(1).await(),
+                    new NotFoundError(
+                        "The key 1 was not found in the map."));
+                test.assertEqual(map.getCount().await(), 0);
+            });
+        });
+
+        runner.testFunction("set(TKey,TValue)", () =>
+        {
+            function setTest(map: MutableMap<number,string>, key: number, value: string): void
+            {
+                runner.test(`with ${runner.andList([map, key, value])}`, (test: Test) =>
+                {
+                    const setResult: MutableMap<number,string> = map.set(key, value);
+                    test.assertSame(setResult, map);
+                    test.assertSame(map.get(key).await(), value);
+                });
+            }
+
+            setTest(creator(), 0, "zero");
+            setTest(creator(), 1, "1");
+            setTest(creator(), -1, "negative one");
+
+            setTest(creator(), undefined!, "hello");
+            setTest(creator(), null!, "oops");
+            setTest(creator(), 10, undefined!);
+            setTest(creator(), 11, null!);
+
+            setTest(creator().set(1, "1"), 1, "one");
+        });
+
+        runner.testFunction("toString()", () =>
+        {
+            function toStringTest(map: MutableMap<number,string>, expected: string): void
+            {
+                runner.test(`with ${runner.toString(map)}`, (test: Test) =>
+                {
+                    test.assertEqual(map.toString(), expected);
+                });
+            }
+
+            toStringTest(creator(), "{}");
+            toStringTest(creator().set(1, "one"), `{1:"one"}`);
+            toStringTest(creator().set(2, "2").set(1, "one"), `{2:"2",1:"one"}`);
+        });
+
+        runner.testFunction("iterateKeys()", () =>
+        {
+            function iterateKeysTests(map: MutableMap<number,string>, expected: JavascriptIterable<number>): void
+            {
+                runner.test(`with ${runner.toString(map)}`, async (test: Test) =>
+                {
+                    const keyIterator: Iterator<number> = map.iterateKeys();
+                    test.assertEqual(await keyIterator.toArray(), [...expected]);
+                });
+            }
+
+            iterateKeysTests(creator(), []);
+            iterateKeysTests(creator().set(5, "five"), [5]);
+            iterateKeysTests(creator().set(5, "five").set(6, "six"), [5, 6]);
+            iterateKeysTests(creator().set(5, "5").set(6, "6").set(7, "7"), [5, 6, 7]);
+        });
+
+        runner.testFunction("iterateValues()", () =>
+        {
+            function iterateValuesTests(map: MutableMap<number,string>, expected: JavascriptIterable<string>): void
+            {
+                runner.test(`with ${runner.toString(map)}`, async (test: Test) =>
+                {
+                    const valueIterator: Iterator<string> = map.iterateValues();
+                    test.assertEqual(await valueIterator.toArray(), [...expected]);
+                });
+            }
+
+            iterateValuesTests(creator(), []);
+            iterateValuesTests(creator().set(5, "five"), ["five"]);
+            iterateValuesTests(creator().set(5, "five").set(6, "six"), ["five", "six"]);
+            iterateValuesTests(creator().set(5, "5").set(6, "6").set(7, "7"), ["5", "6", "7"]);
+        });
+    });
+}

package/tests/nodeJSHttpServerTests.ts

@@ -0,0 +1,75 @@
+import { FetchHttpClient } from "../sources/fetchHttpClient";
+import { FetchHttpIncomingResponse } from "../sources/fetchHttpResponse";
+import { NodeJSHttpServer as NodeJSHttpServer } from "../sources/nodeJSHttpServer";
+import { PreConditionError } from "../sources/preConditionError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("nodeJSHttpServer.ts", () =>
+    {
+        runner.testType("NodeJSHttpServer", () =>
+        {
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const httpServer: NodeJSHttpServer = NodeJSHttpServer.create();
+                test.assertNotUndefinedAndNotNull(httpServer);
+                test.assertFalse(httpServer.isDisposed());
+                test.assertFalse(httpServer.isStarted());
+            });
+
+            runner.testFunction("dispose()", async (test: Test) =>
+            {
+                const httpServer: NodeJSHttpServer = NodeJSHttpServer.create();
+
+                test.assertTrue(await httpServer.dispose());
+                test.assertTrue(httpServer.isDisposed());
+                test.assertFalse(httpServer.isStarted());
+
+                for (let i = 0; i < 3; i++)
+                {
+                    test.assertFalse(await httpServer.dispose());
+                    test.assertTrue(httpServer.isDisposed());
+                    test.assertFalse(httpServer.isStarted());
+                }
+            });
+
+            runner.testFunction("start()", () =>
+            {
+                runner.test("when disposed", async (test: Test) =>
+                {
+                    const httpServer: NodeJSHttpServer = NodeJSHttpServer.create();
+                    test.assertTrue(await httpServer.dispose());
+
+                    test.assertThrows(() => httpServer.start(3000), new PreConditionError(
+                        "Expression: this.isDisposed()",
+                        "Expected: false",
+                        "Actual: true",
+                    ));
+                    test.assertTrue(httpServer.isDisposed());
+                    test.assertFalse(httpServer.isStarted());
+                });
+
+                runner.test("simple scenario", async (test: Test) =>
+                {
+                    const httpServer: NodeJSHttpServer = NodeJSHttpServer.create();
+
+                    httpServer.start(3000);
+                    try
+                    {
+                        const httpClient: FetchHttpClient = FetchHttpClient.create();
+                        const response: FetchHttpIncomingResponse = await httpClient.sendGetRequest("http://localhost:3000");
+
+                        test.assertNotUndefinedAndNotNull(response);
+                        test.assertEqual(200, response.getStatusCode());
+                    }
+                    finally
+                    {
+                        await httpServer.dispose();
+                    }
+                });
+            });
+        });
+    });
+}

package/tests/notFoundErrorTests.ts

@@ -0,0 +1,24 @@
+import { NotFoundError } from "../sources/notFoundError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("notFoundError.ts", () =>
+    {
+        runner.testType("NotFoundError", () =>
+        {
+            runner.testFunction("constructor(...string[])", () =>
+            {
+                runner.test("with no arguments", (test: Test) =>
+                {
+                    const error: NotFoundError = new NotFoundError();
+                    test.assertNotUndefinedAndNotNull(error);
+                    test.assertEqual(error.name, "Error");
+                    test.assertEqual(error.message, "");
+                    test.assertNotUndefinedAndNotNull(error.stack);
+                });
+            });
+        });
+    });
+}

package/tests/postConditionErrorTests.ts

@@ -0,0 +1,24 @@
+import { PostConditionError } from "../sources/postConditionError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("postConditionError.ts", () =>
+    {
+        runner.testType(PostConditionError.name, () =>
+        {
+            runner.testFunction("constructor(string|undefined)", () =>
+            {
+                runner.test("with no arguments", (test: Test) =>
+                {
+                    const error: PostConditionError = new PostConditionError();
+                    test.assertNotUndefinedAndNotNull(error);
+                    test.assertEqual(error.name, "Error");
+                    test.assertEqual(error.message, "");
+                    test.assertNotUndefinedAndNotNull(error.stack);
+                });
+            });
+        });
+    });
+}

package/tests/preConditionErrorTests.ts

@@ -0,0 +1,24 @@
+import { PreConditionError } from "../sources/preConditionError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("preConditionError.ts", () =>
+    {
+        runner.testType("PreConditionError", () =>
+        {
+            runner.testFunction("constructor(string|undefined)", () =>
+            {
+                runner.test("with no arguments", (test: Test) =>
+                {
+                    const error: PreConditionError = new PreConditionError();
+                    test.assertNotUndefinedAndNotNull(error);
+                    test.assertEqual(error.name, "Error");
+                    test.assertEqual(error.message, "");
+                    test.assertNotUndefinedAndNotNull(error.stack);
+                });
+            });
+        });
+    });
+}