Mocking su Android

Mocking su Android

Se ti stai avvicinando ai test unitari in Android, probabilmente ti sei imbattuto nel termine “mocking”. Forse hai sentito parlare di librerie come Mockito e ora ti stai chiedendo: “Cos’è questo MockK?” L’articolo “Mocking su Android” vuole essere una brevissima guida per introdurre le basi del mocking e mostrare perché MockK è uno strumento potente che dovresti prendere in considerazione. Il tono sarà informale e divertente, come se stessimo chiacchierando davanti a un caffè!

Di cosa si tratta?
Prima di tutto, chiariamo cos’è il “mocking”. Quando si scrivono test unitari, vogliamo testare piccoli pezzi di codice isolati (funzioni o classi). Ma spesso, questi pezzi di codice si basano su altri componenti o dipendenze.

Ad esempio, immagina di testare una UserService classe che chiama un’API. Non vuoi effettuare chiamate API effettive durante il test, perché sarebbe lento e inaffidabile. Invece, “simula” la chiamata API sostituendola con una versione falsa che si comporta come ti aspetti.

In pratica:

Il mocking è la creazione di versioni false di oggetti o funzioni per controllarne il comportamento nei test.
Ti aiuta a isolare ciò che stai testando ed evitare di dover gestire dipendenze reali.
Esempio del motivo per cui hai bisogno di simulazioni
Immagina di avere questa funzione:

fun fetchUser(): String {
    val apiResponse = apiService.getUserFromApi() // This makes a real API call
    return "Hello, ${apiResponse.name}"
}

Per testare correttamente questa funzione, non vuoi chiamarla apiService.getUserFromApi() per davvero. Invece, la simulerai per restituire una risposta predefinita come questa:

val mockApiResponse = User(name = "John Doe")

Ora puoi controllare cosa apiService.getUserFromApi() viene restituito e testare la fetchUser() funzione senza preoccuparti dell’API vera e propria.

Perché usare MockK invece di altre librerie?
Ci sono diverse librerie di mocking sul mercato, ma MockK si distingue, specialmente per gli sviluppatori Kotlin. Ecco perché MockK è fantastico:

• Progettato per Kotlin : a differenza di Mockito (che è stato creato per Java e adattato per Kotlin), MockK è stato creato pensando a Kotlin. Ciò significa che supporta funzionalità Kotlin come classi finali, funzioni di estensione e coroutine out of the box.
• Sintassi più semplice : MockK ha una sintassi pulita e di facile lettura che rende i tuoi test più leggibili.
• Funzionalità avanzate : MockK supporta funzionalità avanzate come la simulazione di metodi statici, oggetti e persino costruttori.
• Supporto per le coroutine : se lavori con le coroutine, MockK semplifica notevolmente la simulazione delle funzioni di sospensione.

Un rapido confronto
Ecco un rapido confronto tra MockK e Mockito quando si simula una classe semplice.

Utilizzo di Mockito:

val mockUserService = mock(UserService::class.java)
`when`(mockUserService.getUserName()).thenReturn("John")

Utilizzo di MockK:

val mockUserService = mockk<UserService>()
every { mockUserService.getUserName() } returns "John"

Vedi come la sintassi di MockK è più adatta a Kotlin? Scopriamo come impostarla nel tuo progetto.

Impostazione di MockK nel tuo progetto Android
Aggiungere MockK al tuo progetto è semplicissimo. Ecco cosa devi fare:

Passaggio 1: aggiungere la dipendenza
Nel build.gradle file (a livello di modulo), aggiungi la dipendenza MockK:

dependencies {
    testImplementation "io.mockk:mockk:1.12.0"
}

Se stai testando componenti Android, aggiungi la versione di MockK specifica per Android:

dependencies {
    androidTestImplementation "io.mockk:mockk-android:1.12.0"
}

Passaggio 2: sincronizzare il progetto
Dopo aver aggiunto le dipendenze, sincronizza il progetto per scaricare MockK.

Sintassi di base di MockK ed esempi
Ora che hai configurato MockK, diamo un’occhiata ad alcuni esempi di base per iniziare!

1. Creazione di un mock
   Per creare un mock di una classe o di un’interfaccia, utilizzare mockk():

val mockUserService = mockk<UserService>()

2. Disattivare un metodo con every {}
   Utilizzare every {} per definire cosa dovrebbe restituire un metodo simulato:

every { mockUserService.getUserName() } returns "John Doe"

3. Verifica delle chiamate di metodo con verify {}
   È possibile verificare se un metodo è stato chiamato durante il test utilizzando verify {}:

fetchUser() // Call the function that uses mockUserService
verify { mockUserService.getUserName() } // Verify the method was called

Esempio completo
Ecco un esempio completo che combina tutto:

class UserService {
    fun getUserName(): String = "Real User"
}
class UserGreeting(private val userService: UserService) {
    fun greetUser(): String {
        return "Hello, ${userService.getUserName()}"
    }
}
// In your test class
@Test
fun `test greetUser returns correct greeting`() {
    // Create a mock
    val mockUserService = mockk<UserService>()
    // Stub the method
    every { mockUserService.getUserName() } returns "John Doe"
    // Create the class under test
    val userGreeting = UserGreeting(mockUserService)
    // Call the function
    val result = userGreeting.greetUser()
    // Verify the result
    assertEquals("Hello, John Doe", result)
    // Verify the method call
    verify { mockUserService.getUserName() }
}

Conclusione
Hai imparato cos’è il mocking, perché MockK è un’ottima scelta per gli sviluppatori Kotlin, come impostarlo e come usare funzioni di base come mockk(), every {}, e verify {}.

(fonte)

Innovaformazione, scuola informatica specialistica promuove lo sviluppo mobile consapevole e supporta le aziende nella formazione del proprio team di sviluppatori per apprendere le tecnologie e metodologie di lavoro.

Di seguito trovate il link con l’elenco corsi in ambito mobile rivolto alle aziende, vedi QUI.

INFO: info@innovaformazione.net – tel. 3471012275 (Dario Carrassi)