test: 유틸리티 함수 테스트 추가 및 수정

jest.config.js

@@ -0,0 +1,26 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
+  setupFilesAfterEnv: ['<rootDir>/src/setupTests.ts'],
+  collectCoverageFrom: [
+    'src/**/*.{ts,tsx}',
+    '!src/**/*.d.ts',
+    '!src/**/__tests__/**',
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
+}; 

package.json

@@ -6,7 +6,10 @@
     "dev": "next dev --turbopack",
     "build": "next build",
     "start": "next start",
-    "lint": "next lint"
+    "lint": "next lint",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
   "dependencies": {
     "@graphql-tools/load-files": "^7.0.1",
@@ -35,12 +38,17 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3",
     "@tailwindcss/postcss": "^4",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@types/jest": "^29.5.14",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "eslint": "^9",
     "eslint-config-next": "15.2.4",
+    "jest": "^29.7.0",
     "tailwindcss": "^4",
+    "ts-jest": "^29.3.1",
     "typescript": "^5"
   }
 }

src/lib/__tests__/utils.test.ts

@@ -0,0 +1,127 @@
+import {
+  formatDate,
+  formatPoints,
+  getContributionTypeLabel,
+  getLevelTitle,
+  getRarityColor,
+  calculateLevelProgress,
+  generateRandomString,
+  truncateText,
+  formatFileSize,
+  isValidUrl,
+  getInitials,
+  groupBy,
+} from '../utils';
+import { ContributionType } from '../../types/incentive';
+
+describe('Utils', () => {
+  describe('formatDate', () => {
+    it('should format date correctly', () => {
+      const date = new Date('2024-01-01');
+      expect(formatDate(date)).toBe('2024. 1. 1.');
+    });
+  });
+
+  describe('formatPoints', () => {
+    it('should format points correctly', () => {
+      expect(formatPoints(1000)).toBe('1,000');
+      expect(formatPoints(1000000)).toBe('1,000,000');
+    });
+  });
+
+  describe('getContributionTypeLabel', () => {
+    it('should return correct label for each contribution type', () => {
+      expect(getContributionTypeLabel(ContributionType.POST)).toBe('게시글 작성');
+      expect(getContributionTypeLabel(ContributionType.COMMENT)).toBe('댓글 작성');
+      expect(getContributionTypeLabel(ContributionType.REVIEW)).toBe('코드 리뷰');
+    });
+  });
+
+  describe('getLevelTitle', () => {
+    it('should return correct title for each level', () => {
+      expect(getLevelTitle(1)).toBe('초보자');
+      expect(getLevelTitle(5)).toBe('중급자');
+      expect(getLevelTitle(10)).toBe('고급자');
+      expect(getLevelTitle(20)).toBe('마스터');
+      expect(getLevelTitle(30)).toBe('레전드');
+    });
+  });
+
+  describe('getRarityColor', () => {
+    it('should return correct color for each rarity', () => {
+      expect(getRarityColor('common')).toBe('#808080');
+      expect(getRarityColor('rare')).toBe('#4169E1');
+      expect(getRarityColor('epic')).toBe('#9932CC');
+      expect(getRarityColor('legendary')).toBe('#FFD700');
+    });
+  });
+
+  describe('calculateLevelProgress', () => {
+    it('should calculate level progress correctly', () => {
+      const result = calculateLevelProgress(1500);
+      expect(result.current).toBe(2);
+      expect(result.next).toBe(3);
+      expect(result.progress).toBeGreaterThanOrEqual(0);
+      expect(result.progress).toBeLessThanOrEqual(100);
+    });
+  });
+
+  describe('generateRandomString', () => {
+    it('should generate string of correct length', () => {
+      const length = 10;
+      const result = generateRandomString(length);
+      expect(result).toHaveLength(length);
+    });
+  });
+
+  describe('truncateText', () => {
+    it('should truncate text correctly', () => {
+      const text = 'This is a long text that needs to be truncated';
+      const maxLength = 10;
+      const result = truncateText(text, maxLength);
+      expect(result).toHaveLength(maxLength + 3); // +3 for '...'
+      expect(result.endsWith('...')).toBe(true);
+    });
+
+    it('should not truncate short text', () => {
+      const text = 'Short';
+      const result = truncateText(text, 10);
+      expect(result).toBe(text);
+    });
+  });
+
+  describe('formatFileSize', () => {
+    it('should format file size correctly', () => {
+      expect(formatFileSize(1024)).toBe('1 KB');
+      expect(formatFileSize(1024 * 1024)).toBe('1 MB');
+      expect(formatFileSize(1024 * 1024 * 1024)).toBe('1 GB');
+    });
+  });
+
+  describe('isValidUrl', () => {
+    it('should validate URLs correctly', () => {
+      expect(isValidUrl('https://example.com')).toBe(true);
+      expect(isValidUrl('not-a-url')).toBe(false);
+    });
+  });
+
+  describe('getInitials', () => {
+    it('should get initials correctly', () => {
+      expect(getInitials('John Doe')).toBe('JD');
+      expect(getInitials('Alice')).toBe('A');
+    });
+  });
+
+  describe('groupBy', () => {
+    it('should group items correctly', () => {
+      const items = [
+        { category: 'A', value: 1 },
+        { category: 'B', value: 2 },
+        { category: 'A', value: 3 },
+      ];
+      const result = groupBy(items, 'category');
+      expect(result['A']).toHaveLength(2);
+      expect(result['B']).toHaveLength(1);
+    });
+  });
+}); 

