Create shared UIElement finders

android/build.gradle.kts

@@ -53,6 +53,7 @@ dependencies {
 
     implementation(project(":shared"))
     implementation(project(":cucumber"))
+    implementation(project(":pistakio"))
     implementation("androidx.compose.ui:ui:1.4.3")
     implementation("androidx.compose.ui:ui-tooling:1.4.3")
     implementation("androidx.compose.ui:ui-tooling-preview:1.4.3")

android/src/androidTest/assets/features/Home.feature

@@ -4,5 +4,6 @@ Feature: Home
     And I am in the "Home" screen
     Then I see "[email protected]" text
     And I see the "Logout" button
+    And I see "15" in the scrollview
     When I press the "Logout" button
-    Then I see the "Login" screen
+    Then I see the "Login" screen

android/src/androidTest/assets/features/Login.feature

@@ -5,7 +5,7 @@ Feature: Login
     And I see the "Password" textfield with text "Password"
     And I see the "Login" button
     When I type "[email protected]" in the "Email" textfield
-    And I type "1234" in the "Password" secure textfield
+    And I type "1234" in the "Password" textfield
     And I press the "Login" button
     Then I see the "Home" screen
     And I see "[email protected]" text

android/src/androidTest/kotlin/com/corrado4eyes/cucumberplayground/test/StepDefinitions.kt

@@ -1,114 +1,80 @@
 package com.corrado4eyes.cucumberplayground.test
 
-import android.app.Activity
-import android.content.Intent
-import androidx.compose.ui.test.assertHasClickAction
 import androidx.compose.ui.test.assertIsDisplayed
-import androidx.compose.ui.test.assertTextContains
 import androidx.compose.ui.test.junit4.createComposeRule
 import androidx.compose.ui.test.onNodeWithTag
 import androidx.compose.ui.test.onNodeWithText
-import androidx.compose.ui.test.performClick
-import androidx.compose.ui.test.performTextInput
-import androidx.test.core.app.ActivityScenario
-import androidx.test.platform.app.InstrumentationRegistry
-import com.corrado4eyes.cucumber.errors.UIElementException
-import com.corrado4eyes.cucumberplayground.android.MainActivity
+import androidx.compose.ui.test.performScrollToIndex
 import com.corrado4eyes.cucumberplayground.models.Strings
-import com.corrado4eyes.cucumbershared.tests.Definitions
+import com.corrado4eyes.cucumbershared.tests.AppDefinitions
+import com.corrado4eyes.pistakio.DefaultApplicationAdapter
 import io.cucumber.java8.En
 import io.cucumber.junit.WithJunitRule
 import org.junit.Rule
 
 @WithJunitRule
 class StepDefinitions : En {
-
-    private val arguments = mutableMapOf<String, String>()
-    private var scenario: ActivityScenario<*>? = null
-
     @get:Rule(order = 0)
     val testRule = createComposeRule()
+    private val application = DefaultApplicationAdapter(testRule)
 
     init {
-        Definitions.values().forEach {
+        AppDefinitions.allCases.forEach {
             val definitionString = it.definition.definitionString
             when (it) {
-                Definitions.I_AM_IN_THE_EXPECT_VALUE_STRING_SCREEN -> Given(definitionString) { screenName: String ->
-                        val screenTitleTag = when (screenName) {
-                            Strings.Screen.Tag.login -> {
-                                arguments["isLoggedIn"] = "false"
-                                arguments["testEmail"] = ""
-                                Strings.Screen.Title.login
-                            }
-
-                            Strings.Screen.Tag.home -> {
-                                arguments["isLoggedIn"] = "true"
-                                Strings.Screen.Title.home
-                            }
-
-                            else -> throw UIElementException.Screen.NotFound(screenName)
-                        }
-                        setLaunchScreen()
-                        testRule.onNodeWithTag(screenTitleTag).assertIsDisplayed()
+                is AppDefinitions.CrossPlatform.IAmInScreen -> Given(definitionString) { screenName: String ->
+                    val assertions = AppDefinitions.CrossPlatform.IAmInScreen(
+                        "MainActivity",
+                        application,
+                        listOf(screenName)
+                    ).runAndGetAssertions()
+                    application.assertAll(assertions)
                 }
-                Definitions.I_SEE_EXPECT_VALUE_STRING_TEXT -> Then(definitionString) { title: String ->
-                    testRule.onNodeWithText(title).assertIsDisplayed()
+                is AppDefinitions.CrossPlatform.ISeeText -> Then(definitionString) { textViewTitle: String ->
+                    val assertions = AppDefinitions.CrossPlatform.ISeeText(application, listOf(textViewTitle)).runAndGetAssertions()
+                    application.assertAll(assertions)
                 }
-                Definitions.I_SEE_THE_EXPECT_VALUE_STRING_BUTTON -> Then(definitionString) { buttonName: String ->
-                    when (buttonName) {
-                        Strings.Button.Text.login -> testRule.onNodeWithText(Strings.Button.Text.login).assertIsDisplayed().assertHasClickAction()
-                        Strings.Button.Text.logout -> testRule.onNodeWithTag(Strings.Button.Text.logout).assertIsDisplayed().assertHasClickAction()
-                        else -> throw UIElementException.Button.NotFound(buttonName)
-                    }
+                is AppDefinitions.CrossPlatform.ISeeButton -> Then(definitionString) { buttonTitle: String ->
+                    val assertions = AppDefinitions.CrossPlatform.ISeeButton(application, listOf(buttonTitle)).runAndGetAssertions()
+                    application.assertAll(assertions)
                 }
-                Definitions.I_SEE_THE_EXPECT_VALUE_STRING_SCREEN -> Then(definitionString) { screenName: String ->
-                    Thread.sleep(1000)
-                    when (screenName) {
-                        Strings.Screen.Tag.login -> testRule.onNodeWithTag(Strings.Screen.Title.login).assertIsDisplayed()
-                        Strings.Screen.Tag.home -> testRule.onNodeWithTag(Strings.Screen.Title.home).assertIsDisplayed()
-                        else -> throw UIElementException.Screen.NotFound(screenName)
-                    }
+                is AppDefinitions.CrossPlatform.ISeeScreen -> Then(definitionString) { screenTitle: String ->
+                    val assertions = AppDefinitions.CrossPlatform.ISeeScreen(application, listOf(screenTitle)).runAndGetAssertions()
+                    application.assertAll(assertions)
                 }
-                Definitions.I_SEE_THE_EXPECT_VALUE_STRING_TEXT_FIELD_WITH_TEXT_EXPECT_VALUE_STRING -> Then(definitionString) { tag: String, text: String ->
-                    val elementNode = try {
-                        testRule.onNodeWithTag(tag).assertIsDisplayed()
-                    } catch (e: AssertionError) {
-                        throw UIElementException.TextField.NotFound(tag)
-                    }
 
-                    elementNode.assertTextContains(text)
+                is AppDefinitions.CrossPlatform.ISeeTextFieldWithText -> Then(definitionString) { textFieldTag: String, textFieldText: String ->
+                    val assertions = AppDefinitions.CrossPlatform.ISeeTextFieldWithText(application, listOf(textFieldTag, textFieldText)).runAndGetAssertions()
+                    application.assertAll(assertions)
                 }
-                Definitions.I_TYPE_EXPECT_VALUE_STRING_IN_THE_EXPECT_VALUE_STRING_TEXT_FIELD -> When(definitionString) { textInput: String, tag: String,  ->
-                    testRule.onNodeWithText(tag).performTextInput(textInput)
+                is AppDefinitions.CrossPlatform.ITypeTextIntoTextField -> When(definitionString) { textInput: String, tag: String,  ->
+                    val assertions = AppDefinitions.CrossPlatform.ITypeTextIntoTextField(application, listOf(textInput, tag)).runAndGetAssertions()
+                    application.assertAll(assertions)
                 }
-                Definitions.I_TYPE_EXPECT_VALUE_STRING_IN_THE_EXPECT_VALUE_STRING_SECURE_TEXT_FIELD -> When(definitionString) { textInput: String, tag: String ->
-                    testRule.onNodeWithText(tag).performTextInput(textInput)
+                is AppDefinitions.CrossPlatform.IPressTheButton -> When(definitionString) { buttonTag: String ->
+                    val assertions = AppDefinitions.CrossPlatform.IPressTheButton(application, listOf(buttonTag)).runAndGetAssertions()
+                    application.assertAll(assertions)
                 }
-                Definitions.I_PRESS_THE_EXPECT_VALUE_STRING_BUTTON -> When(definitionString) { buttonName: String ->
-                    val elementNode = try {
-                        testRule.onNodeWithTag(buttonName).assertIsDisplayed()
-                    } catch (e: AssertionError) {
-                        throw UIElementException.TextField.NotFound(buttonName)
-                    }
-                    elementNode.performClick()
+                is AppDefinitions.CrossPlatform.SetLoggedInUserEmail -> Given(definitionString) { loggedInEmail: String ->
+                    application.assertAll(AppDefinitions.CrossPlatform.SetLoggedInUserEmail(application, listOf(loggedInEmail)).runAndGetAssertions())
                 }
-                Definitions.EMAIL_IS_EXPECT_VALUE_STRING -> Given(definitionString) { loggedInEmail: String ->
-                    arguments["testEmail"] = loggedInEmail
+                is AppDefinitions.Platform.ISeeValueInScrollView -> When(definitionString) { index: String ->
+
+                    // Platform implementation
+                    testRule
+                        .onNodeWithTag(Strings.ScrollView.Tag.homeScrollView)
+                        .performScrollToIndex(index.toInt())
+
+                    testRule.onNodeWithText(index).assertIsDisplayed()
+
+                    // Cross-platform implementation
+//                    val element = application.findView(Strings.ScrollView.Tag.homeScrollView)
+//                    element.swipeUntilIndex(index.toInt())
+//                    val text = application.findView(index)
+//                    application.assert(text.isVisible())
                 }
+
             }
         }
     }
-
-    private fun setLaunchScreen() {
-        val instrumentation = InstrumentationRegistry.getInstrumentation()
-        launch<MainActivity>(
-            Intent(instrumentation.targetContext, MainActivity::class.java)
-                .putExtra("isLoggedIn", arguments["isLoggedIn"])
-                .putExtra("testEmail", arguments["testEmail"])
-        )
-    }
-
-    private fun <T: Activity> launch(intent: Intent) {
-        scenario = ActivityScenario.launch<T>(intent)
-    }
 }

android/src/main/java/com/corrado4eyes/cucumberplayground/android/home/HomeLayout.kt

@@ -2,12 +2,19 @@ package com.corrado4eyes.cucumberplayground.android.home
 
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
 import androidx.compose.material.Button
 import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.corrado4eyes.cucumberplayground.models.Strings
 import com.corrado4eyes.cucumberplayground.viewModels.home.HomeViewModel
 import com.splendo.kaluga.architecture.compose.viewModel.ViewModelComposable
 import org.koin.androidx.compose.koinViewModel
@@ -19,15 +26,33 @@ fun HomeLayout() {
         Column(modifier = Modifier.fillMaxSize()) {
             Text(
                 [email protected],
-                modifier = Modifier.testTag([email protected])
+                modifier = Modifier.testTag(Strings.Screen.Tag.home)
+            )
+            Text(
+                [email protected]().email,
+                modifier = Modifier.testTag([email protected]().email)
             )
-            Text([email protected]().email)
             Button(
                 this@ViewModelComposable::logout,
-                modifier = Modifier.testTag([email protected])
+                modifier = Modifier.testTag(Strings.Button.Tag.logout)
             ) {
                 Text([email protected])
             }
+
+            LazyColumn(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                modifier = Modifier
+                .fillMaxWidth()
+                .height(200.dp)
+                .testTag(Strings.ScrollView.Tag.homeScrollView)
+            ) {
+                items(
+                    viewModel.scrollableItems,
+                    key = { it }
+                ) {
+                    Text(it.toString())
+                }
+            }
         }
     }
 }

android/src/main/java/com/corrado4eyes/cucumberplayground/android/login/LoginLayout.kt

@@ -14,6 +14,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.text.input.TextFieldValue
 import androidx.compose.ui.tooling.preview.Preview
+import com.corrado4eyes.cucumberplayground.models.Strings
 import com.corrado4eyes.cucumberplayground.viewModels.login.LoginViewModel
 import com.splendo.kaluga.architecture.compose.state
 import com.splendo.kaluga.architecture.compose.viewModel.ViewModelComposable
@@ -26,18 +27,21 @@ fun LoginLayout() {
     ViewModelComposable(viewModel) {
         val isLoading by this.isLoading.state()
         Column {
-            Text(text = [email protected], modifier = Modifier.testTag("Login screen"))
+            Text(
+                text = [email protected],
+                modifier = Modifier.testTag(Strings.Screen.Tag.login)
+            )
             CustomTextField(
                 value = [email protected],
                 label = "Email",
-                modifier = Modifier.testTag("Email")
+                modifier = Modifier.testTag(Strings.TextField.Tag.email)
             )
             val emailErrorText by [email protected]()
             Text(text = emailErrorText, color = Color.Red)
             CustomTextField(
                 value = [email protected],
                 label = "Password",
-                modifier = Modifier.testTag("Password")
+                modifier = Modifier.testTag(Strings.TextField.Tag.password)
             )
             val passwordErrorText by [email protected]()
             Text(text = passwordErrorText, color = Color.Red)
@@ -50,9 +54,9 @@ fun LoginLayout() {
 
             Button(
                 this@ViewModelComposable::login,
-                modifier = Modifier.testTag("Login")
+                modifier = Modifier.testTag(Strings.Button.Tag.login)
             ) {
-                Text("Login")
+                Text(viewModel.buttonTitle)
             }
         }
     }

build.gradle.kts

@@ -8,6 +8,7 @@ plugins {
 
 buildscript {
     repositories {
+        mavenLocal()
         mavenCentral()
     }
 

cucumberShared/build.gradle.kts

@@ -1,3 +1,4 @@
+import co.touchlab.skie.configuration.SealedInterop
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.konan.file.File
 import org.jetbrains.kotlin.konan.properties.Properties
@@ -7,6 +8,7 @@ import org.jetbrains.kotlin.konan.properties.loadProperties
 plugins {
     kotlin("multiplatform")
     id("com.android.library")
+    id("co.touchlab.skie") version "0.5.0"
 }
 
 kotlin {
@@ -25,12 +27,14 @@ kotlin {
                 transitiveExport = true
                 export(project(":shared"))
                 export(project(":cucumber"))
+                export(project(":pistakio"))
                 baseName = "shared"
 
                 linkFrameworkSearchPaths("$projectDir/../cucumber")
+                linkFrameworkSearchPaths("$projectDir/../pistakio")
 
                 getTest("DEBUG").apply {
-                    linkFrameworkSearchPaths("$projectDir/../cucumber")
+                    linkFrameworkSearchPaths("$projectDir/../pistakio")
                 }
             }
         }
@@ -45,6 +49,7 @@ kotlin {
             dependencies {
                 api(project(":shared"))
                 api(project(":cucumber"))
+                api(project(":pistakio"))
             }
         }
         val commonTest by getting {
@@ -167,4 +172,15 @@ fun org.jetbrains.kotlin.gradle.plugin.mpp.NativeBinary.linkFrameworkSearchPaths
             linkerOpts("-rpath", it)
         }
     }
+}
+
+skie {
+    analytics {
+        disableUpload.set(true)
+    }
+    features {
+        group {
+            SealedInterop.Enabled(true)
+        }
+    }
 }