Cara Menggunakan Pytest untuk Pengujian Unit

Pengujian adalah topik besar dalam pengembangan perangkat lunak. Sebelum sebuah produk perangkat lunak sampai ke tangan pengguna akhir, kemungkinan besar produk tersebut telah melalui beberapa pengujian seperti pengujian integrasi, pengujian sistem, dan pengujian penerimaan. Gagasan di balik pengujian ketat seperti ini adalah memastikan perilaku aplikasi berjalan sesuai harapan dari sudut pandang pengguna akhir. Pendekatan pengujian ini dikenal sebagai behavior-driven development (BDD).   

Belakangan ini, minat terhadap test-driven development (TDD) meningkat pesat di kalangan pengembang. Mengulasnya secara mendalam mungkin terlalu kompleks untuk artikel ini, namun gagasan umumnya adalah proses tradisional pengembangan dan pengujian dibalik: Anda menulis pengujian unit terlebih dahulu, lalu mengimplementasikan perubahan kode hingga pengujian tersebut lulus. 

Dalam artikel ini, kita akan berfokus pada pengujian unit dan, secara khusus, cara melakukannya menggunakan kerangka kerja pengujian Python populer bernama Pytest. 

Apa itu pengujian unit?

Pengujian unit adalah bentuk pengujian otomatis—artinya rencana pengujian dijalankan oleh skrip, bukan secara manual oleh manusia. Ini berfungsi sebagai tingkat pertama pengujian perangkat lunak dan biasanya ditulis dalam bentuk fungsi yang memvalidasi perilaku berbagai fungsionalitas dalam sebuah program perangkat lunak. 

Tingkat pengujian perangkat lunak

Gagasan di balik pengujian ini adalah memungkinkan pengembang mengisolasi unit kode terkecil yang masuk akal secara logis dan menguji apakah unit tersebut berperilaku sesuai harapan. Dengan kata lain, pengujian unit memvalidasi bahwa satu komponen program perangkat lunak bekerja sebagaimana dimaksud oleh pengembang. 

Idealnya, pengujian ini seharusnya cukup kecil—semakin kecil, semakin baik. Salah satu alasan membuat pengujian yang lebih kecil adalah efisiensi yang lebih tinggi karena menguji unit yang lebih kecil memungkinkan kode pengujian dieksekusi jauh lebih cepat. Alasan lain untuk menguji komponen yang lebih kecil adalah memberikan wawasan lebih baik tentang bagaimana kode yang granular berperilaku saat digabungkan. 

Mengapa kita memerlukan pengujian unit? 

Alasan umum mengapa pengujian unit penting adalah pengembang harus memastikan kode yang mereka tulis memenuhi standar kualitas sebelum diizinkan masuk ke lingkungan produksi. Namun, ada beberapa faktor lain yang turut menjadikan pengujian unit perlu. Mari kita telusuri lebih dalam beberapa alasannya.

Melestarikan sumber daya 

Melaksanakan pengujian unit membantu pengembang menangkap bug kode pada tahap konstruksi perangkat lunak, sehingga mencegahnya melaju lebih dalam ke siklus pengembangan. Ini menghemat sumber daya karena pengembang tidak perlu membayar biaya perbaikan bug di tahap akhir—dan juga berarti pengguna akhir kecil kemungkinan harus berhadapan dengan kode yang bermasalah.  

Dokumentasi tambahan 

Alasan kuat lainnya untuk melakukan pengujian unit adalah pengujian tersebut berfungsi sebagai lapisan dokumentasi hidup tambahan untuk produk perangkat lunak Anda. Pengembang dapat merujuk pada pengujian unit untuk pemahaman holistik tentang keseluruhan sistem karena pengujian tersebut merinci bagaimana komponen yang lebih kecil seharusnya berperilaku. 

Suntikan kepercayaan diri

Sangat mudah membuat kesalahan kecil dalam kode saat menulis suatu fungsionalitas. Namun, sebagian besar pengembang akan sepakat bahwa jauh lebih baik mengidentifikasi titik rapuh di dalam basis kode sebelum ditempatkan di lingkungan produksi: pengujian unit memberi pengembang kesempatan ini. 

