पाइथन में यूनिट टेस्टिंग: उदाहरणों के साथ पूर्ण मार्गदर्शिका

           /\
          /  \     E2E Tests (कम)
         /____\
        /      \   Integration Tests (कुछ)
       /________\
      /          \ Unit Tests (अधिक)
     /____________\

import unittest

class TestCalculator(unittest.TestCase):
    def setUp(self):
        """हर टेस्ट से पहले चलाएं"""
        self.calc = Calculator()

    def tearDown(self):
        """हर टेस्ट के बाद चलाएं"""
        self.calc = None

    def test_addition(self):
        result = self.calc.add(2, 3)
        self.assertEqual(result, 5)

    def test_division_by_zero(self):
        with self.assertRaises(ZeroDivisionError):
            self.calc.divide(10, 0)

if __name__ == '__main__':
    unittest.main()

import pytest

def test_addition():
    calc = Calculator()
    assert calc.add(2, 3) == 5

def test_division_by_zero():
    calc = Calculator()
    with pytest.raises(ZeroDivisionError):
        calc.divide(10, 0)

@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_addition_parametrized(a, b, expected):
    calc = Calculator()
    assert calc.add(a, b) == expected

pip install pytest pytest-cov pytest-mock

import pytest
from string_utils import reverse_string, is_palindrome, count_vowels

def test_reverse_string():
    assert reverse_string("hello") == "olleh"
    assert reverse_string("") == ""
    assert reverse_string("a") == "a"

def test_is_palindrome():
    assert is_palindrome("racecar") == True
    assert is_palindrome("hello") == False
    assert is_palindrome("") == True
    assert is_palindrome("A man a plan a canal Panama") == True

def test_count_vowels():
    assert count_vowels("hello") == 2
    assert count_vowels("HELLO") == 2
    assert count_vowels("xyz") == 0
    assert count_vowels("") == 0

def reverse_string(s: str) -> str:
    """एक स्ट्रिंग को उलटें"""
    return s[::-1]

def is_palindrome(s: str) -> bool:
    """चेक करें कि स्ट्रिंग पैलिंड्रोम है (केस और स्पेस को नज़रअंदाज़ करते हुए)"""
    cleaned = ''.join(s.lower().split())
    return cleaned == cleaned[::-1]

def count_vowels(s: str) -> int:
    """स्ट्रिंग में स्वरों की गिनती करें"""
    return sum(1 for char in s.lower() if char in 'aeiou')

pytest test_string_utils.py -v

test_string_utils.py::test_reverse_string PASSED
test_string_utils.py::test_is_palindrome PASSED
test_string_utils.py::test_count_vowels PASSED

import pytest
from database import Database

@pytest.fixture
def db():
    """एक टेस्ट डेटाबेस बनाएं"""
    database = Database(":memory:")
    database.create_tables()
    yield database  # टेस्ट को प्रदान करें
    database.close()  # टेस्ट के बाद साफ़ करें

@pytest.fixture
def sample_users(db):
    """डेटाबेस में नमूना उपयोगकर्ता जोड़ें"""
    db.add_user("Alice", "alice@example.com")
    db.add_user("Bob", "bob@example.com")
    return db

def test_get_user(sample_users):
    user = sample_users.get_user_by_email("alice@example.com")
    assert user.name == "Alice"

def test_user_count(sample_users):
    assert sample_users.count_users() == 2

@pytest.fixture(scope="function")  # डिफ़ॉल्ट: हर टेस्ट के लिए चलाएं
def func_fixture():
    return create_resource()

@pytest.fixture(scope="class")  # एक टेस्ट क्लास के लिए
def class_fixture():
    return create_resource()

@pytest.fixture(scope="module")  # एक मॉड्यूल के लिए
def module_fixture():
    return create_resource()

@pytest.fixture(scope="session")  # एक टेस्ट सेशन के लिए
def session_fixture():
    return create_expensive_resource()

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

class WeatherService:
    def get_temperature(self, city):
        response = requests.get(f"https://api.weather.com/{city}")
        return response.json()["temp"]

