test[isReadonlyOf]: test with isObjectOf with symbol properties

Author: Milly

is/__snapshots__/readonly_of_test.ts.snap

@@ -45,3 +45,25 @@ snapshot[`isReadonlyOf<T> > with isTupleOf > returns properly named predicate fu
 snapshot[`isReadonlyOf<T> > with isUniformTupleOf > returns properly named predicate function 1`] = `"isReadonlyOf(isUniformTupleOf(3, isNumber))"`;
 
 snapshot[`isReadonlyOf<T> > with isUniformTupleOf > returns properly named predicate function 2`] = `"isReadonlyOf(isUniformTupleOf(3, isNumber))"`;
+
+snapshot[`isReadonlyOf<T> > with symbol properties > with isObjectOf > returns properly named predicate function 1`] = `
+"isReadonlyOf(isObjectOf({
+  a: isNumber,
+  Symbol(b): isUnionOf([
+    isString,
+    isUndefined
+  ]),
+  Symbol(c): asReadonly(isBoolean)
+}))"
+`;
+
+snapshot[`isReadonlyOf<T> > with symbol properties > with isObjectOf > returns properly named predicate function 2`] = `
+"isReadonlyOf(isObjectOf({
+  a: isNumber,
+  Symbol(b): isUnionOf([
+    isString,
+    isUndefined
+  ]),
+  Symbol(c): asReadonly(isBoolean)
+}))"
+`;

is/readonly_of_test.ts

@@ -170,4 +170,52 @@ Deno.test("isReadonlyOf<T>", async (t) => {
       }
     });
   });
+
+  await t.step("with symbol properties", async (t) => {
+    await t.step("with isObjectOf", async (t) => {
+      const b = Symbol("b");
+      const c = Symbol("c");
+      const pred = is.ObjectOf({
+        a: is.Number,
+        [b]: is.UnionOf([is.String, is.Undefined]),
+        [c]: as.Readonly(is.Boolean),
+      });
+      await t.step("returns properly named predicate function", async (t) => {
+        await assertSnapshot(t, isReadonlyOf(pred).name);
+        await assertSnapshot(t, isReadonlyOf(isReadonlyOf(pred)).name);
+      });
+
+      await t.step("returns true on Readonly<T> object", () => {
+        assertEquals(
+          isReadonlyOf(pred)({ a: 0, [b]: "b", [c]: true } as const),
+          true,
+        );
+        assertEquals(
+          isReadonlyOf(pred)({ a: 0, [b]: "b", [c]: true }),
+          true,
+        );
+      });
+
+      await t.step("returns false on non Readonly<T> object", () => {
+        assertEquals(isReadonlyOf(pred)("a"), false, "Value is not an object");
+        assertEquals(
+          isReadonlyOf(pred)({ a: 0, [b]: "a", [c]: "" }),
+          false,
+          "Object have a different type property",
+        );
+      });
+
+      await t.step("predicated type is correct", () => {
+        const a: unknown = { a: 0, [b]: "a", [c]: true };
+        if (isReadonlyOf(pred)(a)) {
+          assertType<
+            Equal<
+              typeof a,
+              Readonly<{ a: number; [b]: string | undefined; [c]: boolean }>
+            >
+          >(true);
+        }
+      });
+    });
+  });
 });