Unit tests

Author: EmilianoSanchez

src/evaluator/Engine.ts

@@ -62,7 +62,7 @@ export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync
         };
       }
 
-      const prerequisitesMet = prerequisiteMatcher(key, attributes, splitEvaluator);
+      const prerequisitesMet = prerequisiteMatcher({ key, attributes }, splitEvaluator);
 
       return thenable(prerequisitesMet) ?
         prerequisitesMet.then(evaluate) :

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

@@ -0,0 +1,106 @@
+import { evaluateFeature } from '../../index';
+import { IStorageSync } from '../../../storages/types';
+import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
+import { ISplit } from '../../../dtos/types';
+import { ALWAYS_ON_SPLIT, ALWAYS_OFF_SPLIT } from '../../../storages/__tests__/testUtils';
+import { prerequisitesMatcherContext } from '../prerequisites';
+
+const STORED_SPLITS: Record<string, ISplit> = {
+  'always-on': ALWAYS_ON_SPLIT,
+  'always-off': ALWAYS_OFF_SPLIT
+};
+
+const mockStorage = {
+  splits: {
+    getSplit: (name: string) => STORED_SPLITS[name]
+  }
+} as IStorageSync;
+
+test('MATCHER PREREQUISITES / should return true when all prerequisites are met', () => {
+  // A single prerequisite
+  const matcherTrueAlwaysOn = prerequisitesMatcherContext([{
+    n: 'always-on',
+    ts: ['not-existing', 'on', 'other'] // We should match from a list of treatments
+  }], mockStorage, loggerMock);
+  expect(matcherTrueAlwaysOn({ key: 'a-key' }, evaluateFeature)).toBe(true); // Feature flag returns one of the expected treatments, so the matcher returns true
+
+  const matcherFalseAlwaysOn = prerequisitesMatcherContext([{
+    n: 'always-on',
+    ts: ['off', 'v1']
+  }], mockStorage, loggerMock);
+  expect(matcherFalseAlwaysOn({ key: 'a-key' }, evaluateFeature)).toBe(false); // Feature flag returns treatment "on", but we are expecting ["off", "v1"], so the matcher returns false
+
+  const matcherTrueAlwaysOff = prerequisitesMatcherContext([{
+    n: 'always-off',
+    ts: ['not-existing', 'off']
+  }], mockStorage, loggerMock);
+  expect(matcherTrueAlwaysOff({ key: 'a-key' }, evaluateFeature)).toBe(true); // Feature flag returns one of the expected treatments, so the matcher returns true
+
+  const matcherFalseAlwaysOff = prerequisitesMatcherContext([{
+    n: 'always-off',
+    ts: ['v1', 'on']
+  }], mockStorage, loggerMock);
+  expect(matcherFalseAlwaysOff({ key: 'a-key' }, evaluateFeature)).toBe(false); // Feature flag returns treatment "on", but we are expecting ["off", "v1"], so the matcher returns false
+
+  // Multiple prerequisites
+  const matcherTrueMultiplePrerequisites = prerequisitesMatcherContext([
+    {
+      n: 'always-on',
+      ts: ['on']
+    },
+    {
+      n: 'always-off',
+      ts: ['off']
+    }
+  ], mockStorage, loggerMock);
+  expect(matcherTrueMultiplePrerequisites({ key: 'a-key' }, evaluateFeature)).toBe(true); // All prerequisites are met, so the matcher returns true
+
+  const matcherFalseMultiplePrerequisites = prerequisitesMatcherContext([
+    {
+      n: 'always-on',
+      ts: ['on']
+    },
+    {
+      n: 'always-off',
+      ts: ['on']
+    }
+  ], mockStorage, loggerMock);
+  expect(matcherFalseMultiplePrerequisites({ key: 'a-key' }, evaluateFeature)).toBe(false); // One of the prerequisites is not met, so the matcher returns false
+});
+
+test('MATCHER PREREQUISITES / Edge cases', () => {
+  // No prerequisites
+  const matcherTrueNoPrerequisites = prerequisitesMatcherContext(undefined, mockStorage, loggerMock);
+  expect(matcherTrueNoPrerequisites({ key: 'a-key' }, evaluateFeature)).toBe(true);
+
+  const matcherTrueEmptyPrerequisites = prerequisitesMatcherContext([], mockStorage, loggerMock);
+  expect(matcherTrueEmptyPrerequisites({ key: 'a-key' }, evaluateFeature)).toBe(true);
+
+  // Non existent feature flag
+  const matcherParentNotExist = prerequisitesMatcherContext([{
+    n: 'not-existent-feature-flag',
+    ts: ['on', 'off']
+  }], mockStorage, loggerMock);
+  expect(matcherParentNotExist({ key: 'a-key' }, evaluateFeature)).toBe(false); // If the feature flag does not exist, matcher should return false
+
+  // Empty treatments list
+  const matcherNoTreatmentsExpected = prerequisitesMatcherContext([
+    {
+      n: 'always-on',
+      ts: []
+    }], mockStorage, loggerMock);
+  expect(matcherNoTreatmentsExpected({ key: 'a-key' }, evaluateFeature)).toBe(false); // If treatments expectation list is empty, matcher should return false (no treatment will match)
+
+  const matcherExpectedTreatmentWrongTypeMatching = prerequisitesMatcherContext([{
+    n: 'always-on', // @ts-ignore
+    ts: [null, [1, 2], 3, {}, true, 'on']
+
+  }], mockStorage, loggerMock);
+  expect(matcherExpectedTreatmentWrongTypeMatching({ key: 'a-key' }, evaluateFeature)).toBe(true); // If treatments expectation list has elements of the wrong type, those elements are overlooked.
+
+  const matcherExpectedTreatmentWrongTypeNotMatching = prerequisitesMatcherContext([{
+    n: 'always-off', // @ts-ignore
+    ts: [null, [1, 2], 3, {}, true, 'on']
+  }], mockStorage, loggerMock);
+  expect(matcherExpectedTreatmentWrongTypeNotMatching({ key: 'a-key' }, evaluateFeature)).toBe(false); // If treatments expectation list has elements of the wrong type, those elements are overlooked.
+});

