테스팅 전략의 전환

// 내부 구현을 알고 있어야 작성 가능 - AI의 자유도를 제한
test('calculateDiscount가 Map에서 쿠폰을 조회한다', () => {
  const couponMap = new Map([['VIP10', 0.1]]);
  const service = new DiscountService(couponMap);
  expect(service.calculateDiscount('VIP10', 10000)).toBe(9000);
});

// AI가 어떤 구현이든 자유롭게 선택할 수 있음
describe('할인 계산', () => {
  test('유효한 쿠폰 코드로 할인이 적용된다', () => {
    const result = applyDiscount({ code: 'VIP10', amount: 10000 });
    expect(result.finalAmount).toBe(9000);
    expect(result.discountApplied).toBe(true);
  });

  test('만료된 쿠폰은 할인이 적용되지 않는다', () => {
    const result = applyDiscount({ code: 'EXPIRED', amount: 10000 });
    expect(result.finalAmount).toBe(10000);
    expect(result.discountApplied).toBe(false);
    expect(result.reason).toBe('쿠폰이 만료되었습니다');
  });

  test('할인 후 금액은 0원 미만이 될 수 없다', () => {
    const result = applyDiscount({ code: 'FULL100', amount: 500 });
    expect(result.finalAmount).toBe(0);
  });

  test('쿠폰 코드가 빈 문자열이면 에러를 반환한다', () => {
    expect(() => applyDiscount({ code: '', amount: 10000 }))
      .toThrow('유효하지 않은 쿠폰 코드');
  });
});

// 사람이 작성: 주문 취소 정책의 비즈니스 규칙
describe('주문 취소 정책', () => {
  test('결제 완료 후 24시간 이내 취소하면 전액 환불', async () => {
    const order = createTestOrder({
      paidAt: hoursAgo(12),
      amount: 50000,
    });
    const result = await cancelOrder(order.id);
    expect(result.refundAmount).toBe(50000);
    expect(result.refundType).toBe('FULL');
  });

  test('결제 완료 후 24시간 초과 시 환불 불가', async () => {
    const order = createTestOrder({
      paidAt: hoursAgo(25),
      amount: 50000,
    });
    const result = await cancelOrder(order.id);
    expect(result.refundAmount).toBe(0);
    expect(result.reason).toBe('24시간 초과');
  });

  test('배송 시작된 주문은 반품 절차 안내', async () => {
    const order = createTestOrder({
      paidAt: hoursAgo(5),
      status: 'SHIPPING',
    });
    const result = await cancelOrder(order.id);
    expect(result.action).toBe('RETURN_PROCESS');
    expect(result.returnGuideUrl).toBeDefined();
  });

  test('이미 취소된 주문은 중복 취소 방지', async () => {
    const order = createTestOrder({ status: 'CANCELLED' });
    await expect(cancelOrder(order.id))
      .rejects.toThrow('이미 취소된 주문');
  });

  test('부분 환불 기간에는 수수료 10%를 제외하고 환불', async () => {
    const order = createTestOrder({
      paidAt: hoursAgo(20),
      amount: 50000,
    });
    // 부분 환불 기간: 12-24시간
    const result = await cancelOrder(order.id, { partial: true });
    expect(result.refundAmount).toBe(45000);
    expect(result.fee).toBe(5000);
  });
});

위 테스트를 모두 통과하는 cancelOrder 함수를 구현해줘.

컨텍스트:
- Prisma ORM 사용, Order 모델에 paidAt, status, amount 필드 있음
- 환불 처리는 refundService.process()로 위임
- 시간 계산은 dayjs 사용, KST 기준

제약:
- 트랜잭션 내에서 상태 변경과 환불 처리를 함께 수행
- 동시에 같은 주문을 취소하는 경우 방지 (낙관적 잠금)

// 3단계에서 추가하는 엣지 케이스
test('주문이 존재하지 않으면 NotFoundError', async () => {
  await expect(cancelOrder('non-existent-id'))
    .rejects.toThrow('주문을 찾을 수 없습니다');
});

test('동시 취소 요청 시 하나만 성공한다', async () => {
  const order = createTestOrder({ paidAt: hoursAgo(1) });
  const results = await Promise.allSettled([
    cancelOrder(order.id),
    cancelOrder(order.id),
  ]);
  const fulfilled = results.filter(r => r.status === 'fulfilled');
  const rejected = results.filter(r => r.status === 'rejected');
  expect(fulfilled).toHaveLength(1);
  expect(rejected).toHaveLength(1);
});

// AI가 구현한 함수
function formatUserName(first: string, last: string): string {
  return `${first} ${last}`;  // 한국어에서는 성+이름 순서가 맞음
}

