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

package/tests/utils/wait.spec.ts

@@ -1,145 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { waitTime as time, waitUntil as until, TimeoutError } from "@simplysm/core-common";
-
-describe("Wait", () => {
-  //#region time
-
-  describe("time()", () => {
-    it("지정된 시간만큼 대기한다", async () => {
-      const start = Date.now();
-      await time(100);
-      const elapsed = Date.now() - start;
-
-      // 100ms ± 오차 범위 - CI 환경 부하 및 타이머 정밀도 고려
-      expect(elapsed).toBeGreaterThanOrEqual(95);
-      expect(elapsed).toBeLessThan(250);
-    });
-
-    it("0ms 대기도 정상 동작한다", async () => {
-      const start = Date.now();
-      await time(0);
-      const elapsed = Date.now() - start;
-
-      expect(elapsed).toBeLessThan(50);
-    });
-  });
-
-  //#endregion
-
-  //#region until
-
-  describe("until()", () => {
-    it("조건이 참이 될 때까지 대기한다", async () => {
-      let count = 0;
-
-      await until(() => {
-        count++;
-        return count >= 3;
-      }, 10);
-
-      expect(count).toBe(3);
-    });
-
-    it("비동기 조건 함수도 지원한다", async () => {
-      let count = 0;
-
-      await until(async () => {
-        await time(10);
-        count++;
-        return count >= 3;
-      }, 10);
-
-      expect(count).toBe(3);
-    });
-
-    it("조건이 이미 참이면 즉시 반환한다", async () => {
-      const start = Date.now();
-      await until(() => true, 100);
-      const elapsed = Date.now() - start;
-
-      expect(elapsed).toBeLessThan(50);
-    });
-
-    it("최대 시도 횟수 초과 시 TimeoutError를 던진다", async () => {
-      let count = 0;
-
-      await expect(async () => {
-        await until(
-          () => {
-            count++;
-            return false;
-          },
-          10,
-          5,
-        );
-      }).rejects.toThrow(TimeoutError);
-
-      expect(count).toBe(5);
-    });
-
-    it("maxCount가 undefined면 무제한 대기한다", async () => {
-      let count = 0;
-
-      // 무제한 대기지만 조건이 참이 되면 반환
-      await until(
-        () => {
-          count++;
-          return count >= 10;
-        },
-        10,
-        undefined,
-      );
-
-      expect(count).toBe(10);
-    });
-
-    it("milliseconds 기본값은 100ms다", async () => {
-      let count = 0;
-      const start = Date.now();
-
-      await until(() => {
-        count++;
-        return count >= 3;
-      });
-
-      const elapsed = Date.now() - start;
-      // 100ms * 2회 대기 = 200ms (첫 체크는 즉시), 타이머 오차 고려
-      expect(elapsed).toBeGreaterThanOrEqual(190);
-      expect(elapsed).toBeLessThan(350);
-    });
-
-    it("maxCount=1이면 한 번만 시도 후 에러", async () => {
-      let count = 0;
-
-      await expect(async () => {
-        await until(
-          () => {
-            count++;
-            return false;
-          },
-          10,
-          1,
-        );
-      }).rejects.toThrow(TimeoutError);
-
-      expect(count).toBe(1);
-    });
-
-    it("조건이 maxCount 내에 참이 되면 성공", async () => {
-      let count = 0;
-
-      await until(
-        () => {
-          count++;
-          return count >= 3;
-        },
-        10,
-        5,
-      );
-
-      expect(count).toBe(3);
-    });
-  });
-
-  //#endregion
-});

