import unittest

class Calculator:
    def add(self, x, y):
        return x + y
    
    def subtract(self, x, y):
        return x - y
    
    def multiply(self, x, y):
        return x * y
    
    def divide(self, x, y):
        if y == 0:
            raise ValueError("0으로 나눌 수 없다")
        return x / y

class TestCalculator(unittest.TestCase):
    def setUp(self):
        """각 테스트 메서드 실행 전에 호출된다"""
        self.calc = Calculator()
    
    def test_add(self):
        """덧셈 기능 테스트"""
        result = self.calc.add(3, 5)
        self.assertEqual(result, 8)
        
        # 경계값 테스트
        self.assertEqual(self.calc.add(0, 0), 0)
        self.assertEqual(self.calc.add(-1, 1), 0)
    
    def test_subtract(self):
        """뺄셈 기능 테스트"""
        result = self.calc.subtract(10, 5)
        self.assertEqual(result, 5)
        
        # 음수 결과 테스트
        self.assertEqual(self.calc.subtract(5, 10), -5)
    
    def test_multiply(self):
        """곱셈 기능 테스트"""
        self.assertEqual(self.calc.multiply(3, 4), 12)
        self.assertEqual(self.calc.multiply(0, 5), 0)
        self.assertEqual(self.calc.multiply(-2, 3), -6)
    
    def test_divide(self):
        """나눗셈 기능 테스트"""
        self.assertEqual(self.calc.divide(10, 2), 5)
        self.assertEqual(self.calc.divide(5, 2), 2.5)
        
        # 0으로 나누기 예외 테스트
        with self.assertRaises(ValueError):
            self.calc.divide(10, 0)
    
    def tearDown(self):
        """각 테스트 메서드 실행 후에 호출된다"""
        pass

if __name__ == '__main__':
    # 테스트 실행
    unittest.main()

import pytest

# 테스트할 함수
def is_palindrome(s):
    """문자열이 앞뒤로 동일하게 읽히는지 확인한다"""
    s = s.lower().replace(" ", "")
    return s == s[::-1]

def capitalize_words(text):
    """문자열의 각 단어 첫 글자를 대문자로 변환한다"""
    return ' '.join(word.capitalize() for word in text.split())

# 기본 테스트 함수
def test_string():
    assert 'hello' == 'hello'

def test_list_comparison():
    assert [1, 2, 3] == [1, 2, 3]

# 팰린드롬 테스트
def test_palindrome():
    assert is_palindrome("radar") == True
    assert is_palindrome("A man a plan a canal Panama") == True
    assert is_palindrome("hello") == False

# 에러 발생 테스트
def test_zero_division():
    with pytest.raises(ZeroDivisionError):
        1 / 0

# 픽스처 사용 예제
class TestExample:
    @pytest.fixture
    def sample_data(self):
        """테스트에 사용할 샘플 데이터를 제공한다"""
        return {'name': 'Test', 'value': 42, 'items': [1, 2, 3]}
    
    def test_data(self, sample_data):
        assert sample_data['name'] == 'Test'
        assert sample_data['value'] == 42

    def test_item_count(self, sample_data):
        assert len(sample_data['items']) == 3

# 매개변수화된 테스트
@pytest.mark.parametrize('input,expected', [
    (2, 4),
    (3, 6),
    (4, 8),
    (0, 0),
    (-1, -2)
])
def test_multiply_by_two(input, expected):
    assert input * 2 == expected

# 매개변수화된 테스트 - 팰린드롬
@pytest.mark.parametrize('string,is_valid', [
    ("racecar", True),
    ("level", True),
    ("hello", False),
    ("A Santa at NASA", True),
    ("", True)
])
def test_palindrome_parameterized(string, is_valid):
    assert is_palindrome(string) == is_valid

# 매개변수화된 테스트 - 대문자 변환
@pytest.mark.parametrize('input_str,expected', [
    ("hello world", "Hello World"),
    ("python testing", "Python Testing"),
    ("", "")
])
def test_capitalize_words(input_str, expected):
    assert capitalize_words(input_str) == expected

