Bump to Kotlin 2.0 (#39)

VincentMasselis · Jun 4, 2024 · 214aeac · 214aeac
1 parent c463149
commit 214aeac
Show file tree

Hide file tree

Showing 13 changed files with 148 additions and 74 deletions.
diff --git a/.../src/androidTestDemo/kotlin/com/masselis/tpmsadvanced/interfaces/screens/BindingMethod.kt b/.../src/androidTestDemo/kotlin/com/masselis/tpmsadvanced/interfaces/screens/BindingMethod.kt
@@ -10,16 +10,19 @@ import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable.ExitToken
 import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable.Instructions
 import com.masselis.tpmsadvanced.core.androidtest.onEnterAndOnExit
 import com.masselis.tpmsadvanced.core.androidtest.process
+import com.masselis.tpmsadvanced.feature.unlocated.interfaces.ui.UnlocatedSensorsList
 import com.masselis.tpmsadvanced.interfaces.composable.ChooseBindingMethodTags
 import com.masselis.tpmsadvanced.interfaces.composable.HomeTags
-import com.masselis.tpmsadvanced.feature.unlocated.interfaces.ui.UnlocatedSensorsList
 
-context (ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-internal class BindingMethod : EnterExitComposable<BindingMethod> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(ChooseBindingMethodTags.root)) },
-    { waitUntilDoesNotExist(hasTestTag(ChooseBindingMethodTags.root)) }
-) {
+internal class BindingMethod private constructor(
+    composeTestRule: ComposeTestRule
+) :
+    ComposeTestRule by composeTestRule,
+    EnterExitComposable<BindingMethod> by onEnterAndOnExit(
+        { composeTestRule.waitUntilExactlyOneExists(hasTestTag(ChooseBindingMethodTags.root)) },
+        { composeTestRule.waitUntilDoesNotExist(hasTestTag(ChooseBindingMethodTags.root)) }
+    ) {
     private val backButtonNode
         get() = onNodeWithTag(HomeTags.backButton)
 
@@ -58,4 +61,9 @@ internal class BindingMethod : EnterExitComposable<BindingMethod> by onEnterAndO
         unlocatedSensorsListTest.process(instructions)
         return exitToken
     }
+
+    companion object {
+        context(ComposeTestRule)
+        operator fun invoke(): BindingMethod = BindingMethod(this@ComposeTestRule)
+    }
 }
diff --git a/...e/src/androidTestDemo/kotlin/com/masselis/tpmsadvanced/interfaces/screens/OverflowMenu.kt b/...e/src/androidTestDemo/kotlin/com/masselis/tpmsadvanced/interfaces/screens/OverflowMenu.kt
@@ -8,18 +8,21 @@ import androidx.compose.ui.test.performClick
 import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable
 import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable.ExitToken
 import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable.Instructions
-import com.masselis.tpmsadvanced.core.androidtest.process
 import com.masselis.tpmsadvanced.core.androidtest.onEnterAndOnExit
+import com.masselis.tpmsadvanced.core.androidtest.process
 import com.masselis.tpmsadvanced.feature.main.interfaces.composable.Settings
 import com.masselis.tpmsadvanced.interfaces.composable.HomeTags
 import com.masselis.tpmsadvanced.interfaces.composable.SettingsTag
 
