@everyonesoftware/common 3.0.0 → 4.0.0

package/tests/mutableConditionTests.ts

@@ -1,273 +0,0 @@
-
-
-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

@@ -1,154 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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);
-                });
-            });
-        });
-    });
-}