@simplysm/core-common 13.0.0-beta.2 → 13.0.0-beta.21

package/tests/utils/path.spec.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { pathJoin, pathBasename, pathExtname } from "@simplysm/core-common";
-
-describe("path utils", () => {
-  describe("pathJoin()", () => {
-    it("경로 세그먼트를 결합한다", () => {
-      expect(pathJoin("a", "b", "c")).toBe("a/b/c");
-    });
-
-    it("선행 슬래시를 유지한다", () => {
-      expect(pathJoin("/a", "b")).toBe("/a/b");
-    });
-
-    it("중복 슬래시를 제거한다", () => {
-      expect(pathJoin("a/", "/b/", "/c")).toBe("a/b/c");
-    });
-
-    it("빈 세그먼트를 무시한다", () => {
-      expect(pathJoin("a", "", "b")).toBe("a/b");
-    });
-
-    it("단일 세그먼트를 반환한다", () => {
-      expect(pathJoin("a")).toBe("a");
-    });
-
-    it("빈 입력은 빈 문자열을 반환한다", () => {
-      expect(pathJoin()).toBe("");
-    });
-  });
-
-  describe("pathBasename()", () => {
-    it("파일명을 추출한다", () => {
-      expect(pathBasename("a/b/file.txt")).toBe("file.txt");
-    });
-
-    it("확장자를 제거한다", () => {
-      expect(pathBasename("a/b/file.txt", ".txt")).toBe("file");
-    });
-
-    it("일치하지 않는 확장자는 무시한다", () => {
-      expect(pathBasename("a/b/file.txt", ".md")).toBe("file.txt");
-    });
-
-    it("경로 없는 파일명을 처리한다", () => {
-      expect(pathBasename("file.txt")).toBe("file.txt");
-    });
-
-    it("빈 문자열은 빈 문자열을 반환한다", () => {
-      expect(pathBasename("")).toBe("");
-    });
-  });
-
-  describe("pathExtname()", () => {
-    it("확장자를 추출한다", () => {
-      expect(pathExtname("file.txt")).toBe(".txt");
-    });
-
-    it("마지막 확장자만 추출한다", () => {
-      expect(pathExtname("archive.tar.gz")).toBe(".gz");
-    });
-
-    it("확장자 없는 파일은 빈 문자열을 반환한다", () => {
-      expect(pathExtname("Makefile")).toBe("");
-    });
-
-    it("숨김 파일은 빈 문자열을 반환한다", () => {
-      expect(pathExtname(".gitignore")).toBe("");
-    });
-
-    it("경로 포함 파일의 확장자를 추출한다", () => {
-      expect(pathExtname("a/b/file.ts")).toBe(".ts");
-    });
-
-    it("빈 문자열은 빈 문자열을 반환한다", () => {
-      expect(pathExtname("")).toBe("");
-    });
-  });
-});

package/tests/utils/primitive.spec.ts

@@ -1,55 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getPrimitiveTypeStr, DateTime, DateOnly, Time, Uuid } from "@simplysm/core-common";
-
-describe("primitive utils", () => {
-  describe("getPrimitiveTypeStr()", () => {
-    it("string을 반환한다", () => {
-      expect(getPrimitiveTypeStr("hello")).toBe("string");
-    });
-
-    it("빈 문자열도 string을 반환한다", () => {
-      expect(getPrimitiveTypeStr("")).toBe("string");
-    });
-
-    it("number를 반환한다", () => {
-      expect(getPrimitiveTypeStr(42)).toBe("number");
-    });
-
-    it("0도 number를 반환한다", () => {
-      expect(getPrimitiveTypeStr(0)).toBe("number");
-    });
-
-    it("NaN도 number를 반환한다", () => {
-      expect(getPrimitiveTypeStr(NaN)).toBe("number");
-    });
-
-    it("boolean을 반환한다", () => {
-      expect(getPrimitiveTypeStr(true)).toBe("boolean");
-      expect(getPrimitiveTypeStr(false)).toBe("boolean");
-    });
-
-    it("DateTime을 반환한다", () => {
-      expect(getPrimitiveTypeStr(new DateTime())).toBe("DateTime");
-    });
-
-    it("DateOnly를 반환한다", () => {
-      expect(getPrimitiveTypeStr(new DateOnly())).toBe("DateOnly");
-    });
-
-    it("Time을 반환한다", () => {
-      expect(getPrimitiveTypeStr(new Time())).toBe("Time");
-    });
-
-    it("Uuid를 반환한다", () => {
-      expect(getPrimitiveTypeStr(Uuid.new())).toBe("Uuid");
-    });
-
-    it("Uint8Array는 Bytes를 반환한다", () => {
-      expect(getPrimitiveTypeStr(new Uint8Array([1, 2]))).toBe("Bytes");
-    });
-
-    it("지원하지 않는 타입은 에러를 던진다", () => {
-      expect(() => getPrimitiveTypeStr({} as never)).toThrow();
-    });
-  });
-});