Patut dikatakan bahwa “kode yang tercakup pengujian unit dapat dianggap lebih andal daripada kode yang tidak.” Kerusakan di masa depan pada kode dapat ditemukan jauh lebih cepat dibandingkan kode tanpa cakupan pengujian, sehingga menghemat waktu dan biaya. Pengembang juga diuntungkan dengan dokumentasi ekstra sehingga mereka dapat memahami basis kode lebih cepat, dan ada tambahan kepercayaan diri karena mengetahui bahwa jika mereka membuat kesalahan dalam kode, itu akan tertangkap oleh pengujian unit, bukan oleh pengguna akhir. 

Kerangka kerja pengujian Python

Python berkembang pesat popularitasnya selama bertahun-tahun. Seiring pertumbuhan Python, jumlah kerangka kerja pengujian juga meningkat, menghasilkan banyak alat yang tersedia untuk membantu Anda menguji kode Python. Mengupas detail tiap alat di luar cakupan artikel ini, namun kita akan menyinggung beberapa kerangka kerja pengujian Python yang paling umum. 

unittest

Unittest adalah kerangka kerja bawaan Python untuk pengujian unit. Kerangka ini terinspirasi oleh kerangka pengujian unit bernama JUnit dari bahasa pemrograman Java. Karena hadir langsung bersama bahasa Python, tidak ada modul tambahan untuk diinstal, dan sebagian besar pengembang menggunakannya untuk mulai belajar tentang pengujian.  

Pytest

Pytest mungkin adalah kerangka kerja pengujian Python yang paling luas digunakan—artinya ia memiliki komunitas besar yang siap membantu saat Anda menemui kendala. Ini adalah kerangka kerja open-source yang memungkinkan pengembang menulis suite pengujian yang sederhana dan ringkas sambil mendukung pengujian unit, pengujian fungsional, dan pengujian API.

doctest

doctest memadukan dua komponen inti rekayasa perangkat lunak: dokumentasi dan pengujian. Fungsionalitas ini memastikan semua program perangkat lunak didokumentasikan dan diuji secara menyeluruh agar berjalan sebagaimana mestinya. doctest hadir bersama pustaka standar Python dan cukup mudah dipelajari. 

nose2

Nose2, penerus rejimen nose, pada dasarnya adalah unittest dengan plugin. Orang sering menyebut nose2 sebagai “unit test yang diperluas” atau “unit test dengan plugin” karena keterkaitannya yang erat dengan kerangka pengujian unit bawaan Python. Karena praktis merupakan ekstensi dari kerangka unittest, nose2 sangat mudah diadopsi bagi mereka yang sudah akrab dengan unittest.

Testify

Testify, kerangka Python untuk pengujian unit, integrasi, dan sistem, dikenal luas sebagai kerangka yang dirancang untuk menggantikan unittest dan nose. Kerangka ini dilengkapi plugin yang ekstensif dan kurva belajarnya cukup mulus jika Anda sudah familiar dengan unittest.

Hypothesis

Hypothesis memungkinkan pengembang membuat pengujian unit yang lebih mudah ditulis namun bertenaga saat dijalankan. Karena kerangka ini dibangun untuk mendukung proyek data science, ia membantu menemukan kasus tepi yang tidak begitu jelas saat Anda membuat pengujian dengan menghasilkan contoh input yang selaras dengan properti spesifik yang Anda definisikan.

Untuk tutorial kita, kita akan menggunakan pytest. Lihat bagian berikut untuk mengetahui mengapa Anda mungkin memilih Pytest dibanding yang lain yang telah kami cantumkan. 

Mengapa menggunakan Pytest? 

Di luar komunitas pendukungnya yang luas, pytest memiliki beberapa faktor yang menjadikannya salah satu alat terbaik untuk menjalankan suite pengujian otomatis Anda di Python. Filsafat dan fitur Pytest dirancang untuk membuat pengujian perangkat lunak menjadi pengalaman pengembang yang jauh lebih baik. Salah satu cara pembuat Pytest mencapai tujuan ini adalah dengan mengurangi secara signifikan jumlah kode yang diperlukan untuk melakukan tugas umum dan memungkinkan tugas tingkat lanjut dilakukan dengan perintah dan plugin yang ekstensif. 

Alasan lain untuk menggunakan Pytest antara lain sebagai berikut: 