-context(ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-internal class OverflowMenu : EnterExitComposable<OverflowMenu> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(HomeTags.Overflow.root)) },
-    { waitUntilDoesNotExist(hasTestTag(HomeTags.Overflow.root)) }
-) {
+internal class OverflowMenu private constructor(
+    composeTestRule: ComposeTestRule
+) :
+    ComposeTestRule by composeTestRule,
+    EnterExitComposable<OverflowMenu> by onEnterAndOnExit(
+        { composeTestRule.waitUntilExactlyOneExists(hasTestTag(HomeTags.Overflow.root)) },
+        { composeTestRule.waitUntilDoesNotExist(hasTestTag(HomeTags.Overflow.root)) }
+    ) {
 
     private val settingsNode
         get() = onNodeWithTag(HomeTags.Overflow.settings)
@@ -41,4 +44,9 @@ internal class OverflowMenu : EnterExitComposable<OverflowMenu> by onEnterAndOnE
         bindingMethodTest.process(instructions)
         return exitToken
     }
+
+    companion object {
+        context(ComposeTestRule)
+        operator fun invoke(): OverflowMenu = OverflowMenu(this@ComposeTestRule)
+    }
 }
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
@@ -27,6 +27,7 @@ kotlinDslPluginOptions {
 dependencies {
     implementation(libs.android.gradle.plugin)
     implementation(kotlin("gradle-plugin", libs.versions.kotlin.get()))
+    implementation(libs.compose.gradle.plugin)
     implementation(libs.detekt.gradle.plugin)
     implementation(libs.google.oauth2.http)
     implementation(libs.google.android.publisher)

diff --git a/buildSrc/src/main/kotlin/compose.gradle.kts b/buildSrc/src/main/kotlin/compose.gradle.kts
@@ -1,18 +1,10 @@
 @file:Suppress("UnstableApiUsage")
 
-import com.android.build.gradle.BaseExtension
-
 plugins {
-    com.android.base
+    id("org.jetbrains.kotlin.plugin.compose")
     id("detekt")
 }
 
-the<BaseExtension>().apply android@{
-    buildFeatures.compose = true
-    composeOptions {
-        kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
-    }
-    dependencies {
-        "detektPlugins"(libs.compose.detekt)
-    }
-}
+dependencies {
+    "detektPlugins"(libs.compose.detekt)
+}
diff --git a/...c/debug/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/AddVehicle.kt b/...c/debug/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/AddVehicle.kt
@@ -11,12 +11,16 @@ import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable.ExitToken
 import com.masselis.tpmsadvanced.core.androidtest.onEnterAndOnExit
 import com.masselis.tpmsadvanced.data.vehicle.model.Vehicle
 
-context (ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-public class AddVehicle : EnterExitComposable<AddVehicle> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(CurrentVehicleDropdownTags.AddVehicle.root)) },
-    { waitUntilDoesNotExist(hasTestTag(CurrentVehicleDropdownTags.AddVehicle.root)) }
-) {
+public class AddVehicle private constructor(
+    composeTestRule: ComposeTestRule
+) :
+    ComposeTestRule by composeTestRule,
+    EnterExitComposable<AddVehicle> by onEnterAndOnExit(
+        { composeTestRule.waitUntilExactlyOneExists(hasTestTag(CurrentVehicleDropdownTags.AddVehicle.root)) },
+        { composeTestRule.waitUntilDoesNotExist(hasTestTag(CurrentVehicleDropdownTags.AddVehicle.root)) }
+    ) {
+
     private val textFieldNode
         get() = onNodeWithTag(CurrentVehicleDropdownTags.AddVehicle.textField)
     private val addButtonNode
@@ -42,4 +46,9 @@ public class AddVehicle : EnterExitComposable<AddVehicle> by onEnterAndOnExit(
         cancelButtonNode.performClick()
         return exitToken
     }
+
+    public companion object {
+        context(ComposeTestRule)
+        public operator fun invoke(): AddVehicle = AddVehicle(this@ComposeTestRule)
+    }
 }
diff --git a/...g/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/BindSensorButton.kt b/...g/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/BindSensorButton.kt
@@ -14,13 +14,15 @@ import com.masselis.tpmsadvanced.core.androidtest.onEnter
 import com.masselis.tpmsadvanced.core.androidtest.process
 import com.masselis.tpmsadvanced.data.vehicle.model.Vehicle
 
-context (ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-public class BindSensorButton(
+public class BindSensorButton private constructor(
     private val location: Vehicle.Kind.Location,
-) : EnterComposable<BindSensorButton> by onEnter(
-    { waitUntilExactlyOneExists(hasTestTag(BindSensorTags.Button.tag(location))) }
-) {
+    composeTestRule: ComposeTestRule,
+) :
+    ComposeTestRule by composeTestRule,
+    EnterComposable<BindSensorButton> by onEnter(
+        { composeTestRule.waitUntilExactlyOneExists(hasTestTag(BindSensorTags.Button.tag(location))) }
+    ) {
 
     private val bindSensorDialog = BindSensorDialog()
 
@@ -44,4 +46,10 @@ public class BindSensorButton(
         bindSensorDialog.process(instructions)
         waitForIdle()
     }
+
+    public companion object {
+        context (ComposeTestRule)
+        public operator fun invoke(location: Vehicle.Kind.Location): BindSensorButton =
+            BindSensorButton(location, this@ComposeTestRule)
+    }
 }
diff --git a/...g/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/BindSensorDialog.kt b/...g/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/BindSensorDialog.kt
@@ -9,12 +9,15 @@ import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable
 import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable.ExitToken
 import com.masselis.tpmsadvanced.core.androidtest.onEnterAndOnExit
 
-context (ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-public class BindSensorDialog : EnterExitComposable<BindSensorDialog> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(BindSensorTags.Dialog.root)) },
-    { waitUntilDoesNotExist(hasTestTag(BindSensorTags.Dialog.root)) },
-) {
+public class BindSensorDialog private constructor(
+    composeTestRule: ComposeTestRule
+) :
+    ComposeTestRule by composeTestRule,
+    EnterExitComposable<BindSensorDialog> by onEnterAndOnExit(
+        { composeTestRule.waitUntilExactlyOneExists(hasTestTag(BindSensorTags.Dialog.root)) },
+        { composeTestRule.waitUntilDoesNotExist(hasTestTag(BindSensorTags.Dialog.root)) },
+    ) {
 
     private val addToFavoritesButtonNode
         get() = onNodeWithTag(BindSensorTags.Dialog.addToFavoritesButton)
@@ -30,4 +33,9 @@ public class BindSensorDialog : EnterExitComposable<BindSensorDialog> by onEnter
         cancelButtonNode.performClick()
         return exitToken
     }
+
+    public companion object {
+        context(ComposeTestRule)
+        public operator fun invoke(): BindSensorDialog = BindSensorDialog(this@ComposeTestRule)
+    }
 }
diff --git a/...otlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/DeleteVehicleDialog.kt b/...otlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/DeleteVehicleDialog.kt
@@ -9,12 +9,16 @@ import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable
 import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable.ExitToken
 import com.masselis.tpmsadvanced.core.androidtest.onEnterAndOnExit
 
-context (ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-public class DeleteVehicleDialog : EnterExitComposable<DeleteVehicleDialog> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(DeleteVehicleButtonTags.Dialog.root)) },
-    { waitUntilDoesNotExist(hasTestTag(DeleteVehicleButtonTags.Dialog.root)) },
-) {
+public class DeleteVehicleDialog private constructor(
+    composeTestRule: ComposeTestRule
+) :
+    ComposeTestRule by composeTestRule,
+    EnterExitComposable<DeleteVehicleDialog> by onEnterAndOnExit(
+        { composeTestRule.waitUntilExactlyOneExists(hasTestTag(DeleteVehicleButtonTags.Dialog.root)) },
+        { composeTestRule.waitUntilDoesNotExist(hasTestTag(DeleteVehicleButtonTags.Dialog.root)) },
+    ) {
+
     private val deleteButton
         get() = onNodeWithTag(DeleteVehicleButtonTags.Dialog.delete)
     private val cancelButton
@@ -29,4 +33,10 @@ public class DeleteVehicleDialog : EnterExitComposable<DeleteVehicleDialog> by o
         cancelButton.performClick()
         return exitToken
     }
+
+    public companion object {
+        context(ComposeTestRule)
+        public operator fun invoke(): DeleteVehicleDialog =
+            DeleteVehicleDialog(this@ComposeTestRule)
+    }
 }