package/tests/utils/xml.spec.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { xmlParse as parse, xmlStringify as stringify } from "@simplysm/core-common";
-
-describe("XmlConvert", () => {
-  //#region parse
-
-  describe("parse()", () => {
-    it("기본 XML을 파싱한다", () => {
-      const xml = "<root><child>value</child></root>";
-      const result = parse(xml) as Record<string, unknown>;
-
-      expect(result).toHaveProperty("root");
-    });
-
-    it("속성을 포함한 XML을 파싱한다", () => {
-      const xml = '<root id="1"><child name="test">value</child></root>';
-      const result = parse(xml) as {
-        root: {
-          $: { id: string };
-          child: Array<{ $: { name: string }; _: string }>;
-        };
-      };
-
-      expect(result.root.$.id).toBe("1");
-      expect(result.root.child[0].$.name).toBe("test");
-    });
-
-    it("중첩된 XML을 파싱한다", () => {
-      const xml = "<root><parent><child>value</child></parent></root>";
-      const result = parse(xml) as {
-        root: { parent: Array<{ child: string[] }> };
-      };
-
-      expect(result.root.parent[0].child[0]).toBe("value");
-    });
-
-    it("텍스트 노드를 _ 키로 파싱한다", () => {
-      const xml = '<item id="1">text content</item>';
-      const result = parse(xml) as {
-        item: { $: { id: string }; _: string };
-      };
-
-      expect(result.item._).toBe("text content");
-    });
-
-    it("namespace prefix를 제거한다 (stripTagPrefix: true)", () => {
-      const xml = "<ns:root><ns:child>value</ns:child></ns:root>";
-      const result = parse(xml, { stripTagPrefix: true }) as {
-        root: { child: string[] };
-      };
-
-      expect(result).toHaveProperty("root");
-      expect(result.root).toHaveProperty("child");
-    });
-
-    it("namespace prefix를 유지한다 (기본)", () => {
-      const xml = "<ns:root><ns:child>value</ns:child></ns:root>";
-      const result = parse(xml) as Record<string, unknown>;
-
-      expect(result).toHaveProperty("ns:root");
-    });
-
-    it("여러 개의 같은 태그를 배열로 파싱한다", () => {
-      const xml = "<root><item>1</item><item>2</item><item>3</item></root>";
-      const result = parse(xml) as { root: { item: string[] } };
-
-      expect(result.root.item).toEqual(["1", "2", "3"]);
-    });
-
-    it("속성의 namespace prefix는 제거하지 않는다", () => {
-      const xml = '<ns:root xmlns:ns="http://example.com"><ns:child>value</ns:child></ns:root>';
-      const result = parse(xml, { stripTagPrefix: true }) as {
-        root: { $: Record<string, string>; child: string[] };
-      };
-
-      expect(result.root.$).toHaveProperty("xmlns:ns");
-    });
-  });
-
-  //#endregion
-
-  //#region stringify
-
-  describe("stringify()", () => {
-    it("객체를 XML로 직렬화한다", () => {
-      const obj = { root: { child: "value" } };
-      const result = stringify(obj);
-
-      expect(result).toContain("<root>");
-      expect(result).toContain("<child>value</child>");
-      expect(result).toContain("</root>");
-    });
-
-    it("속성을 포함한 객체를 직렬화한다", () => {
-      const obj = { root: { $: { id: "1" }, child: "value" } };
-      const result = stringify(obj);
-
-      expect(result).toContain('id="1"');
-      expect(result).toContain("<child>value</child>");
-    });
-
-    it("배열을 여러 태그로 직렬화한다", () => {
-      const obj = { root: { item: ["1", "2", "3"] } };
-      const result = stringify(obj);
-
-      expect(result).toContain("<item>1</item>");
-      expect(result).toContain("<item>2</item>");
-      expect(result).toContain("<item>3</item>");
-    });
-
-    it("텍스트 노드를 _ 키로 직렬화한다", () => {
-      const obj = { item: { $: { id: "1" }, _: "text content" } };
-      const result = stringify(obj);
-
-      expect(result).toContain('id="1"');
-      expect(result).toContain("text content");
-    });
-
-    it("중첩된 객체를 직렬화한다", () => {
-      const obj = { root: { parent: { child: "value" } } };
-      const result = stringify(obj);
-
-      expect(result).toContain("<parent>");
-      expect(result).toContain("<child>value</child>");
-      expect(result).toContain("</parent>");
-    });
-  });
-
-  //#endregion
-
-  //#region roundtrip
-
-  describe("parse/stringify roundtrip", () => {
-    it("parse 후 stringify하면 구조가 유지된다", () => {
-      const xml = "<root><child>value</child></root>";
-      const parsed = parse(xml);
-      const result = stringify(parsed);
-
-      expect(result).toContain("<root>");
-      expect(result).toContain("<child>value</child>");
-      expect(result).toContain("</root>");
-    });
-  });
-
-  //#endregion
-});

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

