
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
edilmesinden farklı değildir. Aşağıda
FetchUserUseCase içinde yer alan fetchUserData fonksiyonuna göz atın. Bufonksiyonun verileri beklendiği şekilde gösterip göstermediğini kontrol etmek, birkaç sahte nesne (fake1Fake, bir arayüzü (interface) implemente eden ancak sabit veri içeren ve mantık barındırmayan sınıflardır.) veya
taklit (mock2Mock'lar, gerçek nesnelerin davranışlarını kontrollü şekilde taklit eden evrensel simülasyon nesneleridir.) ve basit doğrulamalar (assertion) sayesinde kolayca gerçekleştirilebilir. Buradaki tek fark, bir
coroutine başlatabilmek için testlerimizi
runBlocking veya runTest bloğu içerisine sarmamız gerektiğidir.import kotlinx.coroutines.async import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.runBlocking import org.junit.Test import kotlin.test.assertEquals // Kullanıcı verilerini getirmek için kullanılan use case sınıfı class FetchUserUseCase( // UserDataRepository tipinde bir dependency injection yapılıyor private val repo: UserDataRepository, ) { // Kullanıcı verilerini asenkron olarak getiren suspend fonksiyon suspend fun fetchUserData(): User = coroutineScope { // İsim bilgisini asenkron olarak getir ve bir Deferred nesnesine ata val name = async { repo.getName() } // Arkadaş listesini asenkron olarak getir ve bir Deferred nesnesine ata val friends = async { repo.getFriends() } // Profil bilgisini asenkron olarak getir ve bir Deferred nesnesine ata val profile = async { repo.getProfile() } // Tüm asenkron işlemlerin sonuçlarını bekleyerek bir User nesnesi oluştur ve döndür User( name = name.await(), // İsim sonucunu bekle friends = friends.await(), // Friends sonucunu bekle profile = profile.await() // Profile sonucunu bekle ) } } // FetchUserUseCase sınıfının davranışını test eden bir test sınıfı class FetchUserDataTest { // Kullanıcı verilerinin doğru şekilde oluşturulduğunu test eden fonksiyon @Test fun `should construct user`() = runBlocking { // given (hazırlık aşaması) // Sahte bir repository oluştur val repo = FakeUserDataRepository() // Test edilecek use case'i, repository'yi vererek oluştur val useCase = FetchUserUseCase(repo) // işlem aşaması // Use case'in fetchUserData metodunu çağır ve sonucu al val result = useCase.fetchUserData() // doğrulama aşaması // Beklenen kullanıcı verisini oluştur val expectedUser = User( name = "Ben", friends = listOf(Friend("some-friend-id-1")), profile = Profile("Example description") ) // Sonucun beklenen veri ile aynı olduğunu doğrula assertEquals(expectedUser, result) } // Test için kullanılan sahte repository sınıfı class FakeUserDataRepository : UserDataRepository { // İsim bilgisini döndüren override edilmiş metot override suspend fun getName(): String = "Ben" // Friends listesini döndüren override edilmiş metot override suspend fun getFriends(): List<Friend> = listOf(Friend("some-friend-id-1")) // Profile bilgisini döndüren override edilmiş metot override suspend fun getProfile(): Profile = Profile("Example description") } } // Kullanıcı verilerine erişim sağlayan repository için interface interface UserDataRepository { // Kullanıcı ismini getiren suspend fonksiyon suspend fun getName(): String // Kullanıcının friends listesini getiren suspend fonksiyon suspend fun getFriends(): List<Friend> // Kullanıcının profile bilgisini getiren suspend fonksiyon suspend fun getProfile(): Profile } // Kullanıcı verilerini temsil eden data class data class User( val name: String, // Kullanıcı ismi val friends: List<Friend>, // Friends listesi val profile: Profile // Profile bilgisi ) // Friend verisini temsil eden data class data class Friend(val id: String) // Friend ID'si // Profile verisini temsil eden data class data class Profile(val description: String) // Profile açıklaması
Test etme mantığı için kullandığım yöntem bir referans olarak alınmamalıdır. Testlerin nasıl olması gerektiğine dair
birçok çelişkili görüş bulunmaktadır. Dış kütüphaneleri dahil etmemek adına burada sahte nesneler (fake) kullandım,
taklitler (mock) tercih etmedim. Ayrıca, tüm testleri daha okunabilir kılmak için olabildiğince minimal tutmaya
çalıştım.
pratikte
runBlocking ve klasik doğrulama araçları (assertion tools) dışında başka bir şeye ihtiyaç duymayız. Buyaklaşım, birçok projedeki birim testlerin (unit tests) nasıl göründüğünü yansıtmaktadır. Aşağıda Kt. Academy arka uç (
backend) projesinden alınmış örnek bir dış arayüz (facade) testi yer almaktadır:
// KtAcademyFacadeTest sınıfını genişleten bir test sınıfı class UserTests : KtAcademyFacadeTest() { // Kullanıcı detaylarının başarıyla değiştirildiğini doğrulayan test metodu @Test fun `should modify user details`() = runBlocking { // given - Testin başlangıç durumunu hazırla // Belirli bir token ve ID ile kullanıcı oluştur thereIsUser(aUserToken, aUserId) // when - Test edilen işlemi gerçekleştir // Kullanıcının kendi profilini güncelle facade.updateUserSelf( // Kullanıcı kimlik doğrulama token'ı aUserToken, // Güncellenecek kullanıcı bilgilerini içeren istek nesnesi PatchUserSelfRequest( // İngilizce biyografi bio = aUserBio, // Lehçe biyografi bioPl = aUserBioPl, // Kullanıcının açık anahtarı publicKey = aUserPublicKey, // Özel profil resmi URL'i customImageUrl = aCustomImageUrl ) ) // then - Sonuçları doğrula // Kullanıcıyı ID ile bul ve alanların doğru güncellendiğini kontrol et with(findUser(aUserId)) { // Biyografi alanının doğru güncellendiğini kontrol et assertEquals(aUserBio, bio) // Lehçe biyografi alanının doğru güncellendiğini kontrol et assertEquals(aUserBioPl, bioPl) // Açık anahtar alanının doğru güncellendiğini kontrol et assertEquals(aUserPublicKey, publicKey) // Özel resim URL'inin doğru güncellendiğini kontrol et assertEquals(aCustomImageUrl, customImageUrl) } } // Diğer test metodları burada yer alır //... }
runBlocking kullanmamız yeterlidir veaskıya alınabilir (suspending) fonksiyonlarla bloklayıcı (blocking) fonksiyonların davranışlarını test etme açısından
neredeyse hiçbir fark yoktur.
olduğunda durum değişir. Özellikle fonksiyonların çalışma süresi veya zamanlamaya dayalı yapıları test edilmeye
başlandığında, test süreci daha karmaşık hale gelir. Aşağıdaki fonksiyon örnekleri bu durumu daha net açıklamaktadır:
// Kullanıcı verilerini senkron olarak getiren suspend fonksiyon // Bu fonksiyon, ilk önce profil bilgisini alır, ardından arkadaş listesini alır // Sıralı olarak çalışır, yani bir işlem bitmeden diğeri başlamaz suspend fun produceCurrentUserSync(): User { // Profil bilgisini repository'den al val profile = repo.getProfile() // Arkadaş listesini repository'den al val friends = repo.getFriends() // Alınan verilerle User nesnesini oluşturup döndür return User(profile, friends) } // Kullanıcı verilerini asenkron olarak getiren suspend fonksiyon // Bu fonksiyon, profil bilgisi ve arkadaş listesini paralel olarak almak için async kullanır // Böylece iki işlem aynı anda başlar ve daha hızlı tamamlanabilir suspend fun produceCurrentUserAsync(): User = coroutineScope { // Profil bilgisini asenkron olarak al ve Deferred nesnesine ata val profile = async { repo.getProfile() } // Arkadaş listesini asenkron olarak al ve Deferred nesnesine ata val friends = async { repo.getFriends() } // Her iki asenkron işlemin tamamlanmasını bekle ve sonuçlarla User nesnesini oluşturup döndür User(profile.await(), friends.await()) }
getProfile ve getFriends işlemlerinieşzamanlı (synchronous) olarak gerçekleştirmesi, ikinci fonksiyonun ise bu işlemleri eşzamanlı olmayan (asynchronous)
şekilde yapmasıdır. Etkili olarak, eğer
getProfile işlemi X milisaniye ve getFriends işlemi Y milisaniye sürüyorsa,ilk fonksiyonun çalışması X + Y milisaniye gerektirir, oysa ikinci fonksiyon yalnızca max(X, Y) milisaniye gerektirir.
getProfile ve getFriends fonksiyonlarının yürütülmesi gerçekten zaman aldığında ortaya çıktığınıunutmayın. Eğer bu fonksiyonlar anında (immediate) yanıt veriyorsa, her iki kullanıcı üretim yöntemi de ayırt edilemez
hale gelir. Bu nedenle, aralarındaki gerçek farkı test edebilmek için sahte (fake) fonksiyonları
delay kullanarakgeciktirerek, verinin geç yüklendiği bir senaryo simüle edilebilir:
// Test için gecikmeli yanıt veren sahte repository sınıfı // UserDataRepository interface'ini implement eder // İşlemleri gerçek bir API çağrısını simüle etmek için geciktirir class FakeDelayedUserDataRepository : UserDataRepository { // Profil bilgisini getiren override edilmiş metot // 1 saniye gecikme ekleyerek gerçek API gecikmesini simüle eder override suspend fun getProfile(): Profile { // İşlemi 1 saniye geciktir delay(1000) // Sahte profil bilgisini döndür return Profile("Example description") } // Arkadaş listesini getiren override edilmiş metot // 1 saniye gecikme ekleyerek gerçek API gecikmesini simüle eder override suspend fun getFriends(): List<Friend> { // İşlemi 1 saniye geciktir delay(1000) // Sahte arkadaş listesini döndür return listOf(Friend("some-friend-id-1")) } }
produceCurrentUserSync çağrısı yaklaşık 2 saniyesürecek,
produceCurrentUserAsync çağrısı ise yaklaşık 1 saniye sürecektir. Ancak, tek bir birim testin bu kadar uzunsürmesini istemeyiz. Projelerimizde genellikle binlerce birim test bulunur ve bunların tamamının mümkün olduğunca hızlı
çalışmasını isteriz. Peki hem pastayı yiyip hem de elde tutmanın (have your cake and eat it too) bir yolu var mı? Bunun
için simüle edilmiş zamanda çalışmamız gerekir. Bu noktada
kotlinx-coroutines-test kütüphanesi ve onunStandardTestDispatcher bileşeni yardımımıza yetişir.Bu bölümde,kotlinx-coroutines-testkütüphanesinin 1.6 sürümüyle tanıtılan fonksiyonları ve sınıfları ele
alınmaktadır. Daha eski bir sürüm kullanıyorsanız, çoğu durumdarunTestyerinerunBlockingTest,
StandardTestDispatcheryerineTestCoroutineDispatcherveTestScopeyerineTestCoroutineScopekullanmanız yeterli
olacaktır. Ayrıca, eski sürümlerdekiadvanceTimeBy, 1.6 ve üzeri sürümlerdekiadvanceTimeByverunCurrent
işlevlerine karşılık gelir. Detaylı farklar için geçiş rehberine (migration guide) göz atabilirsiniz:
https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-test/MIGRATION.md
delay çağrıldığında, coroutine askıya alınır ve belirlenen sürenin ardından yenidenbaşlatılır. Bu davranış,
kotlinx-coroutines-test kütüphanesinden gelen TestCoroutineScheduler sayesindedeğiştirilebilir. Bu bileşen,
delay fonksiyonunun sanal zamanda (virtual time) çalışmasını sağlar; yani zaman tamamensimüle edilir ve gerçek zamanla bağlantılı değildir. Bu sanal zamanı biz manuel olarak ilerletiriz; bunun için
advanceTimeBy veya advanceUntilIdle gibi fonksiyonlar kullanılır.import kotlinx.coroutines.test.TestCoroutineScheduler // TestCoroutineScheduler'ı kullanarak zamanı kontrol etme örneği // Bu örnek, test zamanlamasının nasıl programatik olarak manipüle edilebileceğini gösterir fun main() { // Test amaçlı bir coroutine zamanlayıcısı oluştur val scheduler = TestCoroutineScheduler() // Başlangıç zamanını yazdır (milisaniye cinsinden) println(scheduler.currentTime) // 0 // Zamanı 1 saniye ilerlet scheduler.advanceTimeBy(1_000) // Güncellenmiş zamanı yazdır println(scheduler.currentTime) // 1000 // Zamanı 1 saniye daha ilerlet scheduler.advanceTimeBy(1_000) // Son zamanı yazdır println(scheduler.currentTime) // 2000 }
TestCoroutineScheduler'ı coroutine'ler üzerinde kullanabilmek için, onu destekleyen bir dispatcher kullanmamızgerekir. Bu amaçla kullanılan standart seçenek
StandardTestDispatcher'dır. Çoğu dispatcher'ın aksine, bu dispatcheryalnızca bir coroutine'in hangi iş parçacığında (thread) çalışacağını belirlemek için kullanılmaz. Bu dispatcher ile
başlatılan coroutine'ler, biz sanal zamanı ilerletene kadar çalışmazlar.
advanceUntilIdle fonksiyonunu kullanmaktır. Bu fonksiyon, sanal zamanıilerletir ve ilgili coroutine'lerdeki tüm işlemleri tetikler.
import kotlinx.coroutines.* import kotlinx.coroutines.test.* // TestCoroutineScheduler ve StandardTestDispatcher kullanarak sıralı bir şekilde coroutine'leri // yürütme ve zamanlama örneği fun main() { // Test zamanlayıcısı oluştur val scheduler = TestCoroutineScheduler() // Zamanlayıcıyı kullanan bir test dispatcher'ı oluştur val testDispatcher = StandardTestDispatcher(scheduler) // İlk coroutine kapsamı CoroutineScope(testDispatcher).launch { // İlk iş parçasını yazdır println("İş parçası 1") // 1 saniye bekle delay(1000) // İkinci iş parçasını yazdır println("İş parçası 2") // 1 saniye daha bekle delay(1000) // Coroutine'in tamamlandığını bildir println("Coroutine tamamlandı") } // İkinci coroutine kapsamı CoroutineScope(testDispatcher).launch { // 500 milisaniye bekle delay(500) // Farklı bir iş yap println("Farklı bir işlem") } // İşlemlerden önceki mevcut zamanı yazdır println("[${scheduler.currentTime}] Öncesi") // Tüm coroutine'ler tamamlanana kadar zamanı ilerlet scheduler.advanceUntilIdle() // İşlemlerden sonraki mevcut zamanı yazdır println("[${scheduler.currentTime}] Sonrası") } // [0] Öncesi // İş parçası 1 // Farklı bir işlem // İş parçası 2 // Coroutine tamamlandı // [2000] Sonrası
delay çağrılarının toplamıdır ve bu coroutine'lerin gerçek zamanda nekadar süreceğini temsil eder. Ancak burada kullanılan zaman sanal (virtual) olduğu için, zamanlama hem kesinlik sunar
hem de gerçek zamanın akışına bağlı değildir. Bu da bize yalnızca yüksek verimlilik değil, aynı zamanda mükemmel
öngörülebilirlik (perfect predictability) sağlar.
StandardTestDispatcher, varsayılan olarak kendi TestCoroutineScheduler örneğini oluşturur, bu nedenle bizim bunuayrıca oluşturmamıza gerek yoktur. Bu zamanlayıcıya
scheduler özelliği (property) üzerinden erişebiliriz.import kotlinx.coroutines.* import kotlinx.coroutines.test.StandardTestDispatcher // StandardTestDispatcher kullanarak kontrollü bir coroutine test ortamı oluşturma örneği fun main() { // Kendi zamanlayıcısı ile birlikte bir test dispatcher'ı oluştur val dispatcher = StandardTestDispatcher() // Dispatcher üzerinde bir coroutine başlat CoroutineScope(dispatcher).launch { // İlk iş parçasını yazdır println("İş parçası 1") // 1 saniye bekle delay(1000) // İkinci iş parçasını yazdır println("İş parçası 2") // 1 saniye daha bekle delay(1000) // Coroutine'in tamamlandığını bildir println("Coroutine tamamlandı") } // İşlemlerden önceki mevcut zamanı yazdır println("[${dispatcher.scheduler.currentTime}] Öncesi") // Tüm coroutine'ler tamamlanana kadar zamanı ilerlet dispatcher.scheduler.advanceUntilIdle() // İşlemlerden sonraki mevcut zamanı yazdır println("[${dispatcher.scheduler.currentTime}] Sonrası") } // [0] Öncesi // İş parçası 1 // İş parçası 2 // Coroutine tamamlandı // [2000] Sonrası
StandardTestDispatcher zamanı kendi başına ilerletmez. Zamanı bizim manuel olarakilerletmemiz gerekir; aksi takdirde coroutine hiçbir zaman yeniden başlatılmaz (resume edilmez).
import kotlinx.coroutines.delay import kotlinx.coroutines.runBlocking import kotlinx.coroutines.test.StandardTestDispatcher // StandardTestDispatcher ve runBlocking kullanımında sonsuz döngü örneği fun main() { // Bir test dispatcher'ı oluştur val testDispatcher = StandardTestDispatcher() // runBlocking bloğu ile senkron çalışma runBlocking(testDispatcher) { // 1 milisaniyelik bir gecikme ekle delay(1) // Bu kod hiçbir zaman çalışmaz println("Coroutine tamamlandı") } } // (bu kod sonsuza kadar çalışır)
advanceTimeBy fonksiyonunu belirli bir milisaniye değeri ile kullanmaktır. Bufonksiyon, sanal zamanı verilen süre kadar ileri sarar ve bu süre zarfında gerçekleşmiş olan tüm işlemleri yürütür.
delay çağrılarının ardındanbekleyen işlemlerin yeniden başlatılacağı (resumed) anlamına gelir. Ancak tam olarak 2. milisaniyeye planlanmış
işlemlerin çalıştırılması için ayrıca
runCurrent fonksiyonunun çağrılması gerekir.import kotlinx.coroutines.delay import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.launch import kotlinx.coroutines.test.StandardTestDispatcher // StandardTestDispatcher ile coroutine'lerde hassas zaman kontrolü fun main() { // Test ortamı için özel bir dispatcher oluştur val testDispatcher = StandardTestDispatcher() // İlk coroutine: 1ms gecikme ile çalışacak CoroutineScope(testDispatcher).launch { // 1 milisaniye bekle delay(1) // İşlem tamamlandığında bildir println("Tamamlandı1") } // İkinci coroutine: 2ms gecikme ile çalışacak CoroutineScope(testDispatcher).launch { // 2 milisaniye bekle delay(2) // İşlem tamamlandığında bildir println("Tamamlandı2") } // Zamanı 2 milisaniye ilerlet // Bu, hem 1ms hem de 2ms gecikmeli işlemlerin zamanının dolmasını sağlar testDispatcher.scheduler.advanceTimeBy(2) // Tamamlandı1 // Şu anda çalışmaya hazır olan tüm coroutine'leri çalıştır // Bu, 2ms gecikmesi dolan ikinci coroutine'i çalıştırır testDispatcher.scheduler.runCurrent() // Tamamlandı2 }
advanceTimeBy ile runCurrent fonksiyonlarının birlikte kullanımına dair daha kapsamlı bir örnek.import kotlinx.coroutines.delay import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.launch import kotlinx.coroutines.test.StandardTestDispatcher fun main() { // Test amaçlı özel bir dispatcher oluştur val testDispatcher = StandardTestDispatcher() // İlk coroutine: 2ms gecikme ile çalışacak CoroutineScope(testDispatcher).launch { // 2 milisaniye bekle delay(2) // İşlem tamamlandığında yazdır print("Tamamlandı") } // İkinci coroutine: 4ms gecikme ile çalışacak CoroutineScope(testDispatcher).launch { // 4 milisaniye bekle delay(4) // İşlem tamamlandığında yazdır print("Tamamlandı2") } // Üçüncü coroutine: 6ms gecikme ile çalışacak CoroutineScope(testDispatcher).launch { // 6 milisaniye bekle delay(6) // İşlem tamamlandığında yazdır print("Tamamlandı3") } // 5 kez tekrarla for (i in 1..5) { // İlerleme göstergesi olarak nokta yazdır print(".") // Zamanı 1ms ilerlet testDispatcher.scheduler.advanceTimeBy(1) // Hazır olan coroutine'leri çalıştır testDispatcher.scheduler.runCurrent() } } // ..Tamamlandı..Tamamlandı2.
advanceTimeBy fonksiyonunun runCurrent ile birlikte nasıl kullanılabileceğine dair daha kapsamlı bir örnekyer almaktadır.
Bu sistem perde arkasında nasıl çalışır?delayçağrıldığında, kullanılan dispatcher'ın (yani
ContinuationInterceptoranahtarına sahip sınıfın)Delayarayüzünü (interface) uygulayıp uygulamadığı kontrol
edilir (StandardTestDispatcherbu arayüzü uygular). Bu tür dispatcher'lar için,delayçağrısıDefaultDelay
üzerinden gerçek zamanlı bekleme yerine, doğrudan dispatcher'ınscheduleResumeAfterDelayfonksiyonunu çağırır.
Thread.sleep kullanılması, StandardTestDispatcher ile çalışan coroutine'i etkilemez. Ayrıca, advanceUntilIdleçağrısı yalnızca birkaç milisaniye sürer; gerçek zamanı beklemez. Bu çağrı, sanal zamanı anında ileri sarar ve ilgili
coroutine işlemlerini yürütür.
import kotlinx.coroutines.* import kotlinx.coroutines.test.StandardTestDispatcher import kotlin.random.Random import kotlin.system.measureTimeMillis fun main() { // Test için özel bir dispatcher oluşturulur val dispatcher = StandardTestDispatcher() // Dispatcher üzerinde bir coroutine başlatılır CoroutineScope(dispatcher).launch { // 1 saniye bekler (sanal zaman) delay(1000) // İşlem tamamlandığında mesaj yazdırır println("Coroutine tamamlandı") } // Ana thread rasgele bir süre bekletilir (gerçek zaman) Thread.sleep(Random.nextLong(2000)) // Ne kadar beklediğimiz önemli değil, // bu bekleme sonucu etkilemez. // advanceUntilIdle() fonksiyonunun çalışma süresini ölçer (gerçek zaman) val time = measureTimeMillis { // İşlem öncesi sanal zamanı yazdırır println("[${dispatcher.scheduler.currentTime}] Önce") // Tüm coroutine'ler tamamlanana kadar sanal zamanı ilerletir dispatcher.scheduler.advanceUntilIdle() // İşlem sonrası sanal zamanı yazdırır println("[${dispatcher.scheduler.currentTime}] Sonra") } // İşlemin aldığı gerçek süreyi yazdırır println("$time ms sürdü") } // [0] Önce // Coroutine tamamlandı // [1000] Sonra // Took 15 ms (veya başka küçük bir değer)
StandardTestDispatcher kullanıyor ve bunu bir CoroutineScope ile sarmalıyorduk. Bunun yerineTestScope kullanabiliriz; bu yapı aynı işlevi görür (ve ayrıca tüm hataları CoroutineExceptionHandler ile toplar).advanceUntilIdle, advanceTimeBy gibi fonksiyonları veya currentTimeözelliğini kullanabilmemizdir. Bu işlevlerin tamamı, scope tarafından kullanılan zamanlayıcıya (scheduler) delege
edilir. Bu da oldukça kullanışlıdır.
import kotlinx.coroutines.delay import kotlinx.coroutines.launch import kotlinx.coroutines.test.* fun main() { // Test için özel bir coroutine kapsamı oluşturulur val scope = TestScope() // Bu kapsamda bir coroutine başlatılır scope.launch { // İlk 1 saniye bekle (sanal zaman) delay(1000) // İlk aşama tamamlandığında mesaj yazdır println("İlk aşama tamamlandı") // İkinci 1 saniye bekle (sanal zaman) delay(1000) // Tüm işlem tamamlandığında mesaj yazdır println("Coroutine tamamlandı") } // Başlangıçtaki sanal zamanı yazdır println("[${scope.currentTime}] Başlangıç") // [0] Başlangıç // Sanal zamanı 1000ms ilerlet scope.advanceTimeBy(1000) // O an çalışmaya hazır olan tüm coroutine'leri çalıştır scope.runCurrent() // İlk aşama tamamlandı // Ara noktadaki sanal zamanı yazdır println("[${scope.currentTime}] Orta nokta") // [1000] Orta nokta // Tüm coroutine'ler tamamlanana kadar sanal zamanı ilerlet scope.advanceUntilIdle() // Coroutine tamamlandı // Son noktadaki sanal zamanı yazdır println("[${scope.currentTime}] Bitiş") // [2000] Bitiş }
StandardTestDispatcher genellikle Android üzerinde ViewModel, Presenter, Fragmentgibi bileşenleri test etmek için doğrudan kullanılır. Aynı şekilde,
produceCurrentUserSeq ve produceCurrentUserSymfonksiyonlarını test etmek için de kullanılabilir; bu fonksiyonlar bir coroutine içinde başlatılır, zaman
advanceUntilIdle ile ilerletilir ve ne kadar sanal zaman geçtiği kontrol edilir. Ancak bu yöntem oldukça karmaşıktır.Bunun yerine, bu tür senaryolar için özel olarak tasarlanmış olan
runTest fonksiyonunu kullanmalıyız.runTest, kotlinx-coroutines-test kütüphanesindeki en yaygın kullanılan fonksiyondur. Bu fonksiyon, içinde birTestScope barındıran bir coroutine başlatır ve zaman hemen advanceUntilIdle ile ilerletilir. Bu coroutine’in içindekullanılan scope,
TestScope türündedir; dolayısıyla istediğimiz herhangi bir noktada currentTime değerini kontroledebiliriz. Bu sayede coroutine’lerde zamanın nasıl aktığını görebilirken, testlerimiz yalnızca milisaniyeler içinde
çalışır.
runTest, runBlocking gibi davranır; ancak sanal zaman üzerinde çalışır. Aşağıda yer alan testleryalnızca birkaç milisaniye içinde tamamlanır ve
currentTime değeri tam olarak beklediğimiz gibi olur.class TestTest { @Test fun test1() = runTest { // Başlangıçta sanal zamanın 0 olduğunu doğrula assertEquals(0, currentTime) // 1000ms bekle (sanal zaman) delay(1000) // Sanal zamanın 1000ms ilerlediğini doğrula assertEquals(1000, currentTime) } @Test fun test2() = runTest { // Başlangıçta sanal zamanın 0 olduğunu doğrula assertEquals(0, currentTime) // Bir coroutine kapsamı oluştur ve içinde farklı gecikme sürelerine sahip coroutine'ler başlat coroutineScope { launch { delay(1000) } // 1000ms gecikme launch { delay(1500) } // 1500ms gecikme launch { delay(2000) } // 2000ms gecikme } // coroutineScope tüm alt coroutine'ler tamamlanana kadar dönmeyeceğinden, // sanal zamanın en uzun gecikme süresi olan 2000ms'ye eşit olduğunu doğrula assertEquals(2000, currentTime) } }

runTest includes TestScope, that includes StandardTestDispatcher, that includesTestCoroutineScheduler.dönelim.
runTest ile bu fonksiyonları test etmek oldukça kolaydır. Sahte (fake) repository'mizin her fonksiyon çağrısıiçin 1 saniye gecikmeye ihtiyaç duyduğunu varsayarsak:
- Ardışık çalışan fonksiyonun toplamda 2 saniye,
- Eşzamanlı çalışan fonksiyonun ise yalnızca 1 saniye sürmesi beklenir.
currentTime değerleri tam olarakbeklendiği gibi olur.
private val userDataRepository = FakeDelayedUserDataRepository() private val useCase = ProduceUserUseCase(userDataRepository) @Test fun `Should produce user synchronously`() = runTest { // Senkron kullanıcı üretme işlemi çağrıldığında // Bu metot içinde muhtemelen repository.getUserData() ve repository.getAdditionalUserData() // ardışık olarak çağrılır, her biri 1000ms bekler, toplam 2000ms useCase.produceCurrentUserSync() // Sanal zamanın 2000ms olduğu doğrulanır // Senkron işlemde tüm adımlar sırayla çalıştığından toplam süre ikisinin toplamıdır assertEquals(2000, currentTime) } @Test fun `Should produce user asynchronous`() = runTest { // Asenkron kullanıcı üretme işlemi çağrıldığında // Bu metot içinde muhtemelen repository.getUserData() ve repository.getAdditionalUserData() // paralel olarak çağrılır, her biri 1000ms bekler, ama aynı anda çalıştıklarından toplam süre 1000ms useCase.produceCurrentUserAsync() // Sanal zamanın 1000ms olduğu doğrulanır // Asenkron işlemde adımlar paralel çalıştığından, toplam süre en uzun adımın süresidir assertEquals(1000, currentTime) }
sequential) çalışan bir fonksiyonun nasıl test edileceğine dair tam bir örneği inceleyelim:
// Kullanıcı verisini çekmekten sorumlu use case sınıfı. // Temiz Mimari (Clean Architecture) prensibine uygun olarak repository'ye bağımlıdır. class FetchUserUseCase( // Veri kaynağı bağımlılığı dışarıdan enjekte edilir (Dependency Injection) private val repo: UserDataRepository, ) { // Kullanıcı verisini asenkron olarak çeker. // @return Çekilen veriden oluşturulmuş User nesnesi suspend fun fetchUserData(): User = coroutineScope { // İsim bilgisini asenkron olarak çeker val name = async { repo.getName() } // Arkadaş listesini asenkron olarak çeker val friends = async { repo.getFriends() } // Profil bilgisini asenkron olarak çeker val profile = async { repo.getProfile() } // Tüm asenkron işlemlerin sonuçlarını bekler ve birleştirir // await() çağrıları sırasında coroutine askıya alınır, ancak thread bloke olmaz User( // İsim sonucunu bekler name = name.await(), // Arkadaş listesi sonucunu bekler friends = friends.await(), // Profil sonucunu bekler profile = profile.await() ) } } // Kullanıcı verisi çekme işlevselliğini test eden sınıf. // JUnit test framework ile çalışır. class FetchUserDataTest { // Eşzamanlı (concurrent) veri çekme işlemini test eden metot. // runTest bloğu, coroutine testleri için sanal zaman ortamı oluşturur. @Test fun `should fetch user concurrently`() = runTest { // Gerçek repository yerine geçen sahte implementasyon val userRepo = FakeUserDataRepository() // Test edilecek use case nesnesi val useCase = FetchUserUseCase(userRepo) // Test edilen metot çağrılır val result = useCase.fetchUserData() // Beklenen kullanıcı adı, arkadaş listesi ve profil bilgisi ile bir User nesnesi oluşturulur val expectedUser = User( // Beklenen kullanıcı adı name = "Ben", // Beklenen arkadaş listesi friends = listOf(Friend("some-friend-id-1")), // Beklenen profil bilgisi profile = Profile("Örnek açıklama") ) // Dönen sonucun beklenen değere eşit olup olmadığı kontrol edilir assertEquals(expectedUser, result) // Sanal zamanın doğru değerde olup olmadığı kontrol edilir // Eğer işlemler sırayla yapılsaydı 3000ms geçerdi, paralel yapıldığı için 1000ms geçmiş olmalı assertEquals(1000, currentTime) } // Test için kullanılan sahte repository implementasyonu. // Gerçek bir API çağrısı yapmadan, kontrollü test verisi döndürür. class FakeUserDataRepository : UserDataRepository { // Kullanıcı adını getiren sahte metot. override suspend fun getName(): String { // Ağ gecikmesini simüle eder (sanal zaman) delay(1000) // Sabit test verisi döndürür return "Ben" } // Kullanıcının arkadaş listesini getiren sahte metot. override suspend fun getFriends(): List<Friend> { // Ağ gecikmesini simüle eder (sanal zaman) delay(1000) // Sabit test verisi döndürür return listOf(Friend("some-friend-id-1")) } // Kullanıcı profilini getiren sahte metot. override suspend fun getProfile(): Profile { // Ağ gecikmesini simüle eder (sanal zaman) delay(1000) // Sabit test verisi döndürür return Profile("Örnek açıklama") } } } // Kullanıcı verilerine erişimi tanımlayan arayüz (interface). // Bağımlılık Tersine Çevirme (Dependency Inversion) prensibini uygular. interface UserDataRepository { // Kullanıcı adını asenkron olarak getirir. suspend fun getName(): String // Kullanıcının arkadaşlarını asenkron olarak getirir. suspend fun getFriends(): List<Friend> // Kullanıcı profilini asenkron olarak getirir. suspend fun getProfile(): Profile } // Kullanıcı verilerini taşıyan veri sınıfı (data class). // Equals, hashCode, toString ve copy metotları otomatik olarak oluşturulur. data class User( // Kullanıcı adı. val name: String, // Kullanıcının arkadaş listesi. val friends: List<Friend>, // Kullanıcı profil bilgileri. val profile: Profile ) // Arkadaş verisi taşıyan basit veri sınıfı. data class Friend( // Arkadaş benzersiz tanımlayıcısı. val id: String ) // Profil bilgilerini taşıyan veri sınıfı. data class Profile( // Profil açıklaması. val description: String )
runTest fonksiyonu bir scope oluşturur; bu tür tüm fonksiyonlar gibi, içinde başlatılan alt coroutine'lerin (children)tamamlanmasını bekler. Bu da şu anlama gelir: eğer test içinde sonlanmayan bir işlem başlatırsanız, test sonsuza kadar
çalışmaya devam eder.
@Test fun `should increment counter`() = runTest { var i = 0 launch { while (true) { delay(1000) i++ } } delay(1001) assertEquals(1, i) delay(1000) assertEquals(2, i) // Test, aşağıdaki satır eklenirse geçer: // coroutineContext.job.cancelChildren() }
runTest, backgroundScope adlı bir çözüm sunar. Bu scope da aynı zamanlayıcının sanal zamanı (virtual time) üzerinde çalışır; ancak
runTest, bu scope içindeki coroutine'leri kendi alt işlemleri (children) olarakgörmez ve tamamlanmalarını beklemez.
backgroundScope, testin tamamlanmasınıbeklemesini istemediğimiz tüm işlemleri başlatmak için kullanılır.
// Backtick'ler arasında verilen isimle test fonksiyonu tanımlanıyor ve runTest ile çalıştırılıyor // runTest, coroutine'ler için sanal bir zaman ortamı sağlar @Test fun `should increment counter`() = runTest { // Sayacımız olan i değişkenini 0 olarak başlatıyoruz var i = 0 // Arka planda çalışacak yeni bir coroutine başlatıyoruz launch { // Sonsuz bir döngü başlatıyoruz, bu coroutine iptal edilmezse sonsuza dek çalışır while (true) { // 1 saniye (1000 ms) bekliyoruz - runTest ile bu bekleme sanal zamanda gerçekleşir delay(1000) // Sayacı bir artırıyoruz i++ } } // Ana coroutine'de 1001 ms bekliyoruz ki ilk artırma gerçekleşsin delay(1001) // Sayacın değerinin 1 olduğunu kontrol ediyoruz assertEquals(1, i) // Tekrar 1000 ms bekliyoruz ki ikinci artırma gerçekleşsin delay(1000) // Sayacın değerinin 2 olduğunu kontrol ediyoruz assertEquals(2, i) // Bu yorum testin nasıl düzeltileceğini açıklıyor // Test, aşağıdaki satır eklenirse geçer: // coroutineContext.job.cancelChildren() // Bu satır, bu test fonksiyonu ile başlatılan tüm alt coroutine'leri iptal eder // Sonsuz döngü içinde çalışan coroutine'i durdurarak bellek sızıntısını önler }
istiyorsanız, en kolay yöntem askıya alınabilir (suspending) bir fonksiyon içerisinden coroutine bağlamını (context)
yakalamaktır. Daha sonra bu bağlamın beklenen değeri içerip içermediğini veya job nesnesinin uygun durumda (örneğin
aktif, iptal edilmiş vs.) olup olmadığını kontrol edebilirsiniz.
mapAsync fonksiyonu, bir liste öğelerinin asenkron şekilde eşlenmesini (asynchronous mapping)gerçekleştirir.
// Herhangi bir Iterable koleksiyonu için asenkron mapping işlemi yapan extension function // T: Koleksiyondaki elemanların tipi // R: Dönüşüm sonrası elde edilecek elemanların tipi suspend fun <T, R> Iterable<T>.mapAsync( // Her eleman için uygulanacak asenkron dönüşüm fonksiyonu transformation: suspend (T) -> R ): List<R> = coroutineScope { // 1. this@mapAsync: Bu extension function'ın çağrıldığı Iterable nesnesini ifade eder // 2. map: Her elemana bir işlem uygulayıp yeni bir liste oluşturur // 3. async: Her dönüşümü ayrı bir coroutine'de paralel olarak başlatır // 4. transformation(it): Her elemana uygulanan asenkron dönüşüm işlemidir [email protected] { async { transformation(it) } } // awaitAll: Tüm async işlemlerinin tamamlanmasını bekler ve sonuçları liste olarak döndürür .awaitAll() }
doğrulanabilir.
// Bu test, mapAsync fonksiyonunun elemanları paralel işlerken orijinal sırayı koruduğunu doğrular @Test fun `should map async and keep elements order`() = runTest { // Farklı gecikme süreleriyle asenkron işlemler içeren bir liste oluşturulur val transforms = listOf( suspend { delay(3000); "A" }, // 3 saniye bekleyip "A" döndüren asenkron işlem suspend { delay(2000); "B" }, // 2 saniye bekleyip "B" döndüren asenkron işlem suspend { delay(4000); "C" }, // 4 saniye bekleyip "C" döndüren asenkron işlem suspend { delay(1000); "D" }, // 1 saniye bekleyip "D" döndüren asenkron işlem ) // mapAsync kullanarak tüm işlemleri paralel çalıştırıp sonuçları toplar val res = transforms.mapAsync { it() } // Sonuçların, işlemler farklı zamanlarda tamamlansa bile // liste içindeki orijinal sırayı koruduğunu doğrular assertEquals(listOf("A", "B", "C", "D"), res) // Paralel çalışma sayesinde toplam süre, en uzun süren işlem kadar olmalıdır (4000ms) // Eğer sırayla (senkron) çalışsaydı, süre 10000ms (3000+2000+4000+1000) olurdu assertEquals(4000, currentTime) }
yapılandırılmış eşzamanlılık (structured concurrency) ilkesine uyması da beklenir. Bunu kontrol etmenin en kolay yolu,
üst coroutine'e (
parent coroutine) bir bağlam (context) örneği —örneğin CoroutineName— vermek ve bu bağlamıntransformation fonksiyonu içinde hâlâ korunup korunmadığını kontrol etmektir.currentCoroutineContext fonksiyonu ya dacoroutineContext özelliği kullanılabilir. Ancak, coroutine builder’lar veya scope fonksiyonları içinde iç içe geçmişlambda ifadelerinde
currentCoroutineContext fonksiyonunu kullanmak gerekir. Çünkü CoroutineScope içerisindekicoroutineContext özelliği, o anda geçerli olan coroutine bağlamını sağlayan özelliğin (property) önüne geçerek bağlamıgölgeleme (shadowing) yapabilir.
@Test // Bu test, mapAsync fonksiyonunun coroutine context'lerini doğru şekilde aktardığını doğrular fun `should support context propagation`() = runTest { // Coroutine context'i saklamak için değişken tanımlanır var ctx: CoroutineContext? = null // İlk test için bir coroutine adı tanımlanır val name1 = CoroutineName("Name 1") // Bu isme sahip bir context ile blok çalıştırılır withContext(name1) { // mapAsync fonksiyonu tek elemanlı bir listeye uygulanır listOf("A").mapAsync { // İçerideki coroutine'in context'i kaydedilir ctx = currentCoroutineContext() // Değer değiştirilmeden geri döndürülür it } } // İçerideki coroutine'in, dışarıdaki CoroutineName'i doğru şekilde aldığı doğrulanır assertEquals(name1, ctx?.get(CoroutineName)) // İkinci test için farklı bir coroutine adı tanımlanır val name2 = CoroutineName("Some name 2") // Bu isme sahip bir context ile blok çalıştırılır withContext(name2) { // mapAsync fonksiyonu çok elemanlı bir listeye uygulanır listOf(1, 2, 3).mapAsync { // İçerideki coroutine'in context'i kaydedilir ctx = currentCoroutineContext() // Değer değiştirilmeden geri döndürülür it } } // İçerideki coroutine'in, dışarıdaki yeni CoroutineName'i doğru şekilde aldığı doğrulanır assertEquals(name2, ctx?.get(CoroutineName)) }
sonra bu job’ın gerçekten iptal edilip edilmediğini doğrulamaktır.
// Bu test, mapAsync fonksiyonunun iptal mekanizmasını doğru şekilde desteklediğini kontrol eder @Test fun `should support cancellation`() = runTest { // İçerideki coroutine'in job referansını saklamak için değişken tanımlanır var job: Job? = null // Bir üst coroutine başlatılır ve referansı saklanır val parentJob = launch { // mapAsync fonksiyonu bir listeye uygulanır listOf("A").mapAsync { // İçerideki coroutine'in job referansı kaydedilir job = currentCoroutineContext().job // Çok uzun bir süre bekletilir (pratik olarak sonsuz) // Bu, coroutine'i iptal etmeden tamamlanmasını engeller delay(Long.MAX_VALUE) } } // Test ortamında 1000ms beklenir delay(1000) // Üst coroutine iptal edilir parentJob.cancel() // İçerideki (mapAsync içindeki) job'ın da iptal edilmiş olduğu doğrulanır assertEquals(true, job?.isCancelled) }
faydalı buluyorum. Yapılandırılmış eşzamanlılık (structured concurrency) kuralına uyulup uyulmadığı her zaman açıkça
belli olmayabilir. Yukarıdaki her iki test de, eğer
async dış bir scope içinde başlatılmış olsaydı başarısız olurdu.// Hatalı implementasyon - aşağıdaki sorunları içermektedir suspend fun <T, R> Iterable<T>.mapAsync( transformation: suspend (T) -> R ): List<R> = this@mapAsync // GlobalScope kullanımı hata kaynağı! .map { GlobalScope.async { transformation(it) } } .awaitAll()
StandardTestDispatcher dışında bir de UnconfinedTestDispatcher vardır. Bu iki dispatcher arasındaki en büyük farkşudur:
StandardTestDispatcher, zamanlayıcısı (scheduler) manuel olarak kullanılmadıkça hiçbir işlemi başlatmaz.UnconfinedTestDispatcherise coroutine başladığında, ilkdelayçağrısına kadar olan tüm işlemleri hemen
çalıştırır. Bu nedenle aşağıdaki gibi bir kod "C" çıktısını üretir.
import kotlinx.coroutines.* import kotlinx.coroutines.test.* fun main() { // StandardTestDispatcher ile bir coroutine başlatılıyor CoroutineScope(StandardTestDispatcher()).launch { print("A") delay(1) print("B") } // UnconfinedTestDispatcher ile bir coroutine başlatılıyor CoroutineScope(UnconfinedTestDispatcher()).launch { print("C") delay(1) print("D") } } // Çıktı: C
runTest fonksiyonu, kotlinx-coroutines-test kütüphanesinin 1.6 sürümüyle birlikte tanıtılmıştır. Daha önce,davranışı
UnconfinedTestDispatcher kullanan runTest’e çok daha yakın olan runBlockingTest fonksiyonukullanılıyordu. Dolayısıyla, doğrudan
runBlockingTest’ten runTest’e geçiş yapmak istiyorsanız, testleriniz aşağıdakigibi görünebilir.
// Bu test fonksiyonunu JUnit veya TestNG gibi bir test kütüphanesi için işaretler @Test // runTest: Kotlin Coroutines test fonksiyonu, UnconfinedTestDispatcher: Coroutine'leri hemen çalıştıran özel dispatcher fun testName() = runTest(UnconfinedTestDispatcher()) { // Test içinde yapılacak işlemler buraya yazılacak //... }
UnconfinedTestDispatcher yerineStandardTestDispatcher kullanmanızı öneririm. Çünkü StandardTestDispatcher, artık yeni standart olarak kabuledilmektedir.
delay kullanmak kolaydır ancak çok açık (explicit) değildir. Bu nedenle birçok geliştirici,delay çağrılarını doğrudan test fonksiyonunun içinde yapmayı tercih eder.// Bu test fonksiyonu, verilerin eşzamanlı (concurrently) olarak yüklendiğini doğrulamak için tasarlanmıştır @Test // Özel karakterler içeren test adı için Kotlin'in backtick sözdizimi kullanılmıştır fun `should load data concurrently`() = runTest { // Test verileri ve beklentileri ayarlanır // UserDataRepository'nin sahte bir versiyonu oluşturulur (mockk kütüphanesi kullanarak) val userRepo = mockk<UserDataRepository>() // getName metodu çağrıldığında 600ms bekleyip sonra aName değerini döndürecek şekilde ayarlanır coEvery { userRepo.getName() } coAnswers { delay(600) aName } // getFriends metodu çağrıldığında 700ms bekleyip sonra someFriends değerini döndürecek şekilde ayarlanır coEvery { userRepo.getFriends() } coAnswers { delay(700) someFriends } // getProfile metodu çağrıldığında 800ms bekleyip sonra aProfile değerini döndürecek şekilde ayarlanır coEvery { userRepo.getProfile() } coAnswers { delay(800) aProfile } // Test edilecek use case sınıfının bir örneği oluşturulur ve mock repository ona verilir val useCase = FetchUserUseCase(userRepo) // Test senaryosu uygulanır // useCase'in fetchUserData metodu çağrılır useCase.fetchUserData() // Beklenen sonuç doğrulanır // Eğer tüm işlemler paralel olarak çalıştıysa, toplam süre en uzun işlemin süresi (800ms) kadar olmalıdır assertEquals(800, currentTime) }
Yukarıdaki örnekte MockK kütüphanesini kullandım.
belirtmeleri gerektiğini açıklamıştım. Örneğin:
- Bloklayıcı (blocking) işlemler için
Dispatchers.IO(veya özel bir dispatcher), - CPU yoğunluklu işlemler için ise
Dispatchers.Defaultkullanırız.
// Oyun kayıt durumunu dosyadan okuyan suspend fonksiyon. // Bloke edici dosya okuma işlemini IO dispatcher üzerinde gerçekleştirerek ana thread'i bloke etmez. // // @param name Okunacak kayıt dosyasının adı // @return Dosyadan yüklenen oyun durumu nesnesi suspend fun readSave(name: String): GameState = // Dispatchers.IO kullanarak dosya okuma işlemini IO thread havuzunda gerçekleştirir // Bu, ana thread'i (genellikle UI thread) bloke etmeden I/O işlemlerinin yapılmasını sağlar withContext(Dispatchers.IO) { // CSV formatındaki dosyayı okuyup GameState nesnesine dönüştüren bloke edici çağrı // Bu metot içinde bloke olmak güvenlidir çünkü withContext(Dispatchers.IO) içinde çalışıyor reader.readCsvBlocking(name, GameState::class.java) } // Makine öğrenmesi modelini eğiten suspend fonksiyon. // Yoğun CPU işlemi gerektiren model eğitimini Default dispatcher üzerinde gerçekleştirir. // // @return Eğitim işleminin sonucu (model nesnesinden dönen değer) suspend fun calculateModel() = // Dispatchers.Default kullanarak CPU-yoğun hesaplamaları arka planda gerçekleştirir // Bu dispatcher, CPU çekirdeklerinin sayısına göre optimize edilmiş bir thread havuzu kullanır withContext(Dispatchers.Default) { // Makine öğrenmesi modelini eğitme fonksiyonu model.fit( dataset = newTrain, // Eğitim için kullanılacak veri seti epochs = 10, // Modelin veri setini 10 kez tamamen işleyeceğini belirtir batchSize = 100, // Her bir adımda 100 örneğin işleneceğini belirtir verbose = false // Eğitim sırasında ilerleme çıktısının gösterilmeyeceğini belirtir ) }
değildir. Bunu, farklı bir dispatcher üzerinde çalışması beklenen sahte (fake) veya taklit (mock) bir fonksiyonda
kullanılan bağlamı (context) ya da iş parçacığını (thread) yakalayarak yapabiliriz. Ancak bu tür kontroller yaygın
değildir, çünkü genellikle çok faydalı kabul edilmezler.
durumudur. Sanal zaman (virtual time) mekanizması dispatcher’a bağlı olarak çalışır; dolayısıyla dispatcher
değiştirildiğinde zamanın nasıl işlendiği de değişmiş olur.
işlemler bulunduğunda ortaya çıkabilir. Aşağıdaki fonksiyonu örnek olarak ele alalım:
// Kullanıcı verilerini asenkron ve paralel olarak getiren suspend fonksiyon. // Bu fonksiyon çağrıldığında mevcut thread'i bloke etmez, coroutine mimarisinin avantajlarını kullanır. suspend fun fetchUserData() = withContext(Dispatchers.IO) { // Kullanıcı ID'sini okuyan bloke edici çağrı. Bu adım diğer asenkron işlemlerden önce senkron olarak gerçekleştirilir. // Bloke edici bir çağrı olmasına rağmen Dispatchers.IO içinde çalıştığı için ana thread'i etkilemez. val userId = readUserId() // blocking call // Kullanıcı adını getiren asenkron işlem başlatılır. async{} yapısı bir Deferred<T> nesnesi döndürür. // Bu işlem, diğer iki async çağrısıyla eşzamanlı (paralel) olarak çalışmaya başlar. val name = async { userRepo.getName(userId) } // Kullanıcının arkadaşlarını getiren asenkron işlem başlatılır. Bu işlem hemen başlar ve arka planda çalışır. val friends = async { userRepo.getFriends(userId) } // Kullanıcı profilini getiren asenkron işlem başlatılır. Bu işlem de diğerleriyle eşzamanlı çalışır. val profile = async { userRepo.getProfile(userId) } // User nesnesi oluşturulur ve tüm asenkron işlemlerin tamamlanması beklenir. // await() çağrıları sırayla yazılmış olsa da, işlemler zaten önceden paralel olarak başlatılmıştır. // Bu nedenle, toplam süre en uzun süren işlemin süresi kadardır, üç işlemin toplamı değil. User( name = name.await(), // name Deferred nesnesinin sonucunu bekler ve alır friends = friends.await(), // friends Deferred nesnesinin sonucunu bekler ve alır profile = profile.await() // profile Deferred nesnesinin sonucunu bekler ve alır ) }
name, friends ve profile değişkenleriyle çağrılan getName, getFriends ve getProfile fonksiyonlarınıneşzamanlı (concurrent) olarak çalıştığını test etmek istiyorsanız, sadece
runTest kullanmak ve sahte (fake)fonksiyonlara
delay eklemek yeterli değildir. Bunun nedeni, fetchUserData fonksiyonu içerisinde Dispatchers.IOkullanılmasıdır; bu da
runTest tarafından varsayılan olarak sağlanan StandardTestDispatcher’ın etkisini ortadankaldırır.
getName, getFriends ve getProfile çağrılarındaki delay işlemleri sanal zaman (virtual time) yerinegerçek zaman (real time) üzerinden çalışır. Bu da testin beklenenden daha yavaş çalışmasına ve zaman kontrolünün
doğruluğunun bozulmasına yol açar.
Dispatchers.IO yerinedışarıdan enjekte edilebilen bir dispatcher kullanmaktır. Böylece test sırasında bu dispatcher,
runTest içinden gelenStandardTestDispatcher ile değiştirilebilir.// FetchUserUseCase sınıfı, kullanıcı verilerini getirmek için temiz mimari (clean architecture) // prensiplerine uygun bir kullanım durumu (use case) sınıfıdır. // Bu sınıf, fonksiyonel, test edilebilir ve bağımlılıkların enjeksiyonuna dayalı bir tasarıma sahiptir. class FetchUserUseCase( // UserDataRepository arayüzüne bağımlılık, bağımlılık enjeksiyonu prensibiyle sağlanır. // Bu, teste edilebilirliği artırır ve gerçek implementasyondan soyutlanmayı sağlar. private val userRepo: UserDataRepository, // coroutine dispatcher parametresi, varsayılan olarak IO dispatcher kullanır. // Bu parametre, test edilebilirliği artırmak için enjekte edilebilir yapıdadır. private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO ) { // Kullanıcı verilerini asenkron ve paralel olarak getiren suspend fonksiyon. // coroutine mimarisinin yapısal eşzamanlılık özelliklerini kullanarak verimli veri alımı sağlar. suspend fun fetchUserData() = withContext(ioDispatcher) { // Kullanıcı ID'sini okuyan bloke edici çağrı. Bu adım diğer işlemlerden önce tamamlanmalıdır. // I/O dispatcher içinde çalıştığı için ana thread'i bloke etmez. val userId = readUserId() // blocking call // Kullanıcı adını getiren asenkron işlemi başlatır. async{} coroutine oluşturucusu bir Deferred<T> nesnesi döndürür. // Bu, paralel yürütülecek bağımsız bir iş parçacığı başlatır. val name = async { userRepo.getName(userId) } // Kullanıcının arkadaşlarını getiren asenkron işlemi başlatır. // Bu işlem önceki işlemle eşzamanlı olarak çalışmaya başlar. val friends = async { userRepo.getFriends(userId) } // Kullanıcının profil bilgilerini getiren asenkron işlemi başlatır. // Bu işlem de diğer ikisiyle eşzamanlı olarak çalışır. val profile = async { userRepo.getProfile(userId) } // User nesnesi oluşturulur ve tüm asenkron işlemlerin tamamlanması beklenir. // await() çağrıları, işlemlerin sonuçlarını almak için kullanılır. // Burada önemli olan nokta, işlemlerin önceden paralel olarak başlatılmış olmasıdır. // Bu sayede toplam süre, en uzun süren işlemin süresi kadardır (maksimum paralellik). User( name = name.await(), // name Deferred'ın sonucunu bekler friends = friends.await(), // friends Deferred'ın sonucunu bekler profile = profile.await() // profile Deferred'ın sonucunu bekler ) } }
Dispatchers.IO sağlamak yerine, runTest tarafından sağlanan StandardTestDispatcher’ıkullanmalıyız. Bu dispatcher’a
coroutineContext üzerinden erişebiliriz.ContinuationInterceptor anahtarını kullanarak context’ten dispatcher’ı alabiliriz (veya deneysel olaraksunulan
CoroutineDispatcher anahtarını kullanabiliriz; bu anahtar, ContinuationInterceptor ile aynı bağlamı kullanırve sonucu
CoroutineDispatcher olarak dönüştürür/cast eder).// Bu kod parçası, coroutine tabanlı bir test ortamında FetchUserUseCase sınıfının // test edilebilir bir örneğinin oluşturulmasını göstermektedir. runTest bloğu içerisinde // kullanılır ve test amacıyla dispatcher enjeksiyonunun nasıl yapılacağını gösterir. // runTest bloğu içerisinde // Mevcut coroutine bağlamından test dispatcher'ını alır. // ContinuationInterceptor arayüzü, coroutine devam noktalarını yakalayıp yönlendiren // dispatcher mekanizmasını temsil eder. Bu özel dispatcher, testlerde coroutine // deterministik ve kontrollü bir şekilde çalışmasını sağlar. val testDispatcher = this .coroutineContext[ContinuationInterceptor] as CoroutineDispatcher // ya da alternatif olarak : // val testDispatcher = this // .coroutineContext[CoroutineDispatcher] // FetchUserUseCase sınıfının test edilebilir bir örneğini oluşturur. // userRepo: Test için hazırlanmış sahte (mock) veya test doubleları kullanılır. // ioDispatcher: Gerçek Dispatchers.IO yerine test dispatcher'ı enjekte edilir. // Bu yaklaşım, testlerin gerçek I/O işlemlerini kullanmadan, // kontrollü ve hızlı bir şekilde çalışmasını sağlar. val useCase = FetchUserUseCase( userRepo = userRepo, ioDispatcher = testDispatcher, )
ioDispatcher parametresini CoroutineContext olarak tanımlamaktır. Bu durumda, birim testlerdebu parametreyi
EmptyCoroutineContext ile değiştirebiliriz. Nihai davranış yine aynı olur; çünkü testlerdefetchUserData fonksiyonu dispatcher değiştirmeyeceğinden, varsayılan olarak StandardTestDispatcher kullanılır.CoroutineDispatcher yerine CoroutineContext türünündispatcher olarak kullanılmasını tercih etmez. Çünkü
CoroutineContext, yalnızca dispatcher değil, başka bilgiler de (örneğin
Job, CoroutineName) içerebilir.// Bu kod parçası, testlerde EmptyCoroutineContext kullanımını göstermektedir. // EmptyCoroutineContext, CoroutineContext arayüzünün boş bir implementasyonudur ve // dispatcher davranışı için özel bir değer enjekte etmek yerine, çağrıldığı mevcut // bağlamın dispatcher'ını kullanmasına izin verir. val useCase = FetchUserUseCase( userRepo = userRepo, ioDispatcher = EmptyCoroutineContext, )
tamamlayıp gizliyor:
// Kullanıcı verilerini gönderen suspend (askıya alınabilir) fonksiyon. // Bu fonksiyon, coroutine içinde çağrılabilir ve çağrıldığı thread'i bloke etmeden // asenkron işlemleri sıralı bir şekilde gerçekleştirir. suspend fun sendUserData() { // Veritabanından kullanıcı verilerini asenkron olarak alır. // Bu çağrı, suspend işaretli olduğundan coroutine içinde güvenle çağrılabilir. // İşlem tamamlanana kadar coroutine askıya alınır, ancak thread bloke olmaz. val userData = database.getUserData() // İlerleme çubuğunun görünürlüğünü true olarak ayarlar. // Bu muhtemelen bir State<Boolean> veya MutableLiveData<Boolean> tipinde // reaktif bir değişkendir ve UI'da bir ilerleme çubuğunun görünürlüğünü kontrol eder. progressBarVisible.value = true // Kullanıcı verilerini uzak sunucuya asenkron olarak gönderir. // Bu işlem, suspend fonksiyon olduğundan coroutine içinde askıya alınır. // İşlem tamamlanana kadar mevcut coroutine bekletilir, ancak thread serbest kalır. userRepository.sendUserData(userData) // Veri gönderme işlemi tamamlandıktan sonra ilerleme çubuğunu gizler. // Bu satır, userRepository.sendUserData() çağrısı tamamlandıktan sonra // çalıştırılır ve UI'da ilerleme çubuğunu kapatır. progressBarVisible.value = false }
progress bar) gerçekten görünür hale gelip gelmediğini test edemeyiz. Bu tür durumlarda işe yarayan yöntem, ilgili
fonksiyonu yeni bir coroutine içinde başlatmak ve sanal zamanı (virtual time) dışarıdan kontrol etmektir.
runTest, StandardTestDispatcher kullanarak bir coroutine başlatır ve bu coroutine’inzamanını
advanceUntilIdle ile tamamlanana kadar ilerletir. Bu yapı nedeniyle, bu coroutine'in içindeki alt coroutine'lerin (children) zamanı, ancak üst coroutine onları beklemeye başladığında işlemeye başlar — yani ana gövde (body)
tamamlandığında.
advanceTimeBy, runCurrent veadvanceUntilIdle gibi fonksiyonları kullanabiliriz./** * Kullanıcı verileri gönderilirken ilerleme çubuğunun doğru şekilde gösterilip gizlendiğini * test eden birim test. * Bu test, korutin test ortamında (TestScope) çalışır ve sanal zamanı kontrol eder. */ @Test fun `should show progress bar when sending data`() = runTest { // HAZIRLIK: Test için gerekli nesneler oluşturuluyor val database = FakeDatabase() val vm = UserViewModel(database) // İŞLEM: sendUserData fonksiyonu ayrı bir korutin içinde başlatılıyor launch { vm.sendUserData() } // DOĞRULAMA: Başlangıçta ilerleme çubuğu görünür olmamalı assertEquals(false, vm.progressBarVisible.value) // İŞLEM: Sanal zaman 1000 milisaniye ilerletiliyor advanceTimeBy(1000) // DOĞRULAMA: İlerleme çubuğu hala görünür olmamalı çünkü korutin hala beklemede assertEquals(false, vm.progressBarVisible.value) // İŞLEM: Bekleyen korutinler yürütülüyor runCurrent() // DOĞRULAMA: Artık ilerleme çubuğu görünür hale gelmiş olmalı assertEquals(true, vm.progressBarVisible.value) // İŞLEM: Tüm işlemler tamamlanana kadar sanal zaman ilerletiliyor advanceUntilIdle() // DOĞRULAMA: İşlem tamamlandığında ilerleme çubuğu tekrar gizlenmiş olmalı assertEquals(false, vm.progressBarVisible.value) }
runCurrentsayesinde, bir değerin tam olarak ne zaman değiştiğini kesin biçimde kontrol edebileceğimizi unutmayın.
delay kullanılarak da elde edilebilir. Bu yaklaşım, biri test edilen işlemi çalıştıran, diğeri ise buişlemin yan etkilerini kontrol eden iki bağımsız işlem (process) yürütmeye benzer.
/** * Bu test, kullanıcı verilerini gösterirken ilerleme çubuğunun doğru şekilde * görüntülenip gizlendiğini kontrol eder. * * runTest bloğu, Kotlin korutinlerinin test edilmesi için sanal bir zaman ortamı oluşturur. * Bu sayede asenkron kodlar deterministik bir şekilde test edilebilir. */ @Test fun `should show progress bar when sending data`() = runTest { // Test için gerekli sahte veri tabanı ve ViewModel nesneleri oluşturuluyor val database = FakeDatabase() val vm = UserViewModel(database) // ViewModel'in showUserData metodu ayrı bir korutin içinde başlatılıyor // Bu sayede ana test korutini ve işlevsellik korutini paralel çalışabilir launch { vm.showUserData() } // İlk kontrol: Başlangıçta ilerleme çubuğunun gizli olduğu doğrulanıyor assertEquals(false, vm.progressBarVisible.value) // 1000 milisaniye (1 saniye) bekleniyor // delay fonksiyonu runTest içinde gerçek zamanı beklemeden sanal zamanı ilerletir delay(1000) // İkinci kontrol: 1 saniye sonra ilerleme çubuğunun görünür hale geldiği doğrulanıyor assertEquals(true, vm.progressBarVisible.value) // 1000 milisaniye (1 saniye) daha bekleniyor delay(1000) // Son kontrol: İşlem tamamlandıktan sonra ilerleme çubuğunun tekrar gizlendiği doğrulanıyor assertEquals(false, vm.progressBarVisible.value) }
Ancak bu tür durumlardaadvanceTimeBygibi açık fonksiyonları kullanmak,delaykullanmaktan daha okunabilir ve
daha öngörülebilir kabul edilir. Yine de her iki yaklaşım da geçerlidir.
framework (örneğin Spring veya Ktor) tarafından yapılır. Ancak bazı durumlarda coroutine başlatmak için kendi
scope’umuzu oluşturmamız ve coroutine’leri bu scope üzerinden başlatmamız gerekebilir.
/** * Her 5 saniyede bir çalışan zamanlanmış bir görev. * * @Scheduled anotasyonu, Spring Framework tarafından sağlanan, belirli aralıklarla * metod çalıştırmak için kullanılan bir anotasyondur. * * fixedRate = 5000 parametresi, bu metodun her 5000 milisaniye (5 saniye) aralıklarla * düzenli olarak çalıştırılacağını belirtir. */ @Scheduled(fixedRate = 5000) fun sendNotifications() { // 'notificationsScope' muhtemelen bu sınıf için tanımlanmış bir CoroutineScope'tur. // Bu kod, notifikasyon işlemlerini bu scope içinde çalıştırarak ana thread'i bloke etmez. notificationsScope.launch { // Gönderilmesi gereken bildirimleri veritabanından veya başka bir kaynaktan alır. // Bu muhtemelen bir suspend fonksiyondur ve asenkron olarak çalışır. val notifications = notificationsRepository .notificationsToSend() // Alınan her bir bildirim için ayrı bir işlem başlatır. for (notification in notifications) { // Her bildirim için ayrı bir korutin başlatılır. // Bu sayede bildirimler paralel olarak işlenebilir, // bir bildirimin gecikmesi diğerlerini etkilemez. launch { // Bildirimi gönderme servisini çağırır. Bu, ağ isteği gibi uzun sürebilecek bir // işlem olduğundan muhtemelen suspend fonksiyondur. notificationsService.send(notification) // Bildirim başarıyla gönderildikten sonra veritabanında bildirim durumunu // "gönderildi" olarak işaretler. Bu da muhtemelen bir suspend fonksiyondur. notificationsRepository .markAsSent(notification.id) } } } }
sendNotifications fonksiyonunun bildirimleri gerçekten eşzamanlı olarak gönderip göndermediğini nasıl test edebiliriz? Yine, birim testlerde StandardTestDispatcher kullanmamız gerekir; bu dispatcher test kapsamının (scope) bir parçası olmalıdır. Ayrıca, send ve markAsSent fonksiyonlarına bazı delay çağrıları eklemeliyiz.@Test fun testSendNotifications() { // ön koşul: 100 bildirim oluşturuluyor (given) val notifications = List(100) { Notification(it) } // sahte repository, her işlem için 200 ms gecikmeli çalışacak şekilde tanımlanıyor val repo = FakeNotificationsRepository( delayMillis = 200, notifications = notifications, ) // sahte servis, her gönderim için 300 ms gecikmeli çalışacak şekilde tanımlanıyor val service = FakeNotificationsService( delayMillis = 300, ) // TestScope sanal zaman ile oluşturuluyor val testScope = TestScope() // test edilecek bileşen oluşturuluyor val sender = NotificationsSender( notificationsRepository = repo, notificationsService = service, notificationsScope = testScope ) // işlem: bildirim gönderimi başlatılıyor (when) sender.sendNotifications() // sanal zaman tüm işlemler tamamlanana kadar ilerletiliyor testScope.advanceUntilIdle() // sonuç: tüm bildirimler başarıyla gönderilmiş olmalı (then) assertEquals( notifications.toSet(), service.notificationsSent.toSet() ) // sonuç: tüm bildirimler gönderilmiş olarak işaretlenmiş olmalı (then) assertEquals( notifications.map { it.id }.toSet(), repo.notificationsMarkedAsSent.toSet() ) // ve: işlemler eşzamanlı (concurrent) gerçekleştiği için toplam süre en uzun işlem süresine eşit olmalı assertEquals(700, testScope.currentTime) }
Yukarıdaki koddarunBlockingkullanılmasına gerek yoktur. HemsendNotificationshem deadvanceUntilIdlenormal
fonksiyonlardır.
durumlar yaygındır.Bu tür durumlarda, bir coroutine başlatmak için
runTest fonksiyonunu kullanabiliriz ve testettiğimiz sınıfa aynı
sanal zamanı kullanan bir scope sağlamanın iki yolu vardır.İlk yaklaşım, her testte bu sınıfın bir örneğini oluşturarak
backgroundScope'u scope olarak vermektir./** * UserDetailsRepository sınıfının davranışlarını doğrulamak için yazılmış test sınıfı. */ class UserDetailsRepositoryTest { /** * Kullanıcı detaylarının doğru bir şekilde alınıp alınmadığını test eden birim test. * runTest, korutin testleri için özel bir test ortamı sağlar. */ @Test fun `should fetch details`() = runTest { // HAZIRLIK (given): Test için gerekli bağımlılıklar oluşturuluyor // HTTP istekleri yapmak için kullanılan istemci nesnesi // FakeClient, gerçek ağ istekleri yapmak yerine önceden belirlenmiş yanıtları döndüren sahte bir sınıftır val client = FakeClient() // Test sırasında veri depolamak için kullanılan veritabanı // InMemoryDatabase, gerçek bir veritabanı yerine bellekte veri saklayan hafif bir sınıftır val database = InMemoryDatabase() // Test edilecek olan asıl sınıf nesnesi oluşturuluyor // Bağımlılıkları (client, database, scope) dışarıdan enjekte edilerek testlerini kolaylaştırıyor val repo = UserDetailsRepository( client = client, // Ağ istekleri için sahte istemci database = database, // Verileri saklamak için bellek içi veritabanı scope = backgroundScope // Asenkron işlemler için korutin kapsamı ) // Test gövdesi burada devam edecek... // Bu kısımda genellikle repository üzerinde işlemler yapılır ve beklenen sonuçlar doğrulanır } }
eden kod (boilerplate) üretir.Bazı geliştiriciler bu sınıf oluşturma işlemini ayrı bir fonksiyona çıkarırlar, ancak bu
yöntem yine de çok pratik
değildir.
runTest içindekibackgroundScope'u kullanamayız.Bunun yerine, TestScope kullanarak yeni bir scope oluştururuz ve runTestfonksiyonunu bu scope üzerinde çağırırız.
runTest bu şekilde kullanıldığında, çağrıldığı scope ile aynı sanal zamanı paylaşır./** * UserDetailsRepository sınıfını test etmek için oluşturulan test sınıfı. * Bu sınıf, korutin testleri için gereken yapıları içinde barındırır. */ class UserDetailsRepositoryTest { // Test için kullanılacak hafızada çalışan veritabanı private val database = InMemoryDatabase() // Korutinlerin test edilmesi için özel bir test kapsamı // TestScope, korutinlerin test ortamında kontrollü çalışmasını sağlar private val testScope = TestScope() // Test edilecek repository nesnesi // Bağımlılıklar (client, database, scope) constructor üzerinden enjekte ediliyor // Not: 'client' değişkeni kodun görünen kısmında tanımlanmamış, dışarıda tanımlanmış olmalı private val repo = UserDetailsRepository( client = client, // API istekleri için kullanılacak istemci database = database, // Veri depolama için kullanılacak veritabanı scope = testScope // Asenkron işlemler için kullanılacak korutin kapsamı ) /** * Kullanıcı detaylarının başarıyla alınıp alınmadığını test eden fonksiyon. * testScope.runTest, korutin testlerinin kontrolünü test kapsamına verir. */ @Test fun `should fetch details`() = testScope.runTest { // Test içeriği burada tamamlanacak... } }
Burada, her test sınıfı için özelliklerin (property) yeniden oluşturulduğu varsayılmıştır; bu JUnit 5’in varsayılan
davranışıdır. Eğer JUnit 4 kullanıyorsanız, bu özellikleri@Beforemetodunda oluşturmalısınız.
main fonksiyonu bulunmaz. Bu da, Dispatchers.Main kullanmaya çalışırsak testlerin"Module with the Main dispatcher is missing" hatasıyla başarısız olacağı anlamına gelir.
Öte yandan, her seferinde Main thread’i manuel olarak enjekte etmek zahmetli olacağından,
"kotlinx-coroutines-test" kütüphanesi bunun yerine
Dispatchers üzerinde setMain uzantı fonksiyonunu sağlar.@Before veya @BeforeEachanotasyonlu bir setup fonksiyonunda yapılır.
Bu sayede coroutine’leri her zaman güvenle
Dispatchers.Main üzerinde çalıştırabileceğimizden emin oluruz.Dispatchers.resetMain() fonksiyonunu da çağırmalıyız./** * Coroutine tabanlı kodları test etmek için temel altyapıyı sağlayan sınıf. * Tüm coroutine test sınıfları bu sınıfı miras alarak ortak test altyapısını kullanabilir. */ class BaseUnitTest { // Coroutine testlerinde zamanı ve olayları kontrol eden planlayıcı lateinit var scheduler: TestCoroutineScheduler // Test sırasında kullanılacak özel bir dispatcher lateinit var dispatcher: TestDispatcher /** * Her test çalıştırılmadan önce coroutine test ortamını hazırlar. * JUnit @Before anotasyonu ile işaretlendiği için her testten önce otomatik olarak çağrılır. */ @Before fun setUp() { // Test için yeni bir planlayıcı oluşturulur scheduler = TestCoroutineScheduler() // StandardTestDispatcher, zamanın kontrolünü ele alan ve gerçek zamanda bekleme yapmadan // sanal zaman ilerleyen özel bir dispatcher'dır dispatcher = StandardTestDispatcher(scheduler) // Main dispatcher'ı test dispatcher'ı ile değiştirir // Bu sayede, coroutine kodlarındaki Dispatchers.Main çağrıları test dispatcher'ına yönlendirilir Dispatchers.setMain(dispatcher) } /** * Her test tamamlandıktan sonra coroutine test ortamını temizler. * JUnit @After anotasyonu ile işaretlendiği için her testten sonra otomatik olarak çağrılır. */ @After fun tearDown() { // Main dispatcher'ı orijinal haline döndürür // Bu, bir testin diğerini etkilemesini önler Dispatchers.resetMain() } // Sınıfın diğer yardımcı metotları ve özellikleri burada olabilir // ... }
ViewModel, Presenter, Fragment veya Activity sınıflarında başlatırız.Bunlar önemli sınıflardır ve test edilmeleri gerekir. Aşağıda verilen
MainViewModel implementasyonunu düşünün:/** * Ana ekran için ViewModel sınıfı. * Kullanıcı ve haber verilerini yönetir ve UI'a gerekli verileri sağlar. * * @param userRepo Kullanıcı verilerini sağlayan repository * @param newsRepo Haber verilerini sağlayan repository */ class MainViewModel( private val userRepo: UserRepository, private val newsRepo: NewsRepository, ) : BaseViewModel() { // UI'a gösterilecek kullanıcı adı için LiveData private val _userName = MutableLiveData<String>() val userName: LiveData<String> = _userName // UI'a gösterilecek haberler listesi için LiveData private val _news = MutableLiveData<List<News>>() val news: LiveData<List<News>> = _news // Yükleme göstergesinin görünürlüğü için LiveData private val _progressVisible = MutableLiveData<Boolean>() val progressVisible: LiveData<Boolean> = _progressVisible /** * ViewModel oluşturulduğunda çağrılacak metot. * Kullanıcı bilgilerini ve haberleri asenkron olarak yükler. */ fun onCreate() { // İlk coroutine: Kullanıcı bilgilerini yükleme viewModelScope.launch { val user = userRepo.getUser() // Kullanıcı bilgilerini repository'den al _userName.value = user.name // Kullanıcı adını LiveData'ya ayarla } // İkinci coroutine: Haberleri yükleme viewModelScope.launch { _progressVisible.value = true // Yükleme göstergesini görünür yap val news = newsRepo.getNews() // Haberleri repository'den al .sortedByDescending { it.date } // Haberleri tarihe göre sırala (en yeni başta) _news.value = news // Haberleri LiveData'ya ayarla _progressVisible.value = false // Yükleme göstergesini gizle } } }
viewModelScope yerine kendi scope’umuz olabilir, MutableLiveData yerine MutableStateFlow kullanılabilir veViewModel yerine Presenter, Activity ya da başka bir sınıf olabilir. Örneğimiz açısından bunlar fark etmez.Coroutine başlatan her sınıfta olduğu gibi, burada da sanal zaman (virtual time) üzerinde çalışabilmek için scope’un bir
parçası olarak
StandardTestDispatcher kullanmalıyız. Eskiden, bunun için bağımlılık enjeksiyonu (dependency injection)ile farklı bir scope enjekte etmemiz gerekiyordu,
ancak artık daha basit bir yol var:Android'de varsayılan olarak
Dispatchers.Main kullanılır ve biz bunuDispatchers.setMain fonksiyonu ileStandardTestDispatcher ile değiştirebiliriz.Aşağıdaki örnekte bu gösterilmektedir. Ana dispatcher test dispatcher iledeğiştirildikten sonra,
ViewModel içindecoroutine başlatabilir ve zamanlarını kontrol edebiliriz.
- Belirli bir sürenin geçmiş gibi görünmesini sağlamak için
advanceTimeByfonksiyonunu kullanabiliriz. - Tüm coroutine işlemleri tamamlanana kadar çalıştırmak için
advanceUntilIdlefonksiyonunu kullanabiliriz.
MainViewModel sınıfını tam bir hassasiyetle test edebiliriz.Sahte repository’lere
delay ekleyerek, örneğin bir işlemin diğerinden uzun sürmesi veya bir işlemin ortasında diğeriyürütülmesi gibi senaryoları da test edebiliriz.
// MainViewModel sınıfını test etmek için oluşturulan test sınıfı class MainViewModelTests { // Test coroutine'lerini kontrol etmek için bir zamanlayıcı private lateinit var scheduler: TestCoroutineScheduler // Test edilecek view model private lateinit var viewModel: MainViewModel // Her test öncesinde çağrılan setup metodu @BeforeEach fun setUp() { // Test için zamanlayıcı oluşturulur scheduler = TestCoroutineScheduler() // Main dispatcher'ı test dispatcher'ı ile değiştirilir // Bu sayede asenkron kodlar kontrollü bir ortamda çalıştırılabilir Dispatchers.setMain(StandardTestDispatcher(scheduler)) // Test için kullanılacak ViewModel nesnesi oluşturulur // Gerçek repository'ler yerine fake/test versiyonları kullanılır viewModel = MainViewModel( userRepo = FakeUserRepository(aName), // Test için sabit kullanıcı adı newsRepo = FakeNewsRepository(someNews) // Test için önceden tanımlanmış haberler ) } // Her test sonrasında çağrılan temizleme metodu @AfterEach fun tearDown() { // Main dispatcher'ı eski haline döndürür Dispatchers.resetMain() // ViewModel'in temizlenmesini sağlar, böylece ViewModel içindeki coroutine'ler iptal edilir viewModel.onCleared() } // Kullanıcı adı ve sıralanmış haberlerin doğru gösterildiğini test eden metot @Test fun `should show user name and sorted news`() { // İşlem: ViewModel'in onCreate metodu çağrılıyor viewModel.onCreate() // Test zamanlayıcısında bekleyen tüm coroutine'ler tamamlanana kadar ilerle scheduler.advanceUntilIdle() // Sonuç kontrolü: Kullanıcı adı doğru bir şekilde ayarlandı mı? assertEquals(aName, viewModel.userName.value) // Sıralanmış haberlerin beklenen sonucu val someNewsSorted = listOf(News(date1), News(date2), News(date3)) // Sonuç kontrolü: Haberler doğru sıralandı mı? assertEquals(someNewsSorted, viewModel.news.value) } // İlerleme çubuğunun yükleme sırasında doğru şekilde gösterildiğini test eden metot @Test fun `should show progress bar when loading news`() { // Ön koşul kontrolü: Başlangıçta ilerleme çubuğu görünürlüğü null olmalı assertEquals(null, viewModel.progressVisible.value) // İşlem: ViewModel'in onCreate metodu çağrılır viewModel.onCreate() // Sonuç kontrolü: Coroutine'ler başlatılmadan önce progress değeri false olmalı assertEquals(false, viewModel.progressVisible.value) // İşlem: Zamanlanmış ve şu anda çalışabilecek durumda olan coroutine'leri çalıştır scheduler.runCurrent() // Sonuç kontrolü: Coroutine'ler başlatıldıktan sonra progress değeri true olmalı assertEquals(true, viewModel.progressVisible.value) // İşlem: Test zamanlayıcısını 200 ms ilerlet scheduler.advanceTimeBy(200) // Sonuç kontrolü: 200 ms sonra hala yükleme devam ettiği için progress true olmalı assertEquals(true, viewModel.progressVisible.value) // İşlem: Bekleyen coroutine'leri çalıştır scheduler.runCurrent() // Sonuç kontrolü: Yükleme tamamlandıktan sonra progress false olmalı assertEquals(false, viewModel.progressVisible.value) } // Kullanıcı ve haber bilgilerinin eşzamanlı (concurrent) çağrıldığını test eden metot @Test fun `user and news are called concurrently`() { // İşlem: ViewModel'in onCreate metodu çağrılır viewModel.onCreate() // Tüm coroutine'lerin tamamlanmasını bekle scheduler.advanceUntilIdle() // Sonuç kontrolü: Paralel çalıştığı için geçen süre en uzun olan işlemin süresi olmalı (300 ms) // eğer sıralı çalışsaydı, toplam süre 300+200=500 ms olurdu assertEquals(300, testDispatcher.currentTime) } // Test için sahte bir UserRepository implementasyonu class FakeUserRepository( private val name: String ) : UserRepository { // Kullanıcı verisini getiren metot // 300 ms gecikmeli olarak çalışır override suspend fun getUser(): UserData { delay(300) // 300 ms gecikme simülasyonu return UserData(name) // Test için oluşturulan kullanıcı verisini döndürür } } // Test için sahte bir NewsRepository implementasyonu class FakeNewsRepository( private val news: List<News> ) : NewsRepository { // Haber listesini getiren metot // 200 ms gecikmeli olarak çalışır override suspend fun getNews(): List<News> { delay(200) // 200 ms gecikme simülasyonu return news // Test için oluşturulan haber listesini döndürür } } }
/** * JUnit için özel bir test kuralı (test rule) olarak oluşturulmuş sınıf. * Bu kural, coroutine testleri için gerekli test dispatcher'ı ve zamanlayıcı ayarlarını * otomatik olarak yönetir. */ class MainCoroutineRule : TestWatcher() { // Test coroutine'lerini kontrol etmek için kullanılan zamanlayıcı // private set ile dışarıdan erişimi sadece okuma ile sınırlandırılmıştır lateinit var scheduler: TestCoroutineScheduler private set // Ana iş parçacığını (main thread) simüle eden test dispatcher'ı // private set ile dışarıdan erişimi sadece okuma ile sınırlandırılmıştır lateinit var dispatcher: TestDispatcher private set /** * Her test başlamadan önce otomatik olarak çağrılır. * Test ortamını hazırlar ve ana dispatcher'ı test dispatcher'ı ile değiştirir. * * @param description Test hakkında bilgi içeren nesne */ override fun starting(description: Description) { // Sanal zaman ortamı için yeni bir zamanlayıcı oluşturur scheduler = TestCoroutineScheduler() // Zamanlayıcıyı kullanan test dispatcher'ı oluşturur // StandardTestDispatcher, coroutine'leri hemen çalıştırmak yerine, // zamanlayıcı üzerinden kontrol edilebilir bir şekilde çalıştırır dispatcher = StandardTestDispatcher(scheduler) // Kotlin coroutines kütüphanesindeki ana dispatcher'ı // test dispatcher'ı ile değiştirir. // Bu sayede test sırasında tüm Dispatchers.Main çağrıları // bizim kontrol ettiğimiz test dispatcher'ına yönlendirilir Dispatchers.setMain(dispatcher) } /** * Her test tamamlandıktan sonra otomatik olarak çağrılır. * Test ortamını temizler ve ana dispatcher'ı orijinal haline döndürür. * * @param description Test hakkında bilgi içeren nesne */ override fun finished(description: Description) { // Ana dispatcher'ı orijinal haline döndürür. // Bu adım, bir testin diğerini etkilememesi için önemlidir. Dispatchers.resetMain() } }
MainCoroutineRule, TestWatcher sınıfından genişletilmelidir; çünkü TestWatcher, starting ve finished gibi test yaşam döngüsü metotlarını sağlar ve biz bu metotları override ederiz. Bu MainCoroutineRule, içinde bir TestCoroutineScheduler ve bir TestDispatcher barındırır. Bu sayede:- Her testten önce
TestDispatcher,Dispatchers.Mainolarak ayarlanır. - Her testten sonra
Dispatchers.resetMain()çağrılarak Main dispatcher ilk haline döndürülür.
Bu rule içinde yer alan zamanlayıcıya (scheduler)schedulerözelliği (property) üzerinden erişebiliriz.
/** * MainViewModel sınıfının JUnit testi * Bu sefer önceki örneğe göre daha temiz ve mantıksal olarak organize edilmiş * bir yapı kullanılıyor */ class MainViewModelTests { // JUnit test kuralı - her test için coroutine test ortamını otomatik ayarlar @get:Rule var mainCoroutineRule = MainCoroutineRule() // ... (mainCoroutineRule sayesinde setUp ve tearDown metotlarına ihtiyaç kalmadı) /** * Kullanıcı adı ve haberlerin doğru yüklenip gösterildiğini test eder */ @Test fun `should show user name and sorted news`() { // İşlem: ViewModel başlatılır viewModel.onCreate() // Tüm coroutine'lerin tamamlanmasını bekle mainCoroutineRule.scheduler.advanceUntilIdle() // Sonuç: Kullanıcı adı doğru şekilde ayarlandı mı? assertEquals(aName, viewModel.userName.value) // Sonuç: Haberler doğru sıralandı mı? val someNewsSorted = listOf(News(date1), News(date2), News(date3)) assertEquals(someNewsSorted, viewModel.news.value) } /** * İlerleme çubuğunun yükleme sırasında ve sonrasında * doğru görünüp görünmediğini test eder */ @Test fun `should show progress bar when loading news`() { // Ön koşul: Başlangıçta progress görünürlüğü null olmalı assertEquals(null, viewModel.progressVisible.value) // İşlem: onCreate çağrılır viewModel.onCreate() // Sonuç: Coroutine'ler başlatıldıktan hemen sonra progress true olmalı // Not: Bu test önceki versiyondan farklı - burada StandardTestDispatcher // kullanıldığından, coroutine'ler hemen başlar ve progress true olur assertEquals(true, viewModel.progressVisible.value) // İşlem: 200 ms sanal zaman ilerletilir // FakeNewsRepository'nin simüle edilmiş işlem süresi 200 ms mainCoroutineRule.scheduler.advanceTimeBy(200) // Sonuç: İşlem tamamlandığında progress görünmez olmalı (false) // Not: Bu test senaryosu basitleştirilmiş - ilk örnekte olduğu gibi // adım adım kontrol yerine, doğrudan son durumu kontrol ediyor assertEquals(false, viewModel.progressVisible.value) } /** * Kullanıcı ve haber verilerinin paralel (concurrent) olarak * yüklendiğini test eder */ @Test fun `user and news are called concurrently`() { // İşlem: ViewModel başlatılır viewModel.onCreate() // Tüm coroutine'lerin tamamlanmasını bekle mainCoroutineRule.scheduler.advanceUntilIdle() // Sonuç: Paralel çalıştığı için toplam sanal süre, // en uzun olan işlemin süresi olan 300 ms olmalı assertEquals(300, mainCoroutineRule.currentTime) } }
advanceUntilIdle,advanceTimeBy,runCurrentvecurrentTimefonksiyonlarını doğrudanMainCoroutineRule
üzerinden çağırmak istiyorsanız, bunları uzantı fonksiyon (extension function) ve özellik (property) olarak
tanımlayabilirsiniz.
Google’ın Codelabs materyallerinde de (
örneğin: Advanced Android in Kotlin 05.3: Testing Coroutines and Jetpack integrations)
bu yöntem anlatılmaktadır (şu anda eski
kotlinx-coroutines-test API’si için geçerlidir).Extension tanımlamanın birkaç farklı yolu olsa da, aşağıda en yaygın kullanılan implementasyon yer almaktadır:
// Bu sınıf, coroutine testleri için gerekli test dispatcher'ları ve // zamanlayıcı ayarlarını otomatik olarak yönetir. @ExperimentalCoroutinesApi class MainCoroutineExtension : BeforeEachCallback, AfterEachCallback { // Test coroutine'lerinin zamanlamasını kontrol etmek için kullanılan zamanlayıcı. // private set ile dışarıdan erişim sadece okuma ile sınırlandırılmıştır. lateinit var scheduler: TestCoroutineScheduler private set // Ana iş parçacığını (main thread) simüle eden test dispatcher'ı. // private set ile dışarıdan erişim sadece okuma ile sınırlandırılmıştır. lateinit var dispatcher: TestDispatcher private set // Her test öncesinde otomatik olarak çağrılır. // Test ortamını hazırlar ve ana dispatcher'ı test dispatcher'ı ile değiştirir. override fun beforeEach(context: ExtensionContext?) { // Test için zamanlayıcı oluştur scheduler = TestCoroutineScheduler() // Zamanlayıcıyı kullanan test dispatcher'ı oluştur dispatcher = StandardTestDispatcher(scheduler) // Kotlin coroutines kütüphanesindeki ana dispatcher'ı // test dispatcher'ı ile değiştir Dispatchers.setMain(dispatcher) } // Her test sonrasında otomatik olarak çağrılır. // Test ortamını temizler ve ana dispatcher'ı orijinal haline döndürür. override fun afterEach(context: ExtensionContext?) { // Ana dispatcher'ı orijinal haline döndür Dispatchers.resetMain() } }
MainCoroutineExtension kullanımı, MainCoroutineRule rule'ının kullanımına neredeyse tamamen benzerdir.Tek fark,
@get:Rule anotasyonu yerine @JvmField ve @RegisterExtension anotasyonlarının kullanılmasıdır./** * @JvmField anotasyonu, Kotlin'den Java'ya dönüştürüldüğünde * bu alanın direkt olarak erişilebilir bir alan (field) olacağını belirtir. * Getter/setter yerine doğrudan alana erişim sağlanır. * * @RegisterExtension anotasyonu, bu alanın bir JUnit 5 extension'ı * içerdiğini ve test çalıştırma zamanında JUnit tarafından * kaydedilmesi gerektiğini belirtir. */ @JvmField @RegisterExtension var mainCoroutineExtension = MainCoroutineExtension()
şunlardır:
- Çoğu askıya alınabilir (suspending) fonksiyon,
runBlockingile sarılarak bloklayıcı (blocking) fonksiyonlar gibi
test edilebilir. Alternatif olarakkotlinx-coroutines-testkütüphanesindenrunTestfonksiyonu da kullanılabilir. runTest, sanal zaman (virtual time) üzerinde çalışır; bu nedenle kapsamı (scope) içindekidelayçağrıları gerçek
zaman beklemesi yerine sanal zamanı ilerletir. Bu, askıya alınabilir fonksiyonlardaki eşzamanlı davranışları test
etmemizi sağlar.StandardTestDispatcherkullanarak ve zamanlayıcısınıadvanceTimeBy,runCurrent,advanceUntilIdlegibi
fonksiyonlarla kontrol ederek de sanal zamanda manuel olarak işlem yapabiliriz.StandardTestDispatcher, coroutine başlatan sınıflara enjekte edilebilir veya Android'de ana dispatcher (
Dispatchers.Main) yerine kullanılabilir.UnconfinedTestDispatcher, ilkdelayçağrısına kadar olan tüm işlemleri hemen çalıştıran bir başka dispatcher’dır.
Genelliklekotlinx-coroutines-test’in eski sürümlerindekirunBlockingTestile geriye dönük uyumluluk için
kullanılır.- Android’de coroutine başlatan fonksiyonlar, bir
Ruleveya birExtensionkullanılarak test edilebilir.
- 1.Fake, bir arayüzü (interface) implemente eden ancak sabit veri içeren ve mantık barındırmayan sınıflardır. ↩
- 2.Mock'lar, gerçek nesnelerin davranışlarını kontrollü şekilde taklit eden evrensel simülasyon nesneleridir. ↩
- 3.Her geliştirici mock kullanımını tercih etmez. Bir yandan, mock kütüphaneleri güçlü özellikler sunar; ancak ↩