src/evaluator/matchers/prerequisites.ts

@@ -2,24 +2,23 @@ import { ISplit, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
-import { ISplitEvaluator } from '../types';
-import SplitIO from '../../../types/splitio';
+import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
 
 export function prerequisitesMatcherContext(prerequisites: ISplit['prerequisites'] = [], storage: IStorageSync | IStorageAsync, log: ILogger) {
 
-  return function prerequisitesMatcher(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
+  return function prerequisitesMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
 
     function evaluatePrerequisite(prerequisite: { n: string; ts: string[] }): MaybeThenable<boolean> {
       const evaluation = splitEvaluator(log, key, prerequisite.n, attributes, storage);
-      return thenable(evaluation)
-        ? evaluation.then(evaluation => prerequisite.ts.indexOf(evaluation.treatment!) === -1)
-        : prerequisite.ts.indexOf(evaluation.treatment!) === -1;
+      return thenable(evaluation) ?
+        evaluation.then(evaluation => prerequisite.ts.indexOf(evaluation.treatment!) !== -1) :
+        prerequisite.ts.indexOf(evaluation.treatment!) !== -1;
     }
 
     return prerequisites.reduce<MaybeThenable<boolean>>((prerequisitesMet, prerequisite) => {
       return thenable(prerequisitesMet) ?
-        prerequisitesMet.then(prerequisitesMet => !prerequisitesMet ? false : evaluatePrerequisite(prerequisite)) :
-        !prerequisitesMet ? false : evaluatePrerequisite(prerequisite);
+        prerequisitesMet.then(prerequisitesMet => prerequisitesMet ? evaluatePrerequisite(prerequisite) : false) :
+        prerequisitesMet ? evaluatePrerequisite(prerequisite) : false;
     }, true);
   };
 }