Test: Challenge 리펙토링 및 테스트 작성 (#191)

__mocks__/prisma-factory.ts

@@ -2,6 +2,9 @@ type MockFn<T> = {
   [P in keyof T]: jest.Mock;
 };
 
+/**
+ * 기본 Prisma Mock 생성
+ */
 export const createPrismaMock = (overrides = {}) => {
   const baseMock = {
     user: {
@@ -16,6 +19,9 @@ export const createPrismaMock = (overrides = {}) => {
   };
 };
 
+/**
+ * ETF 테스트용 Prisma Mock 생성
+ */
 export const createEtfTestPrismaMock = (overrides = {}) => {
   const baseMock = {
     user: {
@@ -52,3 +58,91 @@ export const createEtfTestPrismaMock = (overrides = {}) => {
     ...overrides,
   };
 };
+
+/**
+ * 챌린지 테스트용 Prisma Mock 생성
+ */
+export const createChallengePrismaMock = (overrides = {}) => {
+  const baseMock = {
+    user: {
+      findUnique: jest.fn(),
+      findFirst: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn(),
+    },
+    challenge: {
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn(),
+    },
+    userChallengeClaim: {
+      findFirst: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn(),
+      deleteMany: jest.fn(),
+    },
+    userChallengeProgress: {
+      findFirst: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      updateMany: jest.fn(),
+      delete: jest.fn(),
+      deleteMany: jest.fn(),
+      upsert: jest.fn(),
+    },
+    etf: {
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+    },
+    etfDailyTrading: {
+      findFirst: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+    },
+    eTFTransaction: {
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn(),
+    },
+    eTFHolding: {
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      upsert: jest.fn(),
+      delete: jest.fn(),
+    },
+    isaAccount: {
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+    },
+    $transaction: jest.fn(),
+  };
+
+  return {
+    ...baseMock,
+    ...overrides,
+  };
+};
+
+// 타입 정의
+export type BasePrismaMock = ReturnType<typeof createPrismaMock>;
+export type EtfTestPrismaMock = ReturnType<typeof createEtfTestPrismaMock>;
+export type ChallengePrismaMock = ReturnType<typeof createChallengePrismaMock>;
+export type PrismaMockInstance =
+  | BasePrismaMock
+  | EtfTestPrismaMock
+  | ChallengePrismaMock;

__mocks__/prisma.ts

@@ -1,4 +1,8 @@
-import { createEtfTestPrismaMock, createPrismaMock } from './prisma-factory';
+import {
+  createChallengePrismaMock,
+  createEtfTestPrismaMock,
+  createPrismaMock,
+} from './prisma-factory';
 
 // Jest에서 사용할 수 있도록 전역 mock 인스턴스 생성
 let mockPrismaInstance = createPrismaMock();
@@ -17,6 +21,11 @@ export const resetWithEtfTestPrismaMock = () => {
   return mockPrismaInstance;
 };
 
+export const resetWithChallengePrismaMock = () => {
+  mockPrismaInstance = createChallengePrismaMock();
+  return mockPrismaInstance;
+};
+
 // 커스텀 overrides로 재설정
 export const resetWithCustomMock = (overrides = {}) => {
   mockPrismaInstance = createPrismaMock(overrides);

__tests__/api/challenge-claim-api.test.ts

@@ -0,0 +1,188 @@
+/**
+ * @jest-environment node
+ */
+import { getServerSession } from 'next-auth';
+import { resetWithChallengePrismaMock } from '@/__mocks__/prisma';
+import { POST } from '@/app/api/challenge/claim/route';
+import { claimChallengeReward } from '@/services/challenge/challenge-claim';
+import { canClaimChallenge } from '@/services/challenge/challenge-status';
+
+// Mock dependencies
+jest.mock('next-auth');
+jest.mock('@/services/challenge/challenge-status');
+jest.mock('@/services/challenge/challenge-claim');
+jest.mock('@/lib/prisma', () => {
+  const { getPrismaMock } = require('@/__mocks__/prisma');
+  return {
+    get prisma() {
+      return getPrismaMock();
+    },
+  };
+});
+
+const mockGetServerSession = getServerSession as jest.MockedFunction<
+  typeof getServerSession
+>;
+const mockCanClaimChallenge = canClaimChallenge as jest.MockedFunction<
+  typeof canClaimChallenge
+>;
+const mockClaimChallengeReward = claimChallengeReward as jest.MockedFunction<
+  typeof claimChallengeReward
+>;
+
+describe('/api/challenge/claim', () => {
+  let mockPrisma: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockPrisma = resetWithChallengePrismaMock();
+  });
+
+  describe('POST', () => {
+    it('should return 401 when not authenticated', async () => {
+      mockGetServerSession.mockResolvedValue(null);
+
+      const request = new Request('http://localhost/api/challenge/claim', {
+        method: 'POST',
+        body: JSON.stringify({ challengeId: '1' }),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(401);
+      expect(data.message).toBe('Unauthorized');
+    });
+
+    it('should return 400 when challengeId is missing', async () => {
+      mockGetServerSession.mockResolvedValue({
+        user: { id: '1' },
+      });
+
+      const request = new Request('http://localhost/api/challenge/claim', {
+        method: 'POST',
+        body: JSON.stringify({}),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(400);
+      expect(data.message).toBe('Challenge ID is required');
+    });
+
+    it('should successfully claim challenge reward', async () => {
+      mockGetServerSession.mockResolvedValue({
+        user: { id: '1' },
+      });
+
+      mockPrisma.$transaction.mockImplementation(async (callback: any) => {
+        const mockTx = mockPrisma;
+        return await callback(mockTx);
+      });
+
+      mockCanClaimChallenge.mockResolvedValue({ canClaim: true });
+      mockClaimChallengeReward.mockResolvedValue({
+        success: true,
+        message: 'Reward claimed successfully',
+        transactionId: BigInt(123),
+      });
+
+      const request = new Request('http://localhost/api/challenge/claim', {
+        method: 'POST',
+        body: JSON.stringify({ challengeId: '1' }),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.message).toBe('Reward claimed successfully');
+      expect(data.transactionId).toBe('123');
+
+      expect(mockCanClaimChallenge).toHaveBeenCalledWith(
+        BigInt(1),
+        BigInt(1),
+        mockPrisma
+      );
+      expect(mockClaimChallengeReward).toHaveBeenCalledWith(
+        { challengeId: BigInt(1), userId: BigInt(1) },
+        mockPrisma
+      );
+    });
+
+    it('should return 500 when cannot claim challenge', async () => {
+      mockGetServerSession.mockResolvedValue({
+        user: { id: '1' },
+      });
+
+      mockPrisma.$transaction.mockImplementation(async (callback: any) => {
+        const mockTx = mockPrisma;
+        return await callback(mockTx);
+      });
+
+      mockCanClaimChallenge.mockResolvedValue({
+        canClaim: false,
+        reason: 'Already claimed',
+      });
+
+      const request = new Request('http://localhost/api/challenge/claim', {
+        method: 'POST',
+        body: JSON.stringify({ challengeId: '1' }),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(500);
+      expect(data.message).toBe('Already claimed');
+    });
+
+    it('should return 400 when claim service returns failure', async () => {
+      mockGetServerSession.mockResolvedValue({
+        user: { id: '1' },
+      });
+
+      mockPrisma.$transaction.mockImplementation(async (callback: any) => {
+        const mockTx = mockPrisma;
+        return await callback(mockTx);
+      });
+
+      mockCanClaimChallenge.mockResolvedValue({ canClaim: true });
+      mockClaimChallengeReward.mockResolvedValue({
+        success: false,
+        message: 'ISA account not found',
+      });
+
+      const request = new Request('http://localhost/api/challenge/claim', {
+        method: 'POST',
+        body: JSON.stringify({ challengeId: '1' }),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(400);
+      expect(data.message).toBe('ISA account not found');
+    });
+
+    it('should handle unexpected errors', async () => {
+      mockGetServerSession.mockResolvedValue({
+        user: { id: '1' },
+      });
+
+      mockPrisma.$transaction.mockRejectedValue(new Error('Database error'));
+
+      const request = new Request('http://localhost/api/challenge/claim', {
+        method: 'POST',
+        body: JSON.stringify({ challengeId: '1' }),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(500);
+      expect(data.message).toBe('Database error');
+    });
+  });
+});