Test en Kotlin : Unit, Integration, E2E — guide complet

Introduction au Test en Kotlin : du Unitaire au Bout-en-Bout

Une base de code de haute qualité est impossible sans tests automatisés. Kotlin, en tant que langage moderne pour la JVM, offre aux développeurs une boîte à outils riche pour créer des tests fiables. Dans cet article, nous allons décomposer trois niveaux de la pyramide de test appliqués à Kotlin : unitaire, d'intégration et e2e. Vous apprendrez à écrire des tests efficaces en Kotlin en utilisant des frameworks populaires tels que JUnit 5, MockK, Ktor Client et Selenium.

1. Tests Unitaires en Kotlin : Le Fondement de la Stabilité

Les tests unitaires vérifient le fonctionnement de fonctions, classes ou méthodes individuelles, isolées des dépendances externes. En Kotlin, JUnit 5 est le plus souvent utilisé à cet effet, en combinaison avec la bibliothèque de simulation MockK.

1.1. Configuration du Projet

Ajoutez les dépendances au fichier build.gradle.kts :

dependencies {    testImplementation("org.junit.jupiter:junit-jupiter:5.10.0")    testImplementation("io.mockk:mockk:1.13.8")}

1.2. Exemple de Test Unitaire avec MockK

Supposons que nous ayons un UserService qui dépend d'un repository :

class UserService(private val repository: UserRepository) {    fun getUserName(id: Long): String {        val user = repository.findById(id)        return user?.name ?: "Inconnu"    }}

Test utilisant MockK :

import io.mockk.everyimport io.mockk.mockkimport org.junit.jupiter.api.Testimport kotlin.test.assertEquals

class UserServiceTest {    @Test    fun `retourne le nom d'utilisateur quand l'utilisateur existe`() {        val mockRepo = mockk<UserRepository>()        every { mockRepo.findById(1L) } returns User(1L, "Alice")        val service = UserService(mockRepo)

        val result = service.getUserName(1L)

        assertEquals("Alice", result)    }}

1.3. Bonnes Pratiques pour les Tests Unitaires

• Isolez les dépendances — utilisez des mocks pour tous les appels externes (base de données, API).
• Testez les cas limites : null, chaînes vides, nombres négatifs.
• Utilisez des noms de test clairs — ils doivent décrire le scénario et le résultat attendu.
• Suivez le principe AAA : Arrange (Organiser), Act (Agir), Assert (Affirmer).

2. Tests d'Intégration en Kotlin : Vérification des Interactions

Les tests d'intégration vérifient comment plusieurs composants du système fonctionnent ensemble. En Kotlin, cela peut être le test d'une API REST en utilisant Ktor Client ou la vérification des opérations de base de données via Exposed.

2.1. Test d'API REST avec Ktor

Créez un serveur Ktor simple et testez-le :

// Serveurfun Application.module() {    routing {        get("/hello") {            call.respondText("Bonjour, Kotlin!")        }    }}

// Testclass ApiTest {    @Test    fun `test du point d'accès hello`() = testApplication {        application { module() }        val response = client.get("/hello")        assertEquals(HttpStatusCode.OK, response.status)        assertEquals("Bonjour, Kotlin!", response.bodyAsText())    }}

2.2. Travail avec une Base de Données de Test

Pour les tests d'intégration avec une base de données, utilisez H2 (en mémoire) ou Testcontainers pour PostgreSQL :

@Testfun `test de création d'utilisateur`() {    withTestDatabase {        val user = User.new {            name = "Bob"            email = "bob@test.com"        }        assertEquals("Bob", user.name)        assertNotNull(user.id)    }}

private fun withTestDatabase(block: () -> Unit) {    Database.connect("jdbc:h2:mem: