intermediate

core/design/src/androidTest/kotlin/edu/stanford/spezi/core/design/ValidationTest.kt

@@ -0,0 +1,44 @@
+package edu.stanford.spezi.core.design
+
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import edu.stanford.spezi.core.design.composables.FocusValidationRules
+import edu.stanford.spezi.core.design.simulator.FocusValidationRulesSimulator
+import edu.stanford.spezi.core.design.views.validation.state.ValidationContext
+import kotlinx.coroutines.delay
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+class ValidationTest {
+
+    @get:Rule
+    val composeTestRule = createComposeRule()
+
+    @Before
+    fun init() {
+        composeTestRule.setContent {
+            FocusValidationRules()
+        }
+    }
+
+    @Test
+    fun testValidationWithFocus() {
+        focusValidationRules {
+            assertHasEngines(true)
+            assertInputValid(false)
+            assertPasswordMessageExists(false)
+            assertEmptyMessageExists(false)
+            clickValidateButton()
+            assertLastState(false)
+            assertPasswordMessageExists(true)
+            // assertEmptyMessageExists(true)
+        }
+    }
+
+    private fun focusValidationRules(block: FocusValidationRulesSimulator.() -> Unit) {
+        FocusValidationRulesSimulator(composeTestRule).apply(block)
+    }
+
+}

core/design/src/androidTest/kotlin/edu/stanford/spezi/core/design/composables/DefaultValidationRules.kt

@@ -0,0 +1,38 @@
+package edu.stanford.spezi.core.design.composables
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import edu.stanford.spezi.core.design.component.StringResource
+import edu.stanford.spezi.core.design.views.validation.Validate
+import edu.stanford.spezi.core.design.views.validation.ValidationRule
+import edu.stanford.spezi.core.design.views.validation.asciiLettersOnly
+import edu.stanford.spezi.core.design.views.validation.mediumPassword
+import edu.stanford.spezi.core.design.views.validation.minimalEmail
+import edu.stanford.spezi.core.design.views.validation.minimalPassword
+import edu.stanford.spezi.core.design.views.validation.nonEmpty
+import edu.stanford.spezi.core.design.views.validation.strongPassword
+import edu.stanford.spezi.core.design.views.validation.unicodeLettersOnly
+import edu.stanford.spezi.core.design.views.validation.views.VerifiableTextField
+
+@Composable
+fun DefaultValidationRules() {
+    val input = remember { mutableStateOf("") }
+    val rules = remember {
+        listOf(
+            ValidationRule.nonEmpty,
+            ValidationRule.unicodeLettersOnly,
+            ValidationRule.asciiLettersOnly,
+            ValidationRule.minimalEmail,
+            ValidationRule.minimalPassword,
+            ValidationRule.mediumPassword,
+            ValidationRule.strongPassword
+        )
+    }
+    Validate(input.value, rules) {
+        VerifiableTextField(
+            StringResource("Field"),
+            text = input
+        )
+    }
+}

core/design/src/androidTest/kotlin/edu/stanford/spezi/core/design/composables/FocusValidationRules.kt

@@ -0,0 +1,63 @@
+package edu.stanford.spezi.core.design.composables
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.material3.Button
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import edu.stanford.spezi.core.design.component.StringResource
+import edu.stanford.spezi.core.design.views.validation.Validate
+import edu.stanford.spezi.core.design.views.validation.ValidationRule
+import edu.stanford.spezi.core.design.views.validation.minimalPassword
+import edu.stanford.spezi.core.design.views.validation.nonEmpty
+import edu.stanford.spezi.core.design.views.validation.state.ReceiveValidation
+import edu.stanford.spezi.core.design.views.validation.state.ValidationContext
+import edu.stanford.spezi.core.design.views.validation.views.VerifiableTextField
+
+enum class Field {
+    INPUT, NON_EMPTY_INPUT
+}
+
+@Composable
+fun FocusValidationRules() {
+    val input = remember { mutableStateOf("") }
+    val nonEmptyInput = remember { mutableStateOf("") }
+    val validationContext = remember { mutableStateOf(ValidationContext()) }
+    val lastValid = remember { mutableStateOf<Boolean?>(null) }
+    val switchFocus = remember { mutableStateOf(false) }
+
+    ReceiveValidation(validationContext) {
+        Column {
+            Text("Has Engines: ${if (!validationContext.value.isEmpty) "Yes" else "No"}")
+            Text("Input Valid: ${if (validationContext.value.allInputValid) "Yes" else "No"}")
+            lastValid.value?.let { lastValid ->
+                Text("Last state: ${if (lastValid) "valid" else "invalid"}")
+            }
+            Button(
+                onClick = {
+                    val newLastValid = validationContext.value
+                        .validateHierarchy(switchFocus.value)
+                    lastValid.value = newLastValid
+                }
+            ) {
+                Text("Validate")
+            }
+            Row {
+                Text("Switch Focus")
+                Switch(switchFocus.value, onCheckedChange = { switchFocus.value = it })
+            }
+
+            Validate(input.value, rules = listOf(ValidationRule.minimalPassword)) {
+                VerifiableTextField(StringResource(Field.INPUT.name), input)
+            }
+
+            Validate(nonEmptyInput.value, rules = listOf(ValidationRule.nonEmpty)) {
+                VerifiableTextField(StringResource(Field.NON_EMPTY_INPUT.name), nonEmptyInput)
+            }
+        }
+    }
+}

