Apa itu mock di unittest

Ketika menulis pengujian menggunakan pustaka unittest Python, Anda dapat menggunakan mock untuk menulis pengujian yang bebas ketergantungan. Mock memungkinkan Anda untuk mensimulasikan interaksi dengan resource eksternal dan modul lain, sehingga meningkatkan keandalan dan kecepatan pengujian Anda.

Berikut ini adalah langkah-langkah dasar untuk menulis pengujian menggunakan mocks dengan pustaka unittest Python.

1. Impor modul unittest.mock

from unittest.mock import MagicMock, Mock, patch

2. Mengimpor modul, fungsi, dan kelas yang akan diuji

from my_module import my_function

3. Membuat kelas pengujian dan menentukan metode pengujian

import unittest

class TestMyFunction(unittest.TestCase):
    def test_my_function(self):
        # write test code here

4. Membuat objek tiruan dalam metode pengujian untuk menggantikan fungsi dan metode yang sedang diuji

import unittest
from unittest.mock import MagicMock

class TestMyFunction(unittest.TestCase):
    def test_my_function(self):
        mock_obj = MagicMock(return_value=42)
        with patch('my_module.my_function', mock_obj):
            result = my_function()
        self.assertEqual(result, 42)

Pada contoh ini, ketika my_module.my_function() dipanggil, mock_obj dipanggil dan nilai yang ditentukan pada return_value dikembalikan. Pengujian menunjukkan bahwa nilai yang dikembalikan dari my_function() adalah 42.

Mocks dan patch

Mocks dalam unittest Python adalah objek yang digunakan sebagai pengganti objek nyata selama pengujian, memungkinkan Anda untuk mensimulasikan perilaku yang Anda perlukan selama pengujian, meskipun Anda mengandalkan objek lain dalam kode Anda. Hal ini menghilangkan kebutuhan untuk mengakses resource eksternal seperti database atau jaringan nyata selama pengujian. menggunakan objek tiruan meningkatkan kecepatan pengujian dan meningkatkan keandalan pengujian.

Patch unittest Python adalah fitur yang memungkinkan Anda menggunakan Mock untuk memodifikasi kode yang sedang dieksekusi selama pengujian. Patch digunakan untuk menggantikan objek nyata selama pengujian untuk mensimulasikan perilaku yang diperlukan. Patch dapat digunakan selama pengujian tunggal atau digunakan bersama oleh semua pengujian dengan mengaturnya dalam metode setup. Sebagai contoh, ketika menguji metode yang memanggil API eksternal, waktu eksekusi pengujian akan meningkat jika API benar-benar dipanggil, dan pengujian mungkin gagal jika API offline. Oleh karena itu, patch dapat digunakan untuk meniru pemanggilan API dan mensimulasikan data yang diambil dari API selama pengujian. Hal ini meningkatkan kecepatan pengujian dan memastikan bahwa pengujian tidak akan gagal meskipun API sedang offline.

Kelas dan fungsi utama dalam unittest.mock

Paket unittest.mock berisi kelas dan fungsi utama berikut ini.

• Mock: Objek tiruan yang digunakan untuk menggantikan objek lain
• MagicMock: Subkelas dari kelas Mock dengan metode sulap
• patch: Pengelola konteks untuk mengganti objek yang digunakan dalam pengujian

Dengan menggunakan kelas dan fungsi ini, Anda dapat dengan mudah meniru objek eksternal selama pengujian. Misalnya, jika Anda memiliki fungsi yang digunakan untuk membaca file, Anda dapat menggunakan objek file tiruan untuk menguji apa yang harus dilakukan jika file tersebut tidak ada.

Mock

Modul unittest Python memiliki kelas Mock untuk membuat objek tiruan untuk pengujian unit. Kelas Mock adalah objek yang meniru satu atribut atau metode. Anda dapat mengatur nilai balik sembarang untuk atribut atau metode.

