Menguasai Fixture Lanjutan Pytest: Pengujian Berparameter dan Integrasi Mock

Pytest adalah kerangka kerja pengujian yang kuat dan fleksibel untuk Python. Kesederhanaan dan ekstensibilitasnya menjadikannya favorit di kalangan pengembang di seluruh dunia. Salah satu fitur Pytest yang paling menarik adalah sistem fixture-nya, yang memungkinkan penyiapan pengujian yang elegan dan dapat digunakan kembali. Postingan blog ini membahas teknik fixture tingkat lanjut, khususnya berfokus pada pengujian berparameter dan integrasi mock. Kita akan menjelajahi bagaimana teknik-teknik ini dapat secara signifikan meningkatkan alur kerja pengujian Anda, menghasilkan kode yang lebih kuat dan mudah dipelihara.

Memahami Fixture Pytest

Sebelum masuk ke topik lanjutan, mari kita ulas secara singkat dasar-dasar fixture Pytest. Fixture adalah fungsi yang berjalan sebelum setiap fungsi tes yang menerapkannya. Ini digunakan untuk menyediakan dasar yang tetap untuk pengujian, memastikan konsistensi dan mengurangi kode boilerplate. Fixture dapat melakukan tugas-tugas seperti:

• Menyiapkan koneksi basis data
• Membuat file atau direktori sementara
• Menginisialisasi objek dengan konfigurasi spesifik
• Melakukan autentikasi dengan API

Fixture mendorong penggunaan kembali kode dan membuat pengujian Anda lebih mudah dibaca dan dipelihara. Fixture dapat didefinisikan pada cakupan yang berbeda (fungsi, modul, sesi) untuk mengontrol masa pakai dan konsumsi sumber dayanya.

Contoh Fixture Dasar

Berikut adalah contoh sederhana dari fixture Pytest yang membuat direktori sementara:

            
import pytest
import tempfile
import os

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

            

              
                Copy
              
            
          

Untuk menggunakan fixture ini dalam sebuah tes, cukup sertakan sebagai argumen pada fungsi tes Anda:

            
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
              
            
          

Pengujian Berparameter dengan Pytest

Pengujian berparameter memungkinkan Anda menjalankan fungsi tes yang sama berulang kali dengan set data masukan yang berbeda. Ini sangat berguna untuk menguji fungsi dengan berbagai masukan dan keluaran yang diharapkan. Pytest menyediakan dekorator @pytest.mark.parametrize untuk mengimplementasikan pengujian berparameter.

Manfaat Pengujian Berparameter

• Mengurangi Duplikasi Kode: Hindari menulis beberapa fungsi tes yang hampir identik.
• Meningkatkan Cakupan Tes: Mudah menguji rentang nilai masukan yang lebih luas.
• Meningkatkan Keterbacaan Tes: Mendefinisikan dengan jelas nilai masukan dan keluaran yang diharapkan untuk setiap kasus uji.

Contoh Parametrisasi Dasar

Misalkan Anda memiliki fungsi yang menjumlahkan dua angka:

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

            

              
                Copy
              
            
          

Anda dapat menggunakan pengujian berparameter untuk menguji fungsi ini dengan nilai masukan yang berbeda:

            
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
              
            
          

Dalam contoh ini, dekorator @pytest.mark.parametrize mendefinisikan empat kasus uji, masing-masing dengan nilai yang berbeda untuk x, y, dan hasil yang diharapkan. Pytest akan menjalankan fungsi test_add empat kali, sekali untuk setiap set parameter.

Teknik Parametrisasi Lanjutan

Pytest menawarkan beberapa teknik lanjutan untuk parametrisasi, termasuk:

• Menggunakan Fixture dengan Parametrisasi: Menggabungkan fixture dengan parametrisasi untuk menyediakan penyiapan yang berbeda untuk setiap kasus uji.
• Id untuk Kasus Uji: Menetapkan ID kustom ke kasus uji untuk pelaporan dan debugging yang lebih baik.
• Parametrisasi Tidak Langsung (Indirect): Memparameterisasi argumen yang dilewatkan ke fixture, memungkinkan pembuatan fixture yang dinamis.

Menggunakan Fixture dengan Parametrisasi

