LMS-1277 implemented and tested

SVN: 13493

datastore_server/source/java/ch/systemsx/cisd/etlserver/validation/AbstractValidator.java

@@ -16,6 +16,8 @@
 
 package ch.systemsx.cisd.etlserver.validation;
 
+import java.util.Set;
+
 import org.apache.commons.lang.StringUtils;
 
 import ch.systemsx.cisd.common.exceptions.UserFailureException;
@@ -28,17 +30,19 @@ import ch.systemsx.cisd.common.exceptions.UserFailureException;
 abstract class AbstractValidator implements IValidator
 {
     private final boolean allowEmptyValues;
+    private final Set<String> emptyValueSynonyms;
     
-    AbstractValidator(boolean allowEmptyValues)
+    AbstractValidator(boolean allowEmptyValues, Set<String> emptyValueSynonyms)
     {
         this.allowEmptyValues = allowEmptyValues;
+        this.emptyValueSynonyms = emptyValueSynonyms;
     }
     
     public final void assertValid(String value)
     {
         if (allowEmptyValues)
         {
-            if (StringUtils.isBlank(value))
+            if (StringUtils.isBlank(value) || emptyValueSynonyms.contains(value.trim()))
             {
                 return;
             }

datastore_server/source/java/ch/systemsx/cisd/etlserver/validation/AbstractValidatorFactory.java

@@ -16,24 +16,42 @@
 
 package ch.systemsx.cisd.etlserver.validation;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.Properties;
+import java.util.Set;
 
 import ch.systemsx.cisd.common.utilities.PropertyUtils;
+import ch.systemsx.cisd.openbis.dss.generic.shared.utils.PropertyParametersUtil;
 
 /**
- * 
- *
  * @author Franz-Josef Elmer
  */
 abstract class AbstractValidatorFactory implements IValidatorFactory
 {
     static final String ALLOW_EMPTY_VALUES_KEY = "allow-empty-values";
-    
+
+    static final String EMPTY_VALUE_SYNONYMS_KEY = "empty-value-synonyms";
+
     protected final boolean allowEmptyValues;
-    
+
+    protected final Set<String> emptyValueSynonyms;
+
     AbstractValidatorFactory(Properties properties)
     {
         allowEmptyValues = PropertyUtils.getBoolean(properties, ALLOW_EMPTY_VALUES_KEY, false);
+        String property = properties.getProperty(EMPTY_VALUE_SYNONYMS_KEY);
+        if (property == null)
+        {
+            emptyValueSynonyms = Collections.emptySet();
+        } else
+        {
+            String[] synonyms =
+                    PropertyParametersUtil
+                            .parseItemisedProperty(property, EMPTY_VALUE_SYNONYMS_KEY);
+            emptyValueSynonyms = new LinkedHashSet<String>(Arrays.asList(synonyms));
+        }
     }
 
 }

datastore_server/source/java/ch/systemsx/cisd/etlserver/validation/ColumnDefinition.java

@@ -67,7 +67,7 @@ class ColumnDefinition
         if (headerValidatorName == null)
         {
             String headerPattern = properties.getProperty(HEADER_PATTERN_KEY, ".*");
-            headerValidator = new RegExBasedValidator(false, headerPattern);
+            headerValidator = new RegExBasedValidator(headerPattern);
         } else
         {
             headerValidator =

datastore_server/source/java/ch/systemsx/cisd/etlserver/validation/NumericValidatorFactory.java

@@ -17,6 +17,7 @@
 package ch.systemsx.cisd.etlserver.validation;
 
 import java.util.Properties;
+import java.util.Set;
 
 import ch.systemsx.cisd.common.exceptions.ConfigurationFailureException;
 import ch.systemsx.cisd.common.exceptions.UserFailureException;
@@ -117,9 +118,9 @@ class NumericValidatorFactory extends AbstractValidatorFactory
     {
         private final Range rangeOrNull;
         
-        NumericValidator(boolean allowEmptyValues, Range rangeOrNull)
+        NumericValidator(boolean allowEmptyValues, Set<String> emptyValueSynonyms, Range rangeOrNull)
         {
-            super(allowEmptyValues);
+            super(allowEmptyValues, emptyValueSynonyms);
             this.rangeOrNull = rangeOrNull;
         }
         
@@ -148,7 +149,7 @@ class NumericValidatorFactory extends AbstractValidatorFactory
         super(properties);
         String valueRange = properties.getProperty(VALUE_RANGE_KEY);
         Range rangeOrNull = valueRange == null ? null : new Range(valueRange);
-        validator = new NumericValidator(allowEmptyValues, rangeOrNull);
+        validator = new NumericValidator(allowEmptyValues, emptyValueSynonyms, rangeOrNull);
     }
 
     public IValidator createValidator()

datastore_server/source/java/ch/systemsx/cisd/etlserver/validation/RegExBasedValidator.java

@@ -16,6 +16,8 @@
 
 package ch.systemsx.cisd.etlserver.validation;
 
+import java.util.Collections;
+import java.util.Set;
 import java.util.regex.Pattern;
 
 import ch.systemsx.cisd.common.exceptions.UserFailureException;
@@ -28,10 +30,16 @@ import ch.systemsx.cisd.common.exceptions.UserFailureException;
 class RegExBasedValidator extends AbstractValidator implements IColumnHeaderValidator
 {
     private final Pattern pattern;
+    
+    RegExBasedValidator(String regularExpression)
+    {
+        this(false, Collections.<String>emptySet(), regularExpression);
+    }
 
-    RegExBasedValidator(boolean allowEmptyValues, String regularExpression)
+    RegExBasedValidator(boolean allowEmptyValues, Set<String> emptyValueSynonyms,
+            String regularExpression)
     {
-        super(allowEmptyValues);
+        super(allowEmptyValues, emptyValueSynonyms);
         pattern = Pattern.compile(regularExpression);
     }
 

datastore_server/source/java/ch/systemsx/cisd/etlserver/validation/StringValidatorFactory.java

@@ -35,7 +35,7 @@ class StringValidatorFactory extends AbstractValidatorFactory
     {
         super(properties);
         String regex = PropertyUtils.getMandatoryProperty(properties, VALUE_PATTERN_KEY);
-        validator = new RegExBasedValidator(allowEmptyValues, regex);
+        validator = new RegExBasedValidator(allowEmptyValues, emptyValueSynonyms, regex);
     }
     
     public IValidator createValidator()

datastore_server/source/java/ch/systemsx/cisd/etlserver/validation/UniqueValidatorFactory.java

@@ -39,7 +39,7 @@ class UniqueValidatorFactory implements IValidatorFactory
             validator = AnyValidatorFactory.INSTANCE.createValidator();
         } else
         {
-            validator = new RegExBasedValidator(false, regex);
+            validator = new RegExBasedValidator(regex);
         }
     }
 

datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/validation/NumericValidatorFactoryTest.java

@@ -161,6 +161,26 @@ public class NumericValidatorFactoryTest extends AssertJUnit
         assertFailingToSmall("<= 0.0", validator, "0.0");
     }
     
+    @Test
+    public void testAllowEmptyValueSynonyms()
+    {
+        Properties properties = new Properties();
+        properties.setProperty(NumericValidatorFactory.ALLOW_EMPTY_VALUES_KEY, "true");
+        properties.setProperty(NumericValidatorFactory.EMPTY_VALUE_SYNONYMS_KEY, "-, N/A");
+        properties.setProperty(NumericValidatorFactory.VALUE_RANGE_KEY, "(0,1]");
+        NumericValidatorFactory validatorFactory = new NumericValidatorFactory(properties);
+        IValidator validator = validatorFactory.createValidator();
+        
+        validator.assertValid(null);
+        validator.assertValid("");
+        validator.assertValid("  ");
+        validator.assertValid("-");
+        validator.assertValid("N/A");
+        assertNotANumber(validator, "n/a");
+        assertFailingToLarge("> 1.0", validator, "1.25");
+        assertFailingToSmall("<= 0.0", validator, "0.0");
+    }
+    
     @Test
     public void testNoRange()
     {

datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/validation/StringValidatorFactoryTest.java

@@ -98,4 +98,31 @@ public class StringValidatorFactoryTest extends AssertJUnit
             assertEquals("'bc' doesn't match the following regular expression: a.*", ex.getMessage());
         }
     }
+    
+    @Test
+    public void testEmptyValueSynonyms()
+    {
+        Properties properties = new Properties();
+        properties.setProperty(StringValidatorFactory.VALUE_PATTERN_KEY, "a.*");
+        properties.setProperty(StringValidatorFactory.ALLOW_EMPTY_VALUES_KEY, "yes");
+        properties.setProperty(StringValidatorFactory.EMPTY_VALUE_SYNONYMS_KEY, "-");
+        StringValidatorFactory factory = new StringValidatorFactory(properties);
+        IValidator validator = factory.createValidator();
+        
+        validator.assertValid("a");
+        validator.assertValid("a1");
+        validator.assertValid("abc");
+        validator.assertValid(null);
+        validator.assertValid("");
+        validator.assertValid("  ");
+        validator.assertValid("-");
+        try
+        {
+            validator.assertValid("N/A");
+            fail("UserFailureException expected");
+        } catch (UserFailureException ex)
+        {
+            assertEquals("'N/A' doesn't match the following regular expression: a.*", ex.getMessage());
+        }
+    }
 }