diff --git a/...debug/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/DropdownMenu.kt b/...debug/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/DropdownMenu.kt
@@ -13,14 +13,14 @@ import com.masselis.tpmsadvanced.core.androidtest.process
 import com.masselis.tpmsadvanced.feature.main.interfaces.composable.CurrentVehicleDropdownTags.dropdownEntry
 import com.masselis.tpmsadvanced.feature.main.interfaces.composable.CurrentVehicleDropdownTags.dropdownEntryAddVehicle
 
-context (ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-public class DropdownMenu(
+public class DropdownMenu private constructor(
     private val containerTag: String,
-) : EnterExitComposable<DropdownMenu> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(dropdownEntryAddVehicle)) },
-    { waitUntilDoesNotExist(hasTestTag(dropdownEntryAddVehicle)) }
-) {
+    composeTestRule: ComposeTestRule,
+) : ComposeTestRule by composeTestRule, EnterExitComposable<DropdownMenu> by onEnterAndOnExit({
+    composeTestRule.waitUntilExactlyOneExists(hasTestTag(dropdownEntryAddVehicle))
+},
+    { composeTestRule.waitUntilDoesNotExist(hasTestTag(dropdownEntryAddVehicle)) }) {
 
     private val addVehicleNode
         get() = onNodeWithTag(dropdownEntryAddVehicle)
@@ -54,4 +54,10 @@ public class DropdownMenu(
         carListDropdownMenu.performClick()
         return exitToken
     }
+
+    public companion object {
+        context(ComposeTestRule)
+        public operator fun invoke(containerTag: String): DropdownMenu =
+            DropdownMenu(containerTag, this@ComposeTestRule)
+    }
 }
