Pytest ilg'or fixturalarini o'zlashtirish: Parametrlashtirilgan testlash va Mok integratsiyasi

Pytest - bu Python uchun kuchli va moslashuvchan testlash freymvorkidir. Uning soddaligi va kengaytirilishi mumkinligi uni butun dunyo bo'ylab dasturchilar orasida sevimlilaridan biriga aylantiradi. Pytest'ning eng jozibali xususiyatlaridan biri bu uning fixtura tizimi bo'lib, u elegant va qayta ishlatiladigan test sozlamalarini yaratishga imkon beradi. Ushbu blog posti ilg'or fixtura usullariga, xususan parametrlashtirilgan testlash va mok integratsiyasiga qaratilgan. Biz bu usullar sizning testlash ish jarayoningizni qanday sezilarli darajada yaxshilashi va yanada mustahkam hamda qo'llab-quvvatlanadigan kodga olib kelishi mumkinligini o'rganamiz.

Pytest Fixturalarini tushunish

Ilg'or mavzularga sho'ng'ishdan oldin, keling, Pytest fixturalarining asoslarini qisqacha takrorlab o'tamiz. Fixtura - bu qo'llanilgan har bir test funksiyasidan oldin ishga tushadigan funksiyadir. U testlar uchun qat'iy belgilangan asosni ta'minlash, izchillikni ta'minlash va takrorlanuvchi kodni kamaytirish uchun ishlatiladi. Fixturalar quyidagi vazifalarni bajarishi mumkin:

• Ma'lumotlar bazasi ulanishini sozlash
• Vaqtinchalik fayllar yoki kataloglar yaratish
• Obyektlarni ma'lum konfiguratsiyalar bilan ishga tushirish
• API bilan autentifikatsiya qilish

Fixturalar kodni qayta ishlatish imkoniyatini oshiradi va testlaringizni o'qish va qo'llab-quvvatlash uchun qulayroq qiladi. Ular o'zlarining hayot aylanishi va resurs iste'molini nazorat qilish uchun turli darajalarda (funksiya, modul, sessiya) aniqlanishi mumkin.

Oddiy Fixtura Misoli

Mana, vaqtinchalik katalog yaratadigan oddiy Pytest fixturasi misoli:

            
import pytest
import tempfile
import os

@pytest.fixture
def temp_dir():
    with tempfile.TemporaryDirectory() as tmpdir:
        yield tmpdir

            

              
                Copy
              
            
          

Ushbu fixturani testda ishlatish uchun uni shunchaki test funksiyangizga argument sifatida qo'shing:

            
def test_create_file(temp_dir):
    filepath = os.path.join(temp_dir, "test_file.txt")
    with open(filepath, "w") as f:
        f.write("Hello, world!")
    assert os.path.exists(filepath)

            

              
                Copy
              
            
          

Pytest bilan Parametrlashtirilgan Testlash

Parametrlashtirilgan testlash bir xil test funksiyasini turli xil kirish ma'lumotlari to'plamlari bilan bir necha marta ishga tushirish imkonini beradi. Bu o'zgaruvchan kirish va kutilgan natijalarga ega funksiyalarni testlash uchun ayniqsa foydalidir. Pytest parametrlashtirilgan testlarni amalga oshirish uchun @pytest.mark.parametrize dekoratorini taqdim etadi.

Parametrlashtirilgan Testlashning Afzalliklari

• Kodning Takrorlanishini Kamaytiradi: Deyarli bir xil bo'lgan bir nechta test funksiyalarini yozishdan saqlaning.
• Test Qamrovini Yaxshilaydi: Kirish qiymatlarining kengroq doirasini osongina testlang.
• Testning O'qilishini Osonlashtiradi: Har bir test holati uchun kirish qiymatlari va kutilgan natijalarni aniq belgilang.

Oddiy Parametrlashtirish Misoli

Deylik, sizda ikkita sonni qo'shadigan funksiya bor:

            
def add(x, y):
    return x + y

            

              
                Copy
              
            
          

