pr feedback

Author: sanzmauro

client/src/main/java/io/split/client/SplitClientImpl.java

@@ -14,7 +14,6 @@
 import io.split.engine.metrics.Metrics;
 import io.split.grammar.Treatments;
 import io.split.inputValidation.EventsValidator;
-import io.split.inputValidation.InputValidationResult;
 import io.split.inputValidation.KeyValidator;
 import io.split.inputValidation.SplitNameValidator;
 import io.split.inputValidation.TrafficTypeValidator;
@@ -24,6 +23,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.TimeoutException;
 
 import static com.google.common.base.Preconditions.checkNotNull;
@@ -151,11 +151,11 @@ private boolean track(Event event) {
         }
 
         // Traffic Type validations
-        InputValidationResult trafficTypeResult = TrafficTypeValidator.isValid(event.trafficTypeName, _splitCache, "track");
-        if (!trafficTypeResult.getSuccess()) {
+        Optional<String> trafficTypeResult = TrafficTypeValidator.isValid(event.trafficTypeName, _splitCache, "track");
+        if (!trafficTypeResult.isPresent()) {
             return false;
         }
-        event.trafficTypeName = trafficTypeResult.getValue();
+        event.trafficTypeName = trafficTypeResult.get();
 
         // EventType validations
         if (!EventsValidator.typeIsValid(event.eventTypeId, "track")) {
@@ -193,11 +193,11 @@ private SplitResult getTreatmentWithConfigInternal(String label, String matching
                 return SPLIT_RESULT_CONTROL;
             }
 
-            InputValidationResult splitNameResult = SplitNameValidator.isValid(split, method);
-            if (!splitNameResult.getSuccess()) {
+            Optional<String> splitNameResult = SplitNameValidator.isValid(split, method);
+            if (!splitNameResult.isPresent()) {
                 return SPLIT_RESULT_CONTROL;
             }
-            split = splitNameResult.getValue();
+            split = splitNameResult.get();
 
             long start = System.currentTimeMillis();
 

client/src/main/java/io/split/inputValidation/InputValidationResult.java

@@ -3,18 +3,22 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Optional;
+
 public class SplitNameValidator {
     private static final Logger _log = LoggerFactory.getLogger(SplitNameValidator.class);
 
-    public static InputValidationResult isValid(String name, String method) {
+    public static Optional<String> 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);
+            //return new InputValidationResult(false);
+            return Optional.empty();
         }
 
         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);
+            //return new InputValidationResult(false);
+            return Optional.empty();
         }
 
         String trimmed = name.trim();
@@ -23,6 +27,7 @@ public static InputValidationResult isValid(String name, String method) {
             name = trimmed;
         }
 
-        return new InputValidationResult(true, name);
+        //return new InputValidationResult(true, name);
+        return Optional.of(name);
     }
 }

client/src/main/java/io/split/inputValidation/SplitNameValidator.java

@@ -4,18 +4,20 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Optional;
+
 public class TrafficTypeValidator {
     private static final Logger _log = LoggerFactory.getLogger(TrafficTypeValidator.class);
 
-    public static InputValidationResult isValid(String trafficTypeName, SplitCache splitCache, String method) {
+    public static Optional<String> 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 InputValidationResult(false);
+            return Optional.empty();
         }
 
         if (trafficTypeName.isEmpty()) {
             _log.error(String.format("%s: you passed an empty trafficTypeName, trafficTypeName must be a non-empty string", method));
-            return new InputValidationResult(false);
+            return Optional.empty();
         }
 
         if (!trafficTypeName.equals(trafficTypeName.toLowerCase())) {
@@ -28,6 +30,6 @@ public static InputValidationResult isValid(String trafficTypeName, SplitCache s
                     "make sure you’re tracking your events to a valid traffic type defined in the Split console.", method, trafficTypeName));
         }
 
-        return new InputValidationResult(true, trafficTypeName);
+        return Optional.of(trafficTypeName);
     }
 }

client/src/main/java/io/split/inputValidation/TrafficTypeValidator.java

@@ -3,28 +3,28 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Optional;
+
 public class SplitNameValidatorTest {
 
     @Test
     public void isValidWorks() {
-        InputValidationResult result = SplitNameValidator.isValid("split_name_test", "test");
+        Optional<String> result = SplitNameValidator.isValid("split_name_test", "test");
 
-        Assert.assertTrue(result.getSuccess());
-        Assert.assertEquals("split_name_test", result.getValue());
+        Assert.assertTrue(result.isPresent());
+        Assert.assertEquals("split_name_test", result.get());
 
         // when split name is null
         result = SplitNameValidator.isValid(null, "test");
-        Assert.assertFalse(result.getSuccess());
-        Assert.assertNull(result.getValue());
+        Assert.assertFalse(result.isPresent());
 
         // when split name is empty
         result = SplitNameValidator.isValid("", "test");
-        Assert.assertFalse(result.getSuccess());
-        Assert.assertNull(result.getValue());
+        Assert.assertFalse(result.isPresent());
 
         // when split name have empty spaces
         result = SplitNameValidator.isValid(" split name test ", "test");
-        Assert.assertTrue(result.getSuccess());
-        Assert.assertEquals("split name test", result.getValue());
+        Assert.assertTrue(result.isPresent());
+        Assert.assertEquals("split name test", result.get());
     }
 }

client/src/test/java/io/split/inputValidation/SplitNameValidatorTest.java

@@ -5,32 +5,32 @@
 import org.junit.Test;
 import org.mockito.Mockito;
 
+import java.util.Optional;
+
 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());
+        Optional<String> result = TrafficTypeValidator.isValid("traffic_type_test", splitCache, "test");
+        Assert.assertTrue(result.isPresent());
+        Assert.assertEquals("traffic_type_test", result.get());
 
         // when tt have upper case
         result = TrafficTypeValidator.isValid("trafficTypeTest", splitCache, "test");
 
-        Assert.assertTrue(result.getSuccess());
-        Assert.assertEquals("traffictypetest", result.getValue());
+        Assert.assertTrue(result.isPresent());
+        Assert.assertEquals("traffictypetest", result.get());
 
         // when tt is null
         result = TrafficTypeValidator.isValid(null, splitCache, "test");
 
-        Assert.assertFalse(result.getSuccess());
-        Assert.assertNull(result.getValue());
+        Assert.assertFalse(result.isPresent());
 
         // when tt is empty
         result = TrafficTypeValidator.isValid("", splitCache, "test");
 
-        Assert.assertFalse(result.getSuccess());
-        Assert.assertNull(result.getValue());
+        Assert.assertFalse(result.isPresent());
     }
 }