add uts

sanzmauro · sanzmauro · commit ba6f6040f205 · 2020-12-16T19:12:38.000-03:00
diff --git a/client/src/main/java/io/split/client/SplitClientImpl.java b/client/src/main/java/io/split/client/SplitClientImpl.java
@@ -9,10 +9,7 @@
 import io.split.engine.evaluator.Evaluator;
 import io.split.engine.SDKReadinessGates;
 import io.split.engine.evaluator.EvaluatorImp;
-import io.split.engine.inputValidation.EventsValidator;
-import io.split.engine.inputValidation.KeyValidator;
-import io.split.engine.inputValidation.SplitNameValidator;
-import io.split.engine.inputValidation.TrafficTypeValidator;
+import io.split.inputValidation.*;
 import io.split.engine.metrics.Metrics;
 import io.split.grammar.Treatments;
 import org.slf4j.Logger;
@@ -148,7 +145,7 @@ private boolean track(Event event) {
         }
 
         // Traffic Type validations
-        TrafficTypeValidator.TrafficTypeResult trafficTypeResult = TrafficTypeValidator.isValid(event.trafficTypeName, _splitCache, "track");
+        InputValidationResult trafficTypeResult = TrafficTypeValidator.isValid(event.trafficTypeName, _splitCache, "track");
         if (!trafficTypeResult.getSuccess()) {
             return false;
         }
@@ -190,7 +187,7 @@ private SplitResult getTreatmentWithConfigInternal(String label, String matching
                 return SPLIT_RESULT_CONTROL;
             }
 
-            SplitNameValidator.SplitNameResult splitNameResult = SplitNameValidator.isValid(split, method);
+            InputValidationResult splitNameResult = SplitNameValidator.isValid(split, method);
             if (!splitNameResult.getSuccess()) {
                 return SPLIT_RESULT_CONTROL;
             }
diff --git a/client/src/main/java/io/split/client/SplitFactoryBuilder.java b/client/src/main/java/io/split/client/SplitFactoryBuilder.java
@@ -1,6 +1,6 @@
 package io.split.client;
 
-import io.split.engine.inputValidation.ApiKeyValidator;
+import io.split.inputValidation.ApiKeyValidator;
 import io.split.grammar.Treatments;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
diff --git a/client/src/main/java/io/split/engine/inputValidation/SplitNameValidator.java b/client/src/main/java/io/split/engine/inputValidation/SplitNameValidator.java
diff --git a/client/src/main/java/io/split/inputValidation/ApiKeyValidator.java b/client/src/main/java/io/split/inputValidation/ApiKeyValidator.java
@@ -1,4 +1,4 @@
-package io.split.engine.inputValidation;
+package io.split.inputValidation;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
diff --git a/client/src/main/java/io/split/inputValidation/EventsValidator.java b/client/src/main/java/io/split/inputValidation/EventsValidator.java
@@ -1,4 +1,4 @@
-package io.split.engine.inputValidation;
+package io.split.inputValidation;
 
 import io.split.client.dtos.Event;
 import org.slf4j.Logger;
