2장: AI 기반 단위 테스트 자동 생성

def calculate_discount(price: float, membership: str, coupon_code: str | None = None) -> float:
    """회원 등급과 쿠폰에 따른 할인 금액을 계산합니다."""
    if price <= 0:
        raise ValueError("가격은 0보다 커야 합니다")
    
    discount_rate = 0.0
    
    if membership == "gold":
        discount_rate = 0.15
    elif membership == "silver":
        discount_rate = 0.10
    elif membership == "bronze":
        discount_rate = 0.05
    
    if coupon_code == "SPECIAL2026":
        discount_rate += 0.05
    
    return round(price * discount_rate, 2)

public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User findActiveUser(String email) {
        User user = userRepository.findByEmail(email);
        if (user == null) {
            throw new UserNotFoundException("사용자를 찾을 수 없습니다: " + email);
        }
        if (!user.isActive()) {
            throw new InactiveUserException("비활성 사용자입니다: " + email);
        }
        return user;
    }
}

class UserServiceTest {
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private UserService userService;
    
    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }
    
    @Test
    void findActiveUser_WhenUserExistsAndActive_ReturnsUser() {
        User activeUser = new User("test@example.com", true);
        when(userRepository.findByEmail("test@example.com")).thenReturn(activeUser);
        
        User result = userService.findActiveUser("test@example.com");
        
        assertThat(result).isEqualTo(activeUser);
        verify(userRepository).findByEmail("test@example.com");
    }
    
    @Test
    void findActiveUser_WhenUserNotFound_ThrowsException() {
        when(userRepository.findByEmail("unknown@example.com")).thenReturn(null);
        
        assertThrows(UserNotFoundException.class,
            () -> userService.findActiveUser("unknown@example.com"));
    }
    
    @Test
    void findActiveUser_WhenUserInactive_ThrowsException() {
        User inactiveUser = new User("inactive@example.com", false);
        when(userRepository.findByEmail("inactive@example.com")).thenReturn(inactiveUser);
        
        assertThrows(InactiveUserException.class,
            () -> userService.findActiveUser("inactive@example.com"));
    }
}

from dataclasses import dataclass
from typing import Optional
 
 
@dataclass
class CartItem:
    product_id: str
    name: str
    price: float
    quantity: int
 
 
class ShoppingCart:
    def __init__(self, max_items: int = 50):
        self._items: list[CartItem] = []
        self._max_items = max_items
 
    def add_item(self, item: CartItem) -> None:
        if item.quantity <= 0:
            raise ValueError("수량은 1 이상이어야 합니다")
        if item.price < 0:
            raise ValueError("가격은 0 이상이어야 합니다")
 
        total_quantity = sum(i.quantity for i in self._items) + item.quantity
        if total_quantity > self._max_items:
            raise OverflowError(f"장바구니 최대 수량({self._max_items})을 초과합니다")
 
        existing = self._find_item(item.product_id)
        if existing:
            existing.quantity += item.quantity
        else:
            self._items.append(item)
 
    def remove_item(self, product_id: str) -> None:
        item = self._find_item(product_id)
        if item is None:
            raise KeyError(f"상품을 찾을 수 없습니다: {product_id}")
        self._items.remove(item)
 
    def get_total(self, discount_rate: float = 0.0) -> float:
        if not 0.0 <= discount_rate <= 1.0:
            raise ValueError("할인율은 0.0에서 1.0 사이여야 합니다")
        subtotal = sum(item.price * item.quantity for item in self._items)
        return round(subtotal * (1 - discount_rate), 2)
 
    def _find_item(self, product_id: str) -> Optional[CartItem]:
        return next((i for i in self._items if i.product_id == product_id), None)
 
    @property
    def item_count(self) -> int:
        return len(self._items)
 
    @property
    def total_quantity(self) -> int:
        return sum(i.quantity for i in self._items)

import pytest
from shopping_cart import ShoppingCart, CartItem
 
 
class TestShoppingCartAddItem:
    """add_item 메서드 테스트"""
 
    def test_add_single_item(self):
        cart = ShoppingCart()
        item = CartItem("P001", "노트북", 1500000.0, 1)
        cart.add_item(item)
        assert cart.item_count == 1
        assert cart.total_quantity == 1
 
    def test_add_multiple_different_items(self):
        cart = ShoppingCart()
        cart.add_item(CartItem("P001", "노트북", 1500000.0, 1))
        cart.add_item(CartItem("P002", "마우스", 50000.0, 2))
        assert cart.item_count == 2
        assert cart.total_quantity == 3
 
    def test_add_duplicate_item_increases_quantity(self):
        cart = ShoppingCart()
        cart.add_item(CartItem("P001", "노트북", 1500000.0, 1))
        cart.add_item(CartItem("P001", "노트북", 1500000.0, 2))
        assert cart.item_count == 1
        assert cart.total_quantity == 3
 
    def test_add_item_with_zero_quantity_raises_error(self):
        cart = ShoppingCart()
        with pytest.raises(ValueError, match="수량은 1 이상"):
            cart.add_item(CartItem("P001", "노트북", 1500000.0, 0))
 
    def test_add_item_with_negative_quantity_raises_error(self):
        cart = ShoppingCart()
        with pytest.raises(ValueError, match="수량은 1 이상"):
            cart.add_item(CartItem("P001", "노트북", 1500000.0, -1))
 
    def test_add_item_with_negative_price_raises_error(self):
        cart = ShoppingCart()
        with pytest.raises(ValueError, match="가격은 0 이상"):
            cart.add_item(CartItem("P001", "노트북", -100.0, 1))
 
    def test_add_item_exceeding_max_items_raises_error(self):
        cart = ShoppingCart(max_items=3)
        cart.add_item(CartItem("P001", "A", 100.0, 2))
        with pytest.raises(OverflowError, match="최대 수량"):
            cart.add_item(CartItem("P002", "B", 200.0, 2))
 
    def test_add_item_at_exact_max_limit(self):
        cart = ShoppingCart(max_items=3)
        cart.add_item(CartItem("P001", "A", 100.0, 3))
        assert cart.total_quantity == 3
 
 
