# pytest 설치
pip install pytest

import pytest
from pathlib import Path
import json

# 기본 fixture
@pytest.fixture
def sample_config():
    """테스트용 설정 딕셔너리를 제공합니다."""
    return {
        "model": "bert-base",
        "learning_rate": 0.001,
        "epochs": 10,
        "batch_size": 32,
    }

def test_config_has_model(sample_config):
    assert "model" in sample_config
    assert sample_config["learning_rate"] > 0

# 리소스 관리 fixture (setup + teardown)
@pytest.fixture
def temp_config_file(tmp_path):
    """임시 설정 파일을 생성하고 테스트 후 자동 정리합니다."""
    config = {"model": "gpt2", "epochs": 5}
    filepath = tmp_path / "config.json"
    filepath.write_text(json.dumps(config), encoding="utf-8")
    yield filepath  # yield 이전 = setup, 이후 = teardown
    # tmp_path는 pytest가 자동 정리

def test_load_config(temp_config_file):
    with open(temp_config_file, "r") as f:
        config = json.load(f)
    assert config["model"] == "gpt2"

# 스코프 지정 fixture
@pytest.fixture(scope="session")
def heavy_resource():
    """세션 전체에서 한 번만 생성되는 무거운 리소스"""
    print("리소스 생성 (비용이 큰 작업)")
    resource = {"data": list(range(10000))}
    yield resource
    print("리소스 정리")

import pytest

# 여러 입력값에 대해 같은 테스트 실행
@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (100, 200, 300),
    (0.1, 0.2, 0.3),
])
def test_add_parametrize(a, b, expected):
    result = add(a, b)
    assert result == pytest.approx(expected)

# 예외 케이스 포함
@pytest.mark.parametrize("a, b, expected_error", [
    (10, 0, ValueError),
    ("a", 1, TypeError),
])
def test_divide_errors(a, b, expected_error):
    with pytest.raises(expected_error):
        divide(a, b)

# 활성화 함수 테스트
@pytest.mark.parametrize("input_val, expected", [
    (0.0, 0.5),
    (100.0, 1.0),   # 매우 큰 값
    (-100.0, 0.0),  # 매우 작은 값
])
def test_sigmoid(input_val, expected):
    import math
    result = 1 / (1 + math.exp(-input_val))
    assert result == pytest.approx(expected, abs=1e-4)

import pytest

# 테스트 마킹
@pytest.mark.slow
def test_full_training():
    """전체 학습 테스트 (느림)"""
    pass

@pytest.mark.gpu
def test_gpu_computation():
    """GPU가 필요한 테스트"""
    pass

@pytest.mark.skip(reason="API 키가 없어서 건너뜀")
def test_external_api():
    pass

@pytest.mark.skipif(
    not has_gpu(),
    reason="GPU 없음",
)
def test_cuda_operation():
    pass

# 특정 마크만 실행
pytest -m slow
pytest -m "not slow"

# 키워드로 필터링
pytest -k "test_add"
pytest -k "test_add or test_divide"

# 상세 출력
pytest -v

# 첫 번째 실패에서 중단
pytest -x

# 마지막 실패한 테스트만 재실행
pytest --lf

# tests/conftest.py
# 이 파일의 fixture는 같은 디렉토리와 하위 디렉토리에서 자동으로 사용 가능

import pytest
import numpy as np

@pytest.fixture
def random_seed():
    """재현 가능한 테스트를 위한 랜덤 시드"""
    np.random.seed(42)
    yield 42

@pytest.fixture
def sample_dataset():
    """테스트용 작은 데이터셋"""
    np.random.seed(42)
    X = np.random.randn(100, 10)
    y = (X[:, 0] > 0).astype(int)
    return X, y

@pytest.fixture
def model_config():
    """공통 모델 설정"""
    return {
        "input_dim": 10,
        "hidden_dim": 64,
        "output_dim": 2,
        "dropout": 0.1,
    }

import pytest
import numpy as np

# 1. 데이터 전처리 테스트
def normalize(data: np.ndarray) -> np.ndarray:
    """Min-Max 정규화"""
    min_val = data.min()
    max_val = data.max()
    if min_val == max_val:
        return np.zeros_like(data)
    return (data - min_val) / (max_val - min_val)

def test_normalize_basic():
    data = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
    result = normalize(data)
    assert result.min() == pytest.approx(0.0)
    assert result.max() == pytest.approx(1.0)
    assert len(result) == len(data)

def test_normalize_constant():
    """모든 값이 동일한 경우"""
    data = np.array([5.0, 5.0, 5.0])
    result = normalize(data)
    assert np.all(result == 0.0)

def test_normalize_negative():
    """음수 값 포함"""
    data = np.array([-10.0, 0.0, 10.0])
    result = normalize(data)
    assert result[0] == pytest.approx(0.0)
    assert result[1] == pytest.approx(0.5)
    assert result[2] == pytest.approx(1.0)

# 2. 모델 차원 테스트
def test_model_output_shape(model_config):
    """모델 출력 차원이 올바른지 확인합니다."""
    batch_size = 16
    input_dim = model_config["input_dim"]
    output_dim = model_config["output_dim"]

    # 시뮬레이션 (실제로는 모델 forward)
    X = np.random.randn(batch_size, input_dim)
    output = np.random.randn(batch_size, output_dim)  # 모델 출력 시뮬레이션

    assert output.shape == (batch_size, output_dim)

# 3. 손실 함수 테스트
def mse_loss(predictions: np.ndarray, targets: np.ndarray) -> float:
    """평균 제곱 오차"""
    return float(np.mean((predictions - targets) ** 2))

@pytest.mark.parametrize("pred, target, expected_loss", [
    (np.array([1.0, 2.0, 3.0]), np.array([1.0, 2.0, 3.0]), 0.0),  # 완벽 예측
    (np.array([0.0, 0.0, 0.0]), np.array([1.0, 1.0, 1.0]), 1.0),  # 전부 틀림
])
def test_mse_loss(pred, target, expected_loss):
    loss = mse_loss(pred, target)
    assert loss == pytest.approx(expected_loss)

def test_mse_loss_is_non_negative():
    """MSE 손실은 항상 0 이상이어야 합니다."""
    for _ in range(100):
        pred = np.random.randn(50)
        target = np.random.randn(50)
        assert mse_loss(pred, target) >= 0

# 4. 데이터 분할 테스트
def split_data(data, ratio=0.8):
    """학습/검증 데이터 분할"""
    split_idx = int(len(data) * ratio)
    return data[:split_idx], data[split_idx:]

def test_split_preserves_total():
    """분할 후 데이터 수가 보존되는지 확인"""
    data = list(range(100))
    train, val = split_data(data, ratio=0.8)
    assert len(train) + len(val) == len(data)

def test_split_no_overlap():
    """학습/검증 데이터가 겹치지 않는지 확인"""
    data = list(range(100))
    train, val = split_data(data, ratio=0.8)
    assert set(train).isdisjoint(set(val))

def test_split_ratio():
    """분할 비율이 근사적으로 맞는지 확인"""
    data = list(range(1000))
    train, val = split_data(data, ratio=0.8)
    assert len(train) == pytest.approx(800, abs=5)

# pyproject.toml
[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py"]
python_functions = ["test_*"]
markers = [
    "slow: 느린 테스트 (전체 학습 등)",
    "gpu: GPU가 필요한 테스트",
    "integration: 외부 서비스 통합 테스트",
]
addopts = "-v --tb=short"