0Pricing
Kotlin Academy · บทเรียน

การทดสอบ Coroutine

ทดสอบฟังก์ชัน suspend

การทดสอบ Coroutine เป็นบทเรียน Kotlin Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Kotlin Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Kotlin Academy มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดการทดสอบโครูทีนจึงพิเศษ

โครูทีนทำงานแบบอะซิงโครนัสและอาจมีการหน่วงเวลา การทดสอบจึงต้องมีเวลาแบบควบคุมและวิธีรอให้ฟังก์ชัน suspend ทำงานเสร็จ

ไลบรารี kotlinx-coroutines-test มีความสามารถเหล่านี้โดยตรง

การเพิ่มไลบรารีการทดสอบ

เพิ่มอาร์ติแฟกต์การทดสอบโครูทีนลงในการพึ่งพาสำหรับการทดสอบ

dependencies {
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.1")
}

runTest

runTest คือจุดเริ่มต้น โดยจะเรียกใช้เนื้อหาการทดสอบโครูทีนและรอให้โครูทีนลูกทั้งหมดทำงานเสร็จโดยอัตโนมัติ

import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Test

class FetchTest {
    @Test
    fun fetches() = runTest {
        // suspend calls allowed here
    }
}

เวลาเสมือน

ภายใน runTest การเรียกใช้ delay จะถูกข้ามโดยใช้เวลาเสมือน ดังนั้นการหน่วงเวลา 10 วินาทีจึงเสร็จสิ้นทันที โดยยังคงรักษาลำดับการทำงานไว้

import kotlinx.coroutines.delay
import kotlinx.coroutines.test.runTest

// runTest {
//     delay(10_000) // returns immediately
// }

การเลื่อนเวลาด้วยตนเอง

ตัวจัดตารางการทดสอบช่วยให้คุณเลื่อนเวลาอย่างตั้งใจด้วย advanceTimeBy และเรียกใช้งานที่รอดำเนินการด้วย runCurrent

import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.advanceTimeBy
import kotlinx.coroutines.test.runCurrent

// runTest {
//     launch { delay(1000); println("done") }
//     advanceTimeBy(1000)
//     runCurrent()
// }

ตัวกระจายงานสำหรับการทดสอบ

StandardTestDispatcher จะจัดคิวโครูทีนไว้จนกว่าคุณจะเลื่อนเวลา ส่วน UnconfinedTestDispatcher จะเรียกใช้โครูทีนทันที เลือกใช้ตามระดับการควบคุมที่คุณต้องการ

import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.UnconfinedTestDispatcher

val standard = StandardTestDispatcher()
val unconfined = UnconfinedTestDispatcher()

การฉีดตัวกระจายงาน

โค้ดใช้งานจริงควรรับตัวกระจายงานเข้ามา แทนการกำหนด Dispatchers.IO ไว้ตายตัว จากนั้นการทดสอบจึงฉีดตัวกระจายงานสำหรับการทดสอบเข้าไปได้

import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class Service(private val io: CoroutineDispatcher = Dispatchers.IO) {
    suspend fun load(): String = withContext(io) { "data" }
}

การแทนที่ Dispatchers.Main

สำหรับโค้ดรูปแบบ Android ให้สลับตัวกระจายงาน Main ด้วย Dispatchers.setMain(testDispatcher) แล้วรีเซ็ตกลับหลังใช้งาน

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.test.setMain
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.StandardTestDispatcher

// Dispatchers.setMain(StandardTestDispatcher())
// ... test ...
// Dispatchers.resetMain()

การทดสอบฟังก์ชัน Suspend

คุณสามารถเรียกใช้และตรวจยืนยันฟังก์ชัน suspend ได้โดยตรงภายใน runTest

import kotlinx.coroutines.delay
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Assertions.assertEquals

suspend fun compute(): Int { delay(1000); return 42 }

// @Test fun computes() = runTest {
//     assertEquals(42, compute())
// }

การทดสอบโฟลว์

รวบรวมค่า Flow แล้วตรวจยืนยันค่าที่ถูกส่งออกมา ไลบรารี Turbine ช่วยให้การทดสอบโฟลว์เป็นระเบียบและอ่านง่ายยิ่งขึ้น

import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Assertions.assertEquals

// @Test fun emits() = runTest {
//     val values = flowOf(1, 2, 3).toList()
//     assertEquals(listOf(1, 2, 3), values)
// }

ตัวอย่างโค้ดโครูทีนที่รันได้

นอกการทดสอบ runBlocking จะเชื่อมโค้ด suspend เข้ากับ main ปกติ ตัวอย่างนี้แสดงฟังก์ชัน suspend ที่กำลังทดสอบ

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.delay

suspend fun compute(): Int { delay(100); return 42 }

fun main() = runBlocking {
    println(compute())
}

ตรวจสอบอย่างรวดเร็ว

ฟังก์ชัน suspend เรียกใช้ delay(5000) เหตุใดการทดสอบที่ใช้ runTest จึงเสร็จสิ้นเกือบจะทันที

สรุปทบทวน

คุณสามารถทดสอบโครูทีนได้อย่างน่าเชื่อถือ:

  • runTest เรียกใช้โค้ด suspend และรอให้โครูทีนลูกทำงานเสร็จ
  • เวลาเสมือนจะข้ามการหน่วงเวลา และคุณสามารถเลื่อนเวลาเองได้เมื่อต้องการ
  • ฉีดตัวกระจายงาน และใช้ setMain/resetMain
  • ทดสอบโฟลว์ด้วยการรวบรวมค่า (หรือใช้ Turbine)

หลักสูตรการทดสอบจบลงแล้ว

คำถามที่พบบ่อย

บทเรียน “การทดสอบ Coroutine” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การทดสอบ Coroutine” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Kotlin Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Kotlin Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การทดสอบ Coroutine”

ทดสอบฟังก์ชัน suspend คุณปฏิบัติ Kotlin Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Kotlin Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Kotlin Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การทดสอบ Coroutine” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Kotlin Academy นี้ได้ไหม

ได้ บทเรียน Kotlin Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การเขียนเทสต์ด้วย JUnit5
  2. การยืนยันผล
  3. การจำลองด้วย MockK
  4. การทดสอบ Coroutine
← กลับไปที่ Kotlin Academy