diff --git a/...src/debug/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/Settings.kt b/...src/debug/kotlin/com/masselis/tpmsadvanced/feature/main/interfaces/composable/Settings.kt
@@ -17,15 +17,17 @@ import com.masselis.tpmsadvanced.core.androidtest.check
 import com.masselis.tpmsadvanced.core.androidtest.onEnterAndOnExit
 import com.masselis.tpmsadvanced.core.androidtest.process
 
-context (ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
 public class Settings(
     private val backButtonTag: String,
     private val containerTag: String,
-) : EnterExitComposable<Settings> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(containerTag)) },
-    { waitUntilDoesNotExist(hasTestTag(containerTag)) }
-) {
+    composeTestRule: ComposeTestRule,
+) :
+    ComposeTestRule by composeTestRule,
+    EnterExitComposable<Settings> by onEnterAndOnExit(
+        { composeTestRule.waitUntilExactlyOneExists(hasTestTag(containerTag)) },
+        { composeTestRule.waitUntilDoesNotExist(hasTestTag(containerTag)) }
+    ) {
     private val backButton
         get() = onNodeWithTag(backButtonTag)
 
@@ -68,4 +70,10 @@ public class Settings(
         backButton.performClick()
         return exitToken
     }
+
+    public companion object {
+        context(ComposeTestRule)
+        public operator fun invoke(backButtonTag: String, containerTag: String): Settings =
+            Settings(backButtonTag, containerTag, this@ComposeTestRule)
+    }
 }
diff --git a/.../src/debug/kotlin/com/masselis/tpmsadvanced/feature/unlocated/interfaces/ui/BindDialog.kt b/.../src/debug/kotlin/com/masselis/tpmsadvanced/feature/unlocated/interfaces/ui/BindDialog.kt
@@ -14,11 +14,12 @@ import com.masselis.tpmsadvanced.core.androidtest.EnterExitComposable.ExitToken
 import com.masselis.tpmsadvanced.core.androidtest.onEnterAndOnExit
 import com.masselis.tpmsadvanced.data.vehicle.model.Vehicle
 
