add support for semver rule evaluation (FF-1569) (#39)

* add support for semver rule evaluation (FF-1569)

* azul builds

* adjust unit tests for semver comparison

* numeric first

Author: leoromanovsky

Makefile

@@ -28,9 +28,6 @@ help: Makefile
 build: test-data
 	mvn --batch-mode --update-snapshots package
 
-docker-compile-java:
-	@docker run --rm -v "$$(pwd)":/usr/src/myapp -w /usr/src/myapp amd64/maven:3.8.2-ibmjava-8-alpine mvn clean compile
-	
 ## test-data
 testDataDir := src/test/resources/
 tempDir := ${testDataDir}temp/

README.md

@@ -3,3 +3,11 @@
 ## Getting Started
 
 Refer to our [SDK documentation](https://docs.geteppo.com/feature-flags/sdks/server-sdks/java) for how to install and use the SDK.
+
+## Contributing
+
+A version of Java 8 is required to locally compile the SDK.
+
+### Apple M-Series
+
+Download a `arm64` compatible build: https://www.azul.com/downloads/?version=java-8-lts&architecture=arm-64-bit&package=jdk#zulu

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>cloud.eppo</groupId>
     <artifactId>eppo-server-sdk</artifactId>
-    <version>2.2.0</version>
+    <version>2.3.0</version>
 
     <name>${project.groupId}:${project.artifactId}</name>
     <description>Eppo Server-Side SDK for Java</description>
@@ -82,6 +82,11 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>com.github.zafarkhaja</groupId>
+            <artifactId>java-semver</artifactId>
+            <version>0.10.2</version>
+        </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>

src/main/java/com/eppo/sdk/helpers/RuleValidator.java

@@ -3,6 +3,7 @@
 import com.eppo.sdk.dto.EppoValue;
 import com.eppo.sdk.dto.SubjectAttributes;
 import com.eppo.sdk.exception.InvalidSubjectAttribute;
+import com.github.zafarkhaja.semver.Version;
 import com.eppo.sdk.dto.Condition;
 import com.eppo.sdk.dto.Rule;
 
@@ -24,18 +25,6 @@ interface IConditionFunc<T> {
  * Compare Class
  */
 class Compare {
-    /**
-     * This function is used to compare number
-     *
-     * @param a
-     * @param b
-     * @param conditionFunc
-     * @return
-     */
-    public static boolean compareNumber(double a, double b, IConditionFunc<Double> conditionFunc) {
-        return conditionFunc.check(a, b);
-    }
-
     /**
      * This function is used to compare Regex
      *
@@ -75,8 +64,7 @@ public class RuleValidator {
      */
     public static Optional<Rule> findMatchingRule(
             SubjectAttributes subjectAttributes,
-            List<Rule> rules
-    ) {
+            List<Rule> rules) {
         for (Rule rule : rules) {
             if (RuleValidator.matchesRule(subjectAttributes, rule)) {
                 return Optional.of(rule);
@@ -95,9 +83,9 @@ public static Optional<Rule> findMatchingRule(
      */
     private static boolean matchesRule(
             SubjectAttributes subjectAttributes,
-            Rule rule
-    ) throws InvalidSubjectAttribute {
-        List<Boolean> conditionEvaluations = RuleValidator.evaluateRuleConditions(subjectAttributes, rule.getConditions());
+            Rule rule) throws InvalidSubjectAttribute {
+        List<Boolean> conditionEvaluations = RuleValidator.evaluateRuleConditions(subjectAttributes,
+                rule.getConditions());
         return !conditionEvaluations.contains(false);
     }
 
@@ -111,23 +99,57 @@ private static boolean matchesRule(
      */
     private static boolean evaluateCondition(
             SubjectAttributes subjectAttributes,
-            Condition condition
-    ) throws InvalidSubjectAttribute {
+            Condition condition) throws InvalidSubjectAttribute {
         if (subjectAttributes.containsKey(condition.attribute)) {
             EppoValue value = subjectAttributes.get(condition.attribute);
+            Optional<Version> valueSemVer = Version.tryParse(value.stringValue());
+            Optional<Version> conditionSemVer = Version.tryParse(condition.value.stringValue());
+
             try {
                 switch (condition.operator) {
                     case GTE:
-                        return Compare.compareNumber(value.doubleValue(), condition.value.doubleValue()
-                                , (a, b) -> a >= b);
+                        if (value.isNumeric() && condition.value.isNumeric()) {
+                            return value.doubleValue() >= condition.value.doubleValue();
+                        }
+
+                        if (valueSemVer.isPresent() && conditionSemVer.isPresent()) {
+                            return valueSemVer.get().isHigherThanOrEquivalentTo(conditionSemVer.get());
+                        }
+
+                        return false;
                     case GT:
-                        return Compare.compareNumber(value.doubleValue(), condition.value.doubleValue(), (a, b) -> a > b);
+                        if (value.isNumeric() && condition.value.isNumeric()) {
+                            return value.doubleValue() > condition.value.doubleValue();
+                        }
+
+                        if (valueSemVer.isPresent() && conditionSemVer.isPresent()) {
+                            return valueSemVer.get().isHigherThan(conditionSemVer.get());
+                        }
+
+                        return false;
                     case LTE:
-                        return Compare.compareNumber(value.doubleValue(), condition.value.doubleValue(), (a, b) -> a <= b);
+                        if (value.isNumeric() && condition.value.isNumeric()) {
+                            return value.doubleValue() <= condition.value.doubleValue();
+                        }
+
+                        if (valueSemVer.isPresent() && conditionSemVer.isPresent()) {
+                            return valueSemVer.get().isLowerThanOrEquivalentTo(conditionSemVer.get());
+                        }
+
+                        return false;
                     case LT:
-                        return Compare.compareNumber(value.doubleValue(), condition.value.doubleValue(), (a, b) -> a < b);
+                        if (value.isNumeric() && condition.value.isNumeric()) {
+                            return value.doubleValue() < condition.value.doubleValue();
+                        }
+
+                        if (valueSemVer.isPresent() && conditionSemVer.isPresent()) {
+                            return valueSemVer.get().isLowerThan(conditionSemVer.get());
+                        }
+
+                        return false;
                     case MATCHES:
-                        return Compare.compareRegex(value.stringValue(), Pattern.compile(condition.value.stringValue()));
+                        return Compare.compareRegex(value.stringValue(),
+                                Pattern.compile(condition.value.stringValue()));
                     case ONE_OF:
                         return Compare.isOneOf(value.stringValue(), condition.value.arrayValue());
                     case NOT_ONE_OF:
@@ -151,8 +173,7 @@ private static boolean evaluateCondition(
      */
     private static List<Boolean> evaluateRuleConditions(
             SubjectAttributes subjectAttributes,
-            List<Condition> conditions
-    ) throws InvalidSubjectAttribute {
+            List<Condition> conditions) throws InvalidSubjectAttribute {
         return conditions.stream()
                 .map((condition) -> {
                     try {

src/test/java/com/eppo/sdk/helpers/RuleValidatorTest.java

@@ -35,6 +35,21 @@ public void addNumericConditionToRule(Rule rule) {
         addConditionToRule(rule, condition2);
     }
 
+    public void addSemVerConditionToRule(Rule rule) {
+        Condition condition1 = new Condition();
+        condition1.value = EppoValue.valueOf("1.5.0");
+        condition1.attribute = "version";
+        condition1.operator = OperatorType.GTE;
+
+        Condition condition2 = new Condition();
+        condition2.value = EppoValue.valueOf("2.2.0");
+        condition2.attribute = "version";
+        condition2.operator = OperatorType.LT;
+
+        addConditionToRule(rule, condition1);
+        addConditionToRule(rule, condition2);
+    }
+
     public void addRegexConditionToRule(Rule rule) {
         Condition condition = new Condition();
         condition.value = EppoValue.valueOf("[a-z]+");
@@ -85,7 +100,8 @@ void testMatchesAnyRuleWithEmptyConditions() {
         SubjectAttributes subjectAttributes = new SubjectAttributes();
         addNameToSubjectAttribute(subjectAttributes);
 
-        Assertions.assertEquals(ruleWithEmptyConditions, RuleValidator.findMatchingRule(subjectAttributes, rules).get());
+        Assertions.assertEquals(ruleWithEmptyConditions,
+                RuleValidator.findMatchingRule(subjectAttributes, rules).get());
     }
 
     @DisplayName("findMatchingRule() with empty rules")
@@ -126,6 +142,20 @@ void testMatchesAnyRuleWhenRuleMatches() {
         Assertions.assertEquals(rule, RuleValidator.findMatchingRule(subjectAttributes, rules).get());
     }
 
+    @DisplayName("findMatchingRule() when rule matches with semver")
+    @Test
+    void testMatchesAnyRuleWhenRuleMatchesWithSemVer() {
+        List<Rule> rules = new ArrayList<>();
+        Rule rule = createRule(new ArrayList<>());
+        addSemVerConditionToRule(rule);
+        rules.add(rule);
+
+        SubjectAttributes subjectAttributes = new SubjectAttributes();
+        subjectAttributes.put("version", EppoValue.valueOf("1.15.5"));
+
+        Assertions.assertEquals(rule, RuleValidator.findMatchingRule(subjectAttributes, rules).get());
+    }
+
     @DisplayName("findMatchingRule() throw InvalidSubjectAttribute")
     @Test
     void testMatchesAnyRuleWhenThrowInvalidSubjectAttribute() {
@@ -137,7 +167,6 @@ void testMatchesAnyRuleWhenThrowInvalidSubjectAttribute() {
         SubjectAttributes subjectAttributes = new SubjectAttributes();
         subjectAttributes.put("price", EppoValue.valueOf("abcd"));
 
-
         Assertions.assertFalse(RuleValidator.findMatchingRule(subjectAttributes, rules).isPresent());
     }