@simplysm/core-common 13.0.0-beta.1

package/tests/utils/bytes-utils.spec.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect } from "vitest";
+import {
+  ArgumentError,
+  bytesConcat as concat,
+  bytesToHex as toHex,
+  bytesFromHex as fromHex,
+  bytesToBase64 as toBase64,
+  bytesFromBase64 as fromBase64,
+} from "@simplysm/core-common";
+
+describe("BytesUtils", () => {
+  //#region concat
+
+  describe("concat()", () => {
+    it("여러 Uint8Array를 연결한다", () => {
+      const arr1 = new Uint8Array([1, 2, 3]);
+      const arr2 = new Uint8Array([4, 5]);
+      const arr3 = new Uint8Array([6, 7, 8, 9]);
+
+      const result = concat([arr1, arr2, arr3]);
+
+      expect(result).toEqual(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+    });
+
+    it("빈 배열을 처리한다", () => {
+      const result = concat([]);
+
+      expect(result).toEqual(new Uint8Array([]));
+      expect(result.length).toBe(0);
+    });
+
+    it("단일 배열을 처리한다", () => {
+      const arr = new Uint8Array([1, 2, 3]);
+
+      const result = concat([arr]);
+
+      expect(result).toEqual(new Uint8Array([1, 2, 3]));
+    });
+
+    it("빈 Uint8Array가 포함된 경우 처리한다", () => {
+      const arr1 = new Uint8Array([1, 2]);
+      const arr2 = new Uint8Array([]);
+      const arr3 = new Uint8Array([3, 4]);
+
+      const result = concat([arr1, arr2, arr3]);
+
+      expect(result).toEqual(new Uint8Array([1, 2, 3, 4]));
+    });
+  });
+
+  //#endregion
+
+  //#region toHex/fromHex
+
+  describe("toHex()", () => {
+    it("Uint8Array를 hex 문자열로 변환한다", () => {
+      const bytes = new Uint8Array([0, 1, 15, 16, 255]);
+
+      const result = toHex(bytes);
+
+      expect(result).toBe("00010f10ff");
+    });
+
+    it("빈 배열을 처리한다", () => {
+      const result = toHex(new Uint8Array([]));
+
+      expect(result).toBe("");
+    });
+
+    it("단일 바이트를 처리한다", () => {
+      expect(toHex(new Uint8Array([0]))).toBe("00");
+      expect(toHex(new Uint8Array([255]))).toBe("ff");
+    });
+  });
+
+  describe("fromHex()", () => {
+    it("hex 문자열을 Uint8Array로 변환한다", () => {
+      const result = fromHex("00010f10ff");
+
+      expect(result).toEqual(new Uint8Array([0, 1, 15, 16, 255]));
+    });
+
+    it("빈 문자열을 처리한다", () => {
+      const result = fromHex("");
+
+      expect(result).toEqual(new Uint8Array([]));
+    });
+
+    it("대문자 hex도 처리한다", () => {
+      const result = fromHex("FF0A");
+
+      expect(result).toEqual(new Uint8Array([255, 10]));
+    });
+
+    it("홀수 길이 문자열은 에러를 발생시킨다", () => {
+      expect(() => fromHex("abc")).toThrow(ArgumentError);
+      expect(() => fromHex("a")).toThrow(ArgumentError);
+      expect(() => fromHex("12345")).toThrow(ArgumentError);
+    });
+
+    it("유효하지 않은 hex 문자가 포함되면 에러를 발생시킨다", () => {
+      expect(() => fromHex("zz")).toThrow(ArgumentError);
+      expect(() => fromHex("gh")).toThrow(ArgumentError);
+      expect(() => fromHex("12g4")).toThrow(ArgumentError);
+    });
+  });
+
+  describe("toHex/fromHex 왕복 변환", () => {
+    it("왕복 변환이 일치한다", () => {
+      const original = new Uint8Array([0, 127, 128, 255, 1, 2, 3]);
+
+      const hex = toHex(original);
+      const restored = fromHex(hex);
+
+      expect(restored).toEqual(original);
+    });
+
+    it("모든 바이트 값(0-255)에 대해 왕복 변환이 일치한다", () => {
+      const original = new Uint8Array(256);
+      for (let i = 0; i < 256; i++) {
+        original[i] = i;
+      }
+
+      const hex = toHex(original);
+      const restored = fromHex(hex);
+
+      expect(restored).toEqual(original);
+    });
+  });
+
+  //#endregion
+
+  //#region toBase64/fromBase64
+
+  describe("toBase64()", () => {
+    it("빈 배열을 처리한다", () => {
+      expect(toBase64(new Uint8Array([]))).toBe("");
+    });
+
+    it("일반 데이터를 변환한다", () => {
+      expect(toBase64(new Uint8Array([72, 101, 108, 108, 111]))).toBe("SGVsbG8=");
+    });
+
+    it("대용량 데이터 (1MB)를 스택 오버플로우 없이 처리한다", () => {
+      const data = new Uint8Array(1024 * 1024);
+      expect(() => toBase64(data)).not.toThrow();
+    });
+
+    it("패딩이 필요없는 경우를 처리한다", () => {
+      // 3의 배수 길이 - 패딩 없음
+      expect(toBase64(new Uint8Array([1, 2, 3]))).toBe("AQID");
+    });
+
+    it("단일 패딩이 필요한 경우를 처리한다", () => {
+      // 3으로 나눠 나머지 2 - = 1개
+      expect(toBase64(new Uint8Array([1, 2]))).toBe("AQI=");
+    });
+
+    it("이중 패딩이 필요한 경우를 처리한다", () => {
+      // 3으로 나눠 나머지 1 - == 2개
+      expect(toBase64(new Uint8Array([1]))).toBe("AQ==");
+    });
+  });
+
+  describe("fromBase64()", () => {
+    it("빈 문자열을 처리한다", () => {
+      expect(fromBase64("")).toEqual(new Uint8Array([]));
+    });
+
+    it("일반 데이터를 변환한다", () => {
+      expect(fromBase64("SGVsbG8=")).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
+    });
+
+    it("유효하지 않은 base64 문자가 포함되면 에러를 발생시킨다", () => {
+      expect(() => fromBase64("!!invalid!!")).toThrow(ArgumentError);
+    });
+
+    it("유효하지 않은 base64 길이(나머지 1)면 에러를 발생시킨다", () => {
+      expect(() => fromBase64("A")).toThrow(ArgumentError);
+      expect(() => fromBase64("AAAAA")).toThrow(ArgumentError);
+    });
+
+    it("패딩 없는 base64를 처리한다", () => {
+      expect(fromBase64("AQID")).toEqual(new Uint8Array([1, 2, 3]));
+    });
+
+    it("공백이 포함된 base64를 처리한다", () => {
+      expect(fromBase64("SGVs bG8=")).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
+    });
+  });
+
+  describe("toBase64/fromBase64 왕복 변환", () => {
+    it("왕복 변환이 일치한다", () => {
+      const original = new Uint8Array([0, 127, 128, 255, 1, 2, 3]);
+
+      const base64 = toBase64(original);
+      const restored = fromBase64(base64);
+
+      expect(restored).toEqual(original);
+    });
+
+    it("모든 바이트 값(0-255)에 대해 왕복 변환이 일치한다", () => {
+      const original = new Uint8Array(256);
+      for (let i = 0; i < 256; i++) {
+        original[i] = i;
+      }
+
+      const base64 = toBase64(original);
+      const restored = fromBase64(base64);
+
+      expect(restored).toEqual(original);
+    });
+
+    it("다양한 길이(1~10바이트)에 대해 왕복 변환이 일치한다", () => {
+      for (let len = 1; len <= 10; len++) {
+        const original = new Uint8Array(len);
+        for (let i = 0; i < len; i++) {
+          original[i] = (i * 37 + 13) % 256;
+        }
+
+        const base64 = toBase64(original);
+        const restored = fromBase64(base64);
+
+        expect(restored).toEqual(original);
+      }
+    });
+  });
+
+  //#endregion
+});

package/tests/utils/date-format.spec.ts

@@ -0,0 +1,371 @@
+import { describe, it, expect } from "vitest";
+import { formatDate, normalizeMonth } from "@simplysm/core-common";
+
+describe("formatDateTime", () => {
+  //#region 연도 패턴
+
+  describe("연도 패턴", () => {
+    it("yyyy - 4자리 연도를 출력한다", () => {
+      expect(formatDate("yyyy", { year: 2025 })).toBe("2025");
+    });
+
+    it("yy - 2자리 연도를 출력한다", () => {
+      expect(formatDate("yy", { year: 2025 })).toBe("25");
+      expect(formatDate("yy", { year: 2000 })).toBe("00");
+      expect(formatDate("yy", { year: 1999 })).toBe("99");
+    });
+  });
+
+  //#endregion
+
+  //#region 월 패턴
+
+  describe("월 패턴", () => {
+    it("MM - 2자리 월을 출력한다", () => {
+      expect(formatDate("MM", { month: 1 })).toBe("01");
+      expect(formatDate("MM", { month: 9 })).toBe("09");
+      expect(formatDate("MM", { month: 12 })).toBe("12");
+    });
+
+    it("M - 패딩 없이 월을 출력한다", () => {
+      expect(formatDate("M", { month: 1 })).toBe("1");
+      expect(formatDate("M", { month: 9 })).toBe("9");
+      expect(formatDate("M", { month: 12 })).toBe("12");
+    });
+  });
+
+  //#endregion
+
+  //#region 일 패턴
+
+  describe("일 패턴", () => {
+    it("dd - 2자리 일을 출력한다", () => {
+      expect(formatDate("dd", { day: 1 })).toBe("01");
+      expect(formatDate("dd", { day: 9 })).toBe("09");
+      expect(formatDate("dd", { day: 31 })).toBe("31");
+    });
+
+    it("d - 패딩 없이 일을 출력한다", () => {
+      expect(formatDate("d", { day: 1 })).toBe("1");
+      expect(formatDate("d", { day: 9 })).toBe("9");
+      expect(formatDate("d", { day: 31 })).toBe("31");
+    });
+  });
+
+  //#endregion
+
+  //#region 요일 패턴
+
+  describe("요일 패턴", () => {
+    it("ddd - 요일을 한글로 출력한다", () => {
+      // 2025-01-18은 토요일
+      expect(formatDate("ddd", { year: 2025, month: 1, day: 18 })).toBe("토");
+      // 2025-01-19는 일요일
+      expect(formatDate("ddd", { year: 2025, month: 1, day: 19 })).toBe("일");
+      // 2025-01-20은 월요일
+      expect(formatDate("ddd", { year: 2025, month: 1, day: 20 })).toBe("월");
+    });
+  });
+
+  //#endregion
+
+  //#region 시간 패턴
+
+  describe("시간 패턴", () => {
+    it("hh - 12시간 형식으로 패딩하여 출력한다", () => {
+      expect(formatDate("hh", { hour: 0 })).toBe("12");
+      expect(formatDate("hh", { hour: 1 })).toBe("01");
+      expect(formatDate("hh", { hour: 12 })).toBe("12");
+      expect(formatDate("hh", { hour: 13 })).toBe("01");
+    });
+
+    it("h - 12시간 형식으로 패딩 없이 출력한다", () => {
+      expect(formatDate("h", { hour: 0 })).toBe("12");
+      expect(formatDate("h", { hour: 1 })).toBe("1");
+      expect(formatDate("h", { hour: 9 })).toBe("9");
+      expect(formatDate("h", { hour: 10 })).toBe("10");
+      expect(formatDate("h", { hour: 12 })).toBe("12");
+      expect(formatDate("h", { hour: 13 })).toBe("1");
+      expect(formatDate("h", { hour: 23 })).toBe("11");
+    });
+
+    it("HH - 24시간 형식으로 패딩하여 출력한다", () => {
+      expect(formatDate("HH", { hour: 0 })).toBe("00");
+      expect(formatDate("HH", { hour: 9 })).toBe("09");
+      expect(formatDate("HH", { hour: 23 })).toBe("23");
+    });
+
+    it("H - 24시간 형식으로 패딩 없이 출력한다", () => {
+      expect(formatDate("H", { hour: 0 })).toBe("0");
+      expect(formatDate("H", { hour: 9 })).toBe("9");
+      expect(formatDate("H", { hour: 23 })).toBe("23");
+    });
+
+    it("tt - 오전/오후를 출력한다", () => {
+      expect(formatDate("tt", { hour: 0 })).toBe("오전");
+      expect(formatDate("tt", { hour: 11 })).toBe("오전");
+      expect(formatDate("tt", { hour: 12 })).toBe("오후");
+      expect(formatDate("tt", { hour: 23 })).toBe("오후");
+    });
+  });
+
+  //#endregion
+
+  //#region 분 패턴
+
+  describe("분 패턴", () => {
+    it("mm - 2자리 분을 출력한다", () => {
+      expect(formatDate("mm", { minute: 0 })).toBe("00");
+      expect(formatDate("mm", { minute: 5 })).toBe("05");
+      expect(formatDate("mm", { minute: 59 })).toBe("59");
+    });
+
+    it("m - 패딩 없이 분을 출력한다", () => {
+      expect(formatDate("m", { minute: 0 })).toBe("0");
+      expect(formatDate("m", { minute: 5 })).toBe("5");
+      expect(formatDate("m", { minute: 59 })).toBe("59");
+    });
+  });
+
+  //#endregion
+
+  //#region 초 패턴
+
+  describe("초 패턴", () => {
+    it("ss - 2자리 초를 출력한다", () => {
+      expect(formatDate("ss", { second: 0 })).toBe("00");
+      expect(formatDate("ss", { second: 5 })).toBe("05");
+      expect(formatDate("ss", { second: 59 })).toBe("59");
+    });
+
+    it("s - 패딩 없이 초를 출력한다", () => {
+      expect(formatDate("s", { second: 0 })).toBe("0");
+      expect(formatDate("s", { second: 5 })).toBe("5");
+      expect(formatDate("s", { second: 59 })).toBe("59");
+    });
+  });
+
+  //#endregion
+
+  //#region 밀리초 패턴
+
+  describe("밀리초 패턴", () => {
+    it("fff - 3자리 밀리초를 출력한다", () => {
+      expect(formatDate("fff", { millisecond: 0 })).toBe("000");
+      expect(formatDate("fff", { millisecond: 5 })).toBe("005");
+      expect(formatDate("fff", { millisecond: 50 })).toBe("050");
+      expect(formatDate("fff", { millisecond: 500 })).toBe("500");
+      expect(formatDate("fff", { millisecond: 999 })).toBe("999");
+    });
+
+    it("ff - 2자리 밀리초를 출력한다", () => {
+      expect(formatDate("ff", { millisecond: 0 })).toBe("00");
+      expect(formatDate("ff", { millisecond: 5 })).toBe("00");
+      expect(formatDate("ff", { millisecond: 50 })).toBe("05");
+      expect(formatDate("ff", { millisecond: 500 })).toBe("50");
+      expect(formatDate("ff", { millisecond: 999 })).toBe("99");
+    });
+
+    it("f - 1자리 밀리초를 출력한다", () => {
+      expect(formatDate("f", { millisecond: 0 })).toBe("0");
+      expect(formatDate("f", { millisecond: 5 })).toBe("0");
+      expect(formatDate("f", { millisecond: 100 })).toBe("1");
+      expect(formatDate("f", { millisecond: 500 })).toBe("5");
+      expect(formatDate("f", { millisecond: 999 })).toBe("9");
+    });
+  });
+
+  //#endregion
+
+  //#region 타임존 패턴
+
+  describe("타임존 패턴", () => {
+    describe("양수 오프셋 (동쪽)", () => {
+      it("zzz - +HH:mm 형식으로 출력한다", () => {
+        // UTC+9 (540분)
+        expect(formatDate("zzz", { timezoneOffsetMinutes: 540 })).toBe("+09:00");
+        // UTC+5:30 (330분)
+        expect(formatDate("zzz", { timezoneOffsetMinutes: 330 })).toBe("+05:30");
+      });
+
+      it("zz - +HH 형식으로 출력한다", () => {
+        expect(formatDate("zz", { timezoneOffsetMinutes: 540 })).toBe("+09");
+        expect(formatDate("zz", { timezoneOffsetMinutes: 60 })).toBe("+01");
+      });
+
+      it("z - +H 형식으로 출력한다 (패딩 없음)", () => {
+        expect(formatDate("z", { timezoneOffsetMinutes: 540 })).toBe("+9");
+        expect(formatDate("z", { timezoneOffsetMinutes: 60 })).toBe("+1");
+        expect(formatDate("z", { timezoneOffsetMinutes: 600 })).toBe("+10");
+      });
+    });
+
+    describe("음수 오프셋 (서쪽)", () => {
+      it("zzz - -HH:mm 형식으로 출력한다", () => {
+        // UTC-5 (-300분) - 정수 시간대
+        expect(formatDate("zzz", { timezoneOffsetMinutes: -300 })).toBe("-05:00");
+        // UTC-8 (-480분) - 정수 시간대
+        expect(formatDate("zzz", { timezoneOffsetMinutes: -480 })).toBe("-08:00");
+        // UTC-3:30 (-210분) - Newfoundland Standard Time
+        expect(formatDate("zzz", { timezoneOffsetMinutes: -210 })).toBe("-03:30");
+        // UTC-9:30 (-570분) - Marquesas Islands
+        expect(formatDate("zzz", { timezoneOffsetMinutes: -570 })).toBe("-09:30");
+      });
+
+      it("zz - -HH 형식으로 출력한다", () => {
+        expect(formatDate("zz", { timezoneOffsetMinutes: -300 })).toBe("-05");
+        expect(formatDate("zz", { timezoneOffsetMinutes: -60 })).toBe("-01");
+      });
+
+      it("z - -H 형식으로 출력한다 (패딩 없음)", () => {
+        expect(formatDate("z", { timezoneOffsetMinutes: -300 })).toBe("-5");
+        expect(formatDate("z", { timezoneOffsetMinutes: -60 })).toBe("-1");
+        expect(formatDate("z", { timezoneOffsetMinutes: -720 })).toBe("-12");
+      });
+    });
+
+    describe("UTC (0 오프셋)", () => {
+      it("zzz - +00:00으로 출력한다", () => {
+        expect(formatDate("zzz", { timezoneOffsetMinutes: 0 })).toBe("+00:00");
+      });
+
+      it("zz - +00으로 출력한다", () => {
+        expect(formatDate("zz", { timezoneOffsetMinutes: 0 })).toBe("+00");
+      });
+
+      it("z - +0으로 출력한다", () => {
+        expect(formatDate("z", { timezoneOffsetMinutes: 0 })).toBe("+0");
+      });
+    });
+  });
+
+  //#endregion
+
+  //#region 복합 포맷
+
+  describe("복합 포맷", () => {
+    it("전체 날짜/시간 포맷을 처리한다", () => {
+      const result = formatDate("yyyy-MM-dd HH:mm:ss.fff", {
+        year: 2025,
+        month: 1,
+        day: 18,
+        hour: 14,
+        minute: 30,
+        second: 45,
+        millisecond: 123,
+      });
+      expect(result).toBe("2025-01-18 14:30:45.123");
+    });
+
+    it("12시간 형식 포맷을 처리한다", () => {
+      const result = formatDate("yyyy-MM-dd tt h:mm:ss", {
+        year: 2025,
+        month: 1,
+        day: 18,
+        hour: 14,
+        minute: 5,
+        second: 9,
+      });
+      expect(result).toBe("2025-01-18 오후 2:05:09");
+    });
+
+    it("타임존 포함 포맷을 처리한다", () => {
+      const result = formatDate("yyyy-MM-ddTHH:mm:sszzz", {
+        year: 2025,
+        month: 1,
+        day: 18,
+        hour: 14,
+        minute: 30,
+        second: 0,
+        timezoneOffsetMinutes: 540,
+      });
+      expect(result).toBe("2025-01-18T14:30:00+09:00");
+    });
+  });
+
+  //#endregion
+});
+
+describe("normalizeMonth", () => {
+  //#region 정상 범위
+
+  describe("정상 범위 (1-12)", () => {
+    it("월이 1-12 범위 내면 그대로 반환한다", () => {
+      expect(normalizeMonth(2025, 1, 15)).toEqual({ year: 2025, month: 1, day: 15 });
+      expect(normalizeMonth(2025, 6, 15)).toEqual({ year: 2025, month: 6, day: 15 });
+      expect(normalizeMonth(2025, 12, 15)).toEqual({ year: 2025, month: 12, day: 15 });
+    });
+  });
+
+  //#endregion
+
+  //#region 월 오버플로우
+
+  describe("월 오버플로우 (13 이상)", () => {
+    it("13월은 다음 해 1월이 된다", () => {
+      expect(normalizeMonth(2025, 13, 15)).toEqual({ year: 2026, month: 1, day: 15 });
+    });
+
+    it("14월은 다음 해 2월이 된다", () => {
+      expect(normalizeMonth(2025, 14, 15)).toEqual({ year: 2026, month: 2, day: 15 });
+    });
+
+    it("25월은 2년 후 1월이 된다", () => {
+      expect(normalizeMonth(2025, 25, 15)).toEqual({ year: 2027, month: 1, day: 15 });
+    });
+
+    it("24월은 다음 해 12월이 된다", () => {
+      expect(normalizeMonth(2025, 24, 15)).toEqual({ year: 2026, month: 12, day: 15 });
+    });
+  });
+
+  //#endregion
+
+  //#region 월 언더플로우
+
+  describe("월 언더플로우 (0 이하)", () => {
+    it("0월은 이전 해 12월이 된다", () => {
+      expect(normalizeMonth(2025, 0, 15)).toEqual({ year: 2024, month: 12, day: 15 });
+    });
+
+    it("-1월은 이전 해 11월이 된다", () => {
+      expect(normalizeMonth(2025, -1, 15)).toEqual({ year: 2024, month: 11, day: 15 });
+    });
+
+    it("-11월은 이전 해 1월이 된다", () => {
+      expect(normalizeMonth(2025, -11, 15)).toEqual({ year: 2024, month: 1, day: 15 });
+    });
+
+    it("-12월은 2년 전 12월이 된다", () => {
+      expect(normalizeMonth(2025, -12, 15)).toEqual({ year: 2023, month: 12, day: 15 });
+    });
+
+    it("-13월은 2년 전 11월이 된다", () => {
+      expect(normalizeMonth(2025, -13, 15)).toEqual({ year: 2023, month: 11, day: 15 });
+    });
+  });
+
+  //#endregion
+
+  //#region 일 조정
+
+  describe("일 조정 (대상 월의 마지막 날)", () => {
+    it("31일에서 2월로 변경하면 28일로 조정된다 (평년)", () => {
+      expect(normalizeMonth(2025, 2, 31)).toEqual({ year: 2025, month: 2, day: 28 });
+    });
+
+    it("31일에서 2월로 변경하면 29일로 조정된다 (윤년)", () => {
+      expect(normalizeMonth(2024, 2, 31)).toEqual({ year: 2024, month: 2, day: 29 });
+    });
+
+    it("31일에서 4월로 변경하면 30일로 조정된다", () => {
+      expect(normalizeMonth(2025, 4, 31)).toEqual({ year: 2025, month: 4, day: 30 });
+    });
+
+    it("대상 월의 일수보다 작으면 그대로 유지된다", () => {
+      expect(normalizeMonth(2025, 3, 15)).toEqual({ year: 2025, month: 3, day: 15 });
+    });
+  });
+
+  //#endregion
+});