from unittest.mock import Mock

# create mock object
mock_obj = Mock()

# set attribute
mock_obj.attr = 'value'

# assert attribute
assert mock_obj.attr == 'value'

# set method
mock_obj.method.return_value = 42

# call method
result = mock_obj.method()

# verify result
assert result == 42

MagicMock

MagicMock adalah sebuah kelas dalam modul unittest.mock Python dan subkelas dari kelas Mock. MagicMock memiliki semua fitur kelas Mock, ditambah kemampuan untuk menghasilkan atribut dan metode secara otomatis.

Menggunakan MagicMock akan menghemat waktu Anda ketika menulis kode pengujian, karena pemanggilan atribut sebuah objek akan secara otomatis menghasilkan objek MagicMock yang lain. Selain itu, nilai yang ditetapkan pada atribut disimpan dan dapat diakses nanti.

Sebagai contoh, Anda dapat membuat objek MagicMock seperti ini.

from unittest.mock import MagicMock

magic_mock_obj = MagicMock()

Atribut apa pun dapat ditetapkan untuk objek ini.

magic_mock_obj.some_attribute = 10

Dalam kasus ini, atribut some_attribute diatur ke nilai 10. Anda juga dapat membuat pernyataan pada atribut.

assert magic_mock_obj.some_attribute == 10

MagicMock secara otomatis membuat objek MagicMock pada akses atribut. Sebagai contoh, jika Anda memiliki kode magic_mock_obj.some_object.some_method(), meskipun atribut some_object tidak ada, tidak ada kesalahan yang akan terjadi dan objek MagicMock akan dibuat secara otomatis. Hal ini akan menghemat waktu saat menulis kode pengujian.

Objek MagicMock juga memiliki kemampuan untuk melacak informasi tentang pemanggilan, seperti halnya objek Mock. Sebagai contoh, Anda dapat melacak berapa kali objek MagicMock dipanggil, argumennya, dll.

Perbedaan dari Mock

Dalam Python unittest, Mock dan MagicMock merupakan alat untuk membuat objek tiruan, namun ada perbedaan yang tidak kentara.

Objek tiruan digunakan untuk meniru fungsi dan kelas yang dapat dipanggil; Objek tiruan dapat membuat pernyataan pada objek tiruan dan memvalidasi argumen yang dilewatkan pada waktu pemanggilan.

MagicMock, di sisi lain, adalah subkelas dari objek Mock dan juga dapat meniru akses ke atribut. Secara khusus, atribut dapat diatur dan objek Mock dapat dibuat secara otomatis ketika sebuah metode dipanggil.

Dengan kata lain, objek Mock hanya dapat meniru objek yang dapat dipanggil, sedangkan MagicMock dapat meniru tidak hanya objek yang dapat dipanggil tetapi juga atribut.

Sebagai contoh, dengan kelas berikut, objek Mock hanya dapat meniru metode get_name, sedangkan MagicMock dapat meniru tidak hanya metode get_name, tetapi juga atribut name.

class Person:
    def __init__(self, name):
        self.name = name

    def get_name(self):
        return self.name

Oleh karena itu, jika Anda perlu meniru atribut, menggunakan MagicMock adalah tepat.

patch

Modul unittest.mock memiliki fungsi patch() yang digunakan untuk menambal modul, kelas, objek, atau fungsi. Fungsi patch() mengembalikan objek yang ditambal dan hanya dapat digunakan dalam konteks dimana tambalan diterapkan.

Fungsi patch() juga dapat digunakan sebagai dekorator. Dalam hal ini, objek yang ditambal diberikan sebagai argumen ke fungsi yang dihias.

Berikut ini adalah contoh fungsi patch(). Fungsi ini meniru fungsi get() dalam modul requests sehingga tidak ada permintaan HTTP yang dibuat.

from unittest.mock import patch
import requests

