combine test code for obsfucated and unobfuscated

Author: aarsilv

src/client/eppo-client.spec.ts

@@ -317,43 +317,59 @@ describe('EppoClient E2E test', () => {
     });
   });
 
-  describe('UFC Shared Test Cases', () => {
+  describe.each(['Not Obfuscated', 'Obfuscated'])('UFC Shared Test Cases %s', (obfuscationType) => {
     const testCases = testCasesByFileName<IAssignmentTestCase>(ASSIGNMENT_TEST_DATA_DIR);
+    const isObfuscated = obfuscationType === 'Obfuscated';
 
-    describe('Not obfuscated', () => {
-      beforeAll(async () => {
-        global.fetch = jest.fn(() => {
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            json: () => Promise.resolve(readMockUFCResponse(MOCK_UFC_RESPONSE_FILE)),
-          });
-        }) as jest.Mock;
+    beforeAll(async () => {
+      global.fetch = jest.fn(() => {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () =>
+            Promise.resolve(
+              readMockUFCResponse(
+                isObfuscated ? OBFUSCATED_MOCK_UFC_RESPONSE_FILE : MOCK_UFC_RESPONSE_FILE,
+              ),
+            ),
+        });
+      }) as jest.Mock;
 
-        await initConfiguration(storage);
-      });
+      await initConfiguration(storage);
+    });
 
-      afterAll(() => {
-        jest.restoreAllMocks();
-      });
+    afterAll(() => {
+      jest.restoreAllMocks();
+    });
+
+    describe.each(['Scalar', 'With Details'])('%s', (assignmentType) => {
+      const assignmentWithDetails = assignmentType === 'With Details';
 
       it.each(Object.keys(testCases))('test variation assignment splits - %s', async (fileName) => {
         const { flag, variationType, defaultValue, subjects } = testCases[fileName];
-        const client = new EppoClient({ flagConfigurationStore: storage });
+        const client = new EppoClient({ flagConfigurationStore: storage, isObfuscated });
         client.setIsGracefulFailureMode(false);
 
         let assignments: {
           subject: SubjectTestCase;
           assignment: string | boolean | number | null | object;
         }[] = [];
 
-        const typeAssignmentFunctions = {
-          [VariationType.BOOLEAN]: client.getBooleanAssignment.bind(client),
-          [VariationType.NUMERIC]: client.getNumericAssignment.bind(client),
-          [VariationType.INTEGER]: client.getIntegerAssignment.bind(client),
-          [VariationType.STRING]: client.getStringAssignment.bind(client),
-          [VariationType.JSON]: client.getJSONAssignment.bind(client),
-        };
+        const typeAssignmentFunctions = assignmentWithDetails
+          ? {
+              [VariationType.BOOLEAN]: client.getBooleanAssignmentDetails.bind(client),
+              [VariationType.NUMERIC]: client.getNumericAssignmentDetails.bind(client),
+              [VariationType.INTEGER]: client.getIntegerAssignmentDetails.bind(client),
+              [VariationType.STRING]: client.getStringAssignmentDetails.bind(client),
+              [VariationType.JSON]: client.getJSONAssignmentDetails.bind(client),
+            }
+          : {
+              [VariationType.BOOLEAN]: client.getBooleanAssignment.bind(client),
+              [VariationType.NUMERIC]: client.getNumericAssignment.bind(client),
+              [VariationType.INTEGER]: client.getIntegerAssignment.bind(client),
+              [VariationType.STRING]: client.getStringAssignment.bind(client),
+              [VariationType.JSON]: client.getJSONAssignment.bind(client),
+            };
 
         const assignmentFn = typeAssignmentFunctions[variationType] as (
           flagKey: string,
@@ -370,56 +386,7 @@ describe('EppoClient E2E test', () => {
           assignmentFn,
         );
 
-        validateTestAssignments(assignments, flag);
-      });
-    });
-
-    describe('Obfuscated', () => {
-      beforeAll(async () => {
-        global.fetch = jest.fn(() => {
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            json: () => Promise.resolve(readMockUFCResponse(OBFUSCATED_MOCK_UFC_RESPONSE_FILE)),
-          });
-        }) as jest.Mock;
-
-        await initConfiguration(storage);
-      });
-
-      afterAll(() => {
-        jest.restoreAllMocks();
-      });
-
-      it.each(Object.keys(testCases))('test variation assignment splits - %s', async (fileName) => {
-        const { flag, variationType, defaultValue, subjects } = testCases[fileName];
-        const client = new EppoClient({ flagConfigurationStore: storage, isObfuscated: true });
-        client.setIsGracefulFailureMode(false);
-
-        const typeAssignmentFunctions = {
-          [VariationType.BOOLEAN]: client.getBooleanAssignment.bind(client),
-          [VariationType.NUMERIC]: client.getNumericAssignment.bind(client),
-          [VariationType.INTEGER]: client.getIntegerAssignment.bind(client),
-          [VariationType.STRING]: client.getStringAssignment.bind(client),
-          [VariationType.JSON]: client.getJSONAssignment.bind(client),
-        };
-
-        const assignmentFn = typeAssignmentFunctions[variationType] as (
-          flagKey: string,
-          subjectKey: string,
-          subjectAttributes: Record<string, AttributeType>,
-          defaultValue: boolean | string | number | object,
-        ) => never;
-        if (!assignmentFn) {
-          throw new Error(`Unknown variation type: ${variationType}`);
-        }
-
-        const assignments = getTestAssignments(
-          { flag, variationType, defaultValue, subjects },
-          assignmentFn,
-        );
-
-        validateTestAssignments(assignments, flag);
+        validateTestAssignments(assignments, flag, assignmentWithDetails);
       });
     });
   });

