İçeriğe geç
Teknoaktif
Son haberler
Genel

Mobil Mimari Desenleri: MVVM, MVI ve Clean Architecture Katmanlarının Test Edilebilirlik Kıyaslaması

Yayın:

Bir mobil uygulama geliştirirken kodunuzun “çalışıyor” olmasının ötesinde, “anlaşıyor”, “değiştirilebiliyor” ve “test edilebiliyor” olması, projenin ömrünü yıllar uzatır. Peki, MVVM, MVI ve Clean Architecture bu sınavda nasıl performans gösteriyor? Hangi mimari, test yazmayı bir eziyetten bir keyfe dönüştürüyor? Perde arkasına girelim.

Bölüm 1: Bu Nedir ve Neden Hayati Önem Taşır?

Hayatınızı bir mutfak gibi düşünün. Yemek pişiriyorsunuz (kod yazıyorsunuz). Eğer tüm malzemeler tek bir dev tencerede karışık duruyorsa, tuz mu eksik, biber mi fazla anlayamazsınız; hatayı bulmak için tencerenin içine başınızı sokmak zorunda kalırsınız. İşte mimari desenler, bu kaotik mutfağı; soğuklık, ısılık, kesme, pişirme gibi ayrı istasyonlara (katmanlara) bölen profesyonel bir mutfak düzenidir.

MVVM (Model-View-ViewModel), MVI (Model-View-Intent) ve Clean Architecture bu düzenin üç farklı felsefesidir. Neden test edilebilirlik bu kadar önemli? Çünkü test yazmak, “Bu yemek zevkli mi?” diye sormak değil, “Tarifin her adımı, malzemeler değişse bile aynı sonucu veriyor mu?” diye garanti altına almaktır. Test edilebilir kod, gelecekte gelecek o “acil değişiklik” taleplerinde (ve mutlaka gelecekler) uygulamanızın çökmemesini sağlayan sigorta polisidir.

Bölüm 2: Perde Arkası: Sistem Nasıl Çalışıyor?

Mobil Mimari Desenleri: MVVM, MVI ve Clean Architecture Katmanlarının Test Edilebilirlik Kıyaslaması Görsel İncelemesi
Modern mobil mimarilerde veri akışı: Kullanıcı eylemi (Intent) nasıl State’e dönüşür ve UI nasıl güncellenir? Bu şema, MVI’nin tek yönlü veri akışını ve MVVM’in çift yönlü bağlamayı (binding) yan yana koyarak test senaryolarının nasıl değiştiğini gösterir.

Her üç desen de aslında ayrılık sorumluluğu (Separation of Concerns) prensibi etrafında döner. Fark, verinin ve komutların nasıl dans ettiğindedir.

MVVM‘de View (Ekran), ViewModel’e “Ben bu butona bastım” der (Command/Event). ViewModel de arka planda iş yapar ve “Veri hazır, gel al” diye haber verir (LiveData/Flow/StateFlow). Bu çift yönlü bir sohbettir. Test ederken ViewModel’i sahte (mock) bir View’e bağlayıp, “Butona basınca bu veri geldi mi?” diye kontrol edersiniz. Kolaydır ama ViewModel’in içi karmaşıklaşırsa testler de büyür.

MVI ise tek yönlü bir trafik akışıdır. Kullanıcı bir Intent (Niyet) gönderir (Örn: LoginClicked). Bu Intent bir Reducer‘dan geçer, mevcut State (Durum) ile birleşir ve Yeni State doğar. View bu yeni State’i alır ve çizer. Hiçbir yerde “setValue” yoktur, her şey copy() ile değişmez (immutable) veri akışıdır. Test etmek şöyle olur: “Bu State ve bu Intent verildiğinde, çıkış State’i bu olmalı.” Girdi-Cıkı saf fonksiyonel testtir.

Clean Architecture ise bir desen değil, katmanlama kuralıdır. İçerden dışarıya: Entity (Varlıklar) -> Use Case (İş Kuralları) -> Interface Adapters (Presenter/ViewModel/Controller) -> Frameworks (UI, DB, Network). Kural basittir: İç katmanlar dış katmanları tanımaz. Test ederken Use Case’i test etmek için veritabanı veya ağ katmanına ihtiyacınız yoktur; onları “arayüz” (interface) üzerinden sahteleyersiniz.