Mudah dipelajari 

Pytest sangat mudah dipelajari: jika Anda memahami cara kerja keyword assert di Python, maka Anda sudah berada di jalur yang tepat untuk menguasai kerangka ini. Pengujian menggunakan pytest adalah fungsi Python dengan awalan “test_” atau akhiran “_test” pada nama fungsi—meski Anda bisa menggunakan kelas untuk mengelompokkan beberapa pengujian. Secara keseluruhan, kurva belajar pytest jauh lebih landai dibanding unittest karena Anda tidak perlu mempelajari konstruksi baru. 

Pemfilteran pengujian

Anda mungkin tidak ingin menjalankan semua pengujian setiap kali eksekusi—hal ini bisa terjadi seiring pertumbuhan suite pengujian Anda. Terkadang, Anda ingin mengisolasi beberapa pengujian pada fitur baru untuk mendapatkan umpan balik cepat saat Anda mengembangkan, lalu menjalankan keseluruhan suite setelah yakin semuanya berfungsi sesuai rencana. Pytest memiliki tiga cara untuk mengisolasi pengujian: 1) pemfilteran berbasis nama, yang memberi tahu pytest hanya menjalankan pengujian yang namanya cocok dengan pola yang diberikan 2) cakupan direktori, yang merupakan pengaturan default yang memberi tahu pytest untuk hanya menjalankan pengujian yang berada di atau di bawah direktori saat ini dan 3) kategorisasi pengujian yang memungkinkan Anda mendefinisikan kategori pengujian yang harus disertakan atau dikecualikan oleh pytest. 

Parameterisasi

Pytest memiliki decorator bawaan bernama parametrize yang memungkinkan parameterisasi argumen untuk suatu fungsi pengujian. Jadi, jika fungsi yang Anda uji memproses data atau melakukan transformasi generik, Anda tidak perlu menulis banyak pengujian serupa. Kita akan membahas lebih lanjut tentang parameterisasi nanti di artikel. 

Kita berhenti di sini, namun daftar alasan mengapa pytest adalah opsi alat yang hebat untuk suite pengujian otomatis Anda masih panjang. 

Pytest vs unittest

Terlepas dari semua alasan yang telah kita bahas di atas, orang mungkin masih memperdebatkan penggunaan pytest hanya karena ini adalah kerangka pihak ketiga—“apa gunanya memasang kerangka jika sudah ada yang bawaan?” Ini argumen yang bagus, tetapi untuk mengantisipasi perdebatan itu, kami akan memberi Anda beberapa hal untuk dipertimbangkan. 

Catatan: Jika Anda sudah mantap dengan pytest, lewati ke bagian berikutnya di mana kita mempelajari cara menggunakan kerangka tersebut. 

Lebih sedikit boilerplate

Unittest mengharuskan pengembang membuat kelas yang diturunkan dari modul TestCase lalu mendefinisikan kasus uji sebagai metode di dalam kelas. 

"""
An example test case with unittest.
See: https://docs.python.org/3/library/unittest.html
"""
import unittest

class TestStringMethods(unittest.TestCase):

    def test_upper(self):
        self.assertEqual('foo'.upper(), 'FOO')

    def test_isupper(self):
        self.assertTrue('FOO'.isupper())
        self.assertFalse('Foo'.isupper())

    def test_split(self):
        s = 'hello world'
        self.assertEqual(s.split(), ['hello', 'world'])
        # check that s.split fails when the separator is not a string
        with self.assertRaises(TypeError):
            s.split(2)

Pytest, di sisi lain, hanya mengharuskan Anda mendefinisikan fungsi dengan awalan “test_” dan menggunakan kondisi assert di dalamnya. 

"""
An example test case with pytest.
See: https://docs.pytest.org/en/6.2.x/index.html
"""
# content of test_sample.py
def inc(x):
    return x + 1


def test_answer():
    assert inc(3) == 5

Perhatikan perbedaan jumlah kode yang dibutuhkan; unittest memiliki banyak kode boilerplate yang berfungsi sebagai persyaratan minimum untuk pengujian apa pun yang ingin Anda lakukan. Ini berarti sangat mungkin Anda akan berakhir menulis kode yang sama berulang kali. Pytest, sebaliknya, memiliki fitur bawaan yang kaya yang menyederhanakan alur kerja ini dengan mengurangi jumlah kode yang diperlukan untuk menulis kasus uji. 

