[FME-10568] Add fallbackTreatmentCalculator to evaluator

Author: ZamoraEmmanuel

src/evaluator/Engine.ts

@@ -11,6 +11,7 @@ import { IEvaluation, IEvaluationResult, ISplitEvaluator } from './types';
 import { ILogger } from '../logger/types';
 import { ENGINE_DEFAULT } from '../logger/constants';
 import { prerequisitesMatcherContext } from './matchers/prerequisites';
+import { FallbackTreatmentsCalculator } from './fallbackTreatmentsCalculator';
 
 function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
   return {
@@ -19,13 +20,13 @@ function evaluationResult(result: IEvaluation | undefined, defaultTreatment: str
   };
 }
 
-export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync | IStorageAsync) {
+export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync | IStorageAsync, fallbackTreatmentsCalculator: FallbackTreatmentsCalculator) {
   const { killed, seed, trafficAllocation, trafficAllocationSeed, status, conditions, prerequisites } = split;
 
   const defaultTreatment = isString(split.defaultTreatment) ? split.defaultTreatment : CONTROL;
 
   const evaluator = parser(log, conditions, storage);
-  const prerequisiteMatcher = prerequisitesMatcherContext(prerequisites, storage, log);
+  const prerequisiteMatcher = prerequisitesMatcherContext(prerequisites, storage, log, fallbackTreatmentsCalculator);
 
   return {
 

src/evaluator/__tests__/evaluate-feature.spec.ts

@@ -2,6 +2,7 @@
 import { evaluateFeature } from '../index';
 import { EXCEPTION, NOT_IN_SPLIT, SPLIT_ARCHIVED, SPLIT_KILLED, SPLIT_NOT_FOUND } from '../../utils/labels';
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
+import { FallbackTreatmentsCalculator } from '../fallbackTreatmentsCalculator';
 
 const splitsMock = {
   regular: { 'changeNumber': 1487277320548, 'trafficAllocationSeed': 1667452163, 'trafficAllocation': 100, 'trafficTypeName': 'user', 'name': 'always-on', 'seed': 1684183541, 'configurations': {}, 'status': 'ACTIVE', 'killed': false, 'defaultTreatment': 'off', 'conditions': [{ 'conditionType': 'ROLLOUT', 'matcherGroup': { 'combiner': 'AND', 'matchers': [{ 'keySelector': { 'trafficType': 'user', 'attribute': '' }, 'matcherType': 'ALL_KEYS', 'negate': false, 'userDefinedSegmentMatcherData': { 'segmentName': '' }, 'unaryNumericMatcherData': { 'dataType': '', 'value': 0 }, 'whitelistMatcherData': { 'whitelist': null }, 'betweenMatcherData': { 'dataType': '', 'start': 0, 'end': 0 } }] }, 'partitions': [{ 'treatment': 'on', 'size': 100 }, { 'treatment': 'off', 'size': 0 }], 'label': 'in segment all' }] },
@@ -25,6 +26,8 @@ const mockStorage = {
   }
 };
 
+const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator();
+
 test('EVALUATOR / should return label exception, treatment control and config null on error', async () => {
   const expectedOutput = {
     treatment: 'control',
@@ -37,6 +40,7 @@ test('EVALUATOR / should return label exception, treatment control and config nu
     'throw_exception',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
 
   // This validation is async because the only exception possible when retrieving a Split would happen with Async storages.
@@ -61,6 +65,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'config',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluationWithConfig).toEqual(expectedOutput); // If the split is retrieved successfully we should get the right evaluation result, label and config.
 
@@ -70,6 +75,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'not_existent_split',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluationNotFound).toEqual(expectedOutputControl); // If the split is not retrieved successfully because it does not exist, we should get the right evaluation result, label and config.
 
@@ -79,6 +85,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'regular',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluation).toEqual({ ...expectedOutput, config: null }); // If the split is retrieved successfully we should get the right evaluation result, label and config. If Split has no config it should have config equal null.
 
@@ -88,6 +95,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'killed',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluationKilled).toEqual({ ...expectedOutput, treatment: 'off', config: null, label: SPLIT_KILLED });
   // If the split is retrieved but is killed, we should get the right evaluation result, label and config.
@@ -98,6 +106,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'archived',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluationArchived).toEqual({ ...expectedOutput, treatment: 'control', label: SPLIT_ARCHIVED, config: null });
   // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
@@ -108,6 +117,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'trafficAlocation1',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluationtrafficAlocation1).toEqual({ ...expectedOutput, label: NOT_IN_SPLIT, config: null, treatment: 'off' });
   // If the split is retrieved but is not in split (out of Traffic Allocation), we should get the right evaluation result, label and config.