Bölüm 3: Bilim Dünyası ve Uzmanlar Nasıl İnceliyor?

Akademik literatür ve endüstri liderleri (Google Android ekibi, Square, Uber, Airbnb mühendislik blogları) yıllardır bu konuyu “Test Piramidi” ve “Test Elması” metaforlarıyla inceliyor. Ortak kanaat şudur: Mimari, test yazmayı ne kadar zorlar?

Uzmanlar MVVM’i “Başlangıç için mükemmel, ölçeklenmede dikkatli ol” der. Çünkü ViewModel içinde MutableLiveData dolanırken, testler InstantTaskExecutorRule gibi yardımcı araçlar beklemek zorunda kalır. Asenkronluk testlerde baş ağrısı olur.

MVI için ise “Durum yönetiminde kral, ama boilerplate (şablon kod) cehennemi” denir. Her ekran için Intent, State, Reducer yazmak yorucudur. Ancak bir kere kurduğunuzda, testler saf fonksiyon testine döner. reduce(oldState, intent) == newState. Bu, CI/CD hatlarında saniyeler içinde binlerce senaryo koşturmanızı sağlar.

Clean Architecture için ise “Yatırım maliyeti yüksek, getirisi ömür boyu” denir. Use Case’leriniz suspend fun execute(): Result imzasıyla saf Kotlin/Swift fonksiyonlarıdır. Onları test etmek için hiçbir Android/iOS kütüphanesine ihtiyacınız yoktur. Bu, “Platformdan bağımsız iş mantığı” hedefinin zirvesidir.

Bölüm 4: Önemli Parametreler ve Karşılaştırma Rehberi

Parametre MVVM (Model-View-ViewModel) MVI (Model-View-Intent) Clean Architecture (Katmanlı)
Veri Akışı Yönü Çift yönlü (Binding / Observer) Tek yönlü (Unidirectional) Katmanlar arası tek yönlü (Dependency Rule)
Durum (State) Yönetimi Dağınık (Birden fazla LiveData/Flow) Merkezi ve Tek (Single Source of Truth) Use Case çıktısı olarak State/Result döner
Test Yazım Kolaylığı Orta (Mock View, Mock Repository, Async bekleme) Çok Yüksek (Saf fonksiyon: State + Intent = New State) En Yüksek (Use Case’ler Framework’sız, saf mantık)
Boilerplate (Şablon Kod) Düşük / Orta Yüksek (Intent, State, Reducer, Processor) Çok Yüksek (Entity, Repository Interface, Use Case, Mapper)
Asenkronluk Testi Zor (Coroutines/Flow test rule’leri gerekir) Kolay (VirtualTime / TestScheduler ile deterministik) Kolay (Use Case suspend olduğu için test dispatcher yeterli)
Hata Ayıklama (Debug) Orta (Hangi LiveData tetiklendi?) Mükemmel (Log: Intent -> State geçişleri takip edilir) İyi (Use Case logları iş akışını gösterir)
Öğrenme Eğrisi Düşük (Standart Android/Google rehberi) Orta (Fonksiyonel düşünce, Redux pattern) Yüksek (SOLID, Dependency Inversion hakimiyeti)
Yeniden Kullanılabilirlik Orta (ViewModel View’e bağlı kalabilir) Yüksek (State/Reducer View’den bağımsızdır) Maksimum (Use Case’ler Platformdan bağımsızdır)
En İyi Olduğu Senaryo Standart CRUD uygulamaları, küçük/orta ekipler Karmaşık formlar, çoklu durumlu ekranlar, gerçek zamanlı uygulamalar Enterprise, White-label, Çok platformlu (KMM) projeler
Risk Alanı “God ViewModel” (Her işi yapan dev ViewModel) “State Patlaması” (State nesnesi devasa olur) “Over-engineering” (Basit uygulama için abartı)

Bölüm 5: Günlük Hayatta ve Doğada Nerede Karşılaşırız?