-context (ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-public class BindDialog : EnterExitComposable<BindDialog> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(BindDialogTags.root)) },
-    { waitUntilDoesNotExist(hasTestTag(BindDialogTags.root)) },
+public class BindDialog private constructor(
+    composeTestRule: ComposeTestRule
+) : ComposeTestRule by composeTestRule, EnterExitComposable<BindDialog> by onEnterAndOnExit(
+    { composeTestRule.waitUntilExactlyOneExists(hasTestTag(BindDialogTags.root)) },
+    { composeTestRule.waitUntilDoesNotExist(hasTestTag(BindDialogTags.root)) },
 ) {
     private val cancelButtonNode
         get() = onNodeWithTag(BindDialogTags.cancelButton)
@@ -27,8 +28,9 @@ public class BindDialog : EnterExitComposable<BindDialog> by onEnterAndOnExit(
         get() = onNodeWithTag(BindDialogTags.bindButton)
 
     private fun locationNode(location: Vehicle.Kind.Location) =
-        onAllNodesWithTag(VehicleTyresTags.tyreLocation(location))
-            .filterToOne(hasAnyAncestor(hasTestTag(BindDialogTags.root)))
+        onAllNodesWithTag(VehicleTyresTags.tyreLocation(location)).filterToOne(
+                hasAnyAncestor(hasTestTag(BindDialogTags.root))
+            )
 
     public fun assertBindButtonIsNotEnabled() {
         bindButtonNode.assertIsNotEnabled()
@@ -47,4 +49,9 @@ public class BindDialog : EnterExitComposable<BindDialog> by onEnterAndOnExit(
         bindButtonNode.performClick()
         return exitToken
     }
+
+    public companion object {
+        context(ComposeTestRule)
+        public operator fun invoke(): BindDialog = BindDialog(this@ComposeTestRule)
+    }
 }
diff --git a/.../kotlin/com/masselis/tpmsadvanced/feature/unlocated/interfaces/ui/UnlocatedSensorsList.kt b/.../kotlin/com/masselis/tpmsadvanced/feature/unlocated/interfaces/ui/UnlocatedSensorsList.kt
@@ -15,12 +15,15 @@ import com.masselis.tpmsadvanced.core.androidtest.onEnterAndOnExit
 import com.masselis.tpmsadvanced.core.androidtest.process
 import com.masselis.tpmsadvanced.data.vehicle.model.Vehicle
 
-context(ComposeTestRule)
 @OptIn(ExperimentalTestApi::class)
-public class UnlocatedSensorsList : EnterExitComposable<UnlocatedSensorsList> by onEnterAndOnExit(
-    { waitUntilExactlyOneExists(hasTestTag(UnlocatedSensorListTags.root)) },
-    { waitUntilDoesNotExist(hasTestTag(UnlocatedSensorListTags.root)) },
-) {
+public class UnlocatedSensorsList private constructor(
+    composeTestRule: ComposeTestRule
+) :
+    ComposeTestRule by composeTestRule,
+    EnterExitComposable<UnlocatedSensorsList> by onEnterAndOnExit(
+        { composeTestRule.waitUntilExactlyOneExists(hasTestTag(UnlocatedSensorListTags.root)) },
+        { composeTestRule.waitUntilDoesNotExist(hasTestTag(UnlocatedSensorListTags.root)) },
+    ) {
     private val sensorUnpluggedButtonNode
         get() = onNodeWithTag(UnlocatedSensorListTags.sensorUnpluggedButton)
 
@@ -43,14 +46,22 @@ public class UnlocatedSensorsList : EnterExitComposable<UnlocatedSensorsList> by
 
     public fun assertAllLocationBound(vararg locations: Pair<Int, Vehicle.Kind.Location>) {
         locations.forEach { (sensorId, location) ->
-            onAllNodesWithTag(VehicleTyresTags.tyreLocation(location))
-                .filterToOne(hasAnyAncestor(hasTestTag(UnlocatedSensorListTags.boundCell(sensorId))))
-                .assertExists()
+            onAllNodesWithTag(VehicleTyresTags.tyreLocation(location)).filterToOne(
+                hasAnyAncestor(
+                    hasTestTag(UnlocatedSensorListTags.boundCell(sensorId))
+                )
+            ).assertExists()
         }
     }
 
     public fun tapGoBack(): ExitToken<UnlocatedSensorsList> {
         goBackButtonNode.performClick()
         return exitToken
     }
+
+    public companion object {
+        context(ComposeTestRule)
+        public operator fun invoke(): UnlocatedSensorsList =
+            UnlocatedSensorsList(this@ComposeTestRule)
+    }
 }