RDM-3325: White space validation rules applied on text fields (#284)

* RDM-3325: CCD does not apply validation rules to text fields containing only whitespace characters

* RDM-3325: Added TextSanitiser

* RDM-3325: Added unit test cases

* RDM-3325: IsNull condition refined

* RDM-3325: Typo space correction

* RDM-3325: Fixed the code quality issues

* RDM-3325: Removed unused imports

* RDM-3325: Improved the code quality

Author: MKaramath

src/main/java/uk/gov/hmcts/ccd/domain/model/definition/FieldType.java

@@ -18,6 +18,7 @@ public class FieldType implements Serializable {
     public static final String LABEL = "Label";
     public static final String CASE_PAYMENT_HISTORY_VIEWER = "CasePaymentHistoryViewer";
     public static final String CASE_HISTORY_VIEWER = "CaseHistoryViewer";
+    public static final String TEXT = "Text";
 
     private String id = null;
     private String type = null;

src/main/java/uk/gov/hmcts/ccd/domain/types/BaseTypeValidator.java

@@ -19,7 +19,13 @@ List<ValidationResult> validate(final String dataFieldId,
     default Boolean isNullOrEmpty(final JsonNode dataValue) {
         return dataValue == null
             || dataValue.isNull()
-            || (dataValue.isTextual() && (null == dataValue.asText() || dataValue.asText().trim().length() == 0))
+            || (dataValue.isTextual() && (null == dataValue.asText() || dataValue.asText().length() == 0))
             || (dataValue.isObject() && dataValue.toString().equals("{}"));
     }
+
+    default Boolean isNull(final JsonNode dataValue) {
+        return dataValue == null
+            || dataValue.isNull()
+            || (dataValue.isTextual() && (null == dataValue.asText()));
+    }
 }

src/main/java/uk/gov/hmcts/ccd/domain/types/TextValidator.java

@@ -25,7 +25,7 @@ public List<ValidationResult> validate(final String dataFieldId,
                                            final CaseField caseFieldDefinition) {
 
         // Empty text should still check against MIN - MIN may or may not be 0
-        if (isNullOrEmpty(dataValue)) {
+        if (isNull(dataValue)) {
             return Collections.emptyList();
         }
 
@@ -34,7 +34,7 @@ public List<ValidationResult> validate(final String dataFieldId,
             return Collections.singletonList(new ValidationResult(nodeType + " is not a string", dataFieldId));
         }
 
-        final String value = dataValue.textValue();
+        final String value = dataValue.textValue().trim();
 
         if (!checkMax(caseFieldDefinition.getFieldType().getMax(), value)) {
             return Collections.singletonList(new ValidationResult(value + " exceed maximum length " + caseFieldDefinition.getFieldType().getMax(), dataFieldId));

src/main/java/uk/gov/hmcts/ccd/domain/types/sanitiser/TextSanitiser.java

@@ -0,0 +1,28 @@
+package uk.gov.hmcts.ccd.domain.types.sanitiser;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import uk.gov.hmcts.ccd.domain.model.definition.FieldType;
+import static uk.gov.hmcts.ccd.domain.model.definition.FieldType.TEXT;
+
+import javax.inject.Named;
+import javax.inject.Singleton;
+
+@Named
+@Singleton
+public class TextSanitiser implements Sanitiser {
+
+    private static final JsonNodeFactory JSON_NODE_FACTORY = new JsonNodeFactory(false);
+
+    @Override
+    public String getType() {
+        return TEXT;
+    }
+
+    public JsonNode sanitise(FieldType fieldType, JsonNode fieldData) {
+        if (fieldData.isTextual()) {
+            return JSON_NODE_FACTORY.textNode(fieldData.asText().trim());
+        }
+        return fieldData;
+    }
+}

src/test/java/uk/gov/hmcts/ccd/domain/types/TextValidatorTest.java

@@ -151,6 +151,18 @@ void nullTextValue() {
         assertThat(validationResult, hasSize(0));
     }
 
+    @Test
+    @DisplayName("should NOT be valid with only white spaces or leading trailing white spaces")
+    void checkWhitespaces() {
+        final JsonNode whitespaceValue = NODE_FACTORY.textNode("   ");
+        final List<ValidationResult> whitespaceValueResult = validator.validate(FIELD_ID, whitespaceValue, caseField);
+        assertThat(whitespaceValueResult, hasSize(1));
+
+        final JsonNode trailingwhitespaces = NODE_FACTORY.textNode("   Testing   ");
+        final List<ValidationResult> trailingwhitespacesResult = validator.validate(FIELD_ID, trailingwhitespaces, caseField);
+        assertThat(trailingwhitespacesResult, hasSize(0));
+    }
+
     private CaseFieldBuilder caseField() {
         return new CaseFieldBuilder(FIELD_ID).withType(TextValidator.TYPE_ID);
     }

src/test/java/uk/gov/hmcts/ccd/domain/types/sanitiser/TextSanitiserTest.java

@@ -0,0 +1,62 @@
+package uk.gov.hmcts.ccd.domain.types.sanitiser;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+import uk.gov.hmcts.ccd.domain.model.definition.CaseField;
+import uk.gov.hmcts.ccd.domain.model.definition.CaseType;
+import uk.gov.hmcts.ccd.domain.model.definition.FieldType;
+
+import java.util.Collections;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+class TextSanitiserTest {
+
+    private static final JsonNodeFactory JSON_NODE_FACTORY = new JsonNodeFactory(false);
+    private static final CaseType CASE_TYPE = new CaseType();
+    private static final String TYPE_TEXT = "Text";
+    private static final FieldType TEXT_FIELD_TYPE = new FieldType();
+    private static final String TEXT_FIELD_ID = "TestText";
+    private static final CaseField TEXT_FIELD = new CaseField();
+
+    static {
+        TEXT_FIELD_TYPE.setId(TYPE_TEXT);
+        TEXT_FIELD_TYPE.setType(TYPE_TEXT);
+        TEXT_FIELD.setId(TEXT_FIELD_ID);
+        TEXT_FIELD.setFieldType(TEXT_FIELD_TYPE);
+
+        CASE_TYPE.setCaseFields(Collections.singletonList(TEXT_FIELD));
+    }
+
+    @InjectMocks
+    private TextSanitiser textSanitiser;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        textSanitiser = new TextSanitiser();
+    }
+
+    @Test
+    public void shouldSanitizeValidText() {
+        JsonNode data = JSON_NODE_FACTORY.textNode("  Mr Tester  ");
+        JsonNode result = JSON_NODE_FACTORY.textNode("Mr Tester");
+        JsonNode sanitisedText = textSanitiser.sanitise(TEXT_FIELD_TYPE, data);
+
+        assertThat(sanitisedText, is(result));
+    }
+
+    @Test
+    public void shouldSanitizeOnlyWhitespace() {
+        JsonNode data = JSON_NODE_FACTORY.textNode("       ");
+        JsonNode result = JSON_NODE_FACTORY.textNode("");
+        JsonNode sanitisedText = textSanitiser.sanitise(TEXT_FIELD_TYPE, data);
+
+        assertThat(sanitisedText, is(result));
+    }
+}