@simplysm/core-node 13.0.69 → 13.0.71

package/tests/utils/path.spec.ts

@@ -0,0 +1,192 @@
+import { describe, expect, it } from "vitest";
+import path from "path";
+import {
+  pathPosix,
+  pathNorm,
+  pathIsChildPath,
+  pathChangeFileDirectory,
+  pathBasenameWithoutExt,
+  pathFilterByTargets,
+  type NormPath,
+} from "../../src/utils/path";
+
+describe("path functions", () => {
+  //#region posix
+
+  describe("pathPosix", () => {
+    it("converts single path argument to POSIX style", () => {
+      const result = pathPosix("C:\\Users\\test\\file.txt");
+      expect(result).toBe("C:/Users/test/file.txt");
+    });
+
+    it("combines multiple path arguments and converts to POSIX style", () => {
+      const result = pathPosix("C:\\Users", "test", "file.txt");
+      expect(result).toBe("C:/Users/test/file.txt");
+    });
+
+    it("keeps already POSIX-style path as is", () => {
+      const result = pathPosix("/usr/local/bin");
+      expect(result).toBe("/usr/local/bin");
+    });
+
+    it("handles mixed path separators", () => {
+      const result = pathPosix("C:/Users\\test/file.txt");
+      expect(result).toBe("C:/Users/test/file.txt");
+    });
+  });
+
+  //#endregion
+
+  //#region norm
+
+  describe("pathNorm", () => {
+    it("normalizes path and returns NormPath type", () => {
+      const result: NormPath = pathNorm("./test/../file.txt");
+      expect(result).toBe(path.resolve("./test/../file.txt"));
+    });
+
+    it("combines multiple path arguments and normalizes", () => {
+      const basePath = path.resolve("/base");
+      const result = pathNorm(basePath, "sub", "file.txt");
+      expect(result).toBe(path.resolve(basePath, "sub", "file.txt"));
+    });
+
+    it("converts relative path to absolute path", () => {
+      const result = pathNorm("relative/path");
+      expect(path.isAbsolute(result)).toBe(true);
+    });
+  });
+
+  //#endregion
+
+  //#region isChildPath
+
+  describe("pathIsChildPath", () => {
+    it("returns true for child path", () => {
+      const parent = pathNorm("/parent/dir");
+      const child = pathNorm("/parent/dir/child/file.txt");
+      expect(pathIsChildPath(child, parent)).toBe(true);
+    });
+
+    it("returns false for same path", () => {
+      const parent = pathNorm("/parent/dir");
+      const child = pathNorm("/parent/dir");
+      expect(pathIsChildPath(child, parent)).toBe(false);
+    });
+
+    it("returns false for non-child path", () => {
+      const parent = pathNorm("/parent/dir");
+      const child = pathNorm("/other/dir/file.txt");
+      expect(pathIsChildPath(child, parent)).toBe(false);
+    });
+
+    it("returns false when only part of parent path matches", () => {
+      const parent = pathNorm("/parent/dir");
+      const child = pathNorm("/parent/directory/file.txt");
+      expect(pathIsChildPath(child, parent)).toBe(false);
+    });
+  });
+
+  //#endregion
+
+  //#region changeFileDirectory
+
+  describe("pathChangeFileDirectory", () => {
+    it("changes file directory", () => {
+      const file = pathNorm("/source/sub/file.txt");
+      const from = pathNorm("/source");
+      const to = pathNorm("/target");
+
+      const result = pathChangeFileDirectory(file, from, to);
+      expect(result).toBe(pathNorm("/target/sub/file.txt"));
+    });
+
+    it("changes directory in nested path", () => {
+      const file = pathNorm("/a/b/c/d/file.txt");
+      const from = pathNorm("/a/b");
+      const to = pathNorm("/x/y");
+
+      const result = pathChangeFileDirectory(file, from, to);
+      expect(result).toBe(pathNorm("/x/y/c/d/file.txt"));
+    });
+
+    it("throws error when file is not inside fromDirectory", () => {
+      const file = pathNorm("/other/path/file.txt");
+      const from = pathNorm("/source");
+      const to = pathNorm("/target");
+
+      expect(() => pathChangeFileDirectory(file, from, to)).toThrow();
+    });
+
+    it("returns toDirectory when filePath and fromDirectory are the same", () => {
+      const file = pathNorm("/source");
+      const from = pathNorm("/source");
+      const to = pathNorm("/target");
+
+      const result = pathChangeFileDirectory(file, from, to);
+      expect(result).toBe(to);
+    });
+  });
+
+  //#endregion
+
+  //#region basenameWithoutExt
+
+  describe("pathBasenameWithoutExt", () => {
+    it("removes single extension (returns basename only)", () => {
+      const result = pathBasenameWithoutExt("/path/to/file.txt");
+      expect(result).toBe("file");
+    });
+
+    it("removes only last extension in multiple extensions", () => {
+      const result = pathBasenameWithoutExt("/path/to/file.spec.ts");
+      expect(result).toBe("file.spec");
+    });
+
+    it("returns basename for file without extension", () => {
+      const result = pathBasenameWithoutExt("/path/to/file");
+      expect(result).toBe("file");
+    });
+
+    it("returns hidden file (starting with dot) as is", () => {
+      const result = pathBasenameWithoutExt("/path/to/.gitignore");
+      expect(result).toBe(".gitignore");
+    });
+  });
+
+  //#endregion
+
+  //#region filterByTargets
+
+  describe("pathFilterByTargets", () => {
+    const cwd = "/proj";
+    const files = ["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts", "/proj/lib/d.ts"];
+
+    it("returns all files if targets array is empty", () => {
+      const result = pathFilterByTargets(files, [], cwd);
+      expect(result).toEqual(files);
+    });
+
+    it("filters by single target", () => {
+      const result = pathFilterByTargets(files, ["src"], cwd);
+      expect(result).toEqual(["/proj/src/a.ts", "/proj/src/b.ts"]);
+    });
+
+    it("filters by multiple targets", () => {
+      const result = pathFilterByTargets(files, ["src", "tests"], cwd);
+      expect(result).toEqual(["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts"]);
+    });
+
+    it("returns empty array when no matching file is found", () => {
+      const result = pathFilterByTargets(files, ["nonexistent"], cwd);
+      expect(result).toEqual([]);
+    });
+
+    it("filters by exact file path", () => {
+      const result = pathFilterByTargets(files, ["src/a.ts"], cwd);
+      expect(result).toEqual(["/proj/src/a.ts"]);
+    });
+  });
+
+  //#endregion
+});

