Pytest Gelişmiş Fixture'larında Uzmanlaşma: Parametreli Testler ve Mock Entegrasyonu

Pytest, Python için güçlü ve esnek bir test çerçevesidir. Basitliği ve genişletilebilirliği, onu dünya çapındaki geliştiriciler arasında favori yapmaktadır. Pytest'in en çekici özelliklerinden biri, şık ve yeniden kullanılabilir test kurulumlarına olanak tanıyan fixture sistemidir. Bu blog yazısı, özellikle parametreli testler ve mock entegrasyonu üzerine odaklanarak gelişmiş fixture tekniklerini derinlemesine ele alıyor. Bu tekniklerin test iş akışınızı nasıl önemli ölçüde geliştirebileceğini, daha sağlam ve sürdürülebilir kodlara yol açabileceğini keşfedeceğiz.

Pytest Fixture'larını Anlamak

İleri düzey konulara geçmeden önce, Pytest fixture'larının temellerini kısaca özetleyelim. Bir fixture, uygulandığı her test fonksiyonundan önce çalışan bir fonksiyondur. Testler için sabit bir temel sağlamak, tutarlılığı sağlamak ve tekrar eden kodları (boilerplate) azaltmak için kullanılır. Fixture'lar aşağıdaki gibi görevleri yerine getirebilir:

• Bir veritabanı bağlantısı kurma
• Geçici dosyalar veya dizinler oluşturma
• Nesneleri belirli yapılandırmalarla başlatma
• Bir API ile kimlik doğrulama

Fixture'lar kodun yeniden kullanılabilirliğini artırır ve testlerinizi daha okunabilir ve sürdürülebilir hale getirir. Ömürlerini ve kaynak tüketimlerini kontrol etmek için farklı kapsamlarda (fonksiyon, modül, oturum) tanımlanabilirler.

Temel Fixture Örneği

İşte geçici bir dizin oluşturan basit bir Pytest fixture örneği:

            
import pytest
import tempfile
import os

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

            

              
                Copy
              
            
          

Bu fixture'ı bir testte kullanmak için, test fonksiyonunuza bir argüman olarak eklemeniz yeterlidir:

            
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 ile Parametreli Testler

Parametreli testler, aynı test fonksiyonunu farklı girdi veri setleriyle birden çok kez çalıştırmanıza olanak tanır. Bu, özellikle değişen girdilere ve beklenen çıktılara sahip fonksiyonları test etmek için kullanışlıdır. Pytest, parametreli testleri uygulamak için @pytest.mark.parametrize dekoratörünü sağlar.

Parametreli Testlerin Faydaları

• Kod Tekrarını Azaltır: Neredeyse aynı olan birden fazla test fonksiyonu yazmaktan kaçının.
• Test Kapsamını İyileştirir: Daha geniş bir girdi değeri yelpazesini kolayca test edin.
• Test Okunabilirliğini Artırır: Her test senaryosu için girdi değerlerini ve beklenen çıktıları açıkça tanımlayın.

Temel Parametrelendirme Örneği

Diyelim ki iki sayıyı toplayan bir fonksiyonunuz var:

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

            

              
                Copy
              
            
          

Bu fonksiyonu farklı girdi değerleriyle test etmek için parametreli testleri kullanabilirsiniz:

            
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
              
            
          

Bu örnekte, @pytest.mark.parametrize dekoratörü, her biri x, y ve beklenen sonuç için farklı değerlere sahip dört test senaryosu tanımlar. Pytest, test_add fonksiyonunu her bir parametre seti için bir kez olmak üzere dört kez çalıştıracaktır.

Gelişmiş Parametrelendirme Teknikleri

Pytest, parametrelendirme için aşağıdakiler de dahil olmak üzere birkaç gelişmiş teknik sunar:

• Parametrelendirme ile Fixture Kullanımı: Her test senaryosu için farklı kurulumlar sağlamak üzere fixture'ları parametrelendirme ile birleştirin.
• Test Senaryoları için ID'ler: Daha iyi raporlama ve hata ayıklama için test senaryolarına özel ID'ler atayın.
• Dolaylı Parametrelendirme: Dinamik fixture oluşturmaya olanak tanıyarak fixture'lara geçirilen argümanları parametrelendirin.

Parametrelendirme ile Fixture Kullanımı

