Tutorial Pengujian Unit di Python

Pengujian unit adalah metode pengujian perangkat lunak di mana unit-unit individual dari kode sumber dikenakan berbagai pengujian untuk menentukan apakah unit tersebut layak digunakan. Ini menentukan dan memastikan kualitas kode Anda.

Umumnya, ketika proses pengembangan selesai, pengembang menuliskan kriteria atau hasil yang diketahui berpotensi praktis dan berguna ke dalam skrip uji untuk memverifikasi kebenaran unit tertentu. Selama eksekusi test case, berbagai kerangka kerja mencatat pengujian yang gagal memenuhi kriteria apa pun dan melaporkannya dalam ringkasan.

Para pengembang diharapkan menulis skrip uji otomatis, yang memastikan setiap bagian atau unit memenuhi desainnya dan berperilaku sebagaimana mestinya.

Pengujian Unit di Python

Meski menulis pengujian manual untuk kode Anda jelas merupakan tugas yang melelahkan dan memakan waktu, kerangka kerja pengujian unit bawaan Python membuat hidup jauh lebih mudah.

Kerangka kerja pengujian unit di Python disebut unittest yang sudah terpaket dengan Python.

Pengujian unit membuat kode Anda siap menghadapi masa depan karena Anda mengantisipasi kasus-kasus di mana kode Anda berpotensi gagal atau menghasilkan bug. Meski Anda tidak bisa memprediksi semua kasus, Anda tetap dapat menangani sebagian besar di antaranya.

Sebuah unit dapat dikelompokkan ke dalam berbagai kategori:

• Satu modul utuh,
• Satu fungsi individual,
• Satu antarmuka lengkap seperti kelas atau metode.

Cara terbaik untuk menulis pengujian unit untuk kode Anda adalah mulai dari unit terkecil yang dapat diuji yang mungkin dimiliki kode Anda, lalu lanjutkan ke unit lain dan lihat bagaimana unit terkecil itu berinteraksi dengan unit lain. Dengan cara ini Anda dapat membangun pengujian unit yang komprehensif untuk aplikasi Anda.

Kerangka kerja pengujian unit Python terinspirasi oleh JUnit di Java dan memiliki fitur serupa dengan kerangka kerja pengujian unit utama di bahasa lain. Kerangka kerja pengujian unit Python menawarkan berbagai fitur, termasuk:

• Otomatisasi pengujian
• Berbagi kode setup dan shutdown untuk pengujian
• Mengelompokkan pengujian ke dalam koleksi
• Kemandirian pengujian dari kerangka pelaporan

Sekarang mari ambil contoh dan pahami mengapa Anda perlu melakukan pengujian unit pada kode Anda.

Memulai dengan Python unittest

Di bawah ini, kami merinci langkah-langkah yang Anda perlukan untuk menggunakan kerangka kerja unittest di Python

Membuat fungsi kubus

Mari tulis kode untuk menghitung volume kubus di Python

def cuboid_volume(l):
    return (l*l*l)
length = [2,1.1, -2.5, 2j, 'two']
for i in range(len(length)):
    print ("The volume of cuboid:",cuboid_volume(length[i]))

The volume of cuboid: 8
The volume of cuboid: 1.3310000000000004
The volume of cuboid: -15.625
The volume of cuboid: (-0-8j)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-67e1c37a435f> in <module>
      1 for i in range(len(length)):
----> 2     print ("The volume of cuboid:",cuboid_volume(length[i]))
<ipython-input-2-f50464fd88da> in cuboid_volume(l)
      1 def cuboid_volume(l):
----> 2     return (l*l*l)
TypeError: can't multiply sequence by non-int of type 'str'

Analisis hasil

Keluaran di atas seharusnya memberi Anda intuisi tentang pentingnya memiliki pengujian unit untuk kode Anda. Ada tiga hal yang jelas tidak benar dalam kode di atas:

• Pertama, volume balok bernilai negatif,
• Kedua, volume balok berupa bilangan kompleks,
• Terakhir, kode menghasilkan TypeError karena Anda tidak dapat mengalikan string, yang bukan bertipe int.

Masalah ketiga untungnya menghasilkan error sementara yang pertama dan kedua tetap berhasil meskipun volume balok tidak mungkin bernilai negatif maupun bilangan kompleks.

Pengujian unit biasanya ditulis sebagai kode terpisah di berkas berbeda, dan ada berbagai konvensi penamaan yang bisa Anda ikuti. Anda bisa menamai berkas pengujian unit sebagai nama kode/unit + test dipisahkan dengan garis bawah atau test + nama kode/unit dipisahkan dengan garis bawah.