Keluaran

Keluaran yang diberikan oleh masing-masing kerangka sangat berbeda. Berikut contoh eksekusi pytest: 

"""
See: https://docs.pytest.org/en/6.2.x/index.html
"""
$ pytest
=========================== test session starts ============================
platform linux -- Python 3.x.y, pytest-6.x.y, py-1.x.y, pluggy-1.x.y
cachedir: $PYTHON_PREFIX/.pytest_cache
rootdir: $REGENDOC_TMPDIR
collected 1 item

test_sample.py F                                                     [100%]

================================= FAILURES =================================
_______________________________ test_answer ________________________________

    def test_answer():
>       assert inc(3) == 5
E       assert 4 == 5
E        +  where 4 = inc(3)

test_sample.py:6: AssertionError
========================= short test summary info ==========================
FAILED test_sample.py::test_answer - assert 4 == 5
============================ 1 failed in 0.12s =============================

Kasus uji di atas gagal, tetapi perhatikan betapa detailnya rincian kegagalannya. Ini memudahkan pengembang mengidentifikasi lokasi bug dalam kode, yang sangat membantu saat debug. Sebagai bonus, ada juga laporan status keseluruhan untuk suite pengujian, yang memberi tahu kita jumlah pengujian yang gagal dan berapa lama waktu yang dibutuhkan. 

Mari kita lihat contoh kasus uji yang gagal dengan unittest.

import unittest

def square(n):
    return n*n

def cube(n):
    return n*n*n

class TestCase(unittest.TestCase):
    def test_square(self):
        self.asserEquals(square(4), 16)

    def test_cube(self):
        self.assertEquals(cube(4), 16)

Saat kita menjalankan skrip, kita mendapatkan keluaran berikut: 

---------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (errors=1)

Keluaran di atas memberi tahu kita bahwa dua pengujian dijalankan dalam 0,001 dtk dan satu gagal, tetapi tidak banyak informasi lain. Pada akhirnya, pytest memberikan umpan balik yang jauh lebih informatif, yang sangat berguna saat waktunya melakukan debug. 

Secara keseluruhan, pytest dan unittest sama-sama alat yang bagus untuk pengujian otomatis di Python. Banyak pengembang Python mungkin lebih condong ke pytest dibanding rekan-rekannya karena sifatnya yang ringkas dan efisien. Pytest juga sangat mudah diadopsi dan memiliki banyak fitur yang bisa Anda gunakan untuk membangun suite pengujian yang efektif. 

Sekarang masuk ke bagian utama artikel ini. Kita telah membahas apa itu pengujian unit dan mengapa pytest adalah alat yang hebat untuk pengujian otomatis di Python. Sekarang mari kita lihat cara menggunakan alat tersebut. 

Tutorial Pytest

Mari kita lihat bagaimana kerangka kerja pengujian Python yang kita bahas ini bekerja. 

Langkah pertama adalah memasang paketnya, yang dapat dilakukan dengan perintah pip sederhana. 

Catatan: Pencipta pytest menyarankan Anda menggunakan venv untuk pengembangan dan pip untuk memasang aplikasi, dependensi, dan pytest itu sendiri. 

pip install -U pytest

Selanjutnya, periksa apakah kerangka telah terpasang menggunakan perintah berikut: 

>>>> pytest --version

pytest 7.1.2

Semuanya sudah terpasang. Kini Anda siap mulai menjalankan beberapa pengujian. 

Membuat pengujian sederhana

Membuat pengujian itu mudah dengan Pytest. Untuk mendemonstrasikan fungsionalitas ini, kami membuat skrip bernama calcualte_age.py. Skrip ini hanya memiliki satu fungsi, get_age, yang bertanggung jawab menghitung usia pengguna berdasarkan tanggal lahirnya. 

import datetime

def get_age(yyyy:int, mm:int, dd:int) -> int:
    dob = datetime.date(yyyy, mm, dd)
    today = datetime.date.today()
    age = round((today - dob).days / 365.25)
    return age