@@ -118,6 +128,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'killedWithConfig',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluationKilledWithConfig).toEqual({ ...expectedOutput, treatment: 'off', label: SPLIT_KILLED });
   // If the split is retrieved but is killed, we should get the right evaluation result, label and config.
@@ -128,6 +139,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'archivedWithConfig',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluationArchivedWithConfig).toEqual({ ...expectedOutput, treatment: 'control', label: SPLIT_ARCHIVED, config: null });
   // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
@@ -138,6 +150,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     'trafficAlocation1WithConfig',
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   expect(evaluationtrafficAlocation1WithConfig).toEqual({ ...expectedOutput, label: NOT_IN_SPLIT, treatment: 'off' });
   // If the split is retrieved but is not in split (out of Traffic Allocation), we should get the right evaluation result, label and config.

src/evaluator/__tests__/evaluate-features.spec.ts

@@ -3,6 +3,7 @@ import { evaluateFeatures, evaluateFeaturesByFlagSets } from '../index';
 import { EXCEPTION, NOT_IN_SPLIT, SPLIT_ARCHIVED, SPLIT_KILLED, SPLIT_NOT_FOUND } from '../../utils/labels';
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../../logger/constants';
+import { FallbackTreatmentsCalculator } from '../fallbackTreatmentsCalculator';
 
 const splitsMock = {
   regular: { 'changeNumber': 1487277320548, 'trafficAllocationSeed': 1667452163, 'trafficAllocation': 100, 'trafficTypeName': 'user', 'name': 'always-on', 'seed': 1684183541, 'configurations': {}, 'status': 'ACTIVE', 'killed': false, 'defaultTreatment': 'off', 'conditions': [{ 'conditionType': 'ROLLOUT', 'matcherGroup': { 'combiner': 'AND', 'matchers': [{ 'keySelector': { 'trafficType': 'user', 'attribute': '' }, 'matcherType': 'ALL_KEYS', 'negate': false, 'userDefinedSegmentMatcherData': { 'segmentName': '' }, 'unaryNumericMatcherData': { 'dataType': '', 'value': 0 }, 'whitelistMatcherData': { 'whitelist': null }, 'betweenMatcherData': { 'dataType': '', 'start': 0, 'end': 0 } }] }, 'partitions': [{ 'treatment': 'on', 'size': 100 }, { 'treatment': 'off', 'size': 0 }], 'label': 'in segment all' }] },
@@ -42,6 +43,8 @@ const mockStorage = {
   }
 };
 