Mobil Mimari Desenleri: MVVM, MVI ve Clean Architecture Katmanlarının Test Edilebilirlik Kıyaslaması Detay Görseli
Gerçek hayattan bir benzetme: Bir restoran mutfağı. MVVM: Garson (View) mutfakla (ViewModel) sürekli haberleşir. MVI: Sipariş (Intent) mutfağa gider, mutfak tesir (State) verir, garson sadece tesiri masaya koyar. Clean Architecture: Tarifler (Use Case) şefin (Domain) başındadır, malzeme tedarikçisi (Data) değişse bile tarif bozulmaz.

Senaryo 1: E-Ticaret Sepeti (MVVM’nin Rahat Olduğu Yer)
Basit bir sepet ekranı. “Ürün ekle”, “Sil”, “Toplam fiyat güncelle”. Veri akışı basittir. ViewModel bir sepetListesi ve toplamFiyat tutar. XML/Compose buna bağlanır. Test: viewModel.urunEkle(urun) -> assert(viewModel.toplamFiyat == 100). Burada MVI kurmak “kılıçla böceği öldürmek” olur. Clean Architecture ise Use Case yazmanızı ister (AddToCartUseCase), bu da küçük bir ekibin hızını düşürebilir.

Senaryo 2: Finans Uygulaması / Borsa Takibi (MVI’nin Parladığı Yer)
Anlık fiyatlar geliyor, kullanıcı filtreliyor, grafik çiziliyor, portföy güncelleniyor. Durum (State) karmaşıktır: Loading, Error, Content(data, filter, sortOrder). MVVM’de 5-6 tane LiveData yönetmek, “Hangi durum hangi sırayla geldi?” kaosuna yol açar. MVI’de tek bir State nesnesi var. Intent(ApplyFilter) -> Reducer -> NewState. Test: “Filtre uygulandığında, loading biter ve data filtreli gelir.” Bu determinizm, para kazandırır.

Senaryo 3: Bankacılık / Sağlık Uygulaması (Clean Architecture’nin Şart Olduğu Yer)
“Kullanıcı giriş yapacak” iş kuralı. Bugün Firebase Auth, yarın OAuth2, geçse kendi backend’iniz. Clean Architecture’de LoginUseCase sadece AuthRepository arayüzünü bilir. Testte FakeAuthRepository verirsiniz. UI (Jetpack Compose / SwiftUI) değişse bile, LoginUseCase dokunmaz. Bu, 5 yıl sonra uygulamanızı baştan yazmadan modernize etmenizi sağlar.

Bölüm 6: Karşılaşılan Zorluklar ve Pratik Çözümler

Zorluk 1: MVVM’de “God ViewModel” Sendromu
Her şey ViewModel’e dökülür: Ağ çağrısı, veritabanı, navigasyon, loglama, analitik. Test yazmak imkansız hale gelir.
Çözüm: Use Case (Interactor) pattern’ini MVVM’in içine sokun. ViewModel sadece getUserUseCase.execute() çağırsın. ViewModel testinde Use Case’i mock’layın. Bu “Mini Clean Architecture” size nefes alma alanı verir.

Zorluk 2: MVI’de State Patlaması ve Boilerplate
Her buton için Intent, her alan için State alanı… Veri sınıfları devasa olur, copy() zincirleri uzar.
Çözüm: Sealed Class (Mühürlü Sınıf) State kullanın. sealed interface UiState { data class Success(...): UiState; object Loading: UiState; data class Error(...): UiState }. Reducer’ı küçük fonksiyonlara bölün (reduceLoading, reduceError). Kütüphaneler (Orbit/MVIKotlin, ReduxKotlin) boilerplate’i yönetin.

Zorluk 3: Clean Architecture’de Mapper Çilesi
Entity -> Domain Model -> DTO -> UI Model… Her katmanda veri kopyalama (mapping) kodu yazarak hayatınızı yakarsınız.
Çözüm: Sadece gerektiğinde mapleyin. Repository implementasyonunda (Data katmanında) Entity’yi Domain’e çevirin. Use Case Domain modeli döndürsün. ViewModel’de Domain’i UI State’e çevirin. Ortak alanları kopyalayan mapToDomain() extension fonksiyonları yazın, her alan için field = entity.field yazmayın.