Bu, teste geçirilen parametrelere göre fixture'ları dinamik olarak yapılandırmanıza olanak tanır. Bir veritabanıyla etkileşime giren bir fonksiyonu test ettiğinizi hayal edin. Farklı test senaryoları için farklı veritabanı yapılandırmaları (örneğin, farklı bağlantı dizeleri) kullanmak isteyebilirsiniz.

            
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
              
            
          

Bu örnekte, db_config fixture'ı parametrelendirilmiştir. indirect=True argümanı Pytest'e parametreleri ("prod" ve "test") db_config fixture fonksiyonuna geçirmesini söyler. Ardından db_config fixture'ı, parametre değerine göre farklı veritabanı yapılandırmaları döndürür. db_connection fixture'ı bir veritabanı bağlantısı kurmak için db_config fixture'ını kullanır. Son olarak, test_database_interaction fonksiyonu veritabanıyla etkileşim kurmak için db_connection fixture'ını kullanır.

Test Senaryoları için ID'ler

Özel ID'ler, test raporunda test senaryolarınız için daha açıklayıcı isimler sağlar, bu da hataları tanımlamayı ve ayıklamayı kolaylaştırır.

            
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
              
            
          

ID'ler olmadan, Pytest test_uppercase[0], test_uppercase[1] gibi genel isimler üretirdi. ID'ler ile test raporu test_uppercase[lowercase_hello] gibi daha anlamlı isimler gösterecektir.

Dolaylı Parametrelendirme

Dolaylı parametrelendirme, doğrudan test fonksiyonu yerine bir fixture'ın girdisini parametrelendirmenize olanak tanır. Bu, parametre değerine göre farklı fixture örnekleri oluşturmak istediğinizde kullanışlıdır.

            
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
              
            
          

Bu örnekte, input_data fixture'ı "valid" ve "invalid" değerleriyle parametrelendirilmiştir. indirect=True argümanı Pytest'e bu değerleri input_data fixture fonksiyonuna geçirmesini söyler. Ardından input_data fixture'ı, parametre değerine göre farklı veri sözlükleri döndürür. Sonrasında test_validate_data fonksiyonu, farklı girdi verileriyle validate_data fonksiyonunu test etmek için input_data fixture'ını kullanır.

Pytest ile Mocking