from unittest.mock import Mock, patch, MagicMock, call

# 테스트할 클래스
class UserService:
    def __init__(self, db):
        self.db = db
    
    def get_user(self, user_id):
        return self.db.find_user(user_id)

    def create_user(self, user_data):
        if not user_data.get('name'):
            raise ValueError("사용자 이름은 필수이다")
        return self.db.insert_user(user_data)
    
    def update_user_email(self, user_id, new_email):
        user = self.db.find_user(user_id)
        if not user:
            return False
        user['email'] = new_email
        return self.db.update_user(user_id, user)

# Mock 객체 기본 사용
def test_get_user():
    # Mock 객체 생성
    mock_db = Mock()
    # 반환값 설정
    mock_db.find_user.return_value = {
        'id': 1,
        'name': 'Test User',
        'email': '[email protected]'
    }
    
    service = UserService(mock_db)
    user = service.get_user(1)
    
    # 결과 검증
    assert user['name'] == 'Test User'
    assert user['email'] == '[email protected]'
    
    # Mock 호출 검증
    mock_db.find_user.assert_called_once_with(1)

# 예외 상황 테스트
def test_create_user_with_invalid_data():
    mock_db = Mock()
    service = UserService(mock_db)
    
    # 예외 발생 확인
    try:
        service.create_user({})
        assert False, "예외가 발생해야 한다"
    except ValueError as e:
        assert str(e) == "사용자 이름은 필수이다"
    
    # DB 메서드가 호출되지 않았는지 확인
    mock_db.insert_user.assert_not_called()

# 여러 호출에 대한 다른 반환값 설정
def test_update_user_email():
    mock_db = Mock()
    # 첫 번째 호출은 사용자 데이터 반환, 두 번째 호출은 업데이트 성공 반환
    mock_db.find_user.return_value = {'id': 1, 'name': 'Old Name', 'email': '[email protected]'}
    mock_db.update_user.return_value = True
    
    service = UserService(mock_db)
    result = service.update_user_email(1, '[email protected]')
    
    assert result == True
    # 업데이트 호출 시 전달된 이메일 확인
    mock_db.update_user.assert_called_once()
    args, kwargs = mock_db.update_user.call_args
    assert args[1]['email'] == '[email protected]'

# 모듈 또는 함수 패치하기
import requests

def get_user_data(user_id):
    """외부 API에서 사용자 정보를 가져온다"""
    response = requests.get(f'https://api.example.com/users/{user_id}')
    if response.status_code == 200:
        return response.json()
    return None

@patch('requests.get')
def test_api_call(mock_get):
    # Mock 응답 설정
    mock_response = Mock()
    mock_response.status_code = 200
    mock_response.json.return_value = {'id': 123, 'name': 'API User'}
    mock_get.return_value = mock_response
    
    # 함수 호출
    result = get_user_data(123)
    
    # 결과 검증
    assert result['name'] == 'API User'
    mock_get.assert_called_once_with('https://api.example.com/users/123')

# 클래스 메서드 패치하기
class ExternalService:
    @classmethod
    def get_data(cls):
        # 실제로는 외부 서비스에 접근
        return "실제 데이터"

def process_data():
    data = ExternalService.get_data()
    return f"처리된 데이터: {data}"

@patch.object(ExternalService, 'get_data')
def test_process_data(mock_get_data):
    mock_get_data.return_value = "테스트 데이터"
    result = process_data()
    assert result == "처리된 데이터: 테스트 데이터"
    mock_get_data.assert_called_once()

# 여러 호출에 대한 연속적인 반환값 설정
def test_multiple_calls():
    mock = Mock()
    mock.side_effect = [1, 2, 3, Exception("에러 발생")]
    
    assert mock() == 1
    assert mock() == 2
    assert mock() == 3
    
    try:
        mock()
        assert False, "예외가 발생해야 한다"
    except Exception as e:
        assert str(e) == "에러 발생"