core/design/src/androidTest/kotlin/edu/stanford/spezi/core/design/simulator/DefaultValidationRulesSimulator.kt

@@ -0,0 +1,9 @@
+package edu.stanford.spezi.core.design.simulator
+
+import androidx.compose.ui.test.junit4.ComposeTestRule
+
+class DefaultValidationRulesSimulator(
+    private val composeTestRule: ComposeTestRule,
+) {
+
+}

core/design/src/androidTest/kotlin/edu/stanford/spezi/core/design/simulator/FocusValidationRulesSimulator.kt

@@ -0,0 +1,50 @@
+package edu.stanford.spezi.core.design.simulator
+
+import androidx.compose.material3.Text
+import androidx.compose.ui.test.assertHasClickAction
+import androidx.compose.ui.test.assertIsOn
+import androidx.compose.ui.test.junit4.ComposeTestRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+
+class FocusValidationRulesSimulator(
+    private val composeTestRule: ComposeTestRule,
+) {
+    private val passwordMessage = "Your password must be at least 8 characters long."
+    private val emptyMessage = "This field cannot be empty."
+
+    fun assertHasEngines(hasEngines: Boolean) {
+        composeTestRule
+            .onNodeWithText("Has Engines: ${if (hasEngines) "Yes" else "No"}")
+            .assertExists()
+    }
+
+    fun assertInputValid(inputValid: Boolean) {
+        composeTestRule
+            .onNodeWithText("Input Valid: ${if (inputValid) "Yes" else "No"}")
+            .assertExists()
+    }
+
+    fun assertPasswordMessageExists(exists: Boolean) {
+        val node = composeTestRule.onNodeWithText(passwordMessage)
+        if (exists) node.assertExists() else node.assertDoesNotExist()
+    }
+
+    fun assertEmptyMessageExists(exists: Boolean) {
+        val node = composeTestRule.onNodeWithText(emptyMessage)
+        if (exists) node.assertExists() else node.assertDoesNotExist()
+    }
+
+    fun clickValidateButton() {
+        composeTestRule
+            .onNodeWithText("Validate")
+            .assertHasClickAction()
+            .performClick()
+    }
+
+    fun assertLastState(valid: Boolean) {
+        composeTestRule
+            .onNodeWithText("Last state: ${if (valid) "valid" else "invalid"}")
+            .assertExists()
+    }
+}

core/design/src/main/kotlin/edu/stanford/spezi/core/design/views/personalInfo/UserProfileComposable.kt

@@ -20,6 +20,8 @@ import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import edu.stanford.spezi.core.design.component.ImageResource
+import edu.stanford.spezi.core.design.component.ImageResourceComposable
 import edu.stanford.spezi.core.design.theme.Colors
 import edu.stanford.spezi.core.design.theme.lighten
 import kotlin.math.min