# मॉक के साथ टेस्ट करें
def test_get_temperature():
    service = WeatherService()

    # requests.get फंक्शन को मॉक करें
    with patch('requests.get') as mock_get:
        # मॉक रिस्पॉन्स कॉन्फ़िगर करें
        mock_response = Mock()
        mock_response.json.return_value = {"temp": 72}
        mock_get.return_value = mock_response

        # टेस्ट
        temp = service.get_temperature("Boston")
        assert temp == 72

        # कॉल की पुष्टि करें
        mock_get.assert_called_once_with("https://api.weather.com/Boston")

def test_get_temperature(mocker):
    service = WeatherService()

    # pytest-mock का उपयोग करके मॉक करें
    mock_response = mocker.Mock()
    mock_response.json.return_value = {"temp": 72}
    mocker.patch('requests.get', return_value=mock_response)

    temp = service.get_temperature("Boston")
    assert temp == 72

import pytest

@pytest.mark.parametrize("input,expected", [
    ("", True),
    ("a", True),
    ("ab", False),
    ("aba", True),
    ("racecar", True),
    ("hello", False),
])
def test_is_palindrome_parametrized(input, expected):
    assert is_palindrome(input) == expected

@pytest.mark.parametrize("number,is_even", [
    (0, True),
    (1, False),
    (2, True),
    (-1, False),
    (-2, True),
])
def test_is_even(number, is_even):
    assert (number % 2 == 0) == is_even

import pytest

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

def test_divide_by_zero():
    with pytest.raises(ValueError, match="Cannot divide by zero"):
        divide(10, 0)

def test_divide_by_zero_with_message():
    with pytest.raises(ValueError) as exc_info:
        divide(10, 0)
    assert "zero" in str(exc_info.value).lower()

# टेस्ट करें कि कोई एक्सेप्शन नहीं उठाया गया
def test_divide_success():
    result = divide(10, 2)
    assert result == 5.0

import pytest
import asyncio

async def fetch_data(url):
    """डेटा फेच करने के लिए एसिंक्रोनस फंक्शन"""
    await asyncio.sleep(0.1)  # एपीआई कॉल सिमुलेट करें
    return {"status": "success"}

@pytest.mark.asyncio
async def test_fetch_data():
    result = await fetch_data("https://api.example.com")
    assert result["status"] == "success"

@pytest.mark.asyncio
async def test_fetch_data_with_mock(mocker):
    # एसिंक्रोनस फंक्शन को मॉक करें
    mock_fetch = mocker.AsyncMock(return_value={"status": "mocked"})
    mocker.patch('module.fetch_data', mock_fetch)

    result = await fetch_data("https://api.example.com")
    assert result["status"] == "mocked"

# कवरेज के साथ परीक्षण चलाएं
pytest --cov=myproject tests/

# HTML रिपोर्ट बनाएं
pytest --cov=myproject --cov-report=html tests/

# गायब लाइनों को दिखाएं
pytest --cov=myproject --cov-report=term-missing tests/

