📝 **Documentation : Amélioration du README avec des instructions de test**

Ce commit améliore le README en ajoutant des instructions détaillées sur la configuration et l'exécution de tests pour l'application Kotlin Multiplatform.

Le README a été mis à jour avec des informations sur :

- La configuration du projet pour les tests.
- L'écriture de tests instrumentés pour Android.
- L'utilisation de Robolectric et JUnit 5 pour les tests unitaires.
- L'augmentation de la couverture du code avec Kover.

En outre, un lien vers un exemple de projet a été ajouté pour fournir une référence concrète aux développeurs.

Ces améliorations font du README un guide plus complet et plus utile pour les développeurs qui souhaitent tester leurs applications Kotlin Multiplatform.

Author: fpitpit

README.md

@@ -1,26 +1,114 @@
-This is a Kotlin Multiplatform project targeting Android, iOS, Web, Desktop.
+## Testing a Kotlin Multiplatform App with Compose and Robolectric
 
-* `/composeApp` is for code that will be shared across your Compose Multiplatform applications.
-  It contains several subfolders:
-  - `commonMain` is for code that’s common for all targets.
-  - Other folders are for Kotlin code that will be compiled for only the platform indicated in the folder name.
-    For example, if you want to use Apple’s CoreCrypto for the iOS part of your Kotlin app,
-    `iosMain` would be the right folder for such calls.
+This guide explains how to set up unit tests for a Kotlin Multiplatform application using Compose and Robolectric.
 
-* `/iosApp` contains iOS applications. Even if you’re sharing your UI with Compose Multiplatform, 
-  you need this entry point for your iOS app. This is also where you should add SwiftUI code for your project.
+**Why this is important:**
 
+*   **Shared code:** Kotlin Multiplatform lets you share code between Android, iOS, Desktop, and Web.
+*   **Efficient testing:** Robolectric enables fast unit tests by simulating the Android environment on your development machine.
 