class TestShoppingCartRemoveItem:
    """remove_item 메서드 테스트"""
 
    def test_remove_existing_item(self):
        cart = ShoppingCart()
        cart.add_item(CartItem("P001", "노트북", 1500000.0, 1))
        cart.remove_item("P001")
        assert cart.item_count == 0
 
    def test_remove_nonexistent_item_raises_error(self):
        cart = ShoppingCart()
        with pytest.raises(KeyError, match="상품을 찾을 수 없습니다"):
            cart.remove_item("INVALID")
 
 
class TestShoppingCartGetTotal:
    """get_total 메서드 테스트"""
 
    def test_total_without_discount(self):
        cart = ShoppingCart()
        cart.add_item(CartItem("P001", "노트북", 1500000.0, 1))
        cart.add_item(CartItem("P002", "마우스", 50000.0, 2))
        assert cart.get_total() == 1600000.0
 
    def test_total_with_discount(self):
        cart = ShoppingCart()
        cart.add_item(CartItem("P001", "노트북", 1000000.0, 1))
        assert cart.get_total(discount_rate=0.1) == 900000.0
 
    def test_total_empty_cart(self):
        cart = ShoppingCart()
        assert cart.get_total() == 0.0
 
    def test_total_with_invalid_discount_raises_error(self):
        cart = ShoppingCart()
        with pytest.raises(ValueError, match="할인율은"):
            cart.get_total(discount_rate=1.5)
 
    def test_total_with_negative_discount_raises_error(self):
        cart = ShoppingCart()
        with pytest.raises(ValueError, match="할인율은"):
            cart.get_total(discount_rate=-0.1)

export function formatCurrency(amount: number, locale: string = "ko-KR"): string {
  if (!Number.isFinite(amount)) {
    throw new TypeError("유효한 숫자가 아닙니다");
  }
 
  const formatter = new Intl.NumberFormat(locale, {
    style: "currency",
    currency: locale === "ko-KR" ? "KRW" : "USD",
    minimumFractionDigits: locale === "ko-KR" ? 0 : 2,
  });
 
  return formatter.format(amount);
}
 
export function truncateText(text: string, maxLength: number, suffix: string = "..."): string {
  if (maxLength < 0) {
    throw new RangeError("maxLength는 0 이상이어야 합니다");
  }
  if (text.length <= maxLength) {
    return text;
  }
  return text.slice(0, maxLength - suffix.length) + suffix;
}

import { formatCurrency, truncateText } from "./format-utils";
 
describe("formatCurrency", () => {
  it("한국 원화 형식으로 포맷합니다", () => {
    expect(formatCurrency(15000)).toBe("\\15,000");
  });
 
  it("0원을 올바르게 포맷합니다", () => {
    expect(formatCurrency(0)).toBe("\\0");
  });
 
  it("음수 금액을 올바르게 포맷합니다", () => {
    expect(formatCurrency(-5000)).toBe("-\\5,000");
  });
 
  it("US 달러 형식으로 포맷합니다", () => {
    const result = formatCurrency(99.99, "en-US");
    expect(result).toBe("$99.99");
  });
 
  it("NaN 입력 시 TypeError를 던집니다", () => {
    expect(() => formatCurrency(NaN)).toThrow(TypeError);
  });
 
  it("Infinity 입력 시 TypeError를 던집니다", () => {
    expect(() => formatCurrency(Infinity)).toThrow(TypeError);
  });
});
 
describe("truncateText", () => {
  it("maxLength 이하 텍스트는 그대로 반환합니다", () => {
    expect(truncateText("안녕하세요", 10)).toBe("안녕하세요");
  });
 
  it("긴 텍스트를 잘라내고 접미사를 추가합니다", () => {
    expect(truncateText("이것은 매우 긴 텍스트입니다", 10)).toBe("이것은 매우...");
  });
 
  it("커스텀 접미사를 사용합니다", () => {
    expect(truncateText("긴 텍스트 예시", 7, " --")).toBe("긴 텍스 --");
  });
 
  it("음수 maxLength 시 RangeError를 던집니다", () => {
    expect(() => truncateText("테스트", -1)).toThrow(RangeError);
  });
 
  it("maxLength가 0이면 접미사만 반환합니다", () => {
    expect(truncateText("테스트", 3)).toBe("...");
  });
});

pytest --cov=src --cov-report=html --cov-report=term-missing

npx jest --coverage --coverageReporters=text --coverageReporters=html