Add support for large and rule-based segments in exclusion rules

Author: EmilianoSanchez

src/dtos/types.ts

@@ -200,7 +200,7 @@ export interface ISplitCondition {
 }
 
 export interface IExcludedSegments {
-  type: string,
+  type: 'standard' | 'large' | 'rule-based',
   name: string,
 }
 

src/evaluator/matchers/__tests__/rbsegment.spec.ts

@@ -13,10 +13,14 @@ const STORED_SPLITS: Record<string, ISplit> = {
 };
 
 const STORED_SEGMENTS: Record<string, Set<string>> = {
-  'segment_test': new Set(['emi@split.io']),
+  'excluded_standard_segment': new Set(['emi@split.io']),
   'regular_segment': new Set(['nadia@split.io'])
 };
 
+const STORED_LARGE_SEGMENTS: Record<string, Set<string>> = {
+  'excluded_large_segment': new Set(['emi-large@split.io'])
+};
+
 const STORED_RBSEGMENTS: Record<string, IRBSegment> = {
   'mauro_rule_based_segment': {
     changeNumber: 5,
@@ -25,7 +29,9 @@ const STORED_RBSEGMENTS: Record<string, IRBSegment> = {
     excluded: {
       keys: ['mauro@split.io', 'gaston@split.io'],
       segments: [
-        { type: 'regular', name: 'segment_test' }
+        { type: 'standard', name: 'excluded_standard_segment' },
+        { type: 'large', name: 'excluded_large_segment' },
+        { type: 'rule-based', name: 'excluded_rule_based_segment' }
       ]
     },
     conditions: [
@@ -137,6 +143,31 @@ const STORED_RBSEGMENTS: Record<string, IRBSegment> = {
       }
     }]
   },
+  'excluded_rule_based_segment': {
+    name: 'excluded_rule_based_segment',
+    changeNumber: 123,
+    status: 'ACTIVE',
+    conditions: [
+      {
+        matcherGroup: {
+          combiner: 'AND',
+          matchers: [
+            {
+              keySelector: null,
+              matcherType: 'WHITELIST',
+              negate: false,
+              userDefinedSegmentMatcherData: null,
+              whitelistMatcherData: {
+                whitelist: ['emi-rule-based@split.io']
+              },
+              unaryNumericMatcherData: null,
+              betweenMatcherData: null
+            }
+          ]
+        }
+      }
+    ],
+  }
 };
 
 const mockStorageSync = {
@@ -151,6 +182,11 @@ const mockStorageSync = {
       return STORED_SEGMENTS[segmentName] ? STORED_SEGMENTS[segmentName].has(matchingKey) : false;
     }
   },
+  largeSegments: {
+    isInSegment(segmentName: string, matchingKey: string) {
+      return STORED_LARGE_SEGMENTS[segmentName] ? STORED_LARGE_SEGMENTS[segmentName].has(matchingKey) : false;
+    }
+  },
   rbSegments: {
     get(rbsegmentName: string) {
       return STORED_RBSEGMENTS[rbsegmentName];
@@ -170,6 +206,11 @@ const mockStorageAsync = {
       return Promise.resolve(STORED_SEGMENTS[segmentName] ? STORED_SEGMENTS[segmentName].has(matchingKey) : false);
     }
   },
+  largeSegments: {
+    isInSegment(segmentName: string, matchingKey: string) {
+      return Promise.resolve(STORED_LARGE_SEGMENTS[segmentName] ? STORED_LARGE_SEGMENTS[segmentName].has(matchingKey) : false);
+    }
+  },
   rbSegments: {
     get(rbsegmentName: string) {
       return Promise.resolve(STORED_RBSEGMENTS[rbsegmentName]);
@@ -192,18 +233,28 @@ describe.each([
       value: 'depend_on_mauro_rule_based_segment'
     } as IMatcherDto, mockStorage)!;
 
-    [matcher, dependentMatcher].forEach(async matcher => {
+    [matcher, dependentMatcher].forEach(async (matcher) => {
 
       // should return false if the provided key is excluded (even if some condition is met)
       let match = matcher({ key: 'mauro@split.io', attributes: { location: 'mdp' } }, evaluateFeature);
       expect(thenable(match)).toBe(isAsync);
       expect(await match).toBe(false);
 
-      // should return false if the provided key is in some excluded segment (even if some condition is met)
+      // should return false if the provided key is in some excluded standard segment (even if some condition is met)
       match = matcher({ key: 'emi@split.io', attributes: { location: 'tandil' } }, evaluateFeature);
       expect(thenable(match)).toBe(isAsync);
       expect(await match).toBe(false);
 
+      // should return false if the provided key is in some excluded large segment (even if some condition is met)
+      match = matcher({ key: 'emi-large@split.io', attributes: { location: 'tandil' } }, evaluateFeature);
+      expect(thenable(match)).toBe(isAsync);
+      expect(await match).toBe(false);
+
+      // should return false if the provided key is in some excluded rule-based segment (even if some condition is met)
+      match = matcher({ key: 'emi-rule-based@split.io', attributes: { location: 'tandil' } }, evaluateFeature);
+      expect(thenable(match)).toBe(isAsync);
+      expect(await match).toBe(false);
+
       // should return false if doesn't match any condition
       match = matcher({ key: 'zeta@split.io' }, evaluateFeature);
       expect(thenable(match)).toBe(isAsync);

src/evaluator/matchers/rbsegment.ts

@@ -35,8 +35,14 @@ export function ruleBasedSegmentMatcherContext(segmentName: string, storage: ISt
 
       if (excluded.keys && excluded.keys.indexOf(matchingKey) !== -1) return true;
 
-      const isInSegment = (excluded.segments || []).map(segment => {
-        return storage.segments.isInSegment(segment.name, matchingKey);
+      const isInSegment = (excluded.segments || []).map(({ type, name }) => {
+        return type === 'standard' ?
+          storage.segments.isInSegment(name, matchingKey) :
+          type === 'rule-based' ?
+            ruleBasedSegmentMatcherContext(name, storage, log)({ key, attributes }, splitEvaluator) :
+            type === 'large' && (storage as IStorageSync).largeSegments ?
+              (storage as IStorageSync).largeSegments!.isInSegment(name, matchingKey) :
+              false;
       });
 
       return isInSegment.length && thenable(isInSegment[0]) ?