@@ -1,234 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ZipArchive } from "@simplysm/core-common";
-
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-describe("ZipArchive", () => {
-  //#region write + compress
-
-  describe("write + compress", () => {
-    it("write로 파일을 추가하고 compress로 ZIP을 생성한다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file1.txt", encoder.encode("content 1"));
-      zip.write("file2.txt", encoder.encode("content 2"));
-
-      const zipBuffer = await zip.compress();
-
-      expect(zipBuffer instanceof Uint8Array).toBe(true);
-      expect(zipBuffer.length).toBeGreaterThan(0);
-    });
-
-    it("특수 문자가 포함된 파일명을 처리한다", async () => {
-      const zip = new ZipArchive();
-      zip.write("파일 이름.txt", encoder.encode("한글 내용"));
-      zip.write("file (1).txt", encoder.encode("괄호 포함"));
-      zip.write("file@#$.txt", encoder.encode("특수문자"));
-
-      const zipBuffer = await zip.compress();
-      const result = new ZipArchive(zipBuffer);
-
-      const content1 = await result.get("파일 이름.txt");
-      const content2 = await result.get("file (1).txt");
-      const content3 = await result.get("file@#$.txt");
-
-      expect(content1 != null ? decoder.decode(content1) : undefined).toBe("한글 내용");
-      expect(content2 != null ? decoder.decode(content2) : undefined).toBe("괄호 포함");
-      expect(content3 != null ? decoder.decode(content3) : undefined).toBe("특수문자");
-    });
-
-    it("빈 ZIP도 압축할 수 있다", async () => {
-      const zip = new ZipArchive();
-      const zipBuffer = await zip.compress();
-
-      expect(zipBuffer instanceof Uint8Array).toBe(true);
-    });
-
-    it("같은 파일명으로 여러 번 write하면 덮어쓴다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("first"));
-      zip.write("file.txt", encoder.encode("second"));
-
-      const zipBuffer = await zip.compress();
-      const result = new ZipArchive(zipBuffer);
-      const content = await result.get("file.txt");
-
-      expect(content != null ? decoder.decode(content) : undefined).toBe("second");
-    });
-  });
-
-  //#endregion
-
-  //#region extractAll
-
-  describe("extractAll", () => {
-    it("압축된 모든 파일을 추출한다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file1.txt", encoder.encode("content 1"));
-      zip.write("file2.txt", encoder.encode("content 2"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const files = await result.extractAll();
-
-      expect(files.size).toBe(2);
-      expect(files.get("file1.txt") != null ? decoder.decode(files.get("file1.txt")) : undefined).toBe("content 1");
-      expect(files.get("file2.txt") != null ? decoder.decode(files.get("file2.txt")) : undefined).toBe("content 2");
-    });
-
-    it("진행률 콜백을 호출한다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file1.txt", encoder.encode("a".repeat(1000)));
-      zip.write("file2.txt", encoder.encode("b".repeat(1000)));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const progressCalls: Array<{ fileName: string; extractedSize: number }> = [];
-
-      await result.extractAll((progress) => {
-        progressCalls.push({
-          fileName: progress.fileName,
-          extractedSize: progress.extractedSize,
-        });
-      });
-
-      expect(progressCalls.length).toBeGreaterThan(0);
-      expect(progressCalls.some((p) => p.fileName === "file1.txt")).toBe(true);
-      expect(progressCalls.some((p) => p.fileName === "file2.txt")).toBe(true);
-    });
-
-    it("reader가 없으면 빈 캐시를 반환한다", async () => {
-      const zip = new ZipArchive();
-      const files = await zip.extractAll();
-
-      expect(files.size).toBe(0);
-    });
-  });
-
-  //#endregion
-
-  //#region get
-
-  describe("get", () => {
-    it("특정 파일만 추출한다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file1.txt", encoder.encode("content 1"));
-      zip.write("file2.txt", encoder.encode("content 2"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const content = await result.get("file1.txt");
-
-      expect(content != null ? decoder.decode(content) : undefined).toBe("content 1");
-    });
-
-    it("없는 파일은 undefined를 반환한다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const content = await result.get("nonexistent.txt");
-
-      expect(content).toBe(undefined);
-    });
-
-    it("캐시된 파일은 재추출하지 않는다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const content1 = await result.get("file.txt");
-      const content2 = await result.get("file.txt");
-
-      expect(content1).toBe(content2); // 같은 참조
-    });
-
-    it("reader가 없으면 undefined를 반환한다", async () => {
-      const zip = new ZipArchive();
-      const content = await zip.get("file.txt");
-
-      expect(content).toBe(undefined);
-    });
-  });
-
-  //#endregion
-
-  //#region exists
-
-  describe("exists", () => {
-    it("파일 존재 여부를 확인한다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const exists = await result.exists("file.txt");
-      const notExists = await result.exists("nonexistent.txt");
-
-      expect(exists).toBe(true);
-      expect(notExists).toBe(false);
-    });
-
-    it("캐시된 파일은 true를 반환한다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      await result.get("file.txt"); // 캐시에 로드
-      const exists = await result.exists("file.txt");
-
-      expect(exists).toBe(true);
-    });
-
-    it("reader가 없으면 false를 반환한다", async () => {
-      const zip = new ZipArchive();
-      const exists = await zip.exists("file.txt");
-
-      expect(exists).toBe(false);
-    });
-  });
-
-  //#endregion
-
-  //#region close
-
-  describe("close", () => {
-    it("reader를 닫는다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      // extractAll 호출하여 캐시에 로드
-      await result.extractAll();
-      await result.close();
-
-      // close 이후에도 캐시된 데이터는 사용 가능
-      const content = await result.get("file.txt");
-      expect(content != null ? decoder.decode(content) : undefined).toBe("content");
-    });
-
-    it("reader가 없어도 에러 없이 동작한다", async () => {
-      const zip = new ZipArchive();
-      await expect(zip.close()).resolves.not.toThrow();
-    });
-
-    it("await using으로 자동 close된다", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      {
-        await using result = new ZipArchive(zipBuffer);
-        await result.extractAll();
-        const content = await result.get("file.txt");
-        expect(decoder.decode(content)).toBe("content");
-      } // await using 블록 종료 시 close 자동 호출
-    });
-  });
-
-  //#endregion
-});