Mocking, test sırasında gerçek bağımlılıkları kontrollü ikamelerle (mock'lar) değiştirmek için kullanılan bir tekniktir. Bu, test edilen kodu izole etmenize ve veritabanları, API'ler veya dosya sistemleri gibi harici sistemlere güvenmekten kaçınmanıza olanak tanır.

Mocking'in Faydaları

• Kodu İzole Etme: Harici bağımlılıklara güvenmeden kodu izolasyonda test edin.
• Davranışı Kontrol Etme: Geri dönüş değerleri ve istisnalar gibi bağımlılıkların davranışını tanımlayın.
• Testleri Hızlandırma: Yavaş veya güvenilmez harici sistemlerden kaçının.
• Uç Durumları Test Etme: Gerçek bir ortamda yeniden üretilmesi zor olan hata koşullarını ve uç durumları simüle edin.

unittest.mock Kütüphanesini Kullanma

Python, mock'lar oluşturmak için unittest.mock kütüphanesini sağlar. Pytest, unittest.mock ile sorunsuz bir şekilde bütünleşir, bu da testlerinizde bağımlılıkları mock'lamayı kolaylaştırır.

Temel Mocking Örneği

Diyelim ki harici bir API'den veri alan bir fonksiyonunuz var:

            
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 fonksiyonu API'ye gerçekten bir istek yapmadan test etmek için requests.get fonksiyonunu mock'layabilirsiniz:

            
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
              
            
          

Bu örnekte, @patch("requests.get") dekoratörü requests.get fonksiyonunu bir mock nesnesiyle değiştirir. mock_get argümanı mock nesnesidir. Ardından mock nesnesini belirli bir yanıt döndürecek şekilde yapılandırabilir ve doğru URL ile çağrıldığını doğrulayabiliriz.

Fixture'lar ile Mocking

Mock'ları oluşturmak ve yönetmek için fixture'ları da kullanabilirsiniz. Bu, mock'ları birden çok test arasında paylaşmak veya daha karmaşık mock kurulumları oluşturmak için kullanışlı olabilir.

            
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
              
            
          

Burada, mock_api_get bir mock oluşturur ve onu döndürür. patched_get daha sonra gerçek `requests.get`'i mock ile değiştirmek için bir pytest fixture'ı olan monkeypatch'i kullanır. Bu, diğer testlerin aynı mock'lanmış API uç noktasını kullanmasına olanak tanır.

Gelişmiş Mocking Teknikleri

Pytest ve unittest.mock, aşağıdakiler de dahil olmak üzere birkaç gelişmiş mocking tekniği sunar:

• Yan Etkiler (Side Effects): Girdi argümanlarına göre mock'lar için özel davranışlar tanımlayın.
• Özellik Mock'lama (Property Mocking): Nesnelerin özelliklerini mock'layın.
• Bağlam Yöneticileri (Context Managers): Geçici değiştirmeler için bağlam yöneticileri içinde mock'lar kullanın.

Yan Etkiler (Side Effects)

Yan etkiler, aldıkları girdi argümanlarına göre mock'larınız için özel davranışlar tanımlamanıza olanak tanır. Bu, farklı senaryoları veya hata koşullarını simüle etmek için kullanışlıdır.

            
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 mock, ardışık çağrılarda 1, 2 ve 3 değerlerini döndürür, ardından liste tükendiğinde bir `StopIteration` istisnası yükseltir.

Özellik Mock'lama (Property Mocking)

Özellik mock'lama, nesneler üzerindeki özelliklerin davranışını mock'lamanıza olanak tanır. Bu, metotlar yerine nesne özelliklerine dayanan kodu test etmek için kullanışlıdır.

            
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
              
            
          

Bu örnek, MyClass nesnesinin my_property özelliğini mock'lar, bu da test sırasında geri dönüş değerini kontrol etmenize olanak tanır.

Bağlam Yöneticileri (Context Managers)

Bağlam yöneticileri içinde mock'lar kullanmak, belirli bir kod bloğu için bağımlılıkları geçici olarak değiştirmenize olanak tanır. Bu, yalnızca sınırlı bir süre için mock'lanması gereken harici sistemler veya kaynaklarla etkileşime giren kodu test etmek için kullanışlıdır.

            
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
              
            
          

Parametrelendirme ve Mocking'i Birleştirme

Bu iki güçlü teknik, daha da karmaşık ve etkili testler oluşturmak için birleştirilebilir. Farklı mock yapılandırmalarıyla farklı senaryoları test etmek için parametrelendirmeyi kullanabilirsiniz.

            
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
              
            
          

Bu örnekte, test_get_user_data fonksiyonu farklı user_id ve expected_data değerleriyle parametrelendirilmiştir. @patch dekoratörü requests.get fonksiyonunu mock'lar. Pytest, test fonksiyonunu her bir parametre seti için bir kez olmak üzere iki kez çalıştıracak ve mock, ilgili expected_data değerini döndürecek şekilde yapılandırılacaktır.

Gelişmiş Fixture'ları Kullanmak için En İyi Uygulamalar

• Fixture'ları Odaklı Tutun: Her fixture'ın açık ve belirli bir amacı olmalıdır.
• Uygun Kapsamları Kullanın: Kaynak kullanımını optimize etmek için uygun fixture kapsamını (fonksiyon, modül, oturum) seçin.
• Fixture'ları Belgeleyin: Her fixture'ın amacını ve kullanımını açıkça belgeleyin.
• Aşırı Mock'lamadan Kaçının: Yalnızca test edilen kodu izole etmek için gerekli olan bağımlılıkları mock'layın.
• Açık Doğrulamalar Yazın: Doğrulamalarınızın (assertion) açık ve spesifik olduğundan, test edilen kodun beklenen davranışını doğruladığından emin olun.
• Test Odaklı Geliştirmeyi (TDD) Düşünün: Geliştirme sürecine rehberlik etmesi için fixture'ları ve mock'ları kullanarak kodu yazmadan önce testlerinizi yazın.

Sonuç

Parametreli testler ve mock entegrasyonu da dahil olmak üzere Pytest'in gelişmiş fixture teknikleri, sağlam, verimli ve sürdürülebilir testler yazmak için güçlü araçlar sunar. Bu tekniklerde uzmanlaşarak, Python kodunuzun kalitesini önemli ölçüde artırabilir ve test iş akışınızı kolaylaştırabilirsiniz. Açık, odaklanmış fixture'lar oluşturmaya, uygun kapsamları kullanmaya ve kapsamlı doğrulamalar yazmaya odaklanmayı unutmayın. Pratikle, kapsamlı ve etkili bir test stratejisi oluşturmak için Pytest'in fixture sisteminin tüm potansiyelinden yararlanabileceksiniz.