// 같은 AI가 작성한 테스트 - 같은 가정을 공유
test('이름을 포매팅한다', () => {
  expect(formatUserName('길동', '홍')).toBe('길동 홍');
  // 한국어 이름 순서 오류를 테스트도 함께 놓침
  // 올바른 기대값: '홍길동' 또는 '홍 길동'
});

// 함정: toBeDefined()만으로 검증 - 어떤 값이든 통과
test('사용자를 조회한다', async () => {
  const user = await getUser('user-1');
  expect(user).toBeDefined();          // null만 아니면 통과
  expect(user.name).toBeDefined();     // 이름이 뭐든 통과
  expect(user.email).toBeDefined();    // 이메일 형식 검증 없음
});

// 올바른 검증: 구체적 값과 형식을 확인
test('사용자를 조회한다', async () => {
  const user = await getUser('user-1');
  expect(user.name).toBe('홍길동');
  expect(user.email).toMatch(/^[^@]+@[^@]+\.[^@]+$/);
  expect(user.role).toBe('MEMBER');
  expect(user.createdAt).toBeInstanceOf(Date);
});

// AI가 만들 수 있는 의미 없는 테스트들
test('빈 문자열을 전달하면 빈 문자열을 반환한다', () => ...);
test('문자열 "a"를 전달하면 "a"를 반환한다', () => ...);
test('문자열 "ab"를 전달하면 "ab"를 반환한다', () => ...);
test('문자열 "abc"를 전달하면 "abc"를 반환한다', () => ...);
// 이런 패턴이 20개 이상 반복...

// 통합 테스트: API 엔드포인트
describe('POST /api/orders', () => {
  // 사전 조건 설정
  beforeEach(async () => {
    await seedTestData({
      users: [testUser],
      products: [testProduct],
    });
  });

  // 정상 시나리오
  test('인증된 사용자가 유효한 상품을 주문하면 성공', async () => {
    const res = await request(app)
      .post('/api/orders')
      .set('Authorization', `Bearer ${testToken}`)
      .send({ productId: testProduct.id, quantity: 1 });

    expect(res.status).toBe(201);
    expect(res.body.order.status).toBe('PENDING');

    // DB 상태 검증
    const savedOrder = await db.order.findFirst({
      where: { userId: testUser.id },
    });
    expect(savedOrder).toBeTruthy();
    expect(savedOrder.productId).toBe(testProduct.id);
  });

  // 인증 검증
  test('인증 없이 요청하면 401', async () => {
    const res = await request(app)
      .post('/api/orders')
      .send({ productId: testProduct.id, quantity: 1 });
    expect(res.status).toBe(401);
  });

  // 비즈니스 규칙 검증
  test('재고가 부족하면 409 에러', async () => {
    const res = await request(app)
      .post('/api/orders')
      .set('Authorization', `Bearer ${testToken}`)
      .send({ productId: testProduct.id, quantity: 9999 });
    expect(res.status).toBe(409);
    expect(res.body.error).toContain('재고 부족');
  });

  // 데이터 정합성 검증
  test('주문 생성 시 재고가 차감된다', async () => {
    const before = await db.product.findUnique({
      where: { id: testProduct.id },
    });
    await request(app)
      .post('/api/orders')
      .set('Authorization', `Bearer ${testToken}`)
      .send({ productId: testProduct.id, quantity: 2 });
    const after = await db.product.findUnique({
      where: { id: testProduct.id },
    });
    expect(after.stock).toBe(before.stock - 2);
  });
});

## 기능: 쿠폰 적용

### 정상 시나리오
- 유효한 쿠폰 코드 입력 시 할인 적용
- 퍼센트 할인과 정액 할인 모두 지원
- 할인 후 최소 결제금액 0원

### 실패 시나리오
- 만료된 쿠폰: 에러 메시지와 함께 거부
- 이미 사용된 쿠폰: 중복 사용 방지
- 존재하지 않는 쿠폰: 명확한 에러

### 경계 조건
- 할인이 주문 금액보다 큰 경우: 0원 처리
- 동시에 같은 쿠폰 사용 시도: 하나만 성공
- 쿠폰 만료 시각 경계: KST 자정 기준

### 데이터 조건
- 쿠폰 테이블 스키마: code, type, value, expiresAt, usedAt
- 시간 계산: dayjs, KST 기준

describe('주문 취소 정책', () => {
  test('결제 완료 후 24시간 이내: 전액 환불', () => { /* ... */ });
  test('결제 완료 후 24시간 초과: 환불 불가', () => { /* ... */ });
  test('배송 시작 후: 반품 절차 안내', () => { /* ... */ });
  test('이미 취소된 주문: 중복 취소 방지', () => { /* ... */ });
  test('부분 환불 기간: 수수료 10% 제외', () => { /* ... */ });
});