MockK: apa itu, konsep kunci dan sintaksis

Apa itu MockK?

MockK — adalah pustaka untuk membuat objek mock, ditulis dalam Kotlin dan dioptimalkan untuk sintaksisnya. Ini memecahkan tugas yang sama seperti Mockito — isolasi kode yang diuji dari dependensi — tetapi melakukannya menggunakan konstruksi khusus Kotlin: lambda, DSL, reified generics dan fungsi suspend.

Keuntungan utama MockK dibandingkan solusi yang di-porting — dukungan asli Kotlin. Di Mockito, mocking kelas final memerlukan opt-in (mockito-inline), dan metode statis memerlukan mockStatic. MockK mendukung ini secara default, karena kelas Kotlin secara default adalah final, dan penanganan keterbatasan ini sudah dibangun ke dalam arsitektur pustaka.

Versi 1.13.12 (2024) — rilis stabil yang mendukung Kotlin 2.0, kompiler K2 dan proyek multi-platform (KMP). MockK juga bekerja dengan Kotlin/Native dan Kotlin/JS, menjadikannya satu-satunya pilihan untuk proyek KMP di mana Mockito maupun EasyMock tidak dapat diterapkan.

MockK dirancang dengan mempertimbangkan kekhususan Kotlin dan menggunakan kemampuan bahasa — reified generics, DSL dengan lambda, fungsi inline — untuk memberikan API yang ringkas dan aman tipe tanpa kehilangan kinerja.

Bagaimana MockK bekerja

Mekanisme MockK didasarkan pada instrumentasi bytecode melalui pustaka ByteBuddy (seperti Mockito), tetapi membungkusnya dalam DSL yang ramah Kotlin. Alih-alih rantai when().thenReturn(), MockK menggunakan blok lambda every { } dan coEvery { }, yang terlihat seperti perluasan alami bahasa. Di balik layar, MockK mencegat panggilan di dalam lambda, menganalisis metode dan argumen melalui refleksi dan mencocokannya dengan aturan stubbing yang tercatat.

Sintaksis dasar MockK

Blok every { mock.method() } returns value dibaca sebagai “setiap kali metode dipanggil, kembalikan nilainya”. Sintaksis deklaratif semacam ini lebih dekat dengan gaya Kotlin dan menghilangkan kebingungan dengan urutan argumen di when(). Berkat reified generics Kotlin, tipe mock disimpulkan secara otomatis tanpa spesifikasi kelas eksplisit.

val repository = mockk<UserRepository>()

// Stubbing: setiap panggilan findById(1) mengembalikan pengguna
every { repository.findById(1) } returns User("Alice")

// Panggilan dan verifikasi
val result = repository.findById(1)
assertEquals("Alice", result.name)

Relaxed mock: lebih sedikit boilerplate

Berbeda dengan Mockito, di mana setiap metode harus dikonfigurasi secara eksplisit, MockK mendukung relaxed mock — mock yang mengembalikan nilai default “masuk akal” untuk metode apa pun: daftar kosong untuk List, 0 untuk Int, string kosong untuk String. Ini secara drastis mengurangi jumlah kode persiapan.

// Relaxed mock — semua metode mengembalikan nilai default
val api = mockk<ApiService>(relaxed = true)

// Tidak memerlukan stubbing — akan mengembalikan daftar kosong
println(api.getUsers()) // []

Membuat mock dan mock rileks

MockK menawarkan beberapa cara untuk membuat objek mock: mockk<T>() untuk mock ketat (setiap metode harus dikonfigurasi secara eksplisit), mockk<T>(relaxed = true) untuk mock rileks dan spyk(obj) untuk membuat spy pada objek nyata.

Pilihan antara mock ketat dan rileks tergantung pada konteksnya. Mock ketat memastikan bahwa tes tidak menggunakan metode yang perilakunya tidak ditentukan — ini meningkatkan keandalan. Mock rileks nyaman untuk pembuatan prototipe cepat tes di mana tidak semua dependensi penting. Dalam praktiknya, disarankan untuk memulai dengan mock ketat dan beralih ke relaxed hanya ketika stubbing memakan lebih banyak baris daripada tes itu sendiri.

Stubbing: mengonfigurasi perilaku dengan blok every