package/tests/worker/fixtures/test-worker.ts

@@ -0,0 +1,35 @@
+import { createWorker } from "../../../src";
+
+interface TestWorkerEvents extends Record<string, unknown> {
+  progress: number;
+}
+
+const methods = {
+  add: (a: number, b: number) => {
+    sender.send("progress", 50);
+    return a + b;
+  },
+  echo: (message: string) => `Echo: ${message}`,
+  throwError: () => {
+    throw new Error("Intentional error");
+  },
+  delay: async (ms: number) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    return ms;
+  },
+  noReturn: () => {},
+  logMessage: (message: string) => {
+    console.log(message);
+    return "logged";
+  },
+  crash: () => {
+    // Exit immediately
+    setImmediate(() => process.exit(1));
+    return "crashing...";
+  },
+  getEnv: (key: string) => process.env[key],
+};
+
+const sender = createWorker<typeof methods, TestWorkerEvents>(methods);
+
+export default sender;

package/tests/worker/sd-worker.spec.ts

@@ -0,0 +1,189 @@
+import { afterEach, describe, expect, it } from "vitest";
+import path from "path";
+import type { WorkerProxy } from "../../src/worker/types";
+import { Worker } from "../../src/worker/worker";
+import type * as TestWorkerModule from "./fixtures/test-worker";
+
+describe("SdWorker", () => {
+  const workerPath = path.resolve(import.meta.dirname, "fixtures/test-worker.ts");
+  let worker: WorkerProxy<typeof TestWorkerModule> | undefined;
+
+  afterEach(async () => {
+    if (worker) {
+      await worker.terminate();
+      worker = undefined;
+    }
+  });
+
+  //#region Method invocation
+
+  describe("method invocation", () => {
+    it("calls worker method and returns result", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const result = await worker.add(10, 20);
+
+      expect(result).toBe(30);
+    });
+
+    it("calls method that returns string", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const result = await worker.echo("Hello");
+
+      expect(result).toBe("Echo: Hello");
+    });
+
+    it("rejects when error occurs in worker", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      await expect(worker.throwError()).rejects.toThrow();
+    });
+
+    it("throws error when calling nonexistent method", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      // Bypass type system to call nonexistent method
+      const unknownWorker = worker as unknown as { unknownMethod: () => Promise<void> };
+
+      await expect(unknownWorker.unknownMethod()).rejects.toThrow(
+        "Unknown method: unknownMethod",
+      );
+    });
+
+    it("handles multiple concurrent requests", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const [result1, result2, result3] = await Promise.all([
+        worker.add(1, 2),
+        worker.add(3, 4),
+        worker.add(5, 6),
+      ]);
+
+      expect(result1).toBe(3);
+      expect(result2).toBe(7);
+      expect(result3).toBe(11);
+    });
+
+    it("calls method that returns void", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const result = await worker.noReturn();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  //#endregion
+
+  //#region Events
+
+  describe("events", () => {
+    it("receives events from worker", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const events: number[] = [];
+      worker.on("progress", (value) => {
+        events.push(value);
+      });
+
+      await worker.add(1, 2);
+
+      expect(events).toContain(50);
+    });
+
+    it("removes event listener with off()", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const events: number[] = [];
+      const listener = (value: number) => {
+        events.push(value);
+      };
+
+      worker.on("progress", listener);
+      await worker.add(1, 2);
+
+      // Remove listener
+      worker.off("progress", listener);
+      await worker.add(3, 4);
+
+      // Should only receive event from first call
+      expect(events).toHaveLength(1);
+      expect(events[0]).toBe(50);
+    });
+  });
+
+  //#endregion
+
+  //#region Terminate
+
+  describe("terminate", () => {
+    it("rejects pending requests with Worker terminated error", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const runPromise = worker.delay(5000);
+
+      // Prepare to catch error before terminating worker
+      const errorPromise = runPromise.catch((err: unknown) => err);
+
+      // Terminate worker
+      await worker.terminate();
+      worker = undefined;
+
+      const error = await errorPromise;
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toBe("Worker terminated (method: delay)");
+    });
+
+    it("rejects pending requests when worker crashes", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      // Call long delay first to put it in pending state
+      const delayPromise = worker.delay(5000).catch((err: unknown) => err);
+
+      // Call crash after short wait (while delay is pending)
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await worker.crash();
+
+      // When worker crashes, pending delay request should be rejected
+      const error = await delayPromise;
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toContain("Worker crashed");
+    });
+  });
+
+  //#endregion
+
+  //#region stdout/stderr
+
+  describe("stdout/stderr", () => {
+    it("forwards worker console.log output to main process", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const result = await worker.logMessage("test message");
+
+      // If method returns normally, stdout piping is working
+      expect(result).toBe("logged");
+    });
+  });
+
+  //#endregion
+
+  //#region env option
+
+  describe("env option", () => {
+    it("passes env option to worker", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath, {
+        env: {
+          TEST_ENV_VAR: "test-value-123",
+        },
+      });
+
+      const result = await worker.getEnv("TEST_ENV_VAR");
+
+      expect(result).toBe("test-value-123");
+    });
+  });
+
+  //#endregion
+});