@rcompat/test 0.10.0 → 0.11.1

package/lib/private/Assert.d.ts

@@ -16,7 +16,7 @@ export default class Assert<const Actual> {
     undefined(): this;
     defined(): this;
     instance(expected: UnknownFunction): this;
-    throws(expected?: string): this;
+    throws(expected: string | (new (...args: any[]) => Error)): this;
     tries(): this;
     pass(): void;
     fail<const Expected extends Not<Equals<Actual, Expected>> extends true ? unknown : "was supposed to fail but didn't">(): void;

package/lib/private/Assert.js

@@ -80,12 +80,17 @@ export default class Assert {
             this.#failed("[did not throw]");
         }
         catch (error) {
-            const { message } = E(error);
-            if (expected === undefined || expected === message) {
-                this.#passed();
+            if (typeof expected === "string") {
+                const code = E(error).code;
+                code === expected
+                    ? this.#passed()
+                    : this.#failed(expected, code ?? "[no code]");
             }
             else {
-                this.#failed(expected, message);
+                error instanceof expected
+                    ? this.#passed()
+                    : this.#failed(expected.name, error?.constructor?.name
+                        ?? "[unknown]");
             }
         }
         return this;
@@ -96,7 +101,8 @@ export default class Assert {
             this.#passed();
         }
         catch (error) {
-            this.#failed(E(error).message, "[did not throw]");
+            const { code, message } = E(error);
+            this.#failed(`${code ?? message}`, "[did not throw]");
         }
         return this;
     }

package/lib/private/E.d.ts

@@ -1,6 +1,7 @@
-type ErrorMessage = {
+type EncodedError = {
     message: string;
+    code?: string;
 };
-declare const _default: (error: unknown) => ErrorMessage;
+declare const _default: (error: unknown) => EncodedError;
 export default _default;
 //# sourceMappingURL=E.d.ts.map

package/lib/private/extend.d.ts

@@ -0,0 +1,19 @@
+import type Assert from "#Assert";
+import type Asserter from "#Asserter";
+import type Body from "#Body";
+import type { MaybePromise } from "@rcompat/type";
+type ExtendedAssert<T, Extensions> = Assert<T> & Extensions;
+type ExtendedAsserter<Extensions> = <const T>(actual?: T) => ExtendedAssert<T, Extensions>;
+type ExtendedBody<Extensions> = (asserter: ExtendedAsserter<Extensions>) => MaybePromise<void>;
+export type Factory<Subject, Extensions> = (assert: Asserter, subject: Subject) => Extensions;
+export type ExtendedTest<Extensions> = {
+    case(name: string, body: ExtendedBody<Extensions>): void;
+    ended(end: () => MaybePromise<void>): void;
+};
+type Base = {
+    case(name: string, body: Body): void;
+    ended(end: () => MaybePromise<void>): void;
+};
+declare const _default: <Subject, Extensions>(base: Base, factory: Factory<Subject, Extensions>) => ExtendedTest<Extensions>;
+export default _default;
+//# sourceMappingURL=extend.d.ts.map

package/lib/private/extend.js

@@ -0,0 +1,14 @@
+export default (base, factory) => ({
+    case(name, body) {
+        base.case(name, asserter => {
+            const extended = (actual) => {
+                const a = asserter(actual);
+                const extra = factory(asserter, actual);
+                return Object.assign(Object.create(a), extra);
+            };
+            return body(extended);
+        });
+    },
+    ended: base.ended.bind(base),
+});
+//# sourceMappingURL=extend.js.map

package/lib/private/index.d.ts

@@ -1,12 +1,15 @@
+import type Asserter from "#Asserter";
 import type Body from "#Body";
 import type End from "#End";
+import type Env from "#Env";
+import type Result from "#Result";
+import type Test from "#Test";
+import type { ExtendedTest, Factory } from "#extend";
 declare const _default: {
+    extend<Subject, Extensions>(factory: Factory<Subject, Extensions>): ExtendedTest<Extensions>;
     case(name: string, body: Body): void;
     ended(end: End): void;
 };
 export default _default;
-export type { default as Asserter } from "#Asserter";
-export type { default as Env } from "#Env";
-export type { default as Result } from "#Result";
-export type { default as Test } from "#Test";
+export type { Asserter, Env, ExtendedTest, Result, Test };
 //# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -1,5 +1,6 @@
+import extend from "#extend";
 import repository from "#repository";
-export default {
+const base = {
     case(name, body) {
         repository.put(name, body);
     },
@@ -7,4 +8,10 @@ export default {
         repository.ended(end);
     },
 };
+export default {
+    ...base,
+    extend(factory) {
+        return extend(base, factory);
+    },
+};
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcompat/test",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Standard library testing",
   "bugs": "https://github.com/rcompat/rcompat/issues",
   "license": "MIT",
@@ -15,8 +15,8 @@
     "directory": "packages/test"
   },
   "devDependencies": {
-    "@rcompat/fs": "^0.26.0",
-    "@rcompat/type": "^0.9.0"
+    "@rcompat/fs": "^0.27.1",
+    "@rcompat/type": "^0.10.0"
   },
   "type": "module",
   "imports": {