Merge branch 'rb_segments_baseline' into rb_segments_splitschanges_updater

Author: EmilianoSanchez

src/evaluator/combiners/ifelseif.ts

@@ -35,7 +35,7 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
     return undefined;
   }
 
-  function ifElseIfCombiner(key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
+  function ifElseIfCombiner(key: SplitIO.SplitKey, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
     // In Async environments we are going to have async predicates. There is none way to know
     // before hand so we need to evaluate all the predicates, verify for thenables, and finally,
     // define how to return the treatment (wrap result into a Promise or not).

src/evaluator/condition/engineUtils.ts

@@ -5,7 +5,7 @@ import { bucket } from '../../utils/murmur3/murmur3';
 /**
  * Get the treatment name given a key, a seed, and the percentage of each treatment.
  */
-export function getTreatment(log: ILogger, key: string, seed: number, treatments: { getTreatmentFor: (x: number) => string }) {
+export function getTreatment(log: ILogger, key: string, seed: number | undefined, treatments: { getTreatmentFor: (x: number) => string }) {
   const _bucket = bucket(key, seed);
 
   const treatment = treatments.getTreatmentFor(_bucket);

src/evaluator/condition/index.ts

@@ -7,7 +7,7 @@ import SplitIO from '../../../types/splitio';
 import { ILogger } from '../../logger/types';
 
 // Build Evaluation object if and only if matchingResult is true
-function match(log: ILogger, matchingResult: boolean, bucketingKey: string | undefined, seed: number, treatments: { getTreatmentFor: (x: number) => string }, label: string): IEvaluation | undefined {
+function match(log: ILogger, matchingResult: boolean, bucketingKey: string | undefined, seed: number | undefined, treatments: { getTreatmentFor: (x: number) => string }, label: string): IEvaluation | undefined {
   if (matchingResult) {
     const treatment = getTreatment(log, bucketingKey as string, seed, treatments);
 
@@ -24,7 +24,7 @@ function match(log: ILogger, matchingResult: boolean, bucketingKey: string | und
 // Condition factory
 export function conditionContext(log: ILogger, matcherEvaluator: (...args: any) => MaybeThenable<boolean>, treatments: { getTreatmentFor: (x: number) => string }, label: string, conditionType: 'ROLLOUT' | 'WHITELIST'): IEvaluator {
 
-  return function conditionEvaluator(key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
+  return function conditionEvaluator(key: SplitIO.SplitKey, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
 
     // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
     if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation as number, (key as SplitIO.SplitKeyObject).bucketingKey as string, trafficAllocationSeed as number)) {

src/evaluator/index.ts

@@ -43,8 +43,8 @@ export function evaluateFeature(
   if (thenable(parsedSplit)) {
     return parsedSplit.then((split) => getEvaluation(
       log,
-      split,
       key,
+      split,
       attributes,
       storage,
     )).catch(
@@ -56,8 +56,8 @@ export function evaluateFeature(
 
   return getEvaluation(
     log,
-    parsedSplit,
     key,
+    parsedSplit,
     attributes,
     storage,
   );
@@ -80,13 +80,13 @@ export function evaluateFeatures(
   }
 
   return thenable(parsedSplits) ?
-    parsedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
+    parsedSplits.then(splits => getEvaluations(log, key, splitNames, splits, attributes, storage))
       .catch(() => {
         // Exception on async `getSplits` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         return treatmentsException(splitNames);
       }) :
-    getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
+    getEvaluations(log, key, splitNames, parsedSplits, attributes, storage);
 }
 
 export function evaluateFeaturesByFlagSets(
@@ -136,8 +136,8 @@ export function evaluateFeaturesByFlagSets(
 
 function getEvaluation(
   log: ILogger,
-  splitJSON: ISplit | null,
   key: SplitIO.SplitKey,
+  splitJSON: ISplit | null,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
@@ -172,9 +172,9 @@ function getEvaluation(
 
 function getEvaluations(
   log: ILogger,
+  key: SplitIO.SplitKey,
   splitNames: string[],
   splits: Record<string, ISplit | null>,
-  key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
@@ -183,8 +183,8 @@ function getEvaluations(
   splitNames.forEach(splitName => {
     const evaluation = getEvaluation(
       log,
-      splits[splitName],
       key,
+      splits[splitName],
       attributes,
       storage
     );

src/evaluator/types.ts

@@ -4,7 +4,7 @@ import SplitIO from '../../types/splitio';
 import { ILogger } from '../logger/types';
 
 export interface IDependencyMatcherValue {
-  key: SplitIO.SplitKey,
+  key: SplitIO.SplitKeyObject,
   attributes?: SplitIO.Attributes
 }
 
@@ -29,6 +29,6 @@ export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDi
 
 export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
-export type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
+export type IEvaluator = (key: SplitIO.SplitKey, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
 
 export type IMatcher = (...args: any) => MaybeThenable<boolean>

src/evaluator/value/sanitize.ts

@@ -41,7 +41,7 @@ function sanitizeBoolean(val: any): boolean | undefined {
   return undefined;
 }
 
-function dependencyProcessor(sanitizedValue: string, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
+function dependencyProcessor(sanitizedValue: SplitIO.SplitKeyObject, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
   return {
     key: sanitizedValue,
     attributes

src/storages/__tests__/RBSegmentsCacheAsync.spec.ts

@@ -49,6 +49,7 @@ describe.each([{ cache: cacheInRedis, wrapper: redisClient }, { cache: cachePlug
   test('contains should check for segment existence correctly', async () => {
     await cache.update([rbSegment, rbSegmentWithInSegmentMatcher], [], 1);
 
+    expect(await cache.contains(new Set())).toBe(true);
     expect(await cache.contains(new Set([rbSegment.name]))).toBe(true);
     expect(await cache.contains(new Set([rbSegment.name, rbSegmentWithInSegmentMatcher.name]))).toBe(true);
     expect(await cache.contains(new Set(['nonexistent']))).toBe(false);

src/storages/__tests__/RBSegmentsCacheSync.spec.ts

@@ -51,6 +51,7 @@ describe.each([cacheInMemory, cacheInLocal])('Rule-based segments cache sync (Me
   test('contains should check for segment existence correctly', () => {
     cache.update([rbSegment, rbSegmentWithInSegmentMatcher], [], 1);
 
+    expect(cache.contains(new Set())).toBe(true);
     expect(cache.contains(new Set([rbSegment.name]))).toBe(true);
     expect(cache.contains(new Set([rbSegment.name, rbSegmentWithInSegmentMatcher.name]))).toBe(true);
     expect(cache.contains(new Set(['nonexistent']))).toBe(false);