@simplysm/core-node 13.0.0-beta.1

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,
+  pathGetBasenameWithoutExt,
+  pathFilterByTargets,
+  type NormPath,
+} from "../../src/utils/path";
+
+describe("path 함수들", () => {
+  //#region posix
+
+  describe("pathPosix", () => {
+    it("단일 경로 인자를 POSIX 스타일로 변환", () => {
+      const result = pathPosix("C:\\Users\\test\\file.txt");
+      expect(result).toBe("C:/Users/test/file.txt");
+    });
+
+    it("여러 경로 인자를 조합하여 POSIX 스타일로 변환", () => {
+      const result = pathPosix("C:\\Users", "test", "file.txt");
+      expect(result).toBe("C:/Users/test/file.txt");
+    });
+
+    it("이미 POSIX 스타일인 경로는 그대로 유지", () => {
+      const result = pathPosix("/usr/local/bin");
+      expect(result).toBe("/usr/local/bin");
+    });
+
+    it("혼합된 경로 구분자 처리", () => {
+      const result = pathPosix("C:/Users\\test/file.txt");
+      expect(result).toBe("C:/Users/test/file.txt");
+    });
+  });
+
+  //#endregion
+
+  //#region norm
+
+  describe("pathNorm", () => {
+    it("경로를 정규화하고 NormPath 타입으로 반환", () => {
+      const result: NormPath = pathNorm("./test/../file.txt");
+      expect(result).toBe(path.resolve("./test/../file.txt"));
+    });
+
+    it("여러 경로 인자를 조합하여 정규화", () => {
+      const basePath = path.resolve("/base");
+      const result = pathNorm(basePath, "sub", "file.txt");
+      expect(result).toBe(path.resolve(basePath, "sub", "file.txt"));
+    });
+
+    it("상대 경로를 절대 경로로 변환", () => {
+      const result = pathNorm("relative/path");
+      expect(path.isAbsolute(result)).toBe(true);
+    });
+  });
+
+  //#endregion
+
+  //#region isChildPath
+
+  describe("pathIsChildPath", () => {
+    it("자식 경로인 경우 true 반환", () => {
+      const parent = pathNorm("/parent/dir");
+      const child = pathNorm("/parent/dir/child/file.txt");
+      expect(pathIsChildPath(child, parent)).toBe(true);
+    });
+
+    it("같은 경로인 경우 false 반환", () => {
+      const parent = pathNorm("/parent/dir");
+      const child = pathNorm("/parent/dir");
+      expect(pathIsChildPath(child, parent)).toBe(false);
+    });
+
+    it("자식 경로가 아닌 경우 false 반환", () => {
+      const parent = pathNorm("/parent/dir");
+      const child = pathNorm("/other/dir/file.txt");
+      expect(pathIsChildPath(child, parent)).toBe(false);
+    });
+
+    it("부모 경로의 일부 문자열만 일치하는 경우 false 반환", () => {
+      const parent = pathNorm("/parent/dir");
+      const child = pathNorm("/parent/directory/file.txt");
+      expect(pathIsChildPath(child, parent)).toBe(false);
+    });
+  });
+
+  //#endregion
+
+  //#region changeFileDirectory
+
+  describe("pathChangeFileDirectory", () => {
+    it("파일의 디렉토리를 변경", () => {
+      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("중첩된 경로에서 디렉토리 변경", () => {
+      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("파일이 fromDirectory 안에 없으면 에러 발생", () => {
+      const file = pathNorm("/other/path/file.txt");
+      const from = pathNorm("/source");
+      const to = pathNorm("/target");
+
+      expect(() => pathChangeFileDirectory(file, from, to)).toThrow();
+    });
+
+    it("filePath와 fromDirectory가 동일한 경우 toDirectory 반환", () => {
+      const file = pathNorm("/source");
+      const from = pathNorm("/source");
+      const to = pathNorm("/target");
+
+      const result = pathChangeFileDirectory(file, from, to);
+      expect(result).toBe(to);
+    });
+  });
+
+  //#endregion
+
+  //#region getBasenameWithoutExt
+
+  describe("pathGetBasenameWithoutExt", () => {
+    it("단일 확장자 제거 (basename만 반환)", () => {
+      const result = pathGetBasenameWithoutExt("/path/to/file.txt");
+      expect(result).toBe("file");
+    });
+
+    it("다중 확장자에서 마지막 확장자만 제거", () => {
+      const result = pathGetBasenameWithoutExt("/path/to/file.spec.ts");
+      expect(result).toBe("file.spec");
+    });
+
+    it("확장자가 없는 파일은 basename 반환", () => {
+      const result = pathGetBasenameWithoutExt("/path/to/file");
+      expect(result).toBe("file");
+    });
+
+    it("숨김 파일(점으로 시작)은 그대로 반환", () => {
+      const result = pathGetBasenameWithoutExt("/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("빈 타겟 배열이면 모든 파일 반환", () => {
+      const result = pathFilterByTargets(files, [], cwd);
+      expect(result).toEqual(files);
+    });
+
+    it("단일 타겟으로 필터링", () => {
+      const result = pathFilterByTargets(files, ["src"], cwd);
+      expect(result).toEqual(["/proj/src/a.ts", "/proj/src/b.ts"]);
+    });
+
+    it("다중 타겟으로 필터링", () => {
+      const result = pathFilterByTargets(files, ["src", "tests"], cwd);
+      expect(result).toEqual(["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts"]);
+    });
+
+    it("매칭되는 파일이 없으면 빈 배열 반환", () => {
+      const result = pathFilterByTargets(files, ["nonexistent"], cwd);
+      expect(result).toEqual([]);
+    });
+
+    it("정확한 파일 경로로 필터링", () => {
+      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: () => {
+    // 동기적으로 즉시 종료
+    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,183 @@
+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 메서드 호출
+
+  describe("메서드 호출", () => {
+    it("워커 메서드 호출 및 결과 반환", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const result = await worker.add(10, 20);
+
+      expect(result).toBe(30);
+    });
+
+    it("문자열 반환 메서드 호출", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const result = await worker.echo("Hello");
+
+      expect(result).toBe("Echo: Hello");
+    });
+
+    it("워커에서 에러 발생 시 reject", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      await expect(worker.throwError()).rejects.toThrow();
+    });
+
+    it("존재하지 않는 메서드 호출 시 에러", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      // 타입 시스템을 우회하여 존재하지 않는 메서드 호출
+      const unknownWorker = worker as unknown as { unknownMethod: () => Promise<void> };
+
+      await expect(unknownWorker.unknownMethod()).rejects.toThrow("알 수 없는 메서드: unknownMethod");
+    });
+
+    it("다중 요청 동시 처리", 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("void 반환 메서드 호출", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const result = await worker.noReturn();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  //#endregion
+
+  //#region 이벤트
+
+  describe("이벤트", () => {
+    it("워커에서 이벤트 수신", 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("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);
+
+      // 리스너 제거
+      worker.off("progress", listener);
+      await worker.add(3, 4);
+
+      // 첫 번째 호출의 이벤트만 수신되어야 함
+      expect(events).toHaveLength(1);
+      expect(events[0]).toBe(50);
+    });
+  });
+
+  //#endregion
+
+  //#region terminate
+
+  describe("terminate", () => {
+    it("대기 중인 요청이 Worker terminated 에러와 함께 reject", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const runPromise = worker.delay(5000);
+
+      // 워커 종료 전에 미리 에러를 캐치할 준비를 한다
+      const errorPromise = runPromise.catch((err: unknown) => err);
+
+      // 워커 종료
+      await worker.terminate();
+      worker = undefined;
+
+      const error = await errorPromise;
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toBe("워커가 종료됨 (method: delay)");
+    });
+
+    it("워커 비정상 종료 시 대기 중인 요청 reject", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      // 긴 delay를 먼저 호출하여 pending 상태로 만듦
+      const delayPromise = worker.delay(5000).catch((err: unknown) => err);
+
+      // 짧은 대기 후 crash 호출 (delay가 pending 상태인 동안)
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await worker.crash();
+
+      // 워커가 비정상 종료되면 pending 상태의 delay 요청이 reject되어야 함
+      const error = await delayPromise;
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toContain("워커가 비정상 종료됨");
+    });
+  });
+
+  //#endregion
+
+  //#region stdout/stderr
+
+  describe("stdout/stderr", () => {
+    it("워커의 console.log 출력이 메인 프로세스로 전달", async () => {
+      worker = Worker.create<typeof TestWorkerModule>(workerPath);
+
+      const result = await worker.logMessage("test message");
+
+      // 메서드가 정상 반환되면 stdout 파이핑이 동작한 것
+      expect(result).toBe("logged");
+    });
+  });
+
+  //#endregion
+
+  //#region env 옵션
+
+  describe("env 옵션", () => {
+    it("env 옵션이 워커에 전달", 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
+});