Zorluk 4: Testlerde Zaman (Time) ve Asenkronluk
delay(1000) testinizi 1 saniye bekletir. 100 test = 100 saniye.
Çözüm: Test Dispatcher / Virtual Time. runTest { advanceTimeBy(1000) } (Kotlin Coroutines) veya TestScheduler (RxJava/Combine). Gerçek zamanı sanal zamana çevirin. Testler milisaniyelerde bitsin.

Bölüm 7: Gelecek Perspektifi ve Yeni Gelişmeler

Gelecek deklaratif UI (Jetpack Compose, SwiftUI) ve Kotlin Multiplatform (KMP) / Flutter dünyasında şekilleniyor.

  1. MVI Varsayılan Hale Geliyor: Compose ve SwiftUI “State’e bağla, UI çiz” felsefesine dayanır. Bu MVI’nin State -> UI akışıyla birebir örtüşür. Google’ın resmi örnekleri (Now in Android) artık MVI benzeri UiState / Event pattern kullanıyor.
  2. KMP ile Clean Architecture Zorunluluğu: İş mantığını (Use Case/Repository) Kotlin Common modülüne yazıyorsunuz. Platforma özel kod (UI, DB driver) expect/actual ile ayrılıyor. Clean Architecture artık “tercih” değil, KMP için şart.
  3. Derleyici Destekli Testler (Compiler-driven testing): Compose’un ComposeTestRule veya SwiftUI’n ViewInspector gibi araçlar, UI testlerini birim testleri kadar hızlı hale getiriyor. “Ekran render oldu mu, buton tıklanabilir mi?” artık emülatörsiz CI’de koşuyor.
  4. AI ile Test Üretimi: GitHub Copilot / Cursor artık UseCase imzanızı görünce test("success returns data") { ... } iskeletini mükemmel yazıyor. Mimari ne kadar temizse (girdi/çıktı netse), AI o kadar doğru test üretir. Temiz mimari = Yapay zeka dostu kod.

Bölüm 8: Merak Edilen Sorular ve Cevaplar (SSS)

Soru 1: Ben yeni başlıyorum, hangi mimariyle başlaymalıyım?

Cevap: MVVM ile başlayın. Android/iOS resmi dokümantasyonu, codelab’leri ve topluluk desteği MVVM etrafında döner. Öğrenme eğrisi en düşüktür. “ViewModel + Repository + LiveData/StateFlow” üçlüsünü ezberleyin. Proje büyüdüğünde (ViewModel 300 satırı geçtiğinde) Use Case ekleyerek Clean’e, durum karmaşıklaştığında MVI’ye evrilirsiniz.

Soru 2: MVI’de her ekran için ayrı State mi yazmalıyım?

Cevap: Evet, ekran bazlı (Screen-scoped) State en iyisidir. “Global App State” tutmaya çalışırsanız (Redux web tarzı), mobilde yaşam döngüsü (Activity/Fragment recreate, process death) sizi yorar. Her ekran kendi UiState‘ini, kendi ViewModel/Presenter içinde yönetsin. Paylaşılan veri (Kullanıcı profili, Sepet) için SharedFlow / StateFlow tabanlı merkezi bir DataStore / Repository kullanın.

Soru 3: Clean Architecture yaparsam uygulamanız yavaşlar mı?

Cevap: Hayır, çalışma anında (runtime) sıfır maliyeti vardır. Sadece derleme anında (compile time) daha fazla dosya ve sınıfınız olur. interface ve data class nesneleri JVM/ART çalışma zamanında optimize edilir. Aksine, Use Case’ler suspend olduğu için ana iş parçacığını (main thread) bloke etmez, uygulama daha akıcı olur.

Soru 4: MVVM ile MVI’yi aynı projede karıştırabilir miyim?

Cevap: Kesinlikle. Bu hatta en sağlıklı yaklaşımdır. Basit “Ayarlar”, “Hakkında”, “Profil” ekranları için MVVM (StateFlow + Compose) yazın. Karmaşık “Sipariş Ver”, “Çok Adımlı Form”, “Canlı Yayın” ekranları için MVI (Reducer + Sealed State) kurun. Clean Architecture Use Case’leriniz ise her ikisinin de altında ortak zemin olarak durur.