@patch('requests.get')
def test_requests(mock_get):
    mock_response = 'Mock Response'
    mock_get.return_value.text = mock_response

    response = requests.get('https://www.example.com')
    assert response.text == mock_response
    assert mock_get.called

Dalam contoh ini, kita menambal requests.get. Fungsi patch() mengoper nama atau jalur objek yang akan ditambal sebagai argumen. Dalam contoh ini, jalur requests.get dalam format string digunakan untuk menambal requests.get.

Di dalam fungsi test_requests(), objek tiruan mock_get dibuat dan atribut text disetel ke mock_response. Selanjutnya, kita mengatur mock_get ke return_value. Hal ini akan menyebabkan mock_response dikembalikan saat fungsi requests.get() dipanggil.

Terakhir, requests.get() dipanggil untuk memverifikasi teks respons dan bahwa atribut called dari objek tiruan adalah True.

Atribut dan metode objek tiruan

Objek tiruan memiliki berbagai atribut dan metode. Berikut ini adalah atribut dan metode utama yang dimiliki objek Mock.

return_value

Atribut return_value pada objek Mock digunakan untuk mengatur dan mengambil nilai yang dikembalikan ketika mock dipanggil.

Sebagai contoh, misalkan Anda memiliki mock berikut ini.

from unittest.mock import Mock

mock = Mock()

Gunakan atribut return_value untuk mengatur nilai yang dikembalikan ketika mock ini dipanggil.

mock.return_value = 10

Dalam hal ini, 10 selalu dikembalikan ketika mock dipanggil.

assert mock() == 10

Anda juga dapat menggunakan atribut return_value untuk mendapatkan nilai yang dikembalikan ketika mock dipanggil.

assert mock.return_value == 10

Atribut return_value digunakan untuk mengontrol nilai yang dikembalikan ketika mock dipanggil. Ketika digunakan dalam pengujian, atribut ini dapat digunakan untuk memverifikasi bahwa nilai yang dikembalikan sesuai dengan yang diharapkan. Atribut ini juga dapat digunakan untuk menguji perilaku tertentu dari sebuah program dengan mengatur nilai yang dikembalikan ketika mock dipanggil.

side_effect

Atribut side_effect dari objek Mock digunakan untuk mengatur fungsi yang akan dieksekusi ketika mock dipanggil.

Berikut ini adalah contoh mock yang menggunakan side_effect untuk melempar pengecualian.

from unittest.mock import Mock

def func():
    raise ValueError("Error")

mock = Mock(side_effect=func)

Memanggil mock ini akan mengeksekusi fungsi yang ditentukan.

mock()
# ValueError: Error

Side_effect berguna ketika apa yang Anda kembalikan sebagai hasil dari sebuah pemanggilan bukanlah sebuah nilai sederhana, atau ketika Anda ingin mengembalikan hasil yang berbeda untuk beberapa pemanggilan. Sebagai contoh, misalkan Anda memiliki sebuah mock dengan fungsi yang mengembalikan sebuah daftar sebagai berikut.

mock = Mock()
mock.side_effect = [[1, 2], [3, 4], [5, 6]]

Tiruan ini mengembalikan [1, 2] pada panggilan pertama, [3, 4] pada panggilan kedua, dan selalu [5, 6] pada panggilan ketiga dan selanjutnya.

assert mock() == [1, 2]
assert mock() == [3, 4]
assert mock() == [5, 6]
assert mock() == [5, 6]

side_effect digunakan untuk mengatur fungsi yang akan dieksekusi ketika mock dipanggil. Ketika digunakan dalam pengujian, ini dapat digunakan untuk memeriksa apakah suatu fungsi dijalankan seperti yang diharapkan.

called

Atribut dipanggil dari objek Mock adalah nilai boolean yang mengindikasikan apakah mock telah dipanggil atau belum. Nilai atribut ini adalah True jika mock telah dipanggil, dan False jika belum.

