Storage change & matcher implementation

Author: gthea

src/main/java/io/split/android/client/localhost/LocalhostRuleBasedSegmentsStorage.java

@@ -7,12 +7,13 @@
 
 import io.split.android.client.dtos.RuleBasedSegment;
 import io.split.android.client.storage.rbs.RuleBasedSegmentStorage;
+import io.split.android.engine.experiments.ParsedRuleBasedSegment;
 
 public class LocalhostRuleBasedSegmentsStorage implements RuleBasedSegmentStorage {
 
     @Nullable
     @Override
-    public RuleBasedSegment get(String segmentName) {
+    public ParsedRuleBasedSegment get(String segmentName, String matchingKey) {
         return null;
     }
 

src/main/java/io/split/android/client/storage/rbs/RuleBasedSegmentStorage.java

@@ -7,11 +7,12 @@
 
 import io.split.android.client.dtos.RuleBasedSegment;
 import io.split.android.client.storage.RolloutDefinitionsCache;
+import io.split.android.engine.experiments.ParsedRuleBasedSegment;
 
 public interface RuleBasedSegmentStorage extends RolloutDefinitionsCache {
 
     @Nullable
-    RuleBasedSegment get(String segmentName);
+    ParsedRuleBasedSegment get(String segmentName, String matchingKey);
 
     boolean update(@NonNull Set<RuleBasedSegment> toAdd, @NonNull Set<RuleBasedSegment> toRemove, long changeNumber);
 

src/main/java/io/split/android/client/storage/rbs/RuleBasedSegmentStorageImpl.java

@@ -11,23 +11,31 @@
 import java.util.concurrent.ConcurrentHashMap;
 
 import io.split.android.client.dtos.RuleBasedSegment;
+import io.split.android.engine.experiments.ParsedRuleBasedSegment;
+import io.split.android.engine.experiments.RuleBasedSegmentParser;
 
 public class RuleBasedSegmentStorageImpl implements RuleBasedSegmentStorage {
 
     private final ConcurrentHashMap<String, RuleBasedSegment> mInMemorySegments;
+    private final RuleBasedSegmentParser mParser;
     private final PersistentRuleBasedSegmentStorage mPersistentStorage;
     private volatile long mChangeNumber;
 
-    public RuleBasedSegmentStorageImpl(@NonNull PersistentRuleBasedSegmentStorage persistentStorage) {
+    public RuleBasedSegmentStorageImpl(@NonNull PersistentRuleBasedSegmentStorage persistentStorage, @NonNull RuleBasedSegmentParser parser) {
         mInMemorySegments = new ConcurrentHashMap<>();
+        mParser = checkNotNull(parser);
         mPersistentStorage = checkNotNull(persistentStorage);
         mChangeNumber = -1;
     }
 
-    @Nullable
     @Override
-    public RuleBasedSegment get(String segmentName) {
-        return mInMemorySegments.get(segmentName);
+    public @Nullable ParsedRuleBasedSegment get(String segmentName, String matchingKey) {
+        RuleBasedSegment ruleBasedSegment = mInMemorySegments.get(segmentName);
+        if (ruleBasedSegment == null) {
+            return null;
+        }
+
+        return mParser.parse(ruleBasedSegment, matchingKey);
     }
 
     @Override

src/main/java/io/split/android/engine/matchers/InRuleBasedSegmentMatcher.java

@@ -0,0 +1,52 @@
+package io.split.android.engine.matchers;
+
+import static io.split.android.client.utils.Utils.checkNotNull;
+
+import java.util.Map;
+
+import io.split.android.client.Evaluator;
+import io.split.android.client.storage.mysegments.MySegmentsStorage;
+import io.split.android.client.storage.rbs.RuleBasedSegmentStorage;
+import io.split.android.engine.experiments.ParsedCondition;
+import io.split.android.engine.experiments.ParsedRuleBasedSegment;
+
+public class InRuleBasedSegmentMatcher implements Matcher {
+
+    private final RuleBasedSegmentStorage mRuleBasedSegmentStorage;
+    private final MySegmentsStorage mMySegmentsStorage;
+    private final String mSegmentName;
+
+    public InRuleBasedSegmentMatcher(RuleBasedSegmentStorage ruleBasedSegmentStorage, MySegmentsStorage mySegmentsStorage, String segmentName) {
+        mRuleBasedSegmentStorage = checkNotNull(ruleBasedSegmentStorage);
+        mMySegmentsStorage = checkNotNull(mySegmentsStorage);
+        mSegmentName = checkNotNull(segmentName);
+    }
+
+    @Override
+    public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, Evaluator evaluator) {
+        if (!(matchValue instanceof String)) {
+            return false;
+        }
+
+        final String matchingKey = (String) matchValue;
+        final ParsedRuleBasedSegment parsedRuleBasedSegment = mRuleBasedSegmentStorage.get(mSegmentName, matchingKey);
+
+        if (parsedRuleBasedSegment.getExcludedKeys().contains(matchingKey)) {
+            return false;
+        }
+
+        for (String segmentName : parsedRuleBasedSegment.getExcludedSegments()) {
+            if (mMySegmentsStorage.getAll().contains(segmentName)) {
+                return false;
+            }
+        }
+
+        for (ParsedCondition condition : parsedRuleBasedSegment.getParsedConditions()) {
+            if (condition.matcher().match(matchingKey, bucketingKey, attributes, evaluator)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/test/java/io/split/android/client/storage/rbs/RuleBasedSegmentStorageImplTest.java

@@ -22,23 +22,29 @@
 import io.split.android.client.dtos.Excluded;
 import io.split.android.client.dtos.RuleBasedSegment;
 import io.split.android.client.dtos.Status;
+import io.split.android.client.storage.mysegments.MySegmentsStorageContainer;
+import io.split.android.engine.experiments.ParsedRuleBasedSegment;
+import io.split.android.engine.experiments.ParserCommons;
+import io.split.android.engine.experiments.RuleBasedSegmentParser;
 
 public class RuleBasedSegmentStorageImplTest {
 
     private RuleBasedSegmentStorageImpl storage;
     private PersistentRuleBasedSegmentStorage mPersistentStorage;
+    private RuleBasedSegmentParser mParser;
 
     @Before
     public void setUp() {
         mPersistentStorage = mock(PersistentRuleBasedSegmentStorage.class);
-        storage = new RuleBasedSegmentStorageImpl(mPersistentStorage);
+        mParser = new RuleBasedSegmentParser(new ParserCommons(mock(MySegmentsStorageContainer.class), mock(MySegmentsStorageContainer.class), mock(RuleBasedSegmentStorageProvider.class)));
+        storage = new RuleBasedSegmentStorageImpl(mPersistentStorage, mParser);
     }
 
     @Test
     public void get() {
         RuleBasedSegment segment = createRuleBasedSegment("segment1");
         storage.update(Set.of(segment), null, 1);
-        assertNotNull(storage.get("segment1"));
+        assertNotNull(storage.get("segment1", "matchingKey"));
     }
 
     @Test
@@ -51,15 +57,15 @@ public void sequentialUpdate() {
         toAdd.add(segment2);
 
         storage.update(toAdd, null, 2);
-        assertNotNull(storage.get("segment1"));
-        assertNotNull(storage.get("segment2"));
+        assertNotNull(storage.get("segment1", "matchingKey"));
+        assertNotNull(storage.get("segment2", "matchingKey"));
         assertEquals(2, storage.getChangeNumber());
 
         Set<RuleBasedSegment> toRemove = new HashSet<>();
         toRemove.add(segment1);
         storage.update(null, toRemove, 3);
-        assertNull(storage.get("segment1"));
-        assertNotNull(storage.get("segment2"));
+        assertNull(storage.get("segment1", "matchingKey"));
+        assertNotNull(storage.get("segment2", "matchingKey"));
         assertEquals(3, storage.getChangeNumber());
     }
 
@@ -93,7 +99,7 @@ public void clearRemovesAllSegments() {
         RuleBasedSegment segment = createRuleBasedSegment("segment1");
         storage.update(Set.of(segment), null, 1);
         storage.clear();
-        assertNull(storage.get("segment1"));
+        assertNull(storage.get("segment1", "matchingKey"));
     }
 
     @Test
@@ -126,15 +132,15 @@ public void segmentRemoval() {
         toAdd.add(segment2);
         storage.update(toAdd, null, 1);
 
-        assertNotNull(storage.get("segment1"));
-        assertNotNull(storage.get("segment2"));
+        assertNotNull(storage.get("segment1", "matchingKey"));
+        assertNotNull(storage.get("segment2", "matchingKey"));
 
         Set<RuleBasedSegment> toRemove = new HashSet<>();
         toRemove.add(createRuleBasedSegment("segment1"));
         storage.update(null, toRemove, 2);
 
-        assertNull(storage.get("segment1"));
-        assertNotNull(storage.get("segment2"));
+        assertNull(storage.get("segment1", "matchingKey"));
+        assertNotNull(storage.get("segment2", "matchingKey"));
     }
 
     @Test
@@ -143,7 +149,7 @@ public void segmentRemovalOfSameSegment() {
         Set<RuleBasedSegment> segments = Collections.singleton(segment1);
 
         storage.update(segments, segments, 1);
-        assertNull(storage.get("segment1"));
+        assertNull(storage.get("segment1", "matchingKey"));
         assertEquals(1, storage.getChangeNumber());
     }
 
@@ -173,12 +179,12 @@ public void loadLocalPopulatesValues() {
         when(mPersistentStorage.getSnapshot()).thenReturn(snapshot);
 
         long initialCn = storage.getChangeNumber();
-        RuleBasedSegment initialSegment1 = storage.get("segment1");
+        ParsedRuleBasedSegment initialSegment1 = storage.get("segment1", "matchingKey");
 
         storage.loadLocal();
 
         long finalCn = storage.getChangeNumber();
-        RuleBasedSegment finalSegment1 = storage.get("segment1");
+        ParsedRuleBasedSegment finalSegment1 = storage.get("segment1", "matchingKey");
 
         assertEquals(-1, initialCn);
         assertEquals(1, finalCn);