add tests

Author: A-yon Lee

error.test.ts

@@ -4,6 +4,9 @@ import { isDeno } from "./env.ts";
 import { pick } from "./object.ts";
 import { toFsPath } from "./path.ts";
 import { createErrorEvent } from "./event.ts";
+import { isSubclassOf } from "./class.ts";
+import * as common from "./error/common.ts";
+import { getErrorConstructor, registerErrorType } from "./error.ts";
 
 declare var AggregateError: new (errors: Error[], message?: string, options?: { cause: unknown; }) => Error & { errors: Error[]; };
 
@@ -315,7 +318,7 @@ describe("Error", () => {
         strictEqual(normalize(event.filename), toFsPath(import.meta.url));
 
         if (isDeno) {
-            strictEqual(event.lineno, 300);
+            strictEqual(event.lineno, 303);
             strictEqual(event.colno, 21);
         } else {
             ok(event.lineno > 0);
@@ -335,7 +338,7 @@ describe("Error", () => {
         strictEqual(normalize(event2.filename), toFsPath(import.meta.url));
 
         if (isDeno) {
-            strictEqual(event2.lineno, 325);
+            strictEqual(event2.lineno, 328);
             strictEqual(event2.colno, 22);
         } else {
             ok(event2.lineno > 0);
@@ -460,4 +463,53 @@ describe("Error", () => {
             ok(!err2.isCausedBy(Error3));
         });
     });
+
+    describe("registerErrorType", () => {
+        it("register and retrieve", () => {
+            class MyError extends Exception {
+                constructor(message: string, options: ErrorOptions = {}) {
+                    super(message, { ...options, name: "MyError" });
+                }
+            }
+
+            registerErrorType(MyError);
+            strictEqual(getErrorConstructor("MyError"), MyError);
+
+            const obj = Error.toObject(new MyError("something went wrong", {
+                cause: "unknown",
+            }));
+            const err = Error.fromObject(obj);
+            strictEqual(err?.constructor, MyError);
+            strictEqual(err?.name, obj["name"]);
+            strictEqual(err?.message, obj["message"]);
+            strictEqual(err?.stack, obj["stack"]);
+            // @ts-ignore
+            strictEqual(err?.cause, obj["cause"]);
+            // @ts-ignore
+            strictEqual(err?.code, obj["code"]);
+        });
+
+        it("common error types", () => {
+            ok(Object.values(common).some(ctor => isSubclassOf(ctor, Exception)));
+
+            for (const ctor of Object.values(common)) {
+                if (!isSubclassOf(ctor, Exception)) {
+                    continue;
+                }
+
+                const obj = Error.toObject(new ctor("something went wrong", {
+                    cause: "unknown",
+                }));
+                const err = Error.fromObject(obj);
+                strictEqual(err?.constructor, ctor);
+                strictEqual(err?.name, obj["name"]);
+                strictEqual(err?.message, obj["message"]);
+                strictEqual(err?.stack, obj["stack"]);
+                // @ts-ignore
+                strictEqual(err?.cause, obj["cause"]);
+                // @ts-ignore
+                strictEqual(err?.code, obj["code"]);
+            }
+        });
+    });
 });

error.ts

@@ -33,7 +33,7 @@ export function registerErrorType<T extends Error>(ctor: Constructor<T>): void {
  * Returns the error constructor by the `name`.
  * @inner
  */
-export function getErrorType<T extends Error>(name: string): Constructor<T> | null {
+export function getErrorConstructor<T extends Error>(name: string): Constructor<T> | null {
     let type = errorTypeRegistry.get(name);
 
     if (!type && name in globalThis) {
@@ -133,7 +133,7 @@ export function fromObject<T extends Error>(
     // @ts-ignore
     const typeName: string = obj["@@type"] || obj.name;
     // @ts-ignore
-    ctor ??= (getErrorType(typeName) ?? Error) as Constructor<T>;
+    ctor ??= (getErrorConstructor(typeName) ?? Error) as Constructor<T>;
     let err: T;
 
     if (ctor.name === "DOMException" && typeof DOMException === "function") {

parallel/threads.ts

@@ -13,7 +13,7 @@ import {
     fromObject,
     isAggregateError,
     isDOMException,
-    getErrorType,
+    getErrorConstructor,
     toObject,
 } from "../error.ts";
 import * as path from "../path.ts";
@@ -511,7 +511,7 @@ export function wrapArgs<A extends any[]>(
 export function unwrapReturnValue(value: any): any {
     if (isPlainObject(value) &&
         typeof value["@@type"] === "string" &&
-        getErrorType(value["@@type"])
+        getErrorConstructor(value["@@type"])
     ) {
         return fromObject(value);
     }

parallel/worker.ts

@@ -6,7 +6,7 @@ import { isPlainObject } from "../object.ts";
 import {
     Exception,
     fromObject,
-    getErrorType,
+    getErrorConstructor,
     isAggregateError,
     isDOMException,
     toObject,
@@ -52,7 +52,7 @@ function unwrapArgs(
         if (isPlainObject(arg)) {
             if (arg["@@type"] === "Channel" && typeof arg["@@id"] === "number") {
                 return unwrapChannel(arg as any, channelWrite);
-            } else if (typeof arg["@@type"] === "string" && getErrorType(arg["@@type"])) {
+            } else if (typeof arg["@@type"] === "string" && getErrorConstructor(arg["@@type"])) {
                 return fromObject(arg);
             }
         }