@simplysm/core-node 13.0.0-beta.6 → 13.0.0-beta.7

package/tests/utils/path.spec.ts

@@ -1,192 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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
-});