Ini memungkinkan Anda untuk mengonfigurasi fixture secara dinamis berdasarkan parameter yang dilewatkan ke tes. Bayangkan Anda sedang menguji fungsi yang berinteraksi dengan basis data. Anda mungkin ingin menggunakan konfigurasi basis data yang berbeda (misalnya, string koneksi yang berbeda) untuk kasus uji yang berbeda.

            
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
              
            
          

Dalam contoh ini, fixture db_config diparameterisasi. Argumen indirect=True memberitahu Pytest untuk melewatkan parameter ("prod" dan "test") ke fungsi fixture db_config. Fixture db_config kemudian mengembalikan konfigurasi basis data yang berbeda berdasarkan nilai parameter. Fixture db_connection menggunakan fixture db_config untuk membuat koneksi basis data. Akhirnya, fungsi test_database_interaction menggunakan fixture db_connection untuk berinteraksi dengan basis data.

Id untuk Kasus Uji

ID kustom memberikan nama yang lebih deskriptif untuk kasus uji Anda dalam laporan pengujian, membuatnya lebih mudah untuk mengidentifikasi dan men-debug kegagalan.

            
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
              
            
          

Tanpa ID, Pytest akan menghasilkan nama generik seperti test_uppercase[0], test_uppercase[1], dll. Dengan ID, laporan pengujian akan menampilkan nama yang lebih bermakna seperti test_uppercase[lowercase_hello].

Parametrisasi Tidak Langsung (Indirect)

Parametrisasi tidak langsung memungkinkan Anda untuk memparameterisasi masukan ke fixture, bukan langsung ke fungsi tes. Ini berguna ketika Anda ingin membuat instance fixture yang berbeda berdasarkan nilai parameter.

            
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
              
            
          

Dalam contoh ini, fixture input_data diparameterisasi dengan nilai "valid" dan "invalid". Argumen indirect=True memberitahu Pytest untuk melewatkan nilai-nilai ini ke fungsi fixture input_data. Fixture input_data kemudian mengembalikan kamus data yang berbeda berdasarkan nilai parameter. Fungsi test_validate_data kemudian menggunakan fixture input_data untuk menguji fungsi validate_data dengan data masukan yang berbeda.

Mocking dengan Pytest

Mocking adalah teknik yang digunakan untuk menggantikan dependensi nyata dengan pengganti yang terkontrol (mock) selama pengujian. Ini memungkinkan Anda untuk mengisolasi kode yang diuji dan menghindari ketergantungan pada sistem eksternal, seperti basis data, API, atau sistem file.

Manfaat Mocking

• Mengisolasi Kode: Menguji kode secara terisolasi, tanpa bergantung pada dependensi eksternal.
• Mengontrol Perilaku: Mendefinisikan perilaku dependensi, seperti nilai kembalian dan pengecualian.
• Mempercepat Tes: Menghindari sistem eksternal yang lambat atau tidak dapat diandalkan.
• Menguji Kasus Ekstrem (Edge Cases): Mensimulasikan kondisi kesalahan dan kasus ekstrem yang sulit direproduksi di lingkungan nyata.

Menggunakan Pustaka unittest.mock

Python menyediakan pustaka unittest.mock untuk membuat mock. Pytest terintegrasi dengan mulus dengan unittest.mock, membuatnya mudah untuk melakukan mock pada dependensi dalam pengujian Anda.

Contoh Mocking Dasar

Misalkan Anda memiliki fungsi yang mengambil data dari API eksternal:

            
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
              
            
          

Untuk menguji fungsi ini tanpa benar-benar membuat permintaan ke API, Anda dapat melakukan mock pada fungsi requests.get:

            
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
              
            
          

Dalam contoh ini, dekorator @patch("requests.get") menggantikan fungsi requests.get dengan objek mock. Argumen mock_get adalah objek mock tersebut. Kita kemudian dapat mengonfigurasi objek mock untuk mengembalikan respons spesifik dan memastikan bahwa itu dipanggil dengan URL yang benar.

Mocking dengan Fixture

Anda juga dapat menggunakan fixture untuk membuat dan mengelola mock. Ini bisa berguna untuk berbagi mock di beberapa tes atau untuk membuat penyiapan mock yang lebih kompleks.

            
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
              
            
          