# 복잡한 호출 패턴 검증
def test_complex_call_pattern():
    mock = Mock()
    
    mock(1)
    mock(2)
    mock(3, key='value')
    
    # 호출 순서와 매개변수 검증
    expected_calls = [call(1), call(2), call(3, key='value')]
    mock.assert_has_calls(expected_calls, any_order=False)

import unittest
import tempfile
import os
import logging

# 로깅 설정
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

class FileProcessor:
    def __init__(self, filename):
        self.filename = filename
    
    def write_data(self, data):
        with open(self.filename, 'w') as f:
            f.write(data)
        return len(data)
    
    def read_data(self):
        try:
            with open(self.filename, 'r') as f:
                return f.read()
        except FileNotFoundError:
            return None

class TestWithSetup(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        """전체 테스트 시작 전 1회 실행된다"""
        logger.info("테스트 클래스 시작")
        # 임시 디렉토리 생성
        cls.test_dir = tempfile.mkdtemp()
    
    def setUp(self):
        """각 테스트 메서드 시작 전 실행된다"""
        logger.info(f"테스트 시작: {self._testMethodName}")
        self.test_data = [1, 2, 3]
        
        # 테스트 파일 경로 생성
        self.test_file = os.path.join(self.__class__.test_dir, "test_file.txt")
        self.processor = FileProcessor(self.test_file)
    
    def test_list_operations(self):
        """리스트 연산 테스트"""
        self.test_data.append(4)
        self.assertEqual(len(self.test_data), 4)
        self.assertIn(4, self.test_data)
    
    def test_file_operations(self):
        """파일 작업 테스트"""
        test_content = "테스트 내용"
        written_bytes = self.processor.write_data(test_content)
        self.assertEqual(written_bytes, len(test_content))
        
        content = self.processor.read_data()
        self.assertEqual(content, test_content)
    
    def tearDown(self):
        """각 테스트 메서드 종료 후 실행된다"""
        logger.info(f"테스트 종료: {self._testMethodName}")
        
        # 테스트 파일이 있으면 삭제
        if os.path.exists(self.test_file):
            os.remove(self.test_file)
    
    @classmethod
    def tearDownClass(cls):
        """전체 테스트 종료 후 1회 실행된다"""
        logger.info("테스트 클래스 종료")
        
        # 임시 디렉토리 삭제
        os.rmdir(cls.test_dir)

# 테스트 대상 코드
def calculate_grade(score):
    """점수에 따라 학점을 계산한다"""
    if score < 0 or score > 100:
        raise ValueError("점수는 0~100 사이여야 한다")
    
    if score >= 90:
        return 'A'
    elif score >= 80:
        return 'B'
    elif score >= 70:
        return 'C'
    elif score >= 60:
        return 'D'
    else:
        return 'F'

# 커버리지 측정을 위한 테스트
import unittest

class TestGradeCalculation(unittest.TestCase):
    def test_invalid_scores(self):
        """유효하지 않은 점수 테스트"""
        with self.assertRaises(ValueError):
            calculate_grade(-10)
        
        with self.assertRaises(ValueError):
            calculate_grade(110)
    
    def test_grade_a(self):
        """A학점 테스트"""
        self.assertEqual(calculate_grade(95), 'A')
        self.assertEqual(calculate_grade(90), 'A')
    
    def test_grade_b(self):
        """B학점 테스트"""
        self.assertEqual(calculate_grade(85), 'B')
        self.assertEqual(calculate_grade(80), 'B')
    
    def test_grade_c(self):
        """C학점 테스트"""
        self.assertEqual(calculate_grade(75), 'C')
        self.assertEqual(calculate_grade(70), 'C')
    
    def test_grade_d(self):
        """D학점 테스트"""
        self.assertEqual(calculate_grade(65), 'D')
        self.assertEqual(calculate_grade(60), 'D')
    
    def test_grade_f(self):
        """F학점 테스트"""
        self.assertEqual(calculate_grade(55), 'F')
        self.assertEqual(calculate_grade(0), 'F')

# 경계값 테스트
def test_boundary_values(self):
    """경계값 테스트"""
    self.assertEqual(calculate_grade(89), 'B')  # A의 하한 경계 바로 아래
    self.assertEqual(calculate_grade(90), 'A')  # A의 하한 경계
    self.assertEqual(calculate_grade(79), 'C')  # B의 하한 경계 바로 아래
    self.assertEqual(calculate_grade(80), 'B')  # B의 하한 경계

import unittest
from parameterized import parameterized  # pip install parameterized

class TestParameterized(unittest.TestCase):
    @parameterized.expand([
        (0, 'F'),
        (55, 'F'),
        (60, 'D'),
        (70, 'C'),
        (80, 'B'),
        (90, 'A'),
        (100, 'A'),
    ])
    def test_grades(self, score, expected_grade):
        """다양한 점수에 대한 학점 테스트"""
        self.assertEqual(calculate_grade(score), expected_grade)

# pip install hypothesis
from hypothesis import given, strategies as st
import unittest

class TestProperties(unittest.TestCase):
    @given(st.integers(min_value=90, max_value=100))
    def test_a_grade_property(self, score):
        """90~100 사이 모든 점수는 A학점이다"""
        self.assertEqual(calculate_grade(score), 'A')
    
    @given(st.integers(min_value=0, max_value=59))
    def test_f_grade_property(self, score):
        """0~59 사이 모든 점수는 F학점이다"""
        self.assertEqual(calculate_grade(score), 'F')
    
    @given(st.integers().filter(lambda x: x < 0 or x > 100))
    def test_invalid_score_property(self, score):
        """범위 밖의 모든 점수는 ValueError를 발생시킨다"""
        with self.assertRaises(ValueError):
            calculate_grade(score)

import unittest
import sqlite3
import os
import tempfile

# 테스트할 클래스들
class Database:
    def __init__(self, db_file):
        self.db_file = db_file
        self.connection = None
    
    def connect(self):
        self.connection = sqlite3.connect(self.db_file)
        self.connection.row_factory = sqlite3.Row
    
    def close(self):
        if self.connection:
            self.connection.close()
    
    def execute(self, query, params=()):
        cursor = self.connection.cursor()
        cursor.execute(query, params)
        self.connection.commit()
        return cursor

class UserRepository:
    def __init__(self, database):
        self.db = database
    
    def create_table(self):
        self.db.execute('''
            CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                username TEXT NOT NULL UNIQUE,
                email TEXT NOT NULL
            )
        ''')
    
    def add_user(self, username, email):
        cursor = self.db.execute(
            "INSERT INTO users (username, email) VALUES (?, ?)",
            (username, email)
        )
        return cursor.lastrowid
    
    def get_user(self, user_id):
        cursor = self.db.execute("SELECT * FROM users WHERE id = ?", (user_id,))
        return cursor.fetchone()
    
    def get_by_username(self, username):
        cursor = self.db.execute("SELECT * FROM users WHERE username = ?", (username,))
        return cursor.fetchone()

class UserService:
    def __init__(self, user_repository):
        self.repository = user_repository
    
    def register_user(self, username, email):
        # 사용자명 중복 확인
        existing_user = self.repository.get_by_username(username)
        if existing_user:
            raise ValueError(f"사용자명 '{username}'이 이미 존재한다")
        
        # 이메일 형식 검증
        if '@' not in email:
            raise ValueError("올바른 이메일 형식이 아니다")
        
        # 등록
        return self.repository.add_user(username, email)
    
    def get_user_details(self, user_id):
        user = self.repository.get_user(user_id)
        if not user:
            return None
        
        # 사용자 정보 반환
        return dict(user)

# 통합 테스트
class TestUserSystem(unittest.TestCase):
    def setUp(self):
        # 테스트용 임시 데이터베이스 파일 생성
        self.db_file = tempfile.NamedTemporaryFile(delete=False).name
        
        # 컴포넌트 초기화
        self.database = Database(self.db_file)
        self.database.connect()
        
        self.user_repo = UserRepository(self.database)
        self.user_repo.create_table()
        
        self.user_service = UserService(self.user_repo)
    
    def test_user_registration_workflow(self):
        """사용자 등록 워크플로우 통합 테스트"""
        # 새 사용자 등록
        user_id = self.user_service.register_user("testuser", "[email protected]")
        self.assertIsNotNone(user_id)
        
        # 등록된 사용자 정보 조회
        user = self.user_service.get_user_details(user_id)
        self.assertEqual(user["username"], "testuser")
        self.assertEqual(user["email"], "[email protected]")
        
        # 중복 사용자명 등록 시도
        with self.assertRaises(ValueError):
            self.user_service.register_user("testuser", "[email protected]")
    
    def test_invalid_email_format(self):
        """잘못된 이메일 형식 테스트"""
        with self.assertRaises(ValueError):
            self.user_service.register_user("newuser", "invalid-email")
    
    def tearDown(self):
        # 연결 종료
        self.database.close()
        
        # 테스트 파일 삭제
        os.unlink(self.db_file)

import unittest
import requests
import json
from unittest.mock import patch

# 테스트할 API 클라이언트
class WeatherApiClient:
    def __init__(self, api_key, base_url="https://api.weather.example"):
        self.api_key = api_key
        self.base_url = base_url
    
    def get_current_weather(self, city):
        url = f"{self.base_url}/current"
        params = {
            "city": city,
            "apikey": self.api_key
        }
        response = requests.get(url, params=params)
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 404:
            return {"error": "도시를 찾을 수 없다"}
        else:
            response.raise_for_status()

# 날씨 정보를 사용하는 서비스
class WeatherService:
    def __init__(self, weather_client):
        self.client = weather_client
    
    def get_temperature(self, city):
        weather_data = self.client.get_current_weather(city)
        if "error" in weather_data:
            return None
        return weather_data.get("temperature")
    
    def should_wear_jacket(self, city):
        temp = self.get_temperature(city)
        if temp is None:
            return None
        return temp < 15.0

# 모의 서버 응답을 사용한 통합 테스트
class TestWeatherService(unittest.TestCase):
    def setUp(self):
        self.api_key = "test_api_key"
        self.client = WeatherApiClient(self.api_key)
        self.service = WeatherService(self.client)
    
    @patch('requests.get')
    def test_get_temperature(self, mock_get):
        # 모의 응답 설정
        mock_response = requests.Response()
        mock_response.status_code = 200
        mock_response._content = json.dumps({"temperature": 20.5, "humidity": 65}).encode()
        mock_get.return_value = mock_response
        
        # 서비스 메서드 호출
        temp = self.service.get_temperature("Seoul")
        
        # 예상 결과 검증
        self.assertEqual(temp, 20.5)
        mock_get.assert_called_once()
        
        # 호출 URL과 매개변수 검증
        args, kwargs = mock_get.call_args
        self.assertEqual(kwargs['params']['city'], "Seoul")
        self.assertEqual(kwargs['params']['apikey'], self.api_key)
    
    @patch('requests.get')
    def test_should_wear_jacket_cold(self, mock_get):
        # 추운 날씨 응답 모의
        mock_response = requests.Response()
        mock_response.status_code = 200
        mock_response._content = json.dumps({"temperature": 10.0}).encode()
        mock_get.return_value = mock_response
        
        # 자켓 필요 여부 체크
        result = self.service.should_wear_jacket("Moscow")
        
        # 추운 날씨에는 자켓이 필요하다
        self.assertTrue(result)
    
    @patch('requests.get')
    def test_should_wear_jacket_warm(self, mock_get):
        # 따뜻한 날씨 응답 모의
        mock_response = requests.Response()
        mock_response.status_code = 200
        mock_response._content = json.dumps({"temperature": 25.0}).encode()
        mock_get.return_value = mock_response
        
        # 자켓 필요 여부 체크
        result = self.service.should_wear_jacket("Hawaii")
        
        # 따뜻한 날씨에는 자켓이 필요하지 않다
        self.assertFalse(result)