Fix tests - add type validations

Author: ZamoraEmmanuel

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

@@ -6,94 +6,13 @@ import { CONTROL } from '../../../utils/constants';
 describe('FallbackTreatmentsCalculator' , () => {
   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(loggerMock, config);
-    expect(loggerMock.error.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(loggerMock, config);
-    expect(loggerMock.error.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(loggerMock, config);
-    expect(loggerMock.error.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(loggerMock, config);
-    expect(loggerMock.error.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(loggerMock, config);
-    expect(loggerMock.error.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(loggerMock, config);
-    expect(loggerMock.error.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(loggerMock, config);
-    expect(loggerMock.error.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(loggerMock, config);
-    expect(loggerMock.error.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 = {
       byFlag: {
         'featureA': { treatment: 'TREATMENT_A', config: '{ value: 1 }' },
       },
     };
-    const calculator = new FallbackTreatmentsCalculator(loggerMock, config);
+    const calculator = new FallbackTreatmentsCalculator(config);
     const result = calculator.resolve('featureA', 'label by flag');
 
     expect(result).toEqual({
@@ -108,7 +27,7 @@ describe('FallbackTreatmentsCalculator' , () => {
       byFlag: {},
       global: { treatment: 'GLOBAL_TREATMENT', config: '{ global: true }' },
     };
-    const calculator = new FallbackTreatmentsCalculator(loggerMock, config);
+    const calculator = new FallbackTreatmentsCalculator(config);
     const result = calculator.resolve('missingFlag', 'label by global');
 
     expect(result).toEqual({
@@ -122,7 +41,7 @@ describe('FallbackTreatmentsCalculator' , () => {
     const config: FallbackTreatmentConfiguration = {
       byFlag: {},
     };
-    const calculator = new FallbackTreatmentsCalculator(loggerMock, config);
+    const calculator = new FallbackTreatmentsCalculator(config);
     const result = calculator.resolve('missingFlag', 'label by noFallback');
 
     expect(result).toEqual({

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

@@ -1,10 +1,14 @@
-import { FallbacksSanitizer } from '../fallbackSanitizer';
+import { isValidFlagName, isValidTreatment, sanitizeFallbacks } from '../fallbackSanitizer';
 import { TreatmentWithConfig } from '../../../../types/splitio';
 import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
 
 describe('FallbacksSanitizer', () => {
   const validTreatment: TreatmentWithConfig = { treatment: 'on', config: '{"color":"blue"}' };
   const invalidTreatment: TreatmentWithConfig = { treatment: ' ', config: null };
+  const fallbackMock = {
+    global: undefined,
+    byFlag: {}
+  };
 
   beforeEach(() => {
     jest.spyOn(console, 'error').mockImplementation(() => {});
@@ -17,49 +21,54 @@ describe('FallbacksSanitizer', () => {
   describe('isValidFlagName', () => {
     test('returns true for a valid flag name', () => {
       // @ts-expect-private-access
-      expect((FallbacksSanitizer as any).isValidFlagName('my_flag')).toBe(true);
+      expect(isValidFlagName('my_flag')).toBe(true);
     });
 
     test('returns false for a name longer than 100 chars', () => {
       const longName = 'a'.repeat(101);
-      expect((FallbacksSanitizer as any).isValidFlagName(longName)).toBe(false);
+      expect(isValidFlagName(longName)).toBe(false);
     });
 
     test('returns false if the name contains spaces', () => {
-      expect((FallbacksSanitizer as any).isValidFlagName('invalid flag')).toBe(false);
+      expect(isValidFlagName('invalid flag')).toBe(false);
+    });
+
+    test('returns false if the name contains spaces', () => {
+      // @ts-ignore
+      expect(isValidFlagName(true)).toBe(false);
     });
   });
 
   describe('isValidTreatment', () => {
     test('returns true for a valid treatment string', () => {
-      expect((FallbacksSanitizer as any).isValidTreatment(validTreatment)).toBe(true);
+      expect(isValidTreatment(validTreatment)).toBe(true);
     });
 
     test('returns false for null or undefined', () => {
-      expect((FallbacksSanitizer as any).isValidTreatment(null)).toBe(false);
-      expect((FallbacksSanitizer as any).isValidTreatment(undefined)).toBe(false);
+      expect(isValidTreatment()).toBe(false);
+      expect(isValidTreatment(undefined)).toBe(false);
     });
 
     test('returns false for a treatment longer than 100 chars', () => {
-      const long = { treatment: 'a'.repeat(101) };
-      expect((FallbacksSanitizer as any).isValidTreatment(long)).toBe(false);
+      const long = { treatment: 'a'.repeat(101), config: null };
+      expect(isValidTreatment(long)).toBe(false);
     });
 
     test('returns false if treatment does not match regex pattern', () => {
-      const invalid = { treatment: 'invalid treatment!' };
-      expect((FallbacksSanitizer as any).isValidTreatment(invalid)).toBe(false);
+      const invalid = { treatment: 'invalid treatment!', config: null };
+      expect(isValidTreatment(invalid)).toBe(false);
     });
   });
 
   describe('sanitizeGlobal', () => {
     test('returns the treatment if valid', () => {
-      expect(FallbacksSanitizer.sanitizeGlobal(loggerMock, validTreatment)).toEqual(validTreatment);
+      expect(sanitizeFallbacks(loggerMock, { ...fallbackMock, global: validTreatment })).toEqual({ ...fallbackMock, global: validTreatment });
       expect(loggerMock.error).not.toHaveBeenCalled();
     });
 
     test('returns undefined and logs error if invalid', () => {
-      const result = FallbacksSanitizer.sanitizeGlobal(loggerMock, invalidTreatment);
-      expect(result).toBeUndefined();
+      const result = sanitizeFallbacks(loggerMock, { ...fallbackMock, global: invalidTreatment });
+      expect(result).toEqual(fallbackMock);
       expect(loggerMock.error).toHaveBeenCalledWith(
         expect.stringContaining('Fallback treatments - Discarded fallback')
       );
@@ -74,9 +83,9 @@ describe('FallbacksSanitizer', () => {
         bad_treatment: invalidTreatment,
       };
 
-      const result = FallbacksSanitizer.sanitizeByFlag(loggerMock, input);
+      const result = sanitizeFallbacks(loggerMock, {...fallbackMock, byFlag: input});
 
-      expect(result).toEqual({ valid_flag: validTreatment });
+      expect(result).toEqual({ ...fallbackMock, byFlag: { valid_flag: validTreatment } });
       expect(loggerMock.error).toHaveBeenCalledTimes(2); // invalid flag + bad_treatment
     });
 
@@ -85,20 +94,45 @@ describe('FallbacksSanitizer', () => {
         'invalid flag': invalidTreatment,
       };
 
-      const result = FallbacksSanitizer.sanitizeByFlag(loggerMock, input);
-      expect(result).toEqual({});
+      const result = sanitizeFallbacks(loggerMock, {...fallbackMock, byFlag: input});
+      expect(result).toEqual(fallbackMock);
       expect(loggerMock.error).toHaveBeenCalled();
     });
 
     test('returns same object if all valid', () => {
       const input = {
-        flag_one: validTreatment,
-        flag_two: { treatment: 'valid_2', config: null },
+        ...fallbackMock,
+        byFlag:{
+          flag_one: validTreatment,
+          flag_two: { treatment: 'valid_2', config: null },
+        }
       };
 
-      const result = FallbacksSanitizer.sanitizeByFlag(loggerMock, input);
+      const result = sanitizeFallbacks(loggerMock, input);
       expect(result).toEqual(input);
       expect(loggerMock.error).not.toHaveBeenCalled();
     });
   });
+  describe('sanitizeFallbacks', () => {
+    test('returns undefined and logs error if fallbacks is not an object', () => {
+      const result = sanitizeFallbacks(loggerMock, 'invalid_fallbacks');
+      expect(result).toBeUndefined();
+      expect(loggerMock.error).toHaveBeenCalledWith(
+        'Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties'
+      );
+    });
+
+    test('returns undefined and logs error if fallbacks is not an object', () => {
+      const result = sanitizeFallbacks(loggerMock, true);
+      expect(result).toBeUndefined();
+      expect(loggerMock.error).toHaveBeenCalledWith(
+        'Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties'
+      );
+    });
+
+    test('sanitizes both global and byFlag fallbacks for empty object', () => {
+      const result = sanitizeFallbacks(loggerMock, { global: {} });
+      expect(result).toEqual({ global: undefined, byFlag: {} });
+    });
+  });
 });

src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -9,11 +9,11 @@ enum FallbackDiscardReason {
 
 const TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
 
-function isValidFlagName(name: string): boolean {
+export function isValidFlagName(name: string): boolean {
   return name.length <= 100 && !name.includes(' ');
 }
 
-function isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
+export function isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
   const treatment = isObject(t) ? (t as TreatmentWithConfig).treatment : t;
 
   if (!isString(treatment) || treatment.length > 100) {
@@ -23,6 +23,7 @@ function isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
 }
 
 function sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
+  if (treatment === undefined) return undefined;
   if (!isValidTreatment(treatment)) {
     logger.error(`Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`);
     return undefined;
@@ -39,6 +40,7 @@ function sanitizeByFlag(
   const entries = Object.keys(byFlagFallbacks);
   entries.forEach((flag) => {
     const t = byFlagFallbacks[flag];
+    if (!t) return;
     if (!isValidFlagName(flag)) {
       logger.error(`Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`);
       return;

src/sdkClient/__tests__/sdkClientMethod.spec.ts

@@ -19,7 +19,7 @@ const paramMocks = [
     telemetryTracker: telemetryTrackerFactory(),
     clients: {},
     uniqueKeysTracker: { start: jest.fn(), stop: jest.fn() },
-    fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator(loggerMock, {})
+    fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator({})
   },
   // SyncManager (i.e., Sync SDK) and Signal listener
   {
@@ -31,7 +31,7 @@ const paramMocks = [
     telemetryTracker: telemetryTrackerFactory(),
     clients: {},
     uniqueKeysTracker: { start: jest.fn(), stop: jest.fn() },
-    fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator(loggerMock, {})
+    fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator({})
   }
 ];
 

src/sdkFactory/__tests__/index.spec.ts

@@ -37,7 +37,7 @@ const paramsForAsyncSDK = {
   platform: {
     EventEmitter
   },
-  fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator(fullSettings.log)
+  fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator()
 };
 
 const SignalListenerInstanceMock = { start: jest.fn() };