Pytest akan mengeksekusi semua berkas python yang namanya diawali test_ atau diakhiri _test. Lebih spesifik, pytest mengikuti konvensi berikut untuk penemuan pengujian [sumber: dokumentasi]: 

• Jika tidak ada argumen yang ditentukan, pengumpulan pytest akan dimulai di testpaths jika dikonfigurasi: testpaths adalah daftar direktori yang akan dicari pytest saat tidak ada direktori, berkas, atau id uji spesifik yang diberikan. 
• Pytest kemudian akan menelusuri direktori kecuali Anda menyuruhnya untuk tidak melakukannya dengan menyetel norecursedirs; Pytest mencari berkas yang diawali dengan test_*.py atau diakhiri *_test.py
• Di dalam berkas tersebut, pytest akan mengumpulkan item uji dalam urutan berikut:
• Fungsi atau metode uji berawalan di luar kelas
• Fungsi atau metode uji berawalan di dalam kelas berawalan Test yang tidak memiliki metode __init__. 

Kami tidak menentukan argumen apa pun, tetapi kami membuat skrip lain di direktori yang sama bernama test_calculate_age.py: jadi, ketika direktori ditelusuri, pengujian akan ditemukan.  Dalam skrip ini, kami memiliki satu pengujian, test_get_age, untuk memvalidasi bahwa fungsi kami bekerja sebagaimana mestinya. 

Catatan: Anda boleh menaruh pengujian ke dalam direktori terpisah di luar aplikasi Anda, yang merupakan ide bagus jika Anda memiliki banyak pengujian fungsional atau ingin memisahkan kode pengujian dan kode aplikasi karena alasan lain. 

from calculate_age import get_age

def test_get_age():
    # Given.
    yyyy, mm, dd = map(int, "1996/07/11".split(""))   
    # When.
    age = get_age(yyyy, mm, dd)
    # Then.
    assert age == 26 

Untuk mengeksekusi pengujian, jalankan perintah berikut dari command prompt: 

py -m pytest 

Keluaran dari menjalankan pytest yang berhasil.

Dan itu saja. 

Tetapi bagaimana jika kita perlu menyediakan beberapa data agar pengujian kita lulus? Sambutlah fixture pytest. 

Fixture Pytest 

Fitur fixture Pytest yang tak ternilai memungkinkan pengembang memasok data ke dalam pengujian. Pada dasarnya ini adalah fungsi yang berjalan sebelum setiap fungsi uji untuk mengelola status pengujian kita. Misalnya, jika kita memiliki beberapa pengujian yang semuanya menggunakan data yang sama, maka kita dapat menggunakan fixture untuk mengambil data berulang tersebut melalui satu fungsi. 

import pytest
from sklearn.model_selection import train_test_split
from fraud_detection_model.config.core import config
from fraud_detection_model.processing.data_manager import (

load_datasets, 

load_interim_data

) 


@pytest.fixture(scope="session")
def pipeline_inputs():
    # import the training dataset
    dataset = load_datasets(transaction=config.app_config.train_transaction, identity=config.app_config.train_identity, )
    # divide train and test
    X_train, X_test, y_train, y_test = train_test_split(

dataset[config.model_config.all_features], dataset[config.model_config.target],
test_size=config.model_config.test_size,
stratify=dataset[config.model_config.target],
random_state=config.model_config.random_state)
    return X_train, X_test, y_train, y_test

Pada kode di atas, kami membuat fixture menggunakan decorator pytest.fixture. Perhatikan cakupan (scope) diatur ke "session" untuk memberi tahu pytest bahwa kita ingin fixture dihancurkan pada akhir sesi pengujian.

Catatan: fixture kami disimpan di conftest.py.

Kode menggunakan fungsi yang kami impor dari modul lain untuk memuat dua berkas csv ke memori dan menggabungkannya menjadi satu dataset. Setelah itu, dataset dipecah menjadi set pelatihan dan pengujian dan dikembalikan dari fungsi. 

Untuk menggunakan fixture ini dalam pengujian, kita harus meneruskannya sebagai parameter ke fungsi uji kita. Dalam contoh ini, gunakan fixture kita pada skrip uji test_pipeline.py sebagai berikut: 