Sebagai contoh, misalkan nama berkas kode di atas adalah cuboid_volume.py, maka nama kode pengujian unit Anda bisa cuboid_volume_test.py

Tanpa berlama-lama, mari tulis pengujian unit untuk kode di atas.

Menggunakan assertAlmostEqual

Pertama, mari buat berkas python dengan nama volume_cuboid.py, yang berisi kode untuk menghitung volume, dan satu lagi bernama test_volume_cuboid.py, yang berisi kode pengujian unit.

import unittest

Kelas TestCuboid mewarisi modul unittest, dan di kelas ini Anda akan mendefinisikan berbagai metode yang ingin Anda periksa dalam pengujian unit terhadap fungsi cuboid_volume.

Fungsi pertama yang akan Anda definisikan adalah test_volume, yang akan memeriksa apakah keluaran dari cuboid_volume sama dengan yang Anda harapkan. Untuk mencapainya, Anda akan menggunakan metode assertAlmostEqual.

Uji 1

class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),0)
        self.assertAlmostEqual(cuboid_volume(5.5),166.375)

Mari jalankan skrip di atas. Anda akan menjalankan modul unittest sebagai skrip dengan menyertakan -m saat menjalankannya.

!python -m unittest test_volume_cuboid.py

Keluaran:

.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK

Mantap! Jadi kode pengujian unit pertama Anda berhasil berjalan.

Uji berhasil dijalankan dan mengembalikan OK, yang berarti fungsi cuboid_volume bekerja seperti yang Anda harapkan.

Uji 2

Mari lihat apa yang terjadi ketika salah satu metode assertAlmostEqual gagal.

Perhatikan bahwa pernyataan assert terakhir telah diubah.

!python -m unittest test_volume_cuboid.py

Keluaran:

F
======================================================================
FAIL: test_volume (test_volume_cuboid.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "C:\Users\hda3kor\Documents\Unit_Testing_Python\test_volume_cuboid.py", line 15, in test_volume
    self.assertAlmostEqual(cuboid_volume(5.5),0)
AssertionError: 166.375 != 0 within 7 places (166.375 difference)
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)

Dari keluaran di atas, Anda dapat melihat bahwa pernyataan assert terakhir menghasilkan AssertionError, sehingga uji unit gagal. Modul uji unit Python menampilkan alasan kegagalan, beserta jumlah kegagalan pada kode Anda.

Menggunakan assertRaises

Sekarang mari jelajahi metode assert lain, yaitu assertRaises, yang akan membantu Anda mengetahui apakah fungsi cuboid_volume menangani nilai masukan dengan benar.

Misalkan Anda ingin menguji apakah fungsi cuboid_volume menangani kelas atau tipe masukan, misalnya jika Anda memasukkan sebuah string sebagai input, akankah input tersebut ditangani sebagai pengecualian atau dengan kondisi if karena panjang balok tidak pernah bisa berupa string.

!python -m unittest test_volume_cuboid.py

Keluaran:

F.
======================================================================
FAIL: test_input_value (test_volume_cuboid.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "C:\Users\hda3kor\Documents\Unit_Testing_Python\test_volume_cuboid.py", line 17, in test_input_value
    self.assertRaises(TypeError, cuboid_volume, True)
AssertionError: TypeError not raised by cuboid_volume
----------------------------------------------------------------------
Ran 2 tests in 0.001s
FAILED (failures=1)

Bagus! Jadi dari keluaran di atas, jelas bahwa kode Anda volume_cuboid.py belum menangani masukan yang diberikan dengan benar.

Memodifikasi fungsi kubus

Mari tambahkan sebuah kondisi di volume_cuboid.py untuk memeriksa apakah input atau panjang balok berupa boolean atau string dan naikkan error.

!python -m unittest test_volume_cuboid.py

Keluaran:

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s
OK

Menjalankan Skrip Pengujian Python di Jupyter Lab

Sekarang mari jalankan skrip pengujian di dalam Jupyter Lab. Untuk mencapainya, Anda terlebih dahulu mendefinisikan skrip pengujian di Jupyter Lab, seperti ditunjukkan di bawah.

# -*- coding: utf-8 -*-
"""
Created on Sat Apr 25 20:16:58 2020
@author: Aditya
"""
from volume_cuboid import *
import unittest
class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),1)
    def test_input_value(self):
        self.assertRaises(TypeError, cuboid_volume, True)