test/testHelpers.ts

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 
 import { isEqual } from 'lodash';
 
-import { AttributeType, ContextAttributes, IAssignmentDetails, VariationType } from '../src';
+import { AttributeType, ContextAttributes, IAssignmentDetails, Variation, VariationType } from '../src';
 import { IFlagEvaluationDetails } from '../src/flag-evaluation-details-builder';
 import { IBanditParametersResponse, IUniversalFlagConfigResponse } from '../src/http-client';
 
@@ -87,7 +87,16 @@ export function getTestAssignments(
     subjectAttributes: Record<string, AttributeType>,
     defaultValue: string | number | boolean | object,
   ) => never,
-): { subject: SubjectTestCase; assignment: string | boolean | number | null | object }[] {
+): {
+  subject: SubjectTestCase;
+  assignment:
+    | string
+    | boolean
+    | number
+    | null
+    | object
+    | IAssignmentDetails<typeof testCase.defaultValue>;
+}[] {
   const assignments: {
     subject: SubjectTestCase;
     assignment: string | boolean | number | null | object;
@@ -130,22 +139,69 @@ export function getTestAssignmentDetails(
 export function validateTestAssignments(
   assignments: {
     subject: SubjectTestCase;
-    assignment: string | boolean | number | object | null;
+    assignment:
+      | string
+      | boolean
+      | number
+      | object
+      | null
+      | IAssignmentDetails<string | boolean | number | object>;
   }[],
   flag: string,
+  withDetails: boolean,
 ) {
   for (const { subject, assignment } of assignments) {
-    if (!isEqual(assignment, subject.assignment)) {
+    let assignedVariation = assignment;
+    let assignmentDetails: IFlagEvaluationDetails | null = null;
+    if (
+      withDetails === true &&
+      typeof assignment === 'object' &&
+      assignment !== null &&
+      'variation' in assignment
+    ) {
+      assignedVariation = assignment.variation;
+      assignmentDetails = assignment.evaluationDetails;
+    }
+
+    if (!isEqual(assignedVariation, subject.assignment)) {
       // More friendly error message
       console.error(
         `subject ${subject.subjectKey} was assigned ${JSON.stringify(
-          assignment,
+          assignedVariation,
           undefined,
           2,
         )} when expected ${JSON.stringify(subject.assignment, undefined, 2)} for flag ${flag}`,
       );
     }
 
-    expect(assignment).toEqual(subject.assignment);
+    expect(assignedVariation).toEqual(subject.assignment);
+
+    if (withDetails && assignmentDetails) {
+      expect(assignmentDetails.environmentName).toBe(subject.evaluationDetails.environmentName);
+      expect(assignmentDetails.flagEvaluationCode).toBe(
+        subject.evaluationDetails.flagEvaluationCode,
+      );
+      expect(assignmentDetails.flagEvaluationDescription).toBe(
+        subject.evaluationDetails.flagEvaluationDescription,
+      );
+      expect(assignmentDetails.variationKey).toBe(subject.evaluationDetails.variationKey);
+      // Use toString() to handle comparing JSON
+      expect(assignmentDetails.variationValue?.toString()).toBe(
+        subject.evaluationDetails.variationValue?.toString(),
+      );
+      // TODO: below needs to be fixed
+      //expect(assignmentDetails.configFetchedAt).toBe(subject.evaluationDetails.configFetchedAt);
+      //expect(assignmentDetails.configPublishedAt).toBe(subject.evaluationDetails.configPublishedAt);
+      expect(assignmentDetails.matchedRule).toEqual(subject.evaluationDetails.matchedRule);
+      expect(assignmentDetails.matchedAllocation).toEqual(
+        subject.evaluationDetails.matchedAllocation,
+      );
+      expect(assignmentDetails.unmatchedAllocations).toEqual(
+        subject.evaluationDetails.unmatchedAllocations,
+      );
+      expect(assignmentDetails.unevaluatedAllocations).toEqual(
+        subject.evaluationDetails.unevaluatedAllocations,
+      );
+    }
   }
 }