[run]
source = myproject
omit =
    */tests/*
    */venv/*
    */__pycache__/*

[report]
exclude_lines =
    pragma: no cover
    def __repr__
    raise AssertionError
    raise NotImplementedError
    if __name__ == .__main__.:
    if TYPE_CHECKING:
    @abstractmethod

myproject/
├── myproject/
│   ├── __init__.py
│   ├── module1.py
│   ├── module2.py
│   └── utils.py
├── tests/
│   ├── __init__.py
│   ├── conftest.py          # साझा फिक्स्चर
│   ├── test_module1.py
│   ├── test_module2.py
│   ├── test_utils.py
│   └── integration/
│       ├── __init__.py
│       └── test_integration.py
├── pytest.ini
├── requirements.txt
└── requirements-dev.txt

# tests/conftest.py
import pytest
from myproject.database import Database

@pytest.fixture(scope="session")
def test_db():
    """सत्र-विशिष्ट परीक्षण डेटाबेस"""
    db = Database(":memory:")
    db.create_schema()
    yield db
    db.close()

@pytest.fixture
def clean_db(test_db):
    """प्रत्येक परीक्षण के लिए साफ़ डेटाबेस"""
    test_db.clear_all_tables()
    return test_db

[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts =
    -v
    --strict-markers
    --cov=myproject
    --cov-report=term-missing
    --cov-report=html
markers =
    slow: परीक्षणों को धीमा चिह्नित करता है
    integration: परीक्षणों को इंटीग्रेशन चिह्नित करता है
    unit: परीक्षणों को यूनिट चिह्नित करता है

def test_user_creation():
    # Arrange
    username = "john_doe"
    email = "john@example.com"

    # Act
    user = User(username, email)

    # Assert
    assert user.username == username
    assert user.email == email
    assert user.is_active == True

# अच्छा: फोकस्ड परीक्षण
def test_user_username():
    user = User("john_doe", "john@example.com")
    assert user.username == "john_doe"

def test_user_email():
    user = User("john_doe", "john@example.com")
    assert user.email == "john@example.com"

# भी स्वीकार्य: संबंधित assertions
def test_user_creation():
    user = User("john_doe", "john@example.com")
    assert user.username == "john_doe"
    assert user.email == "john@example.com"
    assert isinstance(user.created_at, datetime)

# बुरा
def test_user():
    pass

# अच्छा
def test_user_creation_with_valid_data():
    pass

def test_user_creation_fails_with_invalid_email():
    pass

def test_user_password_is_hashed_after_setting():
    pass

def test_age_validation():
    # वैध मामले
    assert validate_age(0) == True
    assert validate_age(18) == True
    assert validate_age(120) == True

    # सीमा मामले
    assert validate_age(-1) == False
    assert validate_age(121) == False

    # एज मामले
    with pytest.raises(TypeError):
        validate_age("18")
    with pytest.raises(TypeError):
        validate_age(None)

# बुरा: परीक्षणों का क्रम पर निर्भरता
counter = 0

def test_increment():
    global counter
    counter += 1
    assert counter == 1

def test_increment_again():  # अकेले चलाने पर विफल होता है
    global counter
    counter += 1
    assert counter == 2

# अच्छा: परीक्षण स्वतंत्र हैं
def test_increment():
    counter = Counter()
    counter.increment()
    assert counter.value == 1

def test_increment_multiple_times():
    counter = Counter()
    counter.increment()
    counter.increment()
    assert counter.value == 2

# बुरा: कार्यान्वयन का परीक्षण
def test_sort_uses_quicksort():
    sorter = Sorter()
    assert sorter.algorithm == "quicksort"

# अच्छा: व्यवहार का परीक्षण
def test_sort_returns_sorted_list():
    sorter = Sorter()
    result = sorter.sort([3, 1, 2])
    assert result == [1, 2, 3]

# .github/workflows/tests.yml
name: Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: [3.9, 3.10, 3.11, 3.12]

    steps:
    - uses: actions/checkout@v3

    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
        pip install -r requirements-dev.txt        

    - name: Run tests
      run: |
        pytest --cov=myproject --cov-report=xml        

    - name: Upload coverage
      uses: codecov/codecov-action@v3
      with:
        file: ./coverage.xml

class TestUser:
    @pytest.fixture
    def user(self):
        return User("john_doe", "john@example.com")

    def test_username(self, user):
        assert user.username == "john_doe"

    def test_email(self, user):
        assert user.email == "john@example.com"

    def test_full_name(self, user):
        user.first_name = "John"
        user.last_name = "Doe"
        assert user.full_name() == "John Doe"

import pytest
from pathlib import Path

@pytest.fixture
def temp_file(tmp_path):
    """एक अस्थायी फाइल बनाएं"""
    file_path = tmp_path / "test_file.txt"
    file_path.write_text("test content")
    return file_path

def test_read_file(temp_file):
    content = temp_file.read_text()
    assert content == "test content"

@pytest.fixture
def temp_output_dir(tmp_path):
    """एक अस्थायी आउटपुट डायरेक्टरी प्रदान करें"""
    output_dir = tmp_path / "output"
    output_dir.mkdir()
    return output_dir

def test_pdf_generation(temp_output_dir):
    pdf_path = temp_output_dir / "output.pdf"
    generate_pdf(pdf_path, content="Test")

    assert pdf_path.exists()
    assert pdf_path.stat().st_size > 0

def test_environment_variable(monkeypatch):
    monkeypatch.setenv("API_KEY", "test_key_123")
    assert os.getenv("API_KEY") == "test_key_123"

def test_module_attribute(monkeypatch):
    monkeypatch.setattr("module.CONSTANT", 42)
    assert module.CONSTANT == 42