@everyonesoftware/common 1.0.0

package/tests/propertyTests.ts

@@ -0,0 +1,63 @@
+import { Property } from "../sources/property";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("property.ts", () =>
+    {
+        runner.testType("Property<T>", () =>
+        {
+            runner.testFunction("create()", () =>
+            {
+                runner.test("with initialValue", (test: Test) =>
+                {
+                    const property: Property<number> = Property.create(5);
+                    test.assertEqual(5, property.getValue());
+                    
+                    const setResult: Property<number> = property.setValue(20);
+                    test.assertSame(property, setResult);
+                    test.assertEqual(20, property.getValue());
+                    
+                    test.assertEqual("20", property.toString());
+                });
+
+                runner.test("with getter and setter functions", (test: Test) =>
+                {
+                    let propertyValue: string = "hello";
+
+                    const property: Property<string> = Property.create(
+                        () => propertyValue,
+                        (value: string) => { propertyValue = value; },
+                    );
+                    test.assertEqual("hello", property.getValue());
+                    
+                    const setResult: Property<string> = property.setValue("there");
+                    test.assertSame(property, setResult);
+                    test.assertEqual("there", property.getValue());
+                    test.assertEqual("there", propertyValue);
+                    
+                    test.assertEqual("there", property.toString());
+                });
+
+                runner.test("with options", (test: Test) =>
+                {
+                    let propertyValue: string = "hello";
+
+                    const property: Property<string> = Property.create({
+                        getter: () => propertyValue,
+                        setter: (value: string) => { propertyValue = value; },
+                    });
+                    test.assertEqual("hello", property.getValue());
+                    
+                    const setResult: Property<string> = property.setValue("there");
+                    test.assertSame(property, setResult);
+                    test.assertEqual("there", property.getValue());
+                    test.assertEqual("there", propertyValue);
+                    
+                    test.assertEqual("there", property.toString());
+                });
+            });
+        });
+    });
+}

package/tests/queueTests.ts

@@ -0,0 +1,29 @@
+import { EmptyError } from "../sources/emptyError";
+import { ListQueue } from "../sources/listQueue";
+import { Queue } from "../sources/queue";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("queue.ts", () =>
+    {
+        runner.testType("Queue<T>", () =>
+        {
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const queue: ListQueue<number> = Queue.create();
+                test.assertNotUndefinedAndNotNull(queue);
+                test.assertFalse(queue.any().await());
+                test.assertThrows(() => queue.remove().await(), new EmptyError());
+            });
+
+            runner.testFunction("add()", (test: Test) =>
+            {
+                const queue: ListQueue<number> = Queue.create();
+                queue.add(20).await();
+                test.assertEqual(20, queue.remove().await());
+            });
+        });
+    });
+}

package/tests/recreationDotGovClientTests.ts