@@ -28,9 +30,9 @@ import kotlin.math.min
 fun UserProfileComposable(
     modifier: Modifier = Modifier,
     name: PersonNameComponents,
-    imageLoader: suspend () -> ImageVector? = { null }, // TODO: Use ImageResource instead!
+    imageLoader: suspend () -> ImageResource? = { null },
 ) {
-    val image = remember { mutableStateOf<ImageVector?>(null) }
+    val image = remember { mutableStateOf<ImageResource?>(null) }
     val size = remember { mutableStateOf(IntSize.Zero) }
 
     LaunchedEffect(Unit) {
@@ -41,9 +43,9 @@ fun UserProfileComposable(
         val sideLength = min(size.value.height, size.value.width).dp
         Box(modifier.size(sideLength, sideLength), contentAlignment = Alignment.Center) {
             image.value?.let {
-                Image(
+                ImageResourceComposable(
                     it,
-                    null,
+                    "", // TODO: Add contentDescription to ImageResource directly?
                     Modifier
                         .clip(CircleShape)
                         .background(Colors.background, CircleShape)

core/design/src/main/kotlin/edu/stanford/spezi/core/design/views/personalInfo/fields/NameFieldRow.kt

@@ -1,10 +1,7 @@
 package edu.stanford.spezi.core.design.views.personalInfo.fields
 
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.staggeredgrid.LazyHorizontalStaggeredGrid
-import androidx.compose.material3.Divider
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable

core/design/src/main/kotlin/edu/stanford/spezi/core/design/views/personalInfo/fields/NameTextField.kt

@@ -1,6 +1,5 @@
 package edu.stanford.spezi.core.design.views.personalInfo.fields
 
-import android.app.Person
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextField

core/design/src/main/kotlin/edu/stanford/spezi/core/design/views/validation/ValidationEngine.kt

@@ -1,58 +1,69 @@
 package edu.stanford.spezi.core.design.views.validation
 
-import android.provider.Settings.Global
+import androidx.compose.runtime.mutableStateOf
 import edu.stanford.spezi.core.design.views.validation.configuration.DEFAULT_VALIDATION_DEBOUNCE_DURATION
 import edu.stanford.spezi.core.design.views.validation.state.FailedValidationResult
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.async
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
 import java.util.EnumSet
 import kotlin.time.Duration
 
-typealias ValidationEngineConfiguration = EnumSet<ValidationEngine.ConfigurationOption>
-
-class ValidationEngine(
-    val rules: List<ValidationRule>,
-    var debounceDuration: Duration = DEFAULT_VALIDATION_DEBOUNCE_DURATION,
-    var configuration: ValidationEngineConfiguration = ValidationEngineConfiguration.noneOf(ConfigurationOption::class.java),
-) {
-    private enum class Source {
-        SUBMIT, MANUAL
-    }
+internal typealias ValidationEngineConfiguration = EnumSet<ValidationEngine.ConfigurationOption>
 
+interface ValidationEngine {
     enum class ConfigurationOption {
         HIDE_FAILED_VALIDATION_ON_EMPTY_SUBMIT,
         CONSIDER_NO_INPUT_AS_VALID,
     }
 
-    var validationResults: List<FailedValidationResult> = emptyList()
-        private set
+    val rules: List<ValidationRule>
+    val inputValid: Boolean
+    val validationResults: List<FailedValidationResult>
+    val isDisplayingValidationErrors: Boolean
+    val displayedValidationResults: List<FailedValidationResult>
+    var debounceDuration: Duration
+
+    fun submit(input: String, debounce: Boolean = false)
+    fun runValidation(input: String)
+}
+
+internal class ValidationEngineImpl(
+    override val rules: List<ValidationRule>,
+    override var debounceDuration: Duration = DEFAULT_VALIDATION_DEBOUNCE_DURATION,
+    var configuration: ValidationEngineConfiguration =
+        ValidationEngineConfiguration.noneOf(ValidationEngine.ConfigurationOption::class.java),
+) : ValidationEngine {
+    private enum class Source {
+        SUBMIT, MANUAL
+    }
+
+    private var validationResultsState = mutableStateOf(emptyList<FailedValidationResult>())
+
+    override val validationResults get() = validationResultsState.value
 
     private var computedInputValid: Boolean? = null
 
-    val inputValid: Boolean get() =
-        computedInputValid ?: configuration.contains(ConfigurationOption.CONSIDER_NO_INPUT_AS_VALID)
+    override val inputValid: Boolean get() =
+        computedInputValid ?: configuration.contains(ValidationEngine.ConfigurationOption.CONSIDER_NO_INPUT_AS_VALID)
 
     private var source: Source? = null
     private var inputWasEmpty = true
 
-    val isDisplayingValidationErrors: Boolean get() {
+    override val isDisplayingValidationErrors: Boolean get() {
         val gotResults = validationResults.isNotEmpty()
 
-        if (configuration.contains(ConfigurationOption.HIDE_FAILED_VALIDATION_ON_EMPTY_SUBMIT)) {
+        if (configuration.contains(ValidationEngine.ConfigurationOption.HIDE_FAILED_VALIDATION_ON_EMPTY_SUBMIT)) {
             return gotResults && (source == Source.MANUAL || !inputWasEmpty)
         }
 
         return gotResults
     }
 
-    val displayedValidationResults: List<FailedValidationResult> get() =
+    override val displayedValidationResults: List<FailedValidationResult> get() =
         if (isDisplayingValidationErrors) validationResults else emptyList()
 
     private var debounceJob: Job? = null
@@ -75,11 +86,11 @@ class ValidationEngine(
         this.source = source
         this.inputWasEmpty = input.isEmpty()
 
-        this.validationResults = computeFailedValidations(input)
+        this.validationResultsState.value = computeFailedValidations(input)
         this.computedInputValid = validationResults.isEmpty()
     }
 
-    fun submit(input: String, debounce: Boolean = false) {
+    override fun submit(input: String, debounce: Boolean) {
         if (!debounce || computedInputValid == false) {
             computeValidation(input, Source.SUBMIT)
         } else {
@@ -89,7 +100,7 @@ class ValidationEngine(
         }
     }
 
-    fun runValidation(input: String) {
+    override fun runValidation(input: String) {
         computeValidation(input, Source.MANUAL)
     }