Soru 5: Test yazmak için MockK / Mockito / Mocktail zorunlu mu?

Cevap: Kotlin’de MockK, Swift’te Mocktail standarttır ama “Fake” (Sahte) implementasyon yazmak genellikle daha iyidir. FakeUserRepository yazıp var users = mutableListOf() tutmak, mockk { on { getUser() } returns user } yazmaktan daha okunabilir, hata mesajları daha anlaşılır ve refactoring’e (yeniden yapılandırmaya) dayanıklıdır. Mock kütüphanelerini sadece “davranış doğrulama” (verify) gerektiğinde kullanın.

Soru 6: “Test Edilebilir Kod” yazmak geliştirmeyi yavaşlatır mı?

Cevap: İlk sprintte evet, ikinci sprintten sonra hızlandırır. İlk etapta arayüz (interface) tanımlamak, Use Case yazmak, dependency injection (Hilt/Koin/Kodein) kurmak zaman alır. Ama 3. ayda “Ödeme modülünü değiştirmek” istediğinizde, UI’yi dokunmadan, sadece Use Case’i değiştirip 5 dakikada bitirirsiniz. Testler size “Bu değişiklik başka bir yeri bozdu mu?” diye anında cevap verir. Manuel test yapmaktan kurtarır.

Bölüm 9: Bilmeniz Gereken Temel Terimler

ViewModel (Görünüm Modeli): Ekranın (View) verisini tutan, iş mantığını koordine eden, yaşam döngüsünden (rotation, background) etkilenmeyen sınıf. Halk dili: “Ekranın beyni, ekran kapanıp açılsa bile hatırlayan not defteri.”

State (Durum / Hal): Uygulamanın veya ekranın o anki anlık görüntüsü. Butonlar etkin mi? Veri yükleniyor mu? Hata var mı? Liste ne? Hepsi tek bir nesnede. Halk dili: “O anki ekran fotoğrafı; video değil, donmuş kare.”

Intent (Niyet / İstek): Kullanıcının veya sistemin “Yap bunu” demesi. Butona basma, metin yazma, pull-to-refresh çekme. Veri değil, eylemdir. Halk dili: “Kullanıcının mutfakta ‘Bir tane de limonata getir’ demesi.”

Reducer (Azaltıcı / Birleştirici): Eski State + Intent = Yeni State formülünü işleten saf (side-effect’siz) fonksiyon. Hiçbir yerde ağ çağrısı, loglama, veritabanı yazma yapmaz. Halk dili: “Tarif kitabı: Elindeki malzemeler (State) + Yeni malzeme (Intent) = Yeni tarif (New State).”

Use Case / Interactor (Kullanım Durumu / Arabulucu): Tek bir iş kuralını (Örn: Login, AddToCart, ExportPDF) içeren, platformdan (Android/iOS) bağımsız sınıf. Girdi alır, çıktı verir. Halk dili: “Şefin özel tarifi: Malzemeler ne olursa olsun, bu yemek her zaman bu adımlarla yapılır.”

Dependency Inversion (Bağımlılık Ters Çevirme): Yüksek seviye modüllerin (Use Case), düşük seviye modüllere (Room, Retrofit) doğrudan değil, arayüz (Interface) üzerinden bağlanması. Halk dili: “Şef (Use Case) ‘Et istiyorum’ der (Interface), kasap mı (Room) marketten mi (Retrofit) gelir onun umrunda değil.”

Test Double (Test Taklidi / Sahte Nesne): Gerçek bağımlılığın (Veritabanı, API) yerine testte geçen nesne. Türleri: Fake (Basit çalışan versiyon), Mock (Davranış programlanmış), Stub (Sabit cevap veren). Halk dili: “Oyuncak araba: Geribi benzini yakmaz, pil ile gider, test pistinde (CI) rahat kullanılır.”

Bölüm 10: Özet ve Çıkarılması Gereken Dersler

Mobil geliştirmede “En iyi mimari” yoktur, **”Mevcut sorununuz

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Ağ Bağlantıları:İşlemci • Donanım Forumu • Bilim Haberleri • Oyun İnceleme • Donanım Rehberi
\n\n