package/tests/utils/sd-event-emitter.spec.ts

@@ -1,216 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { EventEmitter } from "@simplysm/core-common";
-
-interface TestEvents {
-  message: string;
-  count: number;
-  data: { id: number; name: string };
-  empty: void;
-}
-
-describe("SdEventEmitter", () => {
-  //#region on/emit
-
-  describe("on() / emit()", () => {
-    it("이벤트를 발생시키고 수신한다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("message", listener);
-      emitter.emit("message", "hello");
-
-      expect(listener).toHaveBeenCalledWith("hello");
-      expect(listener).toHaveBeenCalledTimes(1);
-    });
-
-    it("여러 번 emit하면 리스너가 여러 번 호출된다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("count", listener);
-      emitter.emit("count", 1);
-      emitter.emit("count", 2);
-      emitter.emit("count", 3);
-
-      expect(listener).toHaveBeenCalledTimes(3);
-      expect(listener).toHaveBeenNthCalledWith(1, 1);
-      expect(listener).toHaveBeenNthCalledWith(2, 2);
-      expect(listener).toHaveBeenNthCalledWith(3, 3);
-    });
-
-    it("객체 데이터를 전달한다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("data", listener);
-      emitter.emit("data", { id: 1, name: "test" });
-
-      expect(listener).toHaveBeenCalledWith({ id: 1, name: "test" });
-    });
-
-    it("void 이벤트를 처리한다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("empty", listener);
-      emitter.emit("empty");
-
-      expect(listener).toHaveBeenCalledTimes(1);
-    });
-
-    it("같은 이벤트에 여러 리스너를 등록할 수 있다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener1 = vi.fn();
-      const listener2 = vi.fn();
-
-      emitter.on("message", listener1);
-      emitter.on("message", listener2);
-      emitter.emit("message", "test");
-
-      expect(listener1).toHaveBeenCalledWith("test");
-      expect(listener2).toHaveBeenCalledWith("test");
-    });
-  });
-
-  //#endregion
-
-  //#region off
-
-  describe("off()", () => {
-    it("리스너를 해제한다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("message", listener);
-      emitter.off("message", listener);
-      emitter.emit("message", "test");
-
-      expect(listener).not.toHaveBeenCalled();
-    });
-
-    it("해제된 리스너만 제거되고 다른 리스너는 유지된다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener1 = vi.fn();
-      const listener2 = vi.fn();
-
-      emitter.on("message", listener1);
-      emitter.on("message", listener2);
-      emitter.off("message", listener1);
-      emitter.emit("message", "test");
-
-      expect(listener1).not.toHaveBeenCalled();
-      expect(listener2).toHaveBeenCalledWith("test");
-    });
-
-    it("등록되지 않은 리스너를 해제해도 에러가 발생하지 않는다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      // 에러 없이 실행되어야 함
-      expect(() => {
-        emitter.off("message", listener);
-      }).not.toThrow();
-    });
-  });
-
-  //#endregion
-
-  //#region listenerCount
-
-  describe("listenerCount()", () => {
-    it("리스너 수를 정확히 카운트한다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-
-      expect(emitter.listenerCount("message")).toBe(0);
-
-      emitter.on("message", () => {});
-      expect(emitter.listenerCount("message")).toBe(1);
-
-      emitter.on("message", () => {});
-      expect(emitter.listenerCount("message")).toBe(2);
-    });
-
-    it("off 후 카운트가 감소한다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("message", listener);
-      expect(emitter.listenerCount("message")).toBe(1);
-
-      emitter.off("message", listener);
-      expect(emitter.listenerCount("message")).toBe(0);
-    });
-
-    it("등록되지 않은 이벤트 타입의 카운트는 0이다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-
-      expect(emitter.listenerCount("message")).toBe(0);
-      expect(emitter.listenerCount("count")).toBe(0);
-    });
-
-    it("다른 이벤트 타입의 카운트는 독립적이다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-
-      emitter.on("message", () => {});
-      emitter.on("message", () => {});
-      emitter.on("count", () => {});
-
-      expect(emitter.listenerCount("message")).toBe(2);
-      expect(emitter.listenerCount("count")).toBe(1);
-    });
-  });
-
-  //#endregion
-
-  //#region 중복 등록 방지
-
-  describe("중복 등록 방지", () => {
-    it("동일한 리스너를 중복 등록하면 무시된다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("message", listener);
-      emitter.on("message", listener); // 중복 등록 시도
-      emitter.on("message", listener); // 중복 등록 시도
-
-      expect(emitter.listenerCount("message")).toBe(1);
-
-      emitter.emit("message", "test");
-      expect(listener).toHaveBeenCalledTimes(1);
-    });
-
-    it("동일한 리스너를 서로 다른 이벤트에 등록할 수 있다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("message", listener);
-      emitter.on("count", listener as any);
-
-      expect(emitter.listenerCount("message")).toBe(1);
-      expect(emitter.listenerCount("count")).toBe(1);
-
-      emitter.emit("message", "test");
-      emitter.emit("count", 123);
-
-      expect(listener).toHaveBeenCalledTimes(2);
-      expect(listener).toHaveBeenNthCalledWith(1, "test");
-      expect(listener).toHaveBeenNthCalledWith(2, 123);
-    });
-
-    it("중복 등록 후 off 한 번 호출로 제거된다", () => {
-      const emitter = new EventEmitter<TestEvents>();
-      const listener = vi.fn();
-
-      emitter.on("message", listener);
-      emitter.on("message", listener); // 중복 등록 시도
-
-      emitter.off("message", listener);
-      expect(emitter.listenerCount("message")).toBe(0);
-
-      emitter.emit("message", "test");
-      expect(listener).not.toHaveBeenCalled();
-    });
-  });
-
-  //#endregion
-});