import pandas as pd
from pandas.api.types import is_categorical_dtype, is_object_dtype
from fraud_detection_model import pipeline
from fraud_detection_model.config.core import configfrom fraud_detection_model.processing.validation import validate_inputs 


def test_pipeline_most_frequent_imputer(pipeline_inputs):
    # Given
    X_train, _, _, _ = pipeline_inputs assert all( x in X_train.loc[:, X_train.isnull().any()].columns for x in config.model_config.impute_most_freq_cols )
    # When
    X_transformed = pipeline.fraud_detection_pipe[:1].fit_transform(X_train[:50])
    # Then
    assert all( x not in X_transformed.loc[:, X_transformed.isnull().any()].columns for x in config.model_config.impute_most_freq_cols )
def test_pipeline_aggregate_categorical(pipeline_inputs):
    # Given
    X_train, _, _, _ = pipeline_inputs  

    assert X_train["R_emaildomain"].nunique() == 60
    # When
    X_transformed = pipeline.fraud_detection_pipe[:2].fit_transform(X_train[:50])
    # Then
    assert X_transformed["R_emaildomain"].nunique() == 2

Jangan terlalu khawatir tentang apa yang dilakukan kode tersebut. Hal terpenting yang ingin kami soroti adalah bagaimana kami secara signifikan mengurangi kebutuhan menulis kode redundan karena kami membuat fixture yang kami teruskan sebagai parameter untuk menarik data ke dalam pengujian. 

Namun, ada situasi di mana fixture bisa berlebihan. Misalnya, jika data yang ditarik ke dalam pengujian Anda harus diproses lagi di setiap kasus uji—ini praktis setara dengan memenuhi kode Anda dengan banyak objek biasa. Dengan semua itu, fixture kemungkinan akan memainkan peran penting dalam suite pengujian Anda, tetapi membedakan kapan harus menggunakannya atau menghindarinya membutuhkan latihan dan banyak pertimbangan.  

Pytest parametrize

Fixture sangat berguna saat Anda memiliki beberapa pengujian dengan input yang sama. Bagaimana jika Anda ingin menguji satu fungsi dengan sedikit variasi pada inputnya? Salah satu solusinya adalah menulis beberapa pengujian berbeda dengan berbagai kasus. 

def test_eval_addition():
    assert eval("2 + 2") == 4

def test_eval_subtraction():
    assert eval("2 - 2") == 0

def test_eval_multiplication():
    assert eval("2 * 2") == 4

def test_eval_division():
    assert eval("2 / 2") == 1.0

Meski solusi ini pasti bekerja, ini bukan yang paling efisien: sebagai permulaan, ada banyak kode boilerplate. Solusi yang lebih baik adalah menggunakan decorator pytest.mark.parametrize() untuk memungkinkan parameterisasi argumen bagi suatu fungsi pengujian. Ini akan memungkinkan kita mendefinisikan satu definisi uji, lalu pytest akan menguji berbagai parameter yang kita tentukan untuk kita. 

Berikut cara kita menulis ulang kode di atas jika menggunakan parameterisasi: 

import pytest

@pytest.mark.parametrize("test_input, expected_output", [("2+2", 4), ("2-2", 0), ("2*2", 4), ("2/2", 1.0)])
def test_eval(test_input, expected_output):
    assert eval(test_input) == expected_output

Decorator @parametrize mendefinisikan empat input uji berbeda dan nilai yang diharapkan untuk dijalankan oleh fungsi test_eval—artinya fungsi akan berjalan empat kali menggunakan masing-masing secara bergiliran. 

Keluaran dari pytest untuk pengujian parametrize

Dalam artikel ini, kita membahas topik-topik berikut: 

• apa itu pengujian unit
• mengapa kita memerlukan pengujian unit
• berbagai kerangka kerja pengujian di python
• Mengapa pytest sangat berguna 
• cara menggunakan pytest dan dua fitur kuncinya (fixture & parameterisasi)

Sekarang Anda sudah cukup tahu untuk mulai menulis pengujian sendiri menggunakan kerangka pytest. Kami sangat mendorong Anda untuk melakukannya, agar semua yang Anda pelajari di artikel ini melekat. Anda juga sebaiknya melihat kursus kami tentang pengujian unit untuk data science di python untuk penjelasan lebih detail beserta contohnya.