Sebagai contoh, misalkan Anda memiliki mock berikut ini.

from unittest.mock import Mock

mock = Mock()

Pada state sebelum mock ini dipanggil, nilai atribut called adalah False.

assert mock.called == False

Ketika mock ini dipanggil, nilai atribut called akan menjadi True.

mock()
assert mock.called == True

Atribut called dapat digunakan untuk memverifikasi bahwa mock telah dipanggil. Ini berguna, misalnya, jika Anda perlu melakukan pemrosesan setelah memverifikasi bahwa mock telah dipanggil.

call_args

Atribut call_args dari objek Mock adalah objek yang berisi argumen terakhir kali mock dipanggil. Objek ini dikembalikan dalam bentuk objek unittest.mock.call.

Sebagai contoh, misalkan kita memiliki mock berikut ini.

from unittest.mock import Mock

mock = Mock()
mock(1, 2, 3)

Dalam kasus ini, atribut call_args dapat digunakan untuk mendapatkan argumen terakhir kali mock dipanggil.

assert mock.call_args == ((1, 2, 3),)

Dengan demikian, atribut call_args dapat digunakan untuk mengambil argumen terakhir yang dipanggil dan memvalidasinya dalam pengujian. Anda juga dapat menggunakan atribut call_args untuk melihat bagaimana mock dipanggil.

Atribut call_args dapat digunakan bersama dengan metode pernyataan kenyamanan seperti assert_called_with(). Ini juga dapat digunakan untuk memeriksa apakah mock menerima argumen seperti yang diharapkan.

call_args_list

Atribut call_args_list dari objek Mock adalah daftar tupel yang mewakili semua argumen saat mock dipanggil. Atribut ini dapat digunakan untuk mencatat semua argumen yang dilewatkan ketika mock dipanggil.

Sebagai contoh, misalkan kita memiliki mock berikut ini.

from unittest.mock import Mock

mock = Mock()

Jika Anda memanggil mock ini dua kali, dengan memberikan argumen yang berbeda setiap kali, atribut call_args_list akan berisi sebuah tuple yang berisi setiap argumen.

mock('foo')
mock('bar')

assert mock.call_args_list == [('foo',), ('bar',)]

Atribut call_args_list dapat digunakan untuk mengambil semua argumen yang dilewatkan ketika mock dipanggil dan memvalidasinya dalam pengujian. Atribut ini juga mencegah pengujian gagal jika urutan atau jumlah argumen diubah.

Perhatikan bahwa atribut call_args_list menyimpan argumen sesuai urutan pemanggilan mock, sehingga Anda akan mendapatkan hasil yang berbeda jika argumen tersebut dipanggil dengan urutan yang berbeda.

call_count

Atribut call_count dari objek Mock adalah nilai integer yang mengembalikan berapa kali mock dipanggil. Dengan kata lain, atribut ini digunakan untuk memeriksa berapa banyak mock yang telah dipanggil.

Sebagai contoh, misalkan Anda memiliki mock berikut ini.

from unittest.mock import Mock

mock = Mock()

Jika mock ini dipanggil tiga kali, atribut call_count akan berisi jumlah panggilan, 3.

mock()
mock()
mock()

assert mock.call_count == 3

Atribut call_count dapat digunakan untuk mendapatkan berapa kali mock dipanggil dan diverifikasi dalam pengujian. Sebagai contoh, atribut ini dapat digunakan untuk memeriksa apakah sebuah mock telah dipanggil dalam jumlah yang diharapkan.

Atribut call_count dapat digunakan bersama dengan metode pernyataan kenyamanan seperti assert_called_once(). Jumlah panggilan juga dapat dimonitor untuk memastikan bahwa program bekerja dengan baik atau terjadi kesalahan.

mock_calls