Blok every — adalah konstruksi sentral stubbing di MockK. Di dalam lambda, panggilan metode dengan argumen tertentu dijelaskan, dan kemudian nilai dikembalikan melalui returns, pengecualian dilemparkan melalui throws atau jawaban dihitung melalui answers.

Berbagai cara stubbing

MockK mendukung semua skenario yang diperlukan untuk pengujian: mengembalikan nilai, melempar pengecualian, menghitung jawaban berdasarkan argumen, beberapa jawaban secara berurutan (urutan panggilan).

// Mengembalikan nilai
every { repo.findById(1) } returns User("Alice")

// Melempar pengecualian
every { repo.findById(999) } throws NotFoundException()

// Jawaban dinamis
every { repo.save(any()) } answers {
    val user = firstArg<User>()
    user.copy(id = 42)
}

// Urutan jawaban
every { repo.findAll() } returnsMany listOf(
    listOf(User("Alice")),
    listOf(User("Bob")),
    emptyList()
)

Verify dan coVerify untuk korutin

Verify di MockK secara konsep analog dengan Mockito.verify() tetapi menggunakan DSL Kotlin: verify { mock.method() }. Untuk fungsi suspend digunakan coVerify { mock.suspendMethod() }, yang bekerja dengan benar dengan korutin dan tidak memerlukan runner khusus.

Memeriksa jumlah panggilan

MockK mendukung pengubah yang sama seperti Mockito: exactly(1), atLeast(2), atMost(5), wasNot(Called). Sintaksisnya minimalis — pengubah dilewatkan sebagai argumen pertama di verify { }.

// Verifikasi: metode dipanggil tepat 1 kali
verify(exactly = 1) { repo.save(any()) }

// Memeriksa urutan panggilan
verifySequence {
    repo.save(any())
    repo.flush()
}

// coVerify untuk fungsi suspend
coVerify { api.fetchUsers() }

Slot: menangkap argumen

Untuk memeriksa argumen digunakan slot() — analog dari ArgumentCaptor. Slot dideklarasikan sebelum panggilan, dilewatkan ke every atau verify, dan setelah eksekusi tes berisi nilai yang ditangkap.

val userSlot = slot<User>()

verify { repo.save(capture(userSlot)) }

assertEquals("Alice", userSlot.captured.name)

Anotasi MockK dan integrasi JUnit

MockK menyediakan anotasi @MockK dan @RelaxedMockK untuk membuat mock melalui inisialisasi di JUnit 5. Ekstensi MockKExtension secara otomatis membuat mock sebelum setiap tes dan membersihkan setelahnya — mirip dengan MockitoExtension, tetapi dengan dukungan mode relaxed.

Contoh dengan MockKExtension

Anotasi @InjectMockKs (atau alternatif @MockK dengan pembuatan objek eksplisit) menyuntikkan mock ke dalam instance yang diuji. Ini mengurangi boilerplate dan membuat kode tes lebih bersih.

@ExtendWith(MockKExtension::class)
class UserServiceTest {

    @MockK
    lateinit var repository: UserRepository

    @InjectMockKs
    lateinit var service: UserService

    @Test
    fun `getUser returns user from repository`() {
        every { repository.findById(1) } returns User("Alice")
        assertEquals("Alice", service.getUser(1)?.name)
    }
}

MockK vs Mockito: apa yang harus dipilih untuk Kotlin

Pilihan antara MockK dan Mockito tergantung pada komposisi tim dan jenis proyek. Mockito memiliki ekosistem yang lebih besar, lebih banyak contoh dan integrasi, tetapi MockK menawarkan sintaksis Kotlin yang lebih bersih dan dukungan asli untuk fitur bahasa. Untuk proyek Kotlin baru, MockK direkomendasikan sebagai solusi yang lebih idiomatis.

Untuk proyek Kotlin murni (tanpa kelas Java), MockK lebih disukai: lebih sedikit boilerplate, dukungan asli korutin, tidak ada kejutan dengan kelas final. Untuk proyek hibrida atau tim dengan latar belakang Java, Mockito tetap menjadi opsi yang berfungsi — kedua pustaka dapat digunakan dalam satu proyek melalui modul yang berbeda. Saat migrasi dari Mockito ke MockK, cukup ganti anotasi @Mock dengan @MockK dan tulis ulang blok when().thenReturn() ke format every { }.