@@ -25,6 +25,10 @@ public static EventValidatorResult propertiesAreValid(Map<String, Object> proper
 
         Map<String, Object> result = new HashMap<>();
         for (Map.Entry<String, Object> entry : properties.entrySet()) {
+            if (entry.getKey() == null || entry.getKey().isEmpty()) {
+              continue;
+            }
+
             size += entry.getKey().length();
             Object value = entry.getValue();
 
diff --git a/client/src/main/java/io/split/inputValidation/InputValidationResult.java b/client/src/main/java/io/split/inputValidation/InputValidationResult.java
@@ -0,0 +1,24 @@
+package io.split.inputValidation;
+
+public class InputValidationResult {
+    private final boolean _success;
+    private final String _value;
+
+    public InputValidationResult(boolean success, String value) {
+        _success = success;
+        _value = value;
+    }
+
+    public InputValidationResult(boolean success) {
+        _success = success;
+        _value = null;
+    }
+
+    public boolean getSuccess() {
+        return _success;
+    }
+
+    public String getValue() {
+        return _value;
+    }
+}
diff --git a/client/src/main/java/io/split/inputValidation/KeyValidator.java b/client/src/main/java/io/split/inputValidation/KeyValidator.java
@@ -1,4 +1,4 @@
-package io.split.engine.inputValidation;
+package io.split.inputValidation;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
diff --git a/client/src/main/java/io/split/inputValidation/SplitNameValidator.java b/client/src/main/java/io/split/inputValidation/SplitNameValidator.java
@@ -0,0 +1,28 @@
+package io.split.inputValidation;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SplitNameValidator {
+    private static final Logger _log = LoggerFactory.getLogger(SplitNameValidator.class);
+
+    public static InputValidationResult isValid(String name, String method) {
+        if (name == null) {
+            _log.error(String.format("%s: you passed a null split name, split name must be a non-empty string", method));
+            return new InputValidationResult(false);
+        }
+
+        if (name.isEmpty()) {
+            _log.error(String.format("%s: you passed an empty split name, split name must be a non-empty string", method));
+            return new InputValidationResult(false);
+        }
+
+        String trimmed = name.trim();
+        if (!trimmed.equals(name)) {
+            _log.warn(String.format("%s: split name %s has extra whitespace, trimming", method, name));
+            name = trimmed;
+        }
+
+        return new InputValidationResult(true, name);
+    }
+}
diff --git a/client/src/main/java/io/split/inputValidation/TrafficTypeValidator.java b/client/src/main/java/io/split/inputValidation/TrafficTypeValidator.java
@@ -1,4 +1,4 @@
-package io.split.engine.inputValidation;
+package io.split.inputValidation;
 
 import io.split.engine.cache.SplitCache;
 import org.slf4j.Logger;
@@ -7,15 +7,15 @@
 public class TrafficTypeValidator {
     private static final Logger _log = LoggerFactory.getLogger(TrafficTypeValidator.class);
 
-    public static TrafficTypeResult isValid(String trafficTypeName, SplitCache splitCache, String method) {
+    public static InputValidationResult isValid(String trafficTypeName, SplitCache splitCache, String method) {
         if (trafficTypeName == null) {
             _log.error(String.format("%s: you passed a null trafficTypeName, trafficTypeName must be a non-empty string", method));
-            return new TrafficTypeResult(false);
+            return new InputValidationResult(false);
         }
 
         if (trafficTypeName.isEmpty()) {
             _log.error(String.format("%s: you passed an empty trafficTypeName, trafficTypeName must be a non-empty string", method));
-            return new TrafficTypeResult(false);
+            return new InputValidationResult(false);
         }
 
         if (!trafficTypeName.equals(trafficTypeName.toLowerCase())) {
@@ -28,29 +28,6 @@ public static TrafficTypeResult isValid(String trafficTypeName, SplitCache split
                     "make sure you’re tracking your events to a valid traffic type defined in the Split console.", method, trafficTypeName));
         }
 
-        return new TrafficTypeResult(true, trafficTypeName);
-    }
-
-    public static class TrafficTypeResult {
-        private final boolean _success;
-        private final String _value;
-
-        public TrafficTypeResult(boolean success, String value) {
-            _success = success;
-            _value = value;
-        }
-
-        public TrafficTypeResult(boolean success) {
-            _success = success;
-            _value = null;
-        }
-
-        public boolean getSuccess() {
-            return _success;
-        }
-
-        public String getValue() {
-            return _value;
-        }
+        return new InputValidationResult(true, trafficTypeName);
     }
 }
diff --git a/client/src/test/java/io/split/inputValidation/EventsValidatorTest.java b/client/src/test/java/io/split/inputValidation/EventsValidatorTest.java
@@ -0,0 +1,53 @@
+package io.split.inputValidation;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class EventsValidatorTest {
+    @Test
+    public void propertiesAreValidWorks() {
+        Map<String, Object> properties = new HashMap<>();
+        properties.put("prop1", 1);
+        properties.put("prop2", 2L);
+        properties.put("prop3", 7.56);
+        properties.put("prop4", "something");
+        properties.put("prop5", true);
+        properties.put("prop6", null);
+        properties.put(null, "value");
+        properties.put("", "value");
+
+        EventsValidator.EventValidatorResult result = EventsValidator.propertiesAreValid(properties);
+        Assert.assertTrue(result.getSuccess());
+        Assert.assertEquals(1063, result.getEventSize());
+        Assert.assertEquals(6, result.getValue().size());
+
+        // when properties size is > Event.MAX_PROPERTIES_LENGTH_BYTES
+        properties = new HashMap<>();
+        for (int i = 0; i <= (32 * 1024); i++) {
+            properties.put("prop" + i, "something-" + i);
+        }
+        result = EventsValidator.propertiesAreValid(properties);
+        Assert.assertFalse(result.getSuccess());
+    }
+
+    @Test
+    public void typeIsValidWorks() {
+        boolean result = EventsValidator.typeIsValid("event_type_id", "test");
+        Assert.assertTrue(result);
+
+        // when eventTypeId is null
+        result = EventsValidator.typeIsValid(null, "test");
+        Assert.assertFalse(result);
+
+        // when eventTypeId is empty
+        result = EventsValidator.typeIsValid("", "test");
+        Assert.assertFalse(result);
+
+        // when eventTypeId is does not match
+        result = EventsValidator.typeIsValid("aksdjas!@#$@%#^$&%", "test");
+        Assert.assertFalse(result);
+    }
+}
diff --git a/client/src/test/java/io/split/inputValidation/KeyValidatorTest.java b/client/src/test/java/io/split/inputValidation/KeyValidatorTest.java
@@ -0,0 +1,42 @@
+package io.split.inputValidation;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class KeyValidatorTest {
+    @Test
+    public void isValidWorks() {
+        boolean result = KeyValidator.isValid("key",  "propertyName", 5, "test");
+        Assert.assertTrue(result);
+
+        // when key is null
+        result = KeyValidator.isValid(null,  "propertyName", 5, "test");
+        Assert.assertFalse(result);
+
+        // when key is empty
+        result = KeyValidator.isValid("",  "propertyName", 5, "test");
+        Assert.assertFalse(result);
+
+        // when key is > maxStringLength
+        result = KeyValidator.isValid("key",  "propertyName", 0, "test");
+        Assert.assertFalse(result);
+    }
+
+    @Test
+    public void bucketingKeyIsValidWorks() {
+        boolean result = KeyValidator.bucketingKeyIsValid("bucketingKey", 20, "test");
+        Assert.assertTrue(result);
+
+        // when bucketingKey is null
+        result = KeyValidator.bucketingKeyIsValid(null, 20, "test");
+        Assert.assertTrue(result);
+
+        // when bucketingKey is empty
+        result = KeyValidator.bucketingKeyIsValid("", 20, "test");
+        Assert.assertFalse(result);
+
+        // when bucketingKey is > maxStringLength
+        result = KeyValidator.bucketingKeyIsValid("", 5, "test");
+        Assert.assertFalse(result);
+    }
+}
diff --git a/client/src/test/java/io/split/inputValidation/SplitNameValidatorTest.java b/client/src/test/java/io/split/inputValidation/SplitNameValidatorTest.java
@@ -0,0 +1,30 @@
+package io.split.inputValidation;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SplitNameValidatorTest {
+
+    @Test
+    public void isValidWorks() {
+        InputValidationResult result = SplitNameValidator.isValid("split_name_test", "test");
+
+        Assert.assertTrue(result.getSuccess());
+        Assert.assertEquals("split_name_test", result.getValue());
+
+        // when split name is null
+        result = SplitNameValidator.isValid(null, "test");
+        Assert.assertFalse(result.getSuccess());
+        Assert.assertNull(result.getValue());
+
+        // when split name is empty
+        result = SplitNameValidator.isValid("", "test");
+        Assert.assertFalse(result.getSuccess());
+        Assert.assertNull(result.getValue());
+
+        // when split name have empty spaces
+        result = SplitNameValidator.isValid(" split name test ", "test");
+        Assert.assertTrue(result.getSuccess());
+        Assert.assertEquals("split name test", result.getValue());
+    }
+}
diff --git a/client/src/test/java/io/split/inputValidation/TrafficTypeValidatorTest.java b/client/src/test/java/io/split/inputValidation/TrafficTypeValidatorTest.java
@@ -0,0 +1,36 @@
+package io.split.inputValidation;
+
+import io.split.engine.cache.SplitCache;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+public class TrafficTypeValidatorTest {
+
+    @Test
+    public void isValidWorks() {
+        SplitCache splitCache = Mockito.mock(SplitCache.class);
+
+        InputValidationResult result = TrafficTypeValidator.isValid("traffic_type_test", splitCache, "test");
+        Assert.assertTrue(result.getSuccess());
+        Assert.assertEquals("traffic_type_test", result.getValue());
+
+        // when tt have upper case
+        result = TrafficTypeValidator.isValid("trafficTypeTest", splitCache, "test");
+
+        Assert.assertTrue(result.getSuccess());
+        Assert.assertEquals("traffictypetest", result.getValue());
+
+        // when tt is null
+        result = TrafficTypeValidator.isValid(null, splitCache, "test");
+
+        Assert.assertFalse(result.getSuccess());
+        Assert.assertNull(result.getValue());
+
+        // when tt is empty
+        result = TrafficTypeValidator.isValid("", splitCache, "test");
+
+        Assert.assertFalse(result.getSuccess());
+        Assert.assertNull(result.getValue());
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package io.split.engine.inputValidation;`
	`1`	`+package io.split.inputValidation;`
`2`	`2`
`3`	`3`	`import org.slf4j.Logger;`
`4`	`4`	`import org.slf4j.LoggerFactory;`