-Learn more about [Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/get-started.html),
-[Compose Multiplatform](https://github.com/JetBrains/compose-multiplatform/#compose-multiplatform),
-[Kotlin/Wasm](https://kotl.in/wasm/)…
+**What you'll learn:**
 
-We would appreciate your feedback on Compose/Web and Kotlin/Wasm in the public Slack channel [#compose-web](https://slack-chats.kotlinlang.org/c/compose-web).
-If you face any issues, please report them on [GitHub](https://github.com/JetBrains/compose-multiplatform/issues).
+*   How to configure a Kotlin Multiplatform project for testing.
+*   How to write instrumented tests that run on a real Android device or emulator.
+*   How to write unit tests using Robolectric and JUnit 5.
+*   How to increase code coverage with Kover.
 
-You can open the web application by running the `:composeApp:wasmJsBrowserDevelopmentRun` Gradle task.
+**Steps:**
 
+1.  **Project Setup:**
 
-https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-test.html
+    *   Create a `commonTest` directory in your `composeApp` module.
+    *   Add the following dependencies to your `build.gradle.kts`:
 
-https://github.com/apter-tech/junit5-robolectric-extension
+        ```kotlin
+        kotlin {
+            sourceSets {
+                commonTest.dependencies {
+                    implementation(kotlin("test"))
+                    implementation(compose.uiTest)
+                }
+                androidInstrumentedTest.dependencies {
+                    implementation(compose.uiTest)
+                }
+            }
+            androidTarget {
+                instrumentedTestVariant.sourceSetTree.set(KotlinSourceSetTree.test)
+                dependencies {
+                    debugImplementation(libs.androidx.ui.test.manifest)
+                }
+            }
+        }
+        android {
+            defaultConfig {
+                testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+            }
+        }
+        ```
+
+2.  **Write a Simple Test:**
+
+    *   Create a test file (e.g., `AppTest.kt`) in `commonTest`.
+    *   Write a test using `runComposeUiTest` to interact with a Compose component:
+
+        ```kotlin
+        class AppTest: UsingContext() {
+            @Test
+            fun myTest() = runComposeUiTest {
+                setContent {
+                    MaterialTheme {
+                        App()
+                    }
+                }
+                onNodeWithText("Click me!").performClick()
+            }
+        }
+        ```
+
+3.  **Run Instrumented Test:**
+
+    *   Launch an Android emulator.
+    *   Run the test: `./gradlew composeApp:connectedAndroidTest`
+
+4.  **Add Robolectric and JUnit 5:**
+
+    *   Upgrade to Kotlin 2.1.0.
+    *   Add the Robolectric plugin and dependencies.
+    *   Apply the plugin in your `build.gradle.kts`.
+
+5.  **Create and Implement `UsingContext`:**
+
+    *   Create an `expect` class named `UsingContext` in `commonTest`.
+    *   Implement the `actual` class for Android in `androidTest`, configuring Robolectric.
+    *   Implement empty `actual` classes for other platforms (iOS, Desktop, Web).
+
+6.  **Add an Activity to the Manifest:**
+
+    *   Add an empty `ComponentActivity` to your `AndroidManifest.xml`.
+
+7.  **Run Robolectric Tests:**
+
+    *   Run: `./gradlew composeApp:testDebugUnitTest`
+
+8.  **Exclude `UsingContext` from `check` Task:**
+
+    *   Prevent JUnit5 from misinterpreting `UsingContext` as a test class:
+
+        ```kotlin
+        tasks.withType<Test>().configureEach {
+            exclude("fr/pitdev/article/kmtest/utils/UsingContext.class")
+        }
+        ```
+
+    *   Run the check task: `./gradlew check`
+
+**Bonus: Code Coverage with Kover**
+
+1.  Add Kover dependencies and plugin.
+2.  Apply the plugin and configure Kover in your `build.gradle.kts`.
+3.  Generate an HTML report: `gradlew koverHtmlReport`
+
+**Learn More:**
+
+*   [Kover Repository](https://www.google.com/url?sa=E&source=gmail&q=https://github.com/Kotlin/kotlinx-kover)
+*   Example Project [https://github.com/fpitpit/article-km-junit5-robolectric]

build.gradle.kts

@@ -7,4 +7,15 @@ plugins {
     alias(libs.plugins.composeCompiler) apply false
     alias(libs.plugins.kotlinMultiplatform) apply false
     alias(libs.plugins.junit5.robolectric) apply false
+    alias(libs.plugins.kover)
+}
+
+dependencies {
+    kover(project(":composeApp"))
+}
+
+kover {
+    merge {
+        subprojects()
+    }
 }

composeApp/src/androidUnitTest/kotlin/fr/pitdev/article/kmtest/utils/UsingContext.android.kt

@@ -4,17 +4,13 @@ import android.os.Build
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.platform.LocalInspectionMode
-import com.ibm.icu.impl.Assert
 import org.jetbrains.compose.resources.ExperimentalResourceApi
 import org.jetbrains.compose.resources.PreviewContextConfigurationEffect
 import org.junit.jupiter.api.extension.ExtendWith
-import org.robolectric.TestLifecycleApplication
 import org.robolectric.annotation.Config
-import org.robolectric.shadows.ShadowApplicationPackageManager
 import org.robolectric.shadows.ShadowLog
 import tech.apter.junit.jupiter.robolectric.RobolectricExtension
 import kotlin.test.BeforeTest
-import kotlin.test.Test
 
 @ExtendWith(RobolectricExtension::class)
 @Config(

composeApp/src/commonTest/kotlin/fr/pitdev/article/kmtest/AppTest.kt

@@ -10,6 +10,7 @@ class AppTest: UsingContext() {
     @Test
     fun myTest() = runComposeUiTest {
         setContent {
+            initPreviewContextConfiguration()
             MaterialTheme {
                 App()
             }

gradle/libs.versions.toml

@@ -18,6 +18,8 @@ kotlinx-coroutines = "1.9.0"
 uiTestManifest = "1.7.5"
 junit5-robolectric = "0.9.0"
 
+kover = "0.9.0-RC"
+
 [libraries]
 androidx-ui-test-manifest = { module = "androidx.compose.ui:ui-test-manifest", version.ref = "uiTestManifest" }
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
@@ -40,4 +42,5 @@ androidLibrary = { id = "com.android.library", version.ref = "agp" }
 composeMultiplatform = { id = "org.jetbrains.compose", version.ref = "compose-multiplatform" }
 composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
-junit5-robolectric = { id = "tech.apter.junit5.jupiter.robolectric-extension-gradle-plugin", version.ref = "junit5-robolectric" }
+junit5-robolectric = { id = "tech.apter.junit5.jupiter.robolectric-extension-gradle-plugin", version.ref = "junit5-robolectric" }
+kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover"}