Siz bu funksiyani turli xil kirish qiymatlari bilan testlash uchun parametrlashtirilgan testlashdan foydalanishingiz mumkin:

            
import pytest

@pytest.mark.parametrize("x, y, expected", [
    (1, 2, 3),
    (5, 5, 10),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add(x, y, expected):
    assert add(x, y) == expected

            

              
                Copy
              
            
          

Ushbu misolda, @pytest.mark.parametrize dekoratori to'rtta test holatini belgilaydi, har biri x, y va kutilgan natija uchun turli qiymatlarga ega. Pytest test_add funksiyasini to'rt marta, har bir parametrlar to'plami uchun bir martadan ishga tushiradi.

Ilg'or Parametrlashtirish Usullari

Pytest parametrlashtirish uchun bir nechta ilg'or usullarni taklif etadi, jumladan:

• Fixturalarni Parametrlashtirish bilan Ishlatish: Har bir test holati uchun turli xil sozlamalarni taqdim etish uchun fixturalarni parametrlashtirish bilan birlashtiring.
• Test Holatlari uchun IDlar: Yaxshiroq hisobot va nosozliklarni tuzatish uchun test holatlariga maxsus IDlar tayinlang.
• Bilvosita Parametrlashtirish: Fixturalarga uzatiladigan argumentlarni parametrlashtiring, bu esa dinamik fixtura yaratish imkonini beradi.

Fixturalarni Parametrlashtirish bilan Ishlatish

Bu sizga testga uzatilgan parametrlarga asoslanib fixturalarni dinamik ravishda sozlash imkonini beradi. Tasavvur qiling, siz ma'lumotlar bazasi bilan ishlaydigan funksiyani test qilmoqdasiz. Turli test holatlari uchun turli xil ma'lumotlar bazasi konfiguratsiyalaridan (masalan, turli ulanish satrlari) foydalanishni xohlashingiz mumkin.

            
import pytest

@pytest.fixture
def db_config(request):
    if request.param == "prod":
        return {"host": "prod.example.com", "port": 5432}
    elif request.param == "test":
        return {"host": "test.example.com", "port": 5433}
    else:
        raise ValueError("Invalid database environment")


@pytest.fixture
def db_connection(db_config):
    # Simulate establishing a database connection
    print(f"Connecting to database at {db_config['host']}:{db_config['port']}")
    return f"Connection to {db_config['host']}"


@pytest.mark.parametrize("db_config", ["prod", "test"], indirect=True)
def test_database_interaction(db_connection):
    # Your test logic here, using the db_connection fixture
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

Ushbu misolda, db_config fixturasi parametrlashtirilgan. indirect=True argumenti Pytest'ga parametrlarni ("prod" va "test") db_config fixtura funksiyasiga uzatishni bildiradi. Shundan so'ng db_config fixturasi parametr qiymatiga qarab turli xil ma'lumotlar bazasi konfiguratsiyalarini qaytaradi. db_connection fixturasi ma'lumotlar bazasiga ulanishni o'rnatish uchun db_config fixturasidan foydalanadi. Nihoyat, test_database_interaction funksiyasi ma'lumotlar bazasi bilan ishlash uchun db_connection fixturasidan foydalanadi.

Test Holatlari uchun IDlar

Maxsus IDlar test hisobotida test holatlaringiz uchun yanada tavsiflovchi nomlarni taqdim etadi, bu esa nosozliklarni aniqlash va tuzatishni osonlashtiradi.

            
import pytest

@pytest.mark.parametrize(
    "input_string, expected_output",
    [
        ("hello", "HELLO"),
        ("world", "WORLD"),
        ("", ""),
    ],
    ids=["lowercase_hello", "lowercase_world", "empty_string"],
)
def test_uppercase(input_string, expected_output):
    assert input_string.upper() == expected_output

            

              
                Copy
              
            
          

IDlarsiz, Pytest test_uppercase[0], test_uppercase[1] kabi umumiy nomlarni yaratardi. IDlar bilan test hisobotida test_uppercase[lowercase_hello] kabi yanada mazmunli nomlar ko'rsatiladi.

Bilvosita Parametrlashtirish

Bilvosita parametrlashtirish sizga test funksiyasini to'g'ridan-to'g'ri emas, balki fixturaga kirishni parametrlashtirish imkonini beradi. Bu parametr qiymatiga asoslanib turli xil fixtura nusxalarini yaratmoqchi bo'lganingizda foydalidir.

            
import pytest

@pytest.fixture
def input_data(request):
    if request.param == "valid":
        return {"name": "John Doe", "email": "john.doe@example.com"}
    elif request.param == "invalid":
        return {"name": "", "email": "invalid-email"}
    else:
        raise ValueError("Invalid input data type")


def validate_data(data):
    if not data["name"]:
        return False, "Name cannot be empty"
    if "@" not in data["email"]:
        return False, "Invalid email address"
    return True, "Valid data"

@pytest.mark.parametrize("input_data", ["valid", "invalid"], indirect=True)
def test_validate_data(input_data):
    is_valid, message = validate_data(input_data)
    if input_data == {"name": "John Doe", "email": "john.doe@example.com"}:
        assert is_valid is True
        assert message == "Valid data"
    else:
        assert is_valid is False
        assert message in ["Name cannot be empty", "Invalid email address"]

            

              
                Copy
              
            
          

Ushbu misolda, input_data fixturasi "valid" va "invalid" qiymatlari bilan parametrlashtirilgan. indirect=True argumenti Pytest'ga bu qiymatlarni input_data fixtura funksiyasiga uzatishni bildiradi. So'ngra input_data fixturasi parametr qiymatiga qarab turli xil ma'lumotlar lug'atlarini qaytaradi. test_validate_data funksiyasi esa validate_data funksiyasini turli xil kirish ma'lumotlari bilan sinab ko'rish uchun input_data fixturasidan foydalanadi.

Pytest bilan Mocking (Imitatsiya qilish)

Mocking - bu testlash paytida haqiqiy bog'liqliklarni nazorat qilinadigan o'rinbosarlar (moklar) bilan almashtirish uchun ishlatiladigan usul. Bu sizga test qilinayotgan kodni ajratib olish va ma'lumotlar bazalari, APIlar yoki fayl tizimlari kabi tashqi tizimlarga tayanmaslik imkonini beradi.

Mockingning Afzalliklari

• Kodni Ajratish: Tashqi bog'liqliklarga tayanmasdan, kodni alohida sinab ko'ring.
• Xatti-harakatni Nazorat Qilish: Qaytariladigan qiymatlar va istisnolar kabi bog'liqliklarning xatti-harakatlarini belgilang.
• Testlarni Tezlashtirish: Sekin yoki ishonchsiz tashqi tizimlardan saqlaning.
• Chekka Holatlarni Testlash: Haqiqiy muhitda qayta tiklash qiyin bo'lgan xatolik holatlari va chekka holatlarni simulyatsiya qiling.

unittest.mock Kutubxonasidan Foydalanish

Python moklar yaratish uchun unittest.mock kutubxonasini taqdim etadi. Pytest unittest.mock bilan muammosiz integratsiyalashadi, bu esa testlaringizda bog'liqliklarni mok qilishni osonlashtiradi.

Oddiy Mocking Misoli

Aytaylik, sizda tashqi API'dan ma'lumotlarni oladigan funksiya mavjud:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()

            

              
                Copy
              
            
          

Bu funksiyani API'ga haqiqiy so'rov yubormasdan testlash uchun siz requests.get funksiyasini mok qilishingiz mumkin:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Configure the mock to return a specific response
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    mock_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Ushbu misolda, @patch("requests.get") dekoratori requests.get funksiyasini mok obyekti bilan almashtiradi. mock_get argumenti - bu mok obyekti. Keyin biz mok obyektini ma'lum bir javobni qaytarish uchun sozlashimiz va uning to'g'ri URL bilan chaqirilganligini tekshirishimiz mumkin.

Fixturalar bilan Mocking

Siz shuningdek, moklarni yaratish va boshqarish uchun fixturalardan foydalanishingiz mumkin. Bu moklarni bir nechta testlar o'rtasida bo'lishish yoki murakkabroq mok sozlamalarini yaratish uchun foydali bo'lishi mumkin.

            
import pytest
import requests
from unittest.mock import Mock

@pytest.fixture
def mock_api_get():
    mock = Mock()
    mock.return_value.json.return_value = {"data": "test data"}
    mock.return_value.status_code = 200
    return mock


@pytest.fixture
def patched_get(mock_api_get, monkeypatch):
    monkeypatch.setattr(requests, "get", mock_api_get)
    return mock_api_get


def test_get_data_from_api(patched_get):
    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    patched_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Bu yerda mock_api_get mok yaratadi va uni qaytaradi. So'ngra patched_get pytest fixturasi bo'lgan monkeypatch'dan foydalanib, haqiqiy `requests.get`'ni mok bilan almashtiradi. Bu boshqa testlarga ham xuddi shu mok qilingan API nuqtasidan foydalanish imkonini beradi.

Ilg'or Mocking Usullari

Pytest va unittest.mock bir nechta ilg'or mocking usullarini taklif qiladi, jumladan:

• Yon Ta'sirlar (Side Effects): Kirish argumentlariga asoslangan holda moklar uchun maxsus xatti-harakatlarni belgilang.
• Xususiyatlarni Moklash (Property Mocking): Obyektlarning xususiyatlarini mok qiling.
• Kontekst Menejerlari: Vaqtinchalik almashtirishlar uchun kontekst menejerlari ichida moklardan foydalaning.

Yon Ta'sirlar

Yon ta'sirlar sizga moklaringiz uchun ular qabul qilgan kirish argumentlariga asoslanib maxsus xatti-harakatlarni belgilash imkonini beradi. Bu turli xil stsenariylarni yoki xatolik holatlarini simulyatsiya qilish uchun foydalidir.

            
import pytest
from unittest.mock import Mock

def test_side_effect():
    mock = Mock()
    mock.side_effect = [1, 2, 3]

    assert mock() == 1
    assert mock() == 2
    assert mock() == 3
    with pytest.raises(StopIteration):
        mock()

            

              
                Copy
              
            
          

Bu mok ketma-ket chaqiruvlarda 1, 2 va 3 ni qaytaradi, so'ngra ro'yxat tugagach `StopIteration` istisnosini chiqaradi.

Xususiyatlarni Moklash

Xususiyatlarni moklash sizga obyektlardagi xususiyatlarning xatti-harakatlarini mok qilish imkonini beradi. Bu metodlardan ko'ra obyekt xususiyatlariga tayanadigan kodni testlash uchun foydalidir.

            
import pytest
from unittest.mock import patch

class MyClass:
    @property
    def my_property(self):
        return "original value"


def test_property_mocking():
    obj = MyClass()
    with patch.object(obj, "my_property", new_callable=pytest.PropertyMock) as mock_property:
        mock_property.return_value = "mocked value"
        assert obj.my_property == "mocked value"

            

              
                Copy
              
            
          

Ushbu misol MyClass obyektining my_property xususiyatini mok qiladi, bu esa test paytida uning qaytaradigan qiymatini nazorat qilish imkonini beradi.

Kontekst Menejerlari

Kontekst menejerlari ichida moklardan foydalanish sizga ma'lum bir kod bloki uchun bog'liqliklarni vaqtincha almashtirish imkonini beradi. Bu faqat cheklangan vaqt davomida mok qilinishi kerak bo'lgan tashqi tizimlar yoki resurslar bilan ishlaydigan kodni testlash uchun foydalidir.

            
import pytest
from unittest.mock import patch


def test_context_manager_mocking():
    with patch("os.path.exists") as mock_exists:
        mock_exists.return_value = True
        assert os.path.exists("dummy_path") is True
    # The mock is automatically reverted after the 'with' block
    # Ensure the original function is restored, although we can't really assert
    # the real `os.path.exists` function's behavior without a real path.
    # The important thing is that the patch is gone after the context.
    print("Mock has been removed")

            

              
                Copy
              
            
          

Parametrlashtirish va Mockingni Birlashtirish

Ushbu ikkita kuchli usulni yanada murakkab va samarali testlar yaratish uchun birlashtirish mumkin. Siz turli xil mok konfiguratsiyalari bilan turli stsenariylarni testlash uchun parametrlashtirishdan foydalanishingiz mumkin.

            
import pytest
import requests
from unittest.mock import patch


def get_user_data(user_id):
    url = f"https://api.example.com/users/{user_id}"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


@pytest.mark.parametrize(
    "user_id, expected_data",
    [
        (1, {"id": 1, "name": "John Doe"}),
        (2, {"id": 2, "name": "Jane Smith"}),
    ],
)
@patch("requests.get")
def test_get_user_data(mock_get, user_id, expected_data):
    mock_get.return_value.json.return_value = expected_data
    mock_get.return_value.status_code = 200

    data = get_user_data(user_id)

    assert data == expected_data
    mock_get.assert_called_once_with(f"https://api.example.com/users/{user_id}")

            

              
                Copy
              
            
          

Ushbu misolda, test_get_user_data funksiyasi turli user_id va expected_data qiymatlari bilan parametrlashtirilgan. @patch dekoratori requests.get funksiyasini mok qiladi. Pytest test funksiyasini ikki marta ishga tushiradi, har bir parametrlar to'plami uchun bir martadan, mok tegishli expected_data'ni qaytarish uchun sozlangan holda.

Ilg'or Fixturalardan Foydalanish bo'yicha Eng Yaxshi Amaliyotlar

• Fixturalarni Maqsadli saqlang: Har bir fixturaning aniq va o'ziga xos maqsadi bo'lishi kerak.
• Tegishli Ko'lamlardan (Scopes) Foydalaning: Resurslardan foydalanishni optimallashtirish uchun tegishli fixtura ko'lamini (funksiya, modul, sessiya) tanlang.
• Fixturalarni Hujjatlashtiring: Har bir fixturaning maqsadi va ishlatilishini aniq hujjatlashtiring.
• Haddan Tashqari Mockingdan Saqlaning: Faqat test qilinayotgan kodni ajratish uchun zarur bo'lgan bog'liqliklarni mok qiling.
• Aniq Tasdiqlashlar (Assertions) Yozing: Tasdiqlashlaringiz aniq va o'ziga xos ekanligiga ishonch hosil qiling, bu test qilinayotgan kodning kutilgan xatti-harakatini tasdiqlaydi.
• Test Orqali Ishlab Chiqishni (TDD) Ko'rib Chiqing: Kodni yozishdan oldin testlaringizni yozing, ishlab chiqish jarayonini boshqarish uchun fixturalar va moklardan foydalaning.

Xulosa

Pytest'ning ilg'or fixtura usullari, jumladan, parametrlashtirilgan testlash va mok integratsiyasi mustahkam, samarali va qo'llab-quvvatlanadigan testlarni yozish uchun kuchli vositalarni taqdim etadi. Ushbu usullarni o'zlashtirib, siz Python kodingiz sifatini sezilarli darajada yaxshilashingiz va testlash ish jarayoningizni optimallashtirishingiz mumkin. Aniq, maqsadli fixturalar yaratishga, tegishli ko'lamlardan foydalanishga va keng qamrovli tasdiqlashlar yozishga e'tibor qaratishni unutmang. Amaliyot bilan siz Pytest'ning fixtura tizimining to'liq imkoniyatlaridan foydalanib, keng qamrovli va samarali testlash strategiyasini yaratishingiz mumkin bo'ladi.