Prohibit datePicker input when minValue/maxValue conflict

Instead of throwing an IllegalArgumentException

Author: LZRS

datacapture/src/androidTest/java/com/google/android/fhir/datacapture/test/QuestionnaireUiEspressoTest.kt

@@ -23,6 +23,7 @@ import androidx.compose.ui.semantics.SemanticsProperties
 import androidx.compose.ui.test.SemanticsMatcher
 import androidx.compose.ui.test.assert
 import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsNotEnabled
 import androidx.compose.ui.test.assertTextEquals
 import androidx.compose.ui.test.junit4.createAndroidComposeRule
 import androidx.compose.ui.test.hasAnyAncestor
@@ -78,7 +79,6 @@ import org.hl7.fhir.r4.model.DateTimeType
 import org.hl7.fhir.r4.model.DateType
 import org.hl7.fhir.r4.model.Questionnaire
 import org.hl7.fhir.r4.model.QuestionnaireResponse
-import org.junit.Assert
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
@@ -466,7 +466,7 @@ class QuestionnaireUiEspressoTest {
   }
 
   @Test
-  fun datePicker_shouldThrowException_whenMinValueRangeIsGreaterThanMaxValueRange() {
+  fun datePicker_shouldProhibitInputWithErrorMessage_whenMinValueRangeIsGreaterThanMaxValueRange() {
     val questionnaire =
       Questionnaire().apply {
         id = "a-questionnaire"
@@ -490,18 +490,18 @@ class QuestionnaireUiEspressoTest {
       }
 
     buildFragmentFromQuestionnaire(questionnaire)
-    val exception =
-      Assert.assertThrows(IllegalArgumentException::class.java) {
-        composeTestRule
-          .onNodeWithContentDescription(context.getString(R.string.select_date))
-          .performClick()
-        composeTestRule
-          .onNode(hasText("OK") and hasAnyAncestor(isDialog()))
-          .assertIsDisplayed()
-          .performClick()
-        composeTestRule.waitForIdle() // Synchronize
-      }
-    assertThat(exception.message).isEqualTo("minValue cannot be greater than maxValue")
+    composeTestRule
+      .onNodeWithTag(DATE_TEXT_INPUT_FIELD)
+      .assert(
+        SemanticsMatcher.expectValue(
+          SemanticsProperties.Error,
+          "minValue cannot be greater than maxValue",
+        ),
+      )
+    composeTestRule.onNodeWithTag(DATE_TEXT_INPUT_FIELD).assertIsNotEnabled()
+    composeTestRule
+      .onNodeWithContentDescription(context.getString(R.string.select_date))
+      .assertIsNotEnabled()
   }
 
   @Test

datacapture/src/androidTest/java/com/google/android/fhir/datacapture/test/views/DatePickerViewHolderFactoryTest.kt

@@ -27,6 +27,7 @@ import androidx.compose.ui.test.assertIsNotEnabled
 import androidx.compose.ui.test.assertTextContains
 import androidx.compose.ui.test.assertTextEquals
 import androidx.compose.ui.test.junit4.createEmptyComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
 import androidx.compose.ui.test.onNodeWithTag
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performSemanticsAction
@@ -549,6 +550,9 @@ class DatePickerViewHolderFactoryTest {
     )
 
     composeTestRule.onNodeWithTag(DATE_TEXT_INPUT_FIELD).assertIsNotEnabled()
+    composeTestRule
+      .onNodeWithContentDescription(viewHolder.itemView.context.getString(R.string.select_date))
+      .assertIsNotEnabled()
   }
 
   @Test

datacapture/src/main/java/com/google/android/fhir/datacapture/views/compose/DatePickerItem.kt

@@ -63,7 +63,7 @@ internal fun DatePickerItem(
   isError: Boolean,
   enabled: Boolean,
   dateInputFormat: DateInputFormat,
-  selectableDates: () -> SelectableDates,
+  selectableDates: SelectableDates?,
   parseStringToLocalDate: (String, DateFormatPattern) -> LocalDate?,
   onDateInputEntry: (DateInput) -> Unit,
 ) {
@@ -136,7 +136,7 @@ internal fun DatePickerItem(
     visualTransformation = DateVisualTransformation(dateInputFormat),
   )
 
-  if (showDatePickerModal) {
+  if (selectableDates != null && showDatePickerModal) {
     DatePickerModal(
       initialSelectedDateMillis,
       selectableDates,
@@ -159,12 +159,12 @@ internal fun DatePickerItem(
 @Composable
 internal fun DatePickerModal(
   initialSelectedDateMillis: Long?,
-  selectableDates: () -> SelectableDates,
+  selectableDates: SelectableDates,
   onDateSelected: (Long?) -> Unit,
   onDismiss: () -> Unit,
 ) {
   val datePickerState =
-    rememberDatePickerState(initialSelectedDateMillis, selectableDates = selectableDates())
+    rememberDatePickerState(initialSelectedDateMillis, selectableDates = selectableDates)
   val datePickerSelectedDateMillis =
     remember(initialSelectedDateMillis) { initialSelectedDateMillis }
   val confirmEnabled by remember { derivedStateOf { datePickerState.selectedDateMillis != null } }

datacapture/src/main/java/com/google/android/fhir/datacapture/views/factories/DatePickerViewHolderFactory.kt

@@ -106,28 +106,34 @@ internal object DatePickerViewHolderFactory : QuestionnaireItemComposeViewHolder
               ?.let { DateInput(it, questionnaireItemAnswerLocalDate) }
               ?: DateInput(display = draftAnswer ?: "", null)
           }
+
+        val selectableDatesResult =
+          remember(questionnaireViewItem) { getSelectableDates(questionnaireViewItem) }
+
+        val selectableDates = remember(selectableDatesResult) { selectableDatesResult.getOrNull() }
+
+        val prohibitInput = remember(selectableDatesResult) { selectableDatesResult.isFailure }
+
         val validationMessage =
-          remember(draftAnswer) {
-            // If the draft answer is set, this means the user has yet to type a parseable answer,
-            // so we display an error.
-            if (!draftAnswer.isNullOrEmpty()) {
-              getValidationErrorMessage(
-                context,
-                questionnaireViewItem,
-                Invalid(
-                  listOf(invalidDateErrorText(context, canonicalizedDatePattern)),
-                ),
-              )
+          remember(draftAnswer, selectableDatesResult) {
+            if (selectableDatesResult.isFailure) {
+              selectableDatesResult.exceptionOrNull()?.localizedMessage
             } else {
+              // If the draft answer is set, this means the user has yet to type a parseable answer,
+              // so we display an error.
               getValidationErrorMessage(
                 context,
                 questionnaireViewItem,
-                questionnaireViewItem.validationResult,
+                if (!draftAnswer.isNullOrEmpty()) {
+                  Invalid(
+                    listOf(invalidDateErrorText(context, canonicalizedDatePattern)),
+                  )
+                } else {
+                  questionnaireViewItem.validationResult
+                },
               )
             }
           }
-        val selectableDates =
-          remember(questionnaireViewItem) { { getSelectableDates(questionnaireViewItem) } }
 
         Column(
           modifier =
@@ -149,7 +155,7 @@ internal object DatePickerViewHolderFactory : QuestionnaireItemComposeViewHolder
             helperText = validationMessage.takeIf { !it.isNullOrBlank() }
                 ?: getRequiredOrOptionalText(questionnaireViewItem, context),
             isError = !validationMessage.isNullOrBlank(),
-            enabled = !questionnaireViewItem.questionnaireItem.readOnly,
+            enabled = !(questionnaireViewItem.questionnaireItem.readOnly || prohibitInput),
             parseStringToLocalDate = { str, pattern -> getLocalDate(str, pattern) },
             onDateInputEntry = {
               val (display, date) = it
@@ -173,15 +179,15 @@ internal object DatePickerViewHolderFactory : QuestionnaireItemComposeViewHolder
 
       private fun getSelectableDates(
         questionnaireViewItem: QuestionnaireViewItem,
-      ): SelectableDates {
+      ): Result<SelectableDates> {
         val min = (questionnaireViewItem.minAnswerValue as? DateType)?.value?.time
         val max = (questionnaireViewItem.maxAnswerValue as? DateType)?.value?.time
 
-        if (min != null && max != null && min > max) {
-          throw IllegalArgumentException("minValue cannot be greater than maxValue")
+        return if (min != null && max != null && min > max) {
+          Result.failure(IllegalArgumentException("minValue cannot be greater than maxValue"))
+        } else {
+          Result.success(selectableDates(min, max))
         }
-
-        return selectableDates(min, max)
       }
 
       /** Set the answer in the [QuestionnaireResponse]. */