readme-assert 7.2.1 → 7.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "readme-assert",
-  "version": "7.2.1",
+  "version": "7.3.0",
   "description": "Run code blocks in your readme as tests",
   "keywords": [
     "readme",

package/readme.md

@@ -103,6 +103,12 @@ Assert that a promise rejects with `// rejects`:
 Promise.reject(new Error("no")) // rejects /no/
 ```
 
+Or match the error name and message with `//=> rejects`:
+
+```javascript test
+Promise.reject(new TypeError("no")) //=> rejects TypeError: no
+```
+
 ### TypeScript
 
 TypeScript code blocks are supported natively:

package/src/comment-to-assert.js

@@ -11,6 +11,10 @@ import MagicString from "magic-string";
  *   console.log(x) //=> v  → console.log(x); assert.deepEqual(x, v)
  *   expr //=> resolves to v → assert.deepEqual(await expr, v)
  *   expr // rejects /pat/  → assert.rejects(() => expr, /pat/)
+ *   expr //=> rejects Error: msg → assert.rejects(() => expr, { message: "msg" })
+ *
+ * When the expression is an AwaitExpression, throws/Error assertions are
+ * promoted to async rejects (await converts rejection → throw).
  *
  * Uses oxc-parser for AST + comment extraction. Handles both JS and TS.
  *
@@ -33,6 +37,8 @@ export function commentToAssert(code, { typescript = false } = {}) {
     const comment = findTrailingComment(comments, node, code);
     if (!comment) continue;
 
+    const isAwait = node.expression.type === "AwaitExpression";
+
     const match = comment.value.match(/^\s*(=>|→|->)\s*([\s\S]*)$/);
     const throwsMatch = comment.value.match(/^\s*throws\s+([\s\S]*)$/);
     const rejectsMatch = comment.value.match(/^\s*rejects\s+([\s\S]*)$/);
@@ -40,6 +46,9 @@ export function commentToAssert(code, { typescript = false } = {}) {
     if (match) {
       const rest = match[2].trim();
       const resolvesMatch = rest.match(/^resolves\s+(?:to\s+)?([\s\S]*)$/);
+      const rejectsErrorMatch = rest.match(
+        /^rejects\s+((?:[A-Z]\w+)?Error)(?::\s*(.*))?$/,
+      );
       changed = true;
 
       const errorMatch = rest.match(/^((?:[A-Z]\w+)?Error)(?::\s*(.*))?$/);
@@ -56,8 +65,28 @@ export function commentToAssert(code, { typescript = false } = {}) {
           comment.end,
           `assert.deepEqual(await ${exprSource}, ${expected});`,
         );
+      } else if (rejectsErrorMatch) {
+        // expr //=> rejects TypeError: msg → assert.rejects(() => expr, { name, message })
+        const errorName = rejectsErrorMatch[1];
+        const errorMessage = rejectsErrorMatch[2]?.trim();
+        const exprSource = code.slice(
+          node.expression.start,
+          node.expression.end,
+        );
+        const props = [`name: "${errorName}"`];
+        if (errorMessage) {
+          props.push(formatMessageProp(errorMessage));
+        }
+        s.overwrite(
+          node.start,
+          comment.end,
+          isAwait
+            ? `await assert.rejects(async () => { ${exprSource}; }, { ${props.join(", ")} });`
+            : `await assert.rejects(() => ${exprSource}, { ${props.join(", ")} });`,
+        );
       } else if (errorMatch) {
         // expr //=> TypeError: msg → assert.throws(() => { expr }, { name, message })
+        // await expr //=> Error: msg → assert.rejects(async () => { expr }, { name, message })
         const errorName = errorMatch[1];
         const errorMessage = errorMatch[2]?.trim();
         const exprSource = code.slice(
@@ -66,17 +95,14 @@ export function commentToAssert(code, { typescript = false } = {}) {
         );
         const props = [`name: "${errorName}"`];
         if (errorMessage) {
-          const reMatch = errorMessage.match(/^\/(.+)\/([gimsuy]*)$/);
-          props.push(
-            reMatch
-              ? `message: /${reMatch[1]}/${reMatch[2]}`
-              : `message: "${errorMessage}"`,
-          );
+          props.push(formatMessageProp(errorMessage));
         }
         s.overwrite(
           node.start,
           comment.end,
-          `assert.throws(() => { ${exprSource}; }, { ${props.join(", ")} });`,
+          isAwait
+            ? `await assert.rejects(async () => { ${exprSource}; }, { ${props.join(", ")} });`
+            : `assert.throws(() => { ${exprSource}; }, { ${props.join(", ")} });`,
         );
       } else if (isConsoleCall(node.expression)) {
         // console.log(expr) //=> value → keep log, add assertion after.
@@ -112,7 +138,9 @@ export function commentToAssert(code, { typescript = false } = {}) {
       s.overwrite(
         node.start,
         comment.end,
-        `assert.throws(() => { ${exprSource}; }, ${pattern});`,
+        isAwait
+          ? `await assert.rejects(async () => { ${exprSource}; }, ${pattern});`
+          : `assert.throws(() => { ${exprSource}; }, ${pattern});`,
       );
       changed = true;
     } else if (rejectsMatch) {
@@ -124,7 +152,9 @@ export function commentToAssert(code, { typescript = false } = {}) {
       s.overwrite(
         node.start,
         comment.end,
-        `await assert.rejects(() => ${exprSource}, ${pattern});`,
+        isAwait
+          ? `await assert.rejects(async () => { ${exprSource}; }, ${pattern});`
+          : `await assert.rejects(() => ${exprSource}, ${pattern});`,
       );
       changed = true;
     }
@@ -153,6 +183,13 @@ function findTrailingComment(comments, node, code) {
   return null;
 }
 
+function formatMessageProp(msg) {
+  const reMatch = msg.match(/^\/(.+)\/([gimsuy]*)$/);
+  return reMatch
+    ? `message: /${reMatch[1]}/${reMatch[2]}`
+    : `message: "${msg}"`;
+}
+
 function isConsoleCall(expr) {
   return (
     expr.type === "CallExpression" &&

package/src/generate.js

@@ -66,7 +66,9 @@ function assembleUnit(blocks) {
   }
 
   const hasESM = imports.length > 0;
-  const hasCJS = /\brequire\s*\(/.test(bodyLines.join("\n"));
+  const body = bodyLines.join("\n");
+  const hasAwait = /\bawait\s/.test(body);
+  const hasCJS = !hasAwait && /\brequire\s*\(/.test(body);
 
   // Place assert import on line 0 (before markdown line 1) so line numbers
   // in the generated code match the original markdown positions exactly.