package/tests/utils/serial-queue.spec.ts

@@ -1,365 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { SerialQueue, SdError } from "@simplysm/core-common";
-
-describe("SerialQueue", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  //#region 순차 실행
-
-  describe("순차 실행", () => {
-    it("큐에 추가된 함수들을 순서대로 실행한다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-
-      queue.run(() => {
-        calls.push(1);
-      });
-      queue.run(() => {
-        calls.push(2);
-      });
-      queue.run(() => {
-        calls.push(3);
-      });
-
-      await vi.advanceTimersByTimeAsync(50);
-
-      expect(calls).toEqual([1, 2, 3]);
-    });
-
-    it("이전 작업이 완료된 후 다음 작업을 실행한다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-      const timestamps: number[] = [];
-
-      queue.run(async () => {
-        timestamps.push(Date.now());
-        calls.push(1);
-        await new Promise((r) => setTimeout(r, 50));
-      });
-      queue.run(async () => {
-        timestamps.push(Date.now());
-        calls.push(2);
-        await new Promise((r) => setTimeout(r, 50));
-      });
-
-      await vi.advanceTimersByTimeAsync(200);
-
-      expect(calls).toEqual([1, 2]);
-      // 두 번째 작업은 첫 작업 완료 후 시작 (정확히 50ms)
-      expect(timestamps[1] - timestamps[0]).toBe(50);
-    });
-
-    it("실행 중에 추가된 작업도 순차적으로 실행한다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-
-      queue.run(async () => {
-        calls.push(1);
-        await new Promise((r) => setTimeout(r, 50));
-      });
-
-      // 첫 작업 시작 대기
-      await vi.advanceTimersByTimeAsync(10);
-
-      // 실행 중에 추가
-      queue.run(() => {
-        calls.push(2);
-      });
-
-      await vi.advanceTimersByTimeAsync(100);
-
-      expect(calls).toEqual([1, 2]);
-    });
-  });
-
-  //#endregion
-
-  //#region gap 간격
-
-  describe("gap 간격", () => {
-    it("gap이 설정되면 작업 사이에 대기한다", async () => {
-      const queue = new SerialQueue(50);
-      const timestamps: number[] = [];
-
-      queue.run(() => {
-        timestamps.push(Date.now());
-      });
-      queue.run(() => {
-        timestamps.push(Date.now());
-      });
-
-      await vi.advanceTimersByTimeAsync(150);
-
-      expect(timestamps).toHaveLength(2);
-      // 두 작업 사이에 정확히 50ms 간격
-      expect(timestamps[1] - timestamps[0]).toBe(50);
-    });
-
-    it("gap이 0이면 즉시 다음 작업을 실행한다", async () => {
-      const queue = new SerialQueue(0);
-      const timestamps: number[] = [];
-
-      queue.run(() => {
-        timestamps.push(Date.now());
-      });
-      queue.run(() => {
-        timestamps.push(Date.now());
-      });
-
-      await vi.advanceTimersByTimeAsync(50);
-
-      expect(timestamps).toHaveLength(2);
-      // 간격이 0
-      expect(timestamps[1] - timestamps[0]).toBe(0);
-    });
-
-    it("gap은 기본값 0이다", async () => {
-      const queue = new SerialQueue();
-      const timestamps: number[] = [];
-
-      queue.run(() => {
-        timestamps.push(Date.now());
-      });
-      queue.run(() => {
-        timestamps.push(Date.now());
-      });
-
-      await vi.advanceTimersByTimeAsync(50);
-
-      expect(timestamps).toHaveLength(2);
-      expect(timestamps[1] - timestamps[0]).toBe(0);
-    });
-
-    it("마지막 작업 후에는 gap을 대기하지 않는다", async () => {
-      const queue = new SerialQueue(100);
-      const timestamps: number[] = [];
-
-      queue.run(() => {
-        timestamps.push(Date.now());
-      });
-      queue.run(() => {
-        timestamps.push(Date.now());
-      });
-
-      // 충분히 대기 (작업1 + gap100 + 작업2)
-      await vi.advanceTimersByTimeAsync(200);
-
-      // gap이 실제로 적용되었는지 확인 (정확히 100ms)
-      expect(timestamps).toHaveLength(2);
-      expect(timestamps[1] - timestamps[0]).toBe(100);
-    });
-  });
-
-  //#endregion
-
-  //#region 에러 처리
-
-  describe("에러 처리", () => {
-    it("에러 발생 시 error 이벤트를 발생시킨다", async () => {
-      const queue = new SerialQueue();
-      const errors: SdError[] = [];
-
-      queue.on("error", (err) => {
-        errors.push(err);
-      });
-
-      queue.run(() => {
-        throw new Error("test error");
-      });
-
-      await vi.advanceTimersByTimeAsync(50);
-
-      expect(errors).toHaveLength(1);
-      expect(errors[0]).toBeInstanceOf(SdError);
-      expect(errors[0].message).toContain("큐 작업 실행 중 오류 발생");
-      expect(errors[0].message).toContain("test error");
-    });
-
-    it("에러가 발생해도 다음 작업은 계속 실행한다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-      const errors: SdError[] = [];
-
-      // 에러 리스너 추가하여 unhandled rejection 방지
-      queue.on("error", (err) => {
-        errors.push(err);
-      });
-
-      queue.run(() => {
-        calls.push(1);
-        throw new Error("error");
-      });
-      queue.run(() => {
-        calls.push(2);
-      });
-      queue.run(() => {
-        calls.push(3);
-      });
-
-      await vi.advanceTimersByTimeAsync(100);
-
-      expect(calls).toEqual([1, 2, 3]);
-      expect(errors).toHaveLength(1);
-    });
-
-    it("여러 작업에서 에러가 발생해도 모두 실행한다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-      const errors: SdError[] = [];
-
-      queue.on("error", (err) => {
-        errors.push(err);
-      });
-
-      queue.run(() => {
-        calls.push(1);
-        throw new Error("error 1");
-      });
-      queue.run(() => {
-        calls.push(2);
-      });
-      queue.run(() => {
-        calls.push(3);
-        throw new Error("error 3");
-      });
-
-      await vi.advanceTimersByTimeAsync(100);
-
-      expect(calls).toEqual([1, 2, 3]);
-      expect(errors).toHaveLength(2);
-      expect(errors[0].message).toContain("error 1");
-      expect(errors[1].message).toContain("error 3");
-    });
-  });
-
-  //#endregion
-
-  //#region dispose
-
-  describe("dispose()", () => {
-    it("대기 중인 큐를 비운다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-
-      // 첫 작업 실행 중
-      queue.run(async () => {
-        calls.push(1);
-        await new Promise((r) => setTimeout(r, 100));
-      });
-
-      // 대기 중인 작업들 추가
-      queue.run(() => {
-        calls.push(2);
-      });
-      queue.run(() => {
-        calls.push(3);
-      });
-
-      // 첫 작업 시작 후 dispose
-      await vi.advanceTimersByTimeAsync(20);
-      queue.dispose();
-
-      // 모든 작업 완료 대기
-      await vi.advanceTimersByTimeAsync(150);
-
-      // 첫 작업만 실행됨 (실행 중인 작업은 완료됨)
-      expect(calls).toEqual([1]);
-    });
-
-    it("dispose 후 새 작업은 정상 실행된다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-
-      queue.run(() => {
-        calls.push(1);
-      });
-      queue.dispose();
-
-      // dispose 후 새 작업 추가
-      queue.run(() => {
-        calls.push(2);
-      });
-
-      await vi.advanceTimersByTimeAsync(50);
-
-      expect(calls).toContain(2);
-    });
-
-    it("여러 번 호출해도 안전하다", () => {
-      const queue = new SerialQueue();
-
-      // 여러 번 호출해도 에러 없음
-      queue.dispose();
-      queue.dispose();
-      queue.dispose();
-    });
-
-    it("using 문으로 자동 dispose된다", async () => {
-      const calls: number[] = [];
-      {
-        using queue = new SerialQueue();
-        queue.run(async () => {
-          calls.push(1);
-          await new Promise((r) => setTimeout(r, 100));
-        });
-        queue.run(() => {
-          calls.push(2);
-        });
-        await vi.advanceTimersByTimeAsync(20);
-      } // using 블록 종료 시 dispose 자동 호출
-      await vi.advanceTimersByTimeAsync(150);
-      // 첫 작업(실행 중)은 완료되지만, 대기 중인 작업은 실행되지 않음
-      expect(calls).toEqual([1]);
-    });
-  });
-
-  //#endregion
-
-  //#region 동기 함수 지원
-
-  describe("동기 함수 지원", () => {
-    it("동기 함수도 실행할 수 있다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-
-      queue.run(() => {
-        calls.push(1);
-      });
-      queue.run(() => {
-        calls.push(2);
-      });
-
-      await vi.advanceTimersByTimeAsync(50);
-
-      expect(calls).toEqual([1, 2]);
-    });
-
-    it("동기/비동기 함수를 혼합해서 사용할 수 있다", async () => {
-      const queue = new SerialQueue();
-      const calls: number[] = [];
-
-      queue.run(() => {
-        calls.push(1);
-      });
-      queue.run(async () => {
-        await new Promise((r) => setTimeout(r, 10));
-        calls.push(2);
-      });
-      queue.run(() => {
-        calls.push(3);
-      });
-
-      await vi.advanceTimersByTimeAsync(100);
-
-      expect(calls).toEqual([1, 2, 3]);
-    });
-  });
-
-  //#endregion
-});