Lalu, Anda akan menggunakan metode unittest.main() untuk menjalankan skrip pengujian. Anda dapat meneruskan beberapa argumen ke metode di bawah ini, salah satunya adalah tingkat verbositas.

Mari bereksperimen dengan tingkat verbositas yang berbeda dan lihat bagaimana hal itu mengubah deskripsi keluaran.

Verbositas 0

unittest.main(argv=[''],verbosity=0, exit=False)
Output:
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
<unittest.main.TestProgram at 0x1de02774348>

Verbositas 1

unittest.main(argv=[''],verbosity=1, exit=False)
Output:
..
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OK
<unittest.main.TestProgram at 0x1de027a1cc8>

Verbositas 2

unittest.main(argv=[''],verbosity=2, exit=False)
Output:
test_input_value (__main__.TestCuboid) ... ok
test_volume (__main__.TestCuboid) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OK
<unittest.main.TestProgram at 0x1de027a8308>

Memvisualisasikan AssertionError

Terakhir, mari ubah assertAlmostEqual terakhir di metode test_volume dan analisis bagaimana verbositas tingkat 2 akan menampilkan kegagalan metode.

# -*- coding: utf-8 -*-
"""
Created on Sat Apr 25 20:16:58 2020
@author: Aditya
"""
from volume_cuboid import *
import unittest
class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),1)
    def test_input_value(self):
        self.assertRaises(TypeError, cuboid_volume, True)
unittest.main(argv=[''],verbosity=2, exit=False)

Keluaran:

test_input_value (__main__.TestCuboid) ... ok
test_volume (__main__.TestCuboid) ... FAIL
======================================================================
FAIL: test_volume (__main__.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "<ipython-input-28-46ad33b909ee>", line 14, in test_volume
    self.assertAlmostEqual(cuboid_volume(0),1)
AssertionError: 0 != 1 within 7 places (1 difference)
----------------------------------------------------------------------
Ran 2 tests in 0.003s
FAILED (failures=1)
<unittest.main.TestProgram at 0x1de027b5448>

Ringkasan

Dari keluaran di atas, dapat diambil kesimpulan berikut:

• Tingkat verbositas 0 hanya menampilkan berapa banyak uji yang dijalankan, yaitu 2 uji beserta waktu yang diperlukan untuk menjalankannya,
• Tingkat verbositas 1 menambahkan dua titik .. yang menandakan dua uji dieksekusi,
• Tingkat verbositas 2 menampilkan nama metode terperinci yang dijalankan beserta statusnya OK atau FAIL.

Metode Assert unittest yang Tersedia

Ada banyak metode assert di modul pengujian unit Python yang dapat dimanfaatkan untuk tujuan pengujian Anda.

Metode assert yang umum digunakan

Sumber: dokumentasi unittest

 Pemeriksaan produksi

Dengan menggunakan metode berikut, Anda dapat memeriksa terjadinya pengecualian, peringatan, dan pesan log.

Sumber: dokumentasi unittest

 Metode khusus tugas

Sumber: dokumentasi unittest

Untuk mengetahui lebih detail tentang metode assert, lihat dokumentasi resmi Python.

Anda juga dapat mempelajarinya dengan bantuan modul Pydoc, yang mirip dengan fungsi help di Python. Demonstrasi bagaimana Anda dapat menggunakan modul Pydoc untuk membaca dokumentasi metode assertCountEqual ditunjukkan di bawah ini.

!python -m pydoc unittest.TestCase.assertCountEqual

Keluaran:

Help on function assertCountEqual in unittest.TestCase:
unittest.TestCase.assertCountEqual = assertCountEqual(self, first, second, msg=None)
    An unordered sequence comparison asserting that the same elements,
    regardless of order.  If the same element occurs more than once,
    it verifies that the elements occur the same number of times.
        self.assertEqual(Counter(list(first)),
                         Counter(list(second)))
     Example:
        - [0, 1, 1] and [1, 0, 1] compare equal.
        - [0, 0, 1] and [0, 1] compare unequal.

Kesimpulan

Tutorial ini merupakan pengenalan dasar tentang pengujian unit di Python dan pentingnya bagi pengembang. Latihan yang baik bagi Anda adalah menulis modul pengujian unit untuk salah satu proyek Anda sebelumnya. Ini akan memberi Anda pengalaman langsung yang baik dalam menulis pengujian unit. Juga, cobalah mengeksplorasi metode Assert lainnya. Anda dapat membaca lebih lanjut tentang pengujian unit dengan tutorial Pytest kami.

Jika Anda baru memulai dengan Python dan ingin belajar lebih jauh, ikuti Introduction to Data Science in Python kami.