Atribut mock_calls dari objek Mock adalah daftar pemanggilan metode yang mewakili semua pemanggilan yang dilakukan ketika mock tersebut dipanggil. Dengan kata lain, atribut ini digunakan untuk mencatat nama metode, argumen, nilai balik, dan informasi lain ketika mock dipanggil.

Sebagai contoh, misalkan kita memiliki mock berikut ini.

from unittest.mock import Mock

mock = Mock()

Jika mock ini dipanggil dua kali, setiap kali memberikan argumen yang berbeda, atribut mock_calls akan berisi sebuah objek dengan informasi tentang setiap panggilan.

mock('foo')
mock('bar')

assert mock.mock_calls == [call('foo'), call('bar')]

Atribut mock_calls dapat digunakan untuk mendapatkan informasi tentang kapan mock dipanggil dan dapat diverifikasi dalam pengujian. Sebagai contoh, atribut ini dapat digunakan untuk memverifikasi bahwa mock dipanggil dalam urutan yang diharapkan.

Atribut mock_calls sangat berguna untuk melakukan debug dan memvalidasi pengujian karena berisi informasi seperti nama metode yang dipanggil, argumen, dan nilai balik. Namun, karena atribut ini mungkin berisi sejumlah besar informasi, mungkin diinginkan untuk membatasinya pada jumlah pemanggilan yang masuk akal.

reset_mock

Metode reset_mock digunakan untuk mengatur ulang status masa lalu dari objek Mock, termasuk apakah objek tersebut pernah dipanggil sebelumnya dan argumen serta nilai kembalian dari pemanggilan tersebut. Hal ini sangat berguna ketika objek Mock yang sama digunakan di beberapa pengujian.

Memanggil reset_mock akan mengatur ulang atribut berikut.

• call_args
• call_count
• call_args_list
• mock_calls
• return_value
• side_effect

Sebagai contoh, perhatikan objek Mock berikut ini.

from unittest.mock import Mock

mock = Mock(return_value=42)
mock(1, 2, 3)

Objek Mock ini dipanggil sekali dengan argumen 1, 2, dan 3 dan mengembalikan 42 sebagai nilai balik. Memanggil reset_mock akan mereset atribut-atribut ini.

mock.reset_mock()
assert mock.call_count == 0
assert mock.call_args is None
assert mock.call_args_list == []
assert mock.mock_calls == []
assert mock.return_value is None
assert mock.side_effect is None

Dengan demikian, reset_mock dapat digunakan untuk menggunakan kembali objek Mock di antara pengujian.

assert_called

Metode assert_called() digunakan untuk menyatakan bahwa objek Mock telah dipanggil setidaknya satu kali. Metode ini hanya berfungsi jika objek Mock dipanggil seperti fungsi atau metode biasa.

Sebagai contoh, perhatikan objek Mock berikut ini.

from unittest.mock import Mock

mock_obj = Mock()

Untuk menegaskan bahwa objek Mock ini telah dipanggil satu kali atau lebih, lakukan hal berikut.

# assert that the mock object has been called at least once
mock_obj.assert_called()

Metode ini memunculkan pengecualian jika objek Mock tidak dipanggil. Oleh karena itu, objek Mock harus dipanggil setidaknya satu kali sebelum menyatakan pemanggilan. Sebagai alternatif, metode assert_called_once() dapat digunakan jika pemanggilan harus dilakukan sekali.

assert_has_calls

Metode has_assert_calls() digunakan untuk menyatakan apakah objek Mock telah menerima panggilan yang diharapkan. Metode ini dapat berupa satu atau lebih objek call yang mewakili panggilan yang diharapkan.

Metode ini dapat digunakan sebagai berikut.

from unittest.mock import Mock, call

mock_obj = Mock()
mock_obj(1, 2, 3)
mock_obj('a', 'b', 'c')

# asserts that the mock object has been called in the specified order
mock_obj.assert_has_calls([call(1, 2, 3), call('a', 'b', 'c')])

mock_obj.has_assert_calls([call(1, 2, 3), call('a', 'b', 'c')])