+const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator({});
+
 test('EVALUATOR - Multiple evaluations at once  / should return label exception, treatment control and config null on error', async () => {
   const expectedOutput = {
     throw_exception: {
@@ -82,6 +85,7 @@ test('EVALUATOR - Multiple evaluations at once / should return right labels, tre
     ['config', 'not_existent_split', 'regular', 'killed', 'archived', 'trafficAlocation1', 'killedWithConfig', 'archivedWithConfig', 'trafficAlocation1WithConfig'],
     null,
     mockStorage,
+    fallbackTreatmentsCalculator
   );
   // assert evaluationWithConfig
   expect(multipleEvaluationAtOnce['config']).toEqual(expectedOutput['config']); // If the split is retrieved successfully we should get the right evaluation result, label and config.
@@ -134,7 +138,8 @@ describe('EVALUATOR - Multiple evaluations at once by flag sets', () => {
       flagSets,
       null,
       storage,
-      'method-name'
+      'method-name',
+      fallbackTreatmentsCalculator
     );
   };
 

src/evaluator/fallbackTreatmentsCalculator/__tests__/fallback-calculator.spec.ts

@@ -1,7 +1,91 @@
 import { FallbackTreatmentsCalculator } from '../';
-import type { FallbackTreatmentConfiguration } from '../../../../types/splitio'; // adjust path if needed
+import type { FallbackTreatmentConfiguration } from '../../../../types/splitio';
+import { CONTROL } from '../../../utils/constants';
 
 describe('FallbackTreatmentsCalculator', () => {
+  const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  const longName = 'a'.repeat(101);
+
+  test('logs an error if flag name is invalid - by Flag', () => {
+    let config: FallbackTreatmentConfiguration = {
+      byFlag: {
+        'feature A': { treatment: 'TREATMENT_A', config: '{ value: 1 }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(config);
+    expect(spy.mock.calls[0][0]).toBe(
+      'Fallback treatments - Discarded flag \'feature A\': Invalid flag name (max 100 chars, no spaces)'
+    );
+    config = {
+      byFlag: {
+        [longName]: { treatment: 'TREATMENT_A', config: '{ value: 1 }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(config);
+    expect(spy.mock.calls[1][0]).toBe(
+      `Fallback treatments - Discarded flag '${longName}': Invalid flag name (max 100 chars, no spaces)`
+    );
+
+    config = {
+      byFlag: {
+        'featureB': { treatment: longName, config: '{ value: 1 }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(config);
+    expect(spy.mock.calls[2][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureB\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+
+    config = {
+      byFlag: {
+        // @ts-ignore
+        'featureC': { config: '{ global: true }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(config);
+    expect(spy.mock.calls[3][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureC\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+
+    config = {
+      byFlag: {
+        // @ts-ignore
+        'featureC': { treatment: 'invalid treatment!', config: '{ global: true }' },
+      },
+    };
+    new FallbackTreatmentsCalculator(config);
+    expect(spy.mock.calls[4][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureC\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+  });
+
+  test('logs an error if flag name is invalid - global', () => {
+    let config: FallbackTreatmentConfiguration = {
+      global: { treatment: longName, config: '{ value: 1 }' },
+    };
+    new FallbackTreatmentsCalculator(config);
+    expect(spy.mock.calls[2][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureB\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+
+    config = {
+      // @ts-ignore
+      global: { config: '{ global: true }' },
+    };
+    new FallbackTreatmentsCalculator(config);
+    expect(spy.mock.calls[3][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureC\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+
+    config = {
+      // @ts-ignore
+      global: { treatment: 'invalid treatment!', config: '{ global: true }' },
+    };
+    new FallbackTreatmentsCalculator(config);
+    expect(spy.mock.calls[4][0]).toBe(
+      'Fallback treatments - Discarded treatment for flag \'featureC\': Invalid treatment (max 100 chars and must match pattern)'
+    );
+  });
 
   test('returns specific fallback if flag exists', () => {
     const config: FallbackTreatmentConfiguration = {
@@ -42,9 +126,9 @@ describe('FallbackTreatmentsCalculator', () => {
     const result = calculator.resolve('missingFlag', 'label by noFallback');
 
     expect(result).toEqual({
-      treatment: 'CONTROL',
+      treatment: CONTROL,
       config: null,
-      label: 'fallback - label by noFallback',
+      label: 'label by noFallback',
     });
   });
 
@@ -60,7 +144,7 @@ describe('FallbackTreatmentsCalculator', () => {
     expect(result).toEqual({
       treatment: 'TREATMENT_B',
       config: undefined,
-      label: undefined,
+      label: '',
     });
   });
 });

src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -10,7 +10,7 @@ export class FallbacksSanitizer {
     return name.length <= 100 && !name.includes(' ');
   }
 
-  private static isValidTreatment(t?: FallbackTreatment): boolean {
+  private static isValidTreatment(t?: string | FallbackTreatment): boolean {
     if (!t) {
       return false;
     }
@@ -19,30 +19,30 @@ export class FallbacksSanitizer {
       if (t.length > 100) {
         return false;
       }
-      return FallbacksSanitizer.pattern.test(t);
+      return this.pattern.test(t);
     }
 
     const { treatment } = t;
     if (!treatment || treatment.length > 100) {
       return false;
     }
-    return FallbacksSanitizer.pattern.test(treatment);
+    return this.pattern.test(treatment);
   }
 
-  static sanitizeGlobal(treatment?: FallbackTreatment): FallbackTreatment | undefined {
+  static sanitizeGlobal(treatment?: string | FallbackTreatment): string | FallbackTreatment | undefined {
     if (!this.isValidTreatment(treatment)) {
       console.error(
         `Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`
       );
       return undefined;
     }
-    return treatment!;
+    return treatment;
   }
 
   static sanitizeByFlag(
-    byFlagFallbacks: Record<string, FallbackTreatment>
-  ): Record<string, FallbackTreatment> {
-    const sanitizedByFlag: Record<string, FallbackTreatment> = {};
+    byFlagFallbacks: Record<string, string | FallbackTreatment>
+  ): Record<string, string | FallbackTreatment> {
+    const sanitizedByFlag: Record<string, string | FallbackTreatment> = {};
 
     const entries = Object.entries(byFlagFallbacks);
     entries.forEach(([flag, t]) => {

src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -1,16 +1,23 @@
 import { FallbackTreatmentConfiguration, FallbackTreatment, IFallbackTreatmentsCalculator} from '../../../types/splitio';
+import { FallbacksSanitizer } from './fallbackSanitizer';
+import { CONTROL } from '../../utils/constants';
+
 
 export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
   private readonly labelPrefix = 'fallback - ';
-  private readonly control = 'CONTROL';
   private readonly fallbacks: FallbackTreatmentConfiguration;
 
-  constructor(fallbacks: FallbackTreatmentConfiguration) {
-    this.fallbacks = fallbacks;
+  constructor(fallbacks?: FallbackTreatmentConfiguration) {
+    const sanitizedGlobal = fallbacks?.global ? FallbacksSanitizer.sanitizeGlobal(fallbacks.global) : undefined;
+    const sanitizedByFlag = fallbacks?.byFlag ? FallbacksSanitizer.sanitizeByFlag(fallbacks.byFlag) : {};
+    this.fallbacks = {
+      global: sanitizedGlobal,
+      byFlag: sanitizedByFlag
+    };
   }
 
   resolve(flagName: string, label?: string | undefined): FallbackTreatment {
-    const treatment = this.fallbacks.byFlag[flagName];
+    const treatment = this.fallbacks.byFlag?.[flagName];
     if (treatment) {
       return this.copyWithLabel(treatment, label);
     }
@@ -20,13 +27,13 @@ export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculat
     }
 
     return {
-      treatment: this.control,
+      treatment: CONTROL,
       config: null,
-      label: this.resolveLabel(label),
+      label,
     };
   }
 
-  private copyWithLabel(fallback: FallbackTreatment, label: string | undefined): FallbackTreatment {
+  private copyWithLabel(fallback: string | FallbackTreatment, label: string | undefined): FallbackTreatment {
     if (typeof fallback === 'string') {
       return {
         treatment: fallback,
@@ -42,8 +49,8 @@ export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculat
     };
   }
 
-  private resolveLabel(label?: string | undefined): string | undefined {
-    return label ? `${this.labelPrefix}${label}` : undefined;
+  private resolveLabel(label?: string | undefined): string {
+    return label ? `${this.labelPrefix}${label}` : '';
   }
 
 }