Di sini, mock_api_get membuat mock dan mengembalikannya. Kemudian, patched_get menggunakan monkeypatch, sebuah fixture pytest, untuk menggantikan `requests.get` yang asli dengan mock. Ini memungkinkan tes lain untuk menggunakan endpoint API yang di-mock yang sama.

Teknik Mocking Lanjutan

Pytest dan unittest.mock menawarkan beberapa teknik mocking tingkat lanjut, termasuk:

• Efek Samping (Side Effects): Mendefinisikan perilaku kustom untuk mock berdasarkan argumen masukan.
• Mocking Properti: Melakukan mock pada properti objek.
• Manajer Konteks (Context Managers): Menggunakan mock di dalam manajer konteks untuk penggantian sementara.

Efek Samping (Side Effects)

Efek samping memungkinkan Anda untuk mendefinisikan perilaku kustom untuk mock Anda berdasarkan argumen masukan yang mereka terima. Ini berguna untuk mensimulasikan skenario atau kondisi kesalahan yang berbeda.

            
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
              
            
          

Mock ini mengembalikan 1, 2, dan 3 pada pemanggilan berturut-turut, kemudian menimbulkan pengecualian `StopIteration` ketika daftar habis.

Mocking Properti

Mocking properti memungkinkan Anda untuk melakukan mock pada perilaku properti pada objek. Ini berguna untuk menguji kode yang bergantung pada properti objek daripada metode.

            
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
              
            
          

Contoh ini melakukan mock pada properti my_property dari objek MyClass, memungkinkan Anda untuk mengontrol nilai kembaliannya selama pengujian.

Manajer Konteks (Context Managers)

Menggunakan mock di dalam manajer konteks memungkinkan Anda untuk mengganti dependensi sementara untuk blok kode tertentu. Ini berguna untuk menguji kode yang berinteraksi dengan sistem atau sumber daya eksternal yang seharusnya hanya di-mock untuk waktu yang terbatas.

            
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
              
            
          

Menggabungkan Parametrisasi dan Mocking

Kedua teknik yang kuat ini dapat digabungkan untuk membuat pengujian yang lebih canggih dan efektif. Anda dapat menggunakan parametrisasi untuk menguji skenario yang berbeda dengan konfigurasi mock yang berbeda.

            
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
              
            
          

Dalam contoh ini, fungsi test_get_user_data diparameterisasi dengan nilai user_id dan expected_data yang berbeda. Dekorator @patch melakukan mock pada fungsi requests.get. Pytest akan menjalankan fungsi tes dua kali, sekali untuk setiap set parameter, dengan mock yang dikonfigurasi untuk mengembalikan expected_data yang sesuai.

Praktik Terbaik Menggunakan Fixture Lanjutan

• Jaga Agar Fixture Tetap Fokus: Setiap fixture harus memiliki tujuan yang jelas dan spesifik.
• Gunakan Cakupan yang Sesuai: Pilih cakupan fixture yang sesuai (fungsi, modul, sesi) untuk mengoptimalkan penggunaan sumber daya.
• Dokumentasikan Fixture: Dokumentasikan dengan jelas tujuan dan penggunaan setiap fixture.
• Hindari Mocking Berlebihan: Hanya lakukan mock pada dependensi yang diperlukan untuk mengisolasi kode yang diuji.
• Tulis Asersi yang Jelas: Pastikan asersi Anda jelas dan spesifik, memverifikasi perilaku yang diharapkan dari kode yang diuji.
• Pertimbangkan Pengembangan Berbasis Tes (TDD): Tulis tes Anda sebelum menulis kode, menggunakan fixture dan mock untuk memandu proses pengembangan.

Kesimpulan

Teknik fixture lanjutan Pytest, termasuk pengujian berparameter dan integrasi mock, menyediakan alat yang kuat untuk menulis pengujian yang kuat, efisien, dan mudah dipelihara. Dengan menguasai teknik-teknik ini, Anda dapat secara signifikan meningkatkan kualitas kode Python Anda dan menyederhanakan alur kerja pengujian Anda. Ingatlah untuk fokus pada pembuatan fixture yang jelas dan terfokus, menggunakan cakupan yang sesuai, dan menulis asersi yang komprehensif. Dengan latihan, Anda akan dapat memanfaatkan potensi penuh dari sistem fixture Pytest untuk menciptakan strategi pengujian yang komprehensif dan efektif.