Contoh di atas menegaskan bahwa objek Mock mock_obj telah menerima dua panggilan, call(1, 2, 3) dan call('a', 'b', 'c'). Metode assert_has_calls() juga memeriksa apakah panggilan berada dalam urutan yang ditentukan.

assert_called_once

assert_called_once adalah metode yang menyatakan bahwa objek Mock telah dipanggil hanya sekali. Sebelum memanggil assert_called_once, Anda juga bisa memanggil assert_called atau assert_called_with untuk memverifikasi bahwa objek Mock dipanggil hanya sekali.

from unittest.mock import MagicMock

mock_obj = MagicMock()

mock_obj()

mock_obj.assert_called_once()

assert_called_with

assert_called_with adalah metode yang memverifikasi bahwa objek Mock telah dipanggil dengan argumen yang ditentukan. Pengujian akan lulus hanya jika argumen yang dipanggil sesuai dengan nilai yang diharapkan.

Berikut ini adalah contoh penggunaan assert_called_with.

from unittest.mock import MagicMock

def test_example():
    mock_obj = MagicMock()
    mock_obj('foo', 'bar', baz='bazval')
    mock_obj.assert_called_with('foo', 'bar', baz='bazval')

Pengujian ini membuat objek tiruan dan memanggilnya dengan argumen 'foo' dan 'bar' serta argumen kata kunci baz='bazval'. Metode assert_called_with kemudian digunakan untuk memverifikasi bahwa mock dipanggil dengan argumen yang benar.

Dengan demikian, metode assert_called_with dapat digunakan untuk memverifikasi dengan mudah bahwa mock dipanggil dengan argumen yang benar. Metode assert_called_with juga dapat digunakan untuk memverifikasi informasi secara bersamaan seperti jumlah pemanggilan.

Contoh-contoh Mock

Berikut adalah beberapa contoh penggunaan Mock.

Mengejek sebuah fungsi dalam sebuah modul

Berikut ini adalah contoh untuk meniru fungsi get dari modul requests.

import requests
from unittest.mock import Mock

def test_fetch_data():
    mock_response = Mock()
    mock_response.status_code = 200
    mock_response.json.return_value = {"foo": "bar"}

    requests.get = Mock(return_value=mock_response)

    result = fetch_data()
    assert result == {"foo": "bar"}

Dalam contoh ini, kita meniru fungsi requests.get dan mengatur nilai balik ke objek Mock, yang memiliki atribut status_code dan metode json(). Metode json () diatur untuk mengembalikan objek Mock dengan atribut return_value.

Meniru metode dari sebuah kelas

Berikut ini adalah contoh meniru metode tambah dari kelas Kalkulator.

from unittest.mock import Mock

class Calculator:
    def add(self, x, y):
        return x + y

def test_calculator():
    # mock the get function in the requests module
    calculator = Calculator()

    # mock the add method of the Calculator class
    calculator.add = Mock(return_value=10)

    # run test
    result = calculator.add(1, 2)
    assert result == 10

Contoh ini meniru metode tambah dari kelas Kalkulator dan menetapkan nilai balik ke 10.

Menguji pengecualian menggunakan objek tiruan

Berikut ini adalah contoh pengujian pengecualian menggunakan objek tiruan.

from unittest.mock import Mock

def test_divide_by_zero():
    mock_logger = Mock()

    import logger
    logger.error = mock_logger

    try:
        1 / 0
    except ZeroDivisionError as e:
        mock_logger.assert_called_with("division by zero")

Dalam contoh ini, kita menirukan fungsi error dari modul logger untuk menguji bahwa pengecualian ZeroDivisionError yang dimunculkan oleh pembagian nol menyebabkan fungsi logger.error dipanggil.

Contoh MagicMock