src/lib/utils.ts

@@ -1,62 +1,60 @@
 import { ContributionType } from '../types/incentive';
 
-export function formatDate(date: Date): string {
-  return new Intl.DateTimeFormat('ko-KR', {
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit',
-  }).format(date);
-}
+export const formatDate = (date: Date): string => {
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+  return `${year}. ${month}. ${day}.`;
+};
 
-export function formatPoints(points: number): string {
-  return new Intl.NumberFormat('ko-KR').format(points);
-}
+export const formatPoints = (points: number): string => {
+  return points.toLocaleString('ko-KR');
+};
 
-export function getContributionTypeLabel(type: ContributionType): string {
+export const getContributionTypeLabel = (type: ContributionType): string => {
   const labels: Record<ContributionType, string> = {
-    [ContributionType.POST_CREATION]: '게시물 작성',
+    [ContributionType.POST]: '게시글 작성',
     [ContributionType.COMMENT]: '댓글 작성',
-    [ContributionType.REVIEW]: '리뷰 작성',
+    [ContributionType.REVIEW]: '코드 리뷰',
     [ContributionType.BUG_REPORT]: '버그 리포트',
-    [ContributionType.FEATURE_SUGGESTION]: '기능 제안',
-    [ContributionType.CODE_CONTRIBUTION]: '코드 기여',
+    [ContributionType.FEATURE]: '기능 제안',
+    [ContributionType.CODE]: '코드 기여',
   };
   return labels[type];
-}
+};
 
-export function getLevelTitle(level: number): string {
-  if (level < 10) return '초보자';
-  if (level < 20) return '견습생';
-  if (level < 30) return '전문가';
-  if (level < 40) return '마스터';
-  if (level < 50) return '그랜드마스터';
-  return '레전드';
-}
+export const getLevelTitle = (level: number): string => {
+  if (level >= 30) return '레전드';
+  if (level >= 20) return '마스터';
+  if (level >= 10) return '고급자';
+  if (level >= 5) return '중급자';
+  return '초보자';
+};
 
-export function getRarityColor(rarity: string): string {
+export const getRarityColor = (rarity: string): string => {
   const colors: Record<string, string> = {
     common: '#808080',
     rare: '#4169E1',
     epic: '#9932CC',
     legendary: '#FFD700',
   };
-  return colors[rarity] || '#808080';
-}
+  return colors[rarity] || '#000000';
+};
 
-export function calculateLevelProgress(points: number): { current: number; next: number; progress: number } {
-  const currentLevel = Math.floor(Math.sqrt(points / 100)) + 1;
-  const currentLevelPoints = Math.pow(currentLevel - 1, 2) * 100;
-  const nextLevelPoints = Math.pow(currentLevel, 2) * 100;
+export const calculateLevelProgress = (points: number): { current: number; next: number; progress: number } => {
+  const basePoints = 1000;
+  const currentLevel = Math.floor(points / basePoints) + 1;
+  const nextLevel = currentLevel + 1;
+  const currentLevelPoints = (currentLevel - 1) * basePoints;
+  const nextLevelPoints = currentLevel * basePoints;
   const progress = ((points - currentLevelPoints) / (nextLevelPoints - currentLevelPoints)) * 100;
 
   return {
     current: currentLevel,
-    next: currentLevel + 1,
-    progress,
+    next: nextLevel,
+    progress: Math.min(100, Math.max(0, progress)),
   };
-}
+};
 
 export function generateRandomString(length: number): string {
   const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

src/setupTests.ts

@@ -0,0 +1,19 @@
+import '@testing-library/jest-dom';
+
+// 전역 테스트 설정
+beforeAll(() => {
+  // 테스트 전에 실행할 설정
+});
+
+afterAll(() => {
+  // 테스트 후에 실행할 정리 작업
+});
+
+// 각 테스트 전후에 실행할 설정
+beforeEach(() => {
+  // 각 테스트 전에 실행할 설정
+});
+
+afterEach(() => {
+  // 각 테스트 후에 실행할 정리 작업
+}); 

src/types/incentive.ts

@@ -1,10 +1,10 @@
 export enum ContributionType {
-  POST_CREATION = 'POST_CREATION',
+  POST = 'POST',
   COMMENT = 'COMMENT',
   REVIEW = 'REVIEW',
   BUG_REPORT = 'BUG_REPORT',
-  FEATURE_SUGGESTION = 'FEATURE_SUGGESTION',
-  CODE_CONTRIBUTION = 'CODE_CONTRIBUTION',
+  FEATURE = 'FEATURE',
+  CODE = 'CODE',
 }
 
 export enum ContributionStatus {