@rstackjs/test-utils 0.0.0 → 0.2.0

package/README.md

@@ -25,6 +25,28 @@ bun add @rstackjs/test-utils -D
 
 ## Usage
 
+### copyNodeModules
+
+Replaces `node_modules` with a copy of `_node_modules` in the given directory. It uses the current working directory by default.
+
+```ts
+import { copyNodeModules } from '@rstackjs/test-utils';
+
+const nodeModulesPath = await copyNodeModules();
+```
+
+### editFile
+
+Edits a file using a sync or async editor function.
+
+```ts
+import { editFile } from '@rstackjs/test-utils';
+
+await editFile('src/index.ts', (content) =>
+  content.replace('const value = 1', 'const value = 2'),
+);
+```
+
 ### findFile
 
 Finds the first matching path in a file-content map. String matchers use suffix matching, and content hashes are ignored by default.
@@ -119,9 +141,31 @@ try {
 console.log(logHelper.logs);
 ```
 
+### normalizeEol
+
+Normalizes CRLF line endings to LF.
+
+```ts
+import { normalizeEol } from '@rstackjs/test-utils';
+
+const content = normalizeEol('first line\r\nsecond line\r\n');
+// first line\nsecond line\n
+```
+
+### prepareDist
+
+Removes a dist directory and returns its absolute path. It removes `dist` from the current working directory by default.
+
+```ts
+import { prepareDist } from '@rstackjs/test-utils';
+
+const distPath = await prepareDist();
+const customDistPath = await prepareDist('dist-custom');
+```
+
 ### readDirContents
 
-Recursively reads UTF-8 files from a directory and returns a file-content map keyed by sorted absolute paths.
+Recursively reads UTF-8 files from a directory and returns a file-content map keyed by sorted POSIX absolute paths.
 
 ```ts
 import { readDirContents } from '@rstackjs/test-utils';
@@ -159,6 +203,28 @@ await waitFor(() => server.isReady(), {
 
 Condition polling uses a 100ms interval and a 5-second timeout by default.
 
+### waitForFile
+
+Waits until a file path exists.
+
+```ts
+import { waitForFile } from '@rstackjs/test-utils';
+
+await waitForFile('dist/index.js');
+```
+
+### waitForFileContent
+
+Waits until a UTF-8 file includes the expected content.
+
+```ts
+import { waitForFileContent } from '@rstackjs/test-utils';
+
+await waitForFileContent('dist/index.js', 'compiled successfully');
+```
+
+Both helpers accept the same `interval` and `timeout` options as `waitFor`.
+
 ## License
 
 [MIT](./LICENSE).

package/dist/copyNodeModules.d.ts

@@ -0,0 +1,2 @@
+/** Copy `_node_modules` to `node_modules` in a directory. */
+export declare const copyNodeModules: (cwd?: string) => Promise<string>;

package/dist/editFile.d.ts

@@ -0,0 +1,3 @@
+export type FileEditor = (content: string) => string | Promise<string>;
+/** Edits a file using a sync or async editor function */
+export declare const editFile: (filePath: string, editor: FileEditor) => Promise<void>;

package/dist/index.d.ts

@@ -1,8 +1,14 @@
+export { copyNodeModules } from './copyNodeModules.js';
+export { editFile, type FileEditor } from './editFile.js';
 export { type FileMatcher, findFile, type FindFileOptions, } from './findFile.js';
 export { getDistFiles } from './getDistFiles.js';
 export { getFileContent } from './getFileContent.js';
 export { getRandomPort, isPortAvailable } from './getRandomPort.js';
+export { normalizeEol } from './normalizeEol.js';
+export { prepareDist } from './prepareDist.js';
 export { type ConsoleType, createLogHelper, type ExtendedLogHelper, type LogHelper, proxyConsole, type ProxyConsoleOptions, } from './proxyConsole.js';
 export { readDirContents } from './readDirContents.js';
 export { toPosixPath } from './toPosixPath.js';
 export { waitFor, type WaitForCondition, type WaitForOptions, } from './waitFor.js';
+export { waitForFile } from './waitForFile.js';
+export { waitForFileContent } from './waitForFileContent.js';

package/dist/index.js

@@ -1,7 +1,25 @@
-import { readFile, readdir } from "node:fs/promises";
+import { cp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { join, resolve as external_node_path_resolve } from "node:path";
 import node_net from "node:net";
 import { stripVTControlCharacters, styleText } from "node:util";
+import { existsSync } from "node:fs";
+const copyNodeModules = async (cwd = process.cwd())=>{
+    const rootPath = external_node_path_resolve(cwd);
+    const sourcePath = join(rootPath, '_node_modules');
+    const targetPath = join(rootPath, 'node_modules');
+    await rm(targetPath, {
+        force: true,
+        recursive: true
+    });
+    await cp(sourcePath, targetPath, {
+        recursive: true
+    });
+    return targetPath;
+};
+const editFile = async (filePath, editor)=>{
+    const content = await readFile(filePath, 'utf-8');
+    await writeFile(filePath, await editor(content));
+};
 const HASH_PATTERN = /\.[0-9a-z]{8,}(?=\.)/gi;
 const toMatcher = (matcher)=>{
     if ('function' == typeof matcher) return matcher;
@@ -21,6 +39,7 @@ const findFile = (files, matcher, options = {})=>{
     }
     throw new Error(`Unable to find file matching "${matcher.toString()}"`);
 };
+const toPosixPath = (filePath)=>filePath.replaceAll('\\', '/');
 const collectFilePaths = async (directoryPath)=>{
     const entries = await readdir(directoryPath, {
         withFileTypes: true
@@ -38,7 +57,7 @@ const readDirContents = async (directoryPath)=>{
     const filePaths = await collectFilePaths(external_node_path_resolve(directoryPath));
     filePaths.sort();
     const entries = await Promise.all(filePaths.map(async (filePath)=>[
-            filePath,
+            toPosixPath(filePath),
             await readFile(filePath, 'utf-8')
         ]));
     return Object.fromEntries(entries);
@@ -78,7 +97,15 @@ const getRandomPort = async (startPort = Math.ceil(30000 * Math.random()) + 1500
     }
     throw new Error('No available ports found in the valid range.');
 };
-const toPosixPath = (filePath)=>filePath.replaceAll('\\', '/');
+const normalizeEol = (content)=>content.replaceAll('\r\n', '\n');
+const prepareDist = async (distPath = 'dist')=>{
+    const absolutePath = external_node_path_resolve(distPath);
+    await rm(absolutePath, {
+        force: true,
+        recursive: true
+    });
+    return absolutePath;
+};
 const matchPattern = (log, pattern, options = {})=>{
     const logToCheck = options.posix ? toPosixPath(log) : log;
     if ('string' == typeof pattern) return options.strict ? logToCheck.split('\n').some((line)=>line.trim() === pattern.trim()) : logToCheck.includes(pattern);
@@ -191,4 +218,17 @@ async function waitFor(millisecondsOrCondition, options = {}) {
         await delay(Math.min(interval, timeout - elapsedTime));
     }
 }
-export { createLogHelper, findFile, getDistFiles, getFileContent, getRandomPort, isPortAvailable, proxyConsole, readDirContents, toPosixPath, waitFor };
+const waitForFile = async (filePath, options)=>{
+    await waitFor(()=>existsSync(filePath), options);
+};
+const waitForFileContent = async (filePath, expectedContent, options)=>{
+    await waitFor(async ()=>{
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            return content.includes(expectedContent);
+        } catch  {
+            return false;
+        }
+    }, options);
+};
+export { copyNodeModules, createLogHelper, editFile, findFile, getDistFiles, getFileContent, getRandomPort, isPortAvailable, normalizeEol, prepareDist, proxyConsole, readDirContents, toPosixPath, waitFor, waitForFile, waitForFileContent };

package/dist/normalizeEol.d.ts

@@ -0,0 +1,2 @@
+/** Normalize CRLF line endings to LF. */
+export declare const normalizeEol: (content: string) => string;

package/dist/prepareDist.d.ts

@@ -0,0 +1,2 @@
+/** Remove a dist directory and return its absolute path. */
+export declare const prepareDist: (distPath?: string) => Promise<string>;

package/dist/readDirContents.d.ts

@@ -1,6 +1,6 @@
 /**
  * Recursively read UTF-8 files from a directory.
  *
- * The returned record uses sorted absolute file paths as keys.
+ * The returned record uses sorted POSIX absolute file paths as keys.
  */
 export declare const readDirContents: (directoryPath: string) => Promise<Record<string, string>>;

package/dist/waitForFile.d.ts

@@ -0,0 +1,3 @@
+import { type WaitForOptions } from './waitFor.js';
+/** Wait until a file path exists. */
+export declare const waitForFile: (filePath: string, options?: WaitForOptions) => Promise<void>;

package/dist/waitForFileContent.d.ts

@@ -0,0 +1,3 @@
+import { type WaitForOptions } from './waitFor.js';
+/** Wait until a UTF-8 file includes the expected content. */
+export declare const waitForFileContent: (filePath: string, expectedContent: string, options?: WaitForOptions) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstackjs/test-utils",
-  "version": "0.0.0",
+  "version": "0.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/rstackjs/test-utils"