Berikut ini adalah contoh sederhana menggunakan MagicMock. Sebagai contoh, kita memiliki kode yang memanggil fungsi get () dari modul requests. Contoh ini menirukan respons yang dikembalikan ketika fungsi get() dipanggil.

import requests
from unittest.mock import MagicMock

def test_requests():
    response_mock = MagicMock()
    response_mock.status_code = 200
    response_mock.json.return_value = {'key': 'value'}

    requests.get = MagicMock(return_value=response_mock)

    response = requests.get('https://www.example.com')
    assert response.status_code == 200
    assert response.json()['key'] == 'value'

Contoh ini membuat response_mock dan menetapkan atribut status_code. Contoh ini juga meniru metode json() dan menyetel nilai kembalinya. Selanjutnya, kita mengganti requests.get dengan MagicMock dan menetapkan return_value ke response_mock. Terakhir, requests.get('https://www.example.com') dipanggil untuk memverifikasi kode status respons dan nilai JSON.

Contoh-contoh patch

Berikut adalah beberapa contoh penggunaan patch.

Meniru fungsi dalam modul eksternal

Sebagai contoh, misalkan Anda memiliki fungsi yang menggunakan modul math berikut ini.

import math

def calculate_square_root(num):
    return math.sqrt(num)

Di dalam fungsi calculate_square_root ini, Anda dapat meniru fungsi math.sqrt. Berikut ini adalah contoh mengejek math.sqrt menggunakan patch.

import unittest
from unittest.mock import patch
from my_module import calculate_square_root

class TestCalculateSquareRoot(unittest.TestCase):
    @patch('my_module.math.sqrt')
    def test_calculate_square_root(self, mock_sqrt):
        mock_sqrt.return_value = 2.0
        result = calculate_square_root(4)
        self.assertEqual(result, 2.0)

Contoh di atas menggunakan dekorator @patch('my_module.math.sqrt') untuk membuat tiruan dari math.sqrt. Kita juga mengatur mock_sqrt.return_value untuk mengatur nilai balik dari mock.

Membuat tiruan dari sebuah atribut objek

Misalkan Anda memiliki kelas berikut ini.

class MyClass:
    def __init__(self):
        self.my_attribute = 42

    def my_method(self):
        return self.my_attribute

Anda bisa mengejek atribut my_attribute dari sebuah instance kelas ini. Berikut ini adalah contoh mengejek atribut my_attribute menggunakan patch.

import unittest
from unittest.mock import patch
from my_module import MyClass

class TestMyClass(unittest.TestCase):
    @patch('my_module.MyClass.my_attribute', new=50)
    def test_my_method(self):
        my_instance = MyClass()
        result = my_instance.my_method()
        self.assertEqual(result, 50)

Contoh di atas menggunakan dekorator @patch('my_module.MyClass.my_attribute', new=50) untuk membuat tiruan dari atribut my_attribute.

Pembukaan file tiruan

Berikut ini adalah contoh fungsi yang membaca sebuah file.

def read_file(filename):
    with open(filename, 'r') as f:
        return f.read()

Untuk menguji fungsi ini, objek file tiruan dapat digunakan untuk menguji apakah file tersebut tidak ada. Untuk melakukan hal ini, gunakan fungsi patch untuk mengganti file dan atur untuk mengembalikan objek file tiruan.

from unittest.mock import patch

def test_read_file():
    with patch('builtins.open', return_value=Mock(spec=open)) as mock_file:
        mock_file.return_value.__enter__.return_value.read.return_value = 'test file contents'
        assert read_file('test.txt') == 'test file contents'

Pada contoh ini, builtins.open diganti dengan objek tiruan. Objek mock_file.return_value merepresentasikan objek yang dikembalikan oleh fungsi open. Objek file tiruan mengembalikan objek file dalam metode __enter__ dan isi file dalam metode read. Anda dapat mengganti metode objek file tiruan dalam konteks patch.

Referensi

https://docs.python.org/3/library/unittest.mock.html