@@ -0,0 +1,191 @@
+import { HttpClient } from "../sources/httpClient";
+import { PreConditionError } from "../sources/preConditionError";
+import { RecreationDotGovClient, RecreationDotGovDivisionAvailability, RecreationDotGovDivisionAvailabilityJson, RecreationDotGovError, RecreationDotGovPermitItineraryJson } from "../sources/recreationDotGovClient";
+import { WonderlandTrailClient, WonderlandTrailLocations } from "../sources/wonderlandTrailClient";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+import { hasNetworkAccess } from "./tests";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("recreationDotGovClient.ts", () =>
+    {
+        runner.testType("RecreationDotGovClient", () =>
+        {
+            runner.testFunction("create()", () =>
+            {
+                function createErrorTest(httpClient: HttpClient, expected: Error): void
+                {
+                    runner.test(`with ${runner.toString(httpClient)}`, (test: Test) =>
+                    {
+                        test.assertThrows(() => RecreationDotGovClient.create(httpClient), expected);
+                    });
+                }
+
+                createErrorTest(undefined!, new PreConditionError(
+                    "Expression: httpClient",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+                createErrorTest(null!, new PreConditionError(
+                    "Expression: httpClient",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+
+                runner.test("with default HttpClient", (test: Test) =>
+                {
+                    const httpClient: HttpClient = HttpClient.create();
+                    const recreationDotGovClient: RecreationDotGovClient = RecreationDotGovClient.create(httpClient);
+                    test.assertNotUndefinedAndNotNull(recreationDotGovClient);
+                });
+            });
+
+            runner.testFunction("getPermitItinerary()", () =>
+            {
+                function getPermitItineraryErrorTest(itineraryId: string, expected: Error): void
+                {
+                    runner.test(`with ${runner.toString(itineraryId)}`, async (test: Test) =>
+                    {
+                        const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
+                        await test.assertThrowsAsync(async () => await client.getPermitItinerary(itineraryId), expected);
+                    });
+                }
+
+                getPermitItineraryErrorTest(undefined!, new PreConditionError(
+                    "Expression: permitItineraryId",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+                getPermitItineraryErrorTest(null!, new PreConditionError(
+                    "Expression: permitItineraryId",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+                getPermitItineraryErrorTest("", new PreConditionError(
+                    "Expression: permitItineraryId",
+                    "Expected: not empty",
+                    "Actual: \"\"",
+                ));
+
+                runner.test("with invalid permit itinerary id", runner.skip(!hasNetworkAccess), async (test: Test) =>
+                {
+                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
+                    await test.assertThrowsAsync(
+                        async () => await client.getPermitItinerary("oopsie!"),
+                        new RecreationDotGovError(
+                            `No permit itinerary found for id: "oopsie!"`,
+                        ),
+                    );
+                });
+
+                runner.test("with valid permit itinerary id", runner.skip(!hasNetworkAccess), async (test: Test) =>
+                {
+                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
+                    const result: RecreationDotGovPermitItineraryJson = await client.getPermitItinerary(WonderlandTrailClient.permitItineraryId);
+                    test.assertNotUndefinedAndNotNull(result);
+                    test.assertEqual(result.id, WonderlandTrailClient.permitItineraryId);
+                    test.assertEqual(result.name, "Mount Rainier National Park Wilderness and Climbing Permits");
+                    test.assertNotUndefinedAndNotNull(result.divisions);
+                    test.assertTrue(Object.keys(result.divisions).length > 0);
+                    for (const division of Object.values(result.divisions))
+                    {
+                        test.assertNotUndefinedAndNotNull(division.id);
+                        test.assertNotUndefinedAndNotNull(division.district);
+                        test.assertNotUndefinedAndNotNull(division.name);
+                        test.assertNotUndefinedAndNotNull(division.type);
+                    }
+                });
+            });
+
+            runner.testFunction("getDivisionAvailability()", () =>
+            {
+                function getDivisionAvailabilityErrorTest(itineraryId: string, divisionId: string, month: number, year: number, expected: Error): void
+                {
+                    runner.test(`with ${runner.andList([itineraryId, divisionId, month, year])}`, async (test: Test) =>
+                    {
+
+                    });
+                }
+
+                getDivisionAvailabilityErrorTest(undefined!, "fake-division-id", 5, 2026, new PreConditionError(
+                    "Expression: permitItineraryId",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+                getDivisionAvailabilityErrorTest(null!, "fake-division-id", 5, 2026, new PreConditionError(
+                    "Expression: permitItineraryId",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+                getDivisionAvailabilityErrorTest("", "fake-division-id", 5, 2026, new PreConditionError(
+                    "Expression: permitItineraryId",
+                    "Expected: not empty",
+                    "Actual: \"\"",
+                ));
+                getDivisionAvailabilityErrorTest("oopsie!", "fake-division-id", 5, 2026, new RecreationDotGovError(
+                    `No permit itinerary found for id: "oopsie!"`,
+                ));
+
+                runner.test("with invalid division id", runner.skip(!hasNetworkAccess), async (test: Test) =>
+                {
+                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
+                    const itineraryId: string = WonderlandTrailClient.permitItineraryId;
+                    const divisionId: string = "fake-division-id";
+                    const month: number = 5;
+                    const year: number = 2026;
+                    const earlyAccessPermitLotteryId: string = "";
+                    
+                    const response: RecreationDotGovDivisionAvailability = await client.getDivisionAvailability(itineraryId, divisionId, month, year, earlyAccessPermitLotteryId);
+
+                    test.assertNotUndefinedAndNotNull(response);
+                    test.assertNotUndefinedAndNotNull(response.json);
+                    test.assertNotUndefinedAndNotNull(response.dayAvailabilities);
+                    test.assertEqual(0, response.dayAvailabilities.getCount().await());
+                    test.assertUndefined(response.maximumGroupSize);
+                    test.assertUndefined(response.minimumGroupSize);
+                });
+
+                runner.test("with Sunrise Camp division id", runner.skip(!hasNetworkAccess), async (test: Test) =>
+                {
+                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
+
+                    const itineraryId: string = WonderlandTrailClient.permitItineraryId;
+                    const divisionId: string = WonderlandTrailLocations.sunriseCamp.divisionId;
+                    const month: number = 8;
+                    const year: number = 2026;
+                    const earlyAccessPermitLotteryId: string = "";
+                    
+                    const response: RecreationDotGovDivisionAvailability = await client.getDivisionAvailability(itineraryId, divisionId, month, year, earlyAccessPermitLotteryId);
+
+                    test.assertNotUndefinedAndNotNull(response);
+                    test.assertNotUndefinedAndNotNull(response.json);
+                    test.assertNotUndefinedAndNotNull(response.dayAvailabilities);
+                    test.assertEqual(31, response.dayAvailabilities.getCount().await());
+                    test.assertNotUndefinedAndNotNull(response.maximumGroupSize);
+                    test.assertNotUndefinedAndNotNull(response.minimumGroupSize);
+                });
+
+                runner.test("with Indian Bar division id", runner.skip(!hasNetworkAccess), async (test: Test) =>
+                {
+                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
+
+                    const itineraryId: string = WonderlandTrailClient.permitItineraryId;
+                    const divisionId: string = WonderlandTrailLocations.indianBar.divisionId;
+                    const month: number = 7;
+                    const year: number = 2026;
+                    const earlyAccessPermitLotteryId: string = "";
+                    
+                    const response: RecreationDotGovDivisionAvailability = await client.getDivisionAvailability(itineraryId, divisionId, month, year, earlyAccessPermitLotteryId);
+
+                    test.assertNotUndefinedAndNotNull(response);
+                    test.assertNotUndefinedAndNotNull(response.json);
+                    test.assertNotUndefinedAndNotNull(response.dayAvailabilities);
+                    test.assertEqual(31, response.dayAvailabilities.getCount().await());
+                    test.assertNotUndefinedAndNotNull(response.maximumGroupSize);
+                    test.assertNotUndefinedAndNotNull(response.minimumGroupSize);
+                });
+            });
+        });
+    });
+}

package/tests/setTests.ts

@@ -0,0 +1,140 @@
+import { TestRunner } from "./testRunner";
+import { Set } from "../sources/set";
+import { Test } from "./test";
+import { JavascriptSetSet } from "../sources/javascriptSetSet";
+import { NotFoundError } from "../sources/notFoundError";
+import { SyncResult } from "../sources/syncResult";
+import { JavascriptIterable } from "../sources/javascript";
+import { PreCondition } from "../sources/preCondition";
+import { PreConditionError } from "../sources/preConditionError";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("set.ts", () =>
+    {
+        runner.testType("Set<T>", () =>
+        {
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const set: JavascriptSetSet<number> = Set.create();
+                test.assertNotUndefinedAndNotNull(set);
+                test.assertEqual(0, set.getCount().await());
+                test.assertEqual([], set.toArray().await());
+            });
+
+            runner.testFunction("add()", (test: Test) =>
+            {
+                const set: Set<number> = Set.create();
+                for (let i = 0; i < 3; i++)
+                {
+                    const addResult: Set<number> = set.add(20);
+                    test.assertSame(set, addResult);
+                    test.assertTrue(set.contains(20).await());
+                    test.assertEqual(set.getCount().await(), 1);
+                    test.assertEqual([20], set.toArray().await());
+                }
+            });
+
+            runner.testFunction("addAll()", (test: Test) =>
+            {
+                const set: Set<number> = Set.create();
+                for (let i = 0; i < 3; i++)
+                {
+                    const addResult: Set<number> = set.addAll([20, 20, 25, 26]);
+                    test.assertSame(set, addResult);
+                    test.assertTrue(set.contains(20).await());
+                    test.assertTrue(set.contains(25).await());
+                    test.assertTrue(set.contains(26).await());
+                    test.assertEqual(set.getCount().await(), 3);
+                    test.assertEqual([20, 25, 26], set.toArray().await());
+                }
+            });
+
+            runner.testFunction("remove()", (test: Test) =>
+            {
+                const set: Set<number> = Set.create();
+
+                test.assertThrows(set.remove(15), new NotFoundError("Could not find 15."));
+
+                set.add(16);
+                const removeResult: SyncResult<void> = set.remove(16);
+                test.assertNotUndefinedAndNotNull(removeResult);
+                test.assertFalse(set.contains(16).await());
+                test.assertUndefined(removeResult.await());
+
+                test.assertThrows(set.remove(16), new NotFoundError("Could not find 16."));
+            });
+
+            runner.testFunction("toString()", () =>
+            {
+                function toStringTest<T>(set: Set<T>, expected: string): void
+                {
+                    runner.test(`with ${runner.toString(set)}`, (test: Test) =>
+                    {
+                        test.assertEqual(set.toString(), expected);
+                    });
+                }
+
+                toStringTest(Set.create(), "{}");
+                toStringTest(Set.create().addAll([1]), "{1}");
+                toStringTest(Set.create().addAll([1, 2]), "{1,2}");
+                toStringTest(Set.create().addAll([3, 1, 2]), "{3,1,2}");
+            });
+
+            runner.testFunction("equals()", () =>
+            {
+                function equalsTest<T>(set: Set<T>, right: JavascriptIterable<T>, expected: boolean): void
+                {
+                    runner.test(`with ${runner.andList([set, right])}`, (test: Test) =>
+                    {
+                        test.assertEqual(set.equals(right).await(), expected);
+                    });
+                }
+
+                equalsTest(Set.create(), [], true);
+                equalsTest(Set.create(), [1], false);
+                equalsTest(Set.create<number>().addAll([1]), [], false);
+                equalsTest(Set.create<number>().addAll([1]), [1], true);
+                equalsTest(Set.create<number>().addAll([1]), [1, 1], false);
+                equalsTest(Set.create<number>().addAll([1, 2]), [1, 2], true);
+                equalsTest(Set.create<number>().addAll([1, 2]), [2, 1], false);
+                equalsTest(Set.create<number>().addAll([1, 2]), Set.create<number>().addAll([2, 1]), true);
+            });
+
+            runner.testFunction("union()", () =>
+            {
+                function unionErrorTest<T>(set: Set<T>, values: JavascriptIterable<T>, expected: Error): void
+                {
+                    runner.test(`with ${runner.andList([set, values])}`, (test: Test) =>
+                    {
+                        test.assertThrows(() => set.union(values), expected);
+                    });
+                }
+
+                unionErrorTest(Set.create<number>(), undefined!, new PreConditionError(
+                    "Expression: values",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+                unionErrorTest(Set.create<number>(), null!, new PreConditionError(
+                    "Expression: values",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+
+                function unionTest<T>(set: Set<T>, values: JavascriptIterable<T>, expected: JavascriptIterable<T>): void
+                {
+                    runner.test(`with ${runner.andList([set, values])}`, (test: Test) =>
+                    {
+                        test.assertEqual(set.union(values).toArray().await(), expected);
+                    });
+                }
+
+                unionTest(Set.create(), [], []);
+                unionTest(Set.create(), [1, 2], [1, 2]);
+                unionTest(Set.create([1]), [2], [1, 2]);
+                unionTest(Set.create([1, 2]), [1], [1, 2]);
+            });
+        });
+    });
+}

package/tests/skippedTest.ts

@@ -0,0 +1,39 @@
+import { JavascriptIterable } from "../sources/javascript";
+import { PreCondition } from "../sources/preCondition";
+import { join } from "../sources/strings";
+import { TestSkip } from "./testSkip";
+
+export class SkippedTest
+{
+    private readonly skip: TestSkip;
+    private readonly fullTestNameParts: JavascriptIterable<string>;
+
+    private constructor(skip: TestSkip, fullTestNameParts: JavascriptIterable<string>)
+    {
+        PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
+        PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
+
+        this.skip = skip;
+        this.fullTestNameParts = fullTestNameParts;
+    }
+
+    public static create(skip: TestSkip, fullTestNameParts: JavascriptIterable<string>): SkippedTest
+    {
+        return new SkippedTest(skip, fullTestNameParts);
+    }
+
+    public getSkipMessage(): string
+    {
+        return this.skip.getMessage();
+    }
+
+    public getFullTestNameParts(): JavascriptIterable<string>
+    {
+        return this.fullTestNameParts;
+    }
+
+    public getFullTestName(): string
+    {
+        return join(" ", this.fullTestNameParts);
+    }
+}

package/tests/stackTests.ts

@@ -0,0 +1,66 @@
+import { EmptyError } from "../sources/emptyError";
+import { ListStack } from "../sources/listStack";
+import { Stack } from "../sources/stack";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("stack.ts", () =>
+    {
+        runner.testType("Stack<T>", () =>
+        {
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const stack: ListStack<number> = Stack.create();
+                test.assertNotUndefinedAndNotNull(stack);
+                test.assertFalse(stack.any().await());
+            });
+
+            runner.testFunction("add()", (test: Test) =>
+            {
+                const stack: ListStack<number> = Stack.create();
+
+                stack.add(10).await();
+                test.assertTrue(stack.any().await());
+
+                stack.add(20).await();
+                test.assertTrue(stack.any().await());
+
+                test.assertEqual(20, stack.remove().await());
+                test.assertEqual(10, stack.remove().await());
+                test.assertFalse(stack.any().await());
+            });
+
+            runner.testFunction("addAll()", () =>
+            {
+                function addAllTest(values: number[]): void
+                {
+                    runner.test(`with ${runner.toString(values)}`, (test: Test) =>
+                    {
+                        const stack: ListStack<number> = Stack.create();
+                        stack.addAll(values).await();
+
+                        for (const value of values.reverse())
+                        {
+                            test.assertTrue(stack.any().await());
+                            test.assertEqual(value, stack.remove().await());
+                        }
+                        test.assertFalse(stack.any().await());
+                    });
+                }
+
+                addAllTest([]);
+                addAllTest([1]);
+                addAllTest([1, 2]);
+                addAllTest([1, 2, 3]);
+            });
+
+            runner.testFunction("remove()", (test: Test) =>
+            {
+                const stack: ListStack<number> = Stack.create();
+                test.assertThrows(() => stack.remove().await(), new EmptyError());
+            });
+        });
+    });
+}

package/tests/stringComparerTests.ts

@@ -0,0 +1,60 @@
+import { Comparison } from "../sources/comparison";
+import { StringComparer } from "../sources/stringComparer";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("stringComparer.ts", () =>
+    {
+        runner.testType("StringComparer", () =>
+        {
+            runner.testFunction("compare(string, string)", () =>
+            {
+                function compareTest(left: string, right: string, expected: Comparison): void
+                {
+                    runner.test(`with ${runner.andList([left, right])}`, (test: Test) =>
+                    {
+                        const comparer: StringComparer = StringComparer.create();
+                        test.assertEqual(comparer.compare(left, right), expected);
+                        test.assertEqual(comparer.lessThan(left, right), expected === Comparison.LessThan);
+                        test.assertEqual(comparer.lessThanOrEqual(left, right), expected !== Comparison.GreaterThan);
+                        test.assertEqual(comparer.equal(left, right), expected === Comparison.Equal);
+                        test.assertEqual(comparer.greaterThanOrEqualTo(left, right), expected !== Comparison.LessThan);
+                        test.assertEqual(comparer.greaterThan(left, right), expected === Comparison.GreaterThan);
+                    });
+                }
+
+                compareTest(undefined!, undefined!, Comparison.Equal);
+                compareTest(undefined!, null!, Comparison.LessThan);
+                compareTest(undefined!, "", Comparison.LessThan);
+                compareTest(undefined!, "a", Comparison.LessThan);
+                compareTest(undefined!, "def", Comparison.LessThan);
+
+                compareTest(null!, undefined!, Comparison.GreaterThan);
+                compareTest(null!, null!, Comparison.Equal);
+                compareTest(null!, "", Comparison.LessThan);
+                compareTest(null!, "a", Comparison.LessThan);
+                compareTest(null!, "def", Comparison.LessThan);
+
+                compareTest("", undefined!, Comparison.GreaterThan);
+                compareTest("", null!, Comparison.GreaterThan);
+                compareTest("", "", Comparison.Equal);
+                compareTest("", "a", Comparison.LessThan);
+                compareTest("", "def", Comparison.LessThan);
+
+                compareTest("a", undefined!, Comparison.GreaterThan);
+                compareTest("a", null!, Comparison.GreaterThan);
+                compareTest("a", "", Comparison.GreaterThan);
+                compareTest("a", "a", Comparison.Equal);
+                compareTest("a", "def", Comparison.LessThan);
+
+                compareTest("def", undefined!, Comparison.GreaterThan);
+                compareTest("def", null!, Comparison.GreaterThan);
+                compareTest("def", "", Comparison.GreaterThan);
+                compareTest("def", "a", Comparison.GreaterThan);
+                compareTest("def", "def", Comparison.Equal);
+            });
+        });
+    });
+}