merge main

Author: typotter

.github/workflows/publish.yml

@@ -19,7 +19,7 @@ jobs:
           access: public
       - name: Upload npm debug log
         if: failure()  # This step will run only if the previous steps failed
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: npm-debug-logs
           path: /home/runner/.npm/_logs/*.log

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eppo/js-client-sdk-common",
-  "version": "4.0.2",
+  "version": "4.2.0",
   "description": "Eppo SDK for client-side JavaScript applications (base for both web and react native)",
   "main": "dist/index.js",
   "files": [

src/cache/abstract-assignment-cache.spec.ts

@@ -5,7 +5,7 @@ import {
 } from './abstract-assignment-cache';
 
 describe('NonExpiringInMemoryAssignmentCache', () => {
-  it('read and write entries', () => {
+  it('read and write variation entries', () => {
     const cache = new NonExpiringInMemoryAssignmentCache();
     const key1 = { subjectKey: 'a', flagKey: 'b', allocationKey: 'c', variationKey: 'd' };
     const key2 = { subjectKey: '1', flagKey: '2', allocationKey: '3', variationKey: '4' };
@@ -14,7 +14,7 @@ describe('NonExpiringInMemoryAssignmentCache', () => {
     expect(cache.has(key2)).toBeFalsy();
     cache.set(key2);
     expect(cache.has(key2)).toBeTruthy();
-    // this makes an assumption about the internal implementation of the cache, which is not ideal
+    // this makes an assumption about the internal implementation of the cache, which is not ideal,
     // but it's the only way to test the cache without exposing the internal state
     expect(Array.from(cache.entries())).toEqual([
       [assignmentCacheKeyToString(key1), assignmentCacheValueToString(key1)],
@@ -24,4 +24,24 @@ describe('NonExpiringInMemoryAssignmentCache', () => {
     expect(cache.has({ ...key1, allocationKey: 'c1' })).toBeFalsy();
     expect(cache.has({ ...key2, variationKey: 'd1' })).toBeFalsy();
   });
+
+  it('read and write bandit entries', () => {
+    const cache = new NonExpiringInMemoryAssignmentCache();
+    const key1 = { subjectKey: 'a', flagKey: 'b', banditKey: 'c', actionKey: 'd' };
+    const key2 = { subjectKey: '1', flagKey: '2', banditKey: '3', actionKey: '4' };
+    cache.set(key1);
+    expect(cache.has(key1)).toBeTruthy();
+    expect(cache.has(key2)).toBeFalsy();
+    cache.set(key2);
+    expect(cache.has(key2)).toBeTruthy();
+    // this makes an assumption about the internal implementation of the cache, which is not ideal,
+    // but it's the only way to test the cache without exposing the internal state
+    expect(Array.from(cache.entries())).toEqual([
+      [assignmentCacheKeyToString(key1), assignmentCacheValueToString(key1)],
+      [assignmentCacheKeyToString(key2), assignmentCacheValueToString(key2)],
+    ]);
+
+    expect(cache.has({ ...key1, banditKey: 'c1' })).toBeFalsy();
+    expect(cache.has({ ...key2, actionKey: 'd1' })).toBeFalsy();
+  });
 });

src/cache/abstract-assignment-cache.ts

@@ -2,28 +2,37 @@ import { getMD5Hash } from '../obfuscation';
 
 import { LRUCache } from './lru-cache';
 
-export type AssignmentCacheValue = {
-  allocationKey: string;
-  variationKey: string;
-};
-
+/**
+ * Assignment cache keys are only on the subject and flag level, while the entire value is used
+ * for uniqueness checking. This way that if an assigned variation or bandit action changes for a
+ * flag, it evicts the old one. Then, if an older assignment is later reassigned, it will be treated
+ * as new.
+ */
 export type AssignmentCacheKey = {
   subjectKey: string;
   flagKey: string;
 };
 
+export type CacheKeyPair<T extends string, U extends string> = {
+  [K in T]: string;
+} & {
+  [K in U]: string;
+};
+
+type VariationCacheValue = CacheKeyPair<'allocationKey', 'variationKey'>;
+type BanditCacheValue = CacheKeyPair<'banditKey', 'actionKey'>;
+export type AssignmentCacheValue = VariationCacheValue | BanditCacheValue;
+
 export type AssignmentCacheEntry = AssignmentCacheKey & AssignmentCacheValue;
 
 /** Converts an {@link AssignmentCacheKey} to a string. */
 export function assignmentCacheKeyToString({ subjectKey, flagKey }: AssignmentCacheKey): string {
   return getMD5Hash([subjectKey, flagKey].join(';'));
 }
 
-export function assignmentCacheValueToString({
-  allocationKey,
-  variationKey,
-}: AssignmentCacheValue): string {
-  return getMD5Hash([allocationKey, variationKey].join(';'));
+/** Converts an {@link AssignmentCacheValue} to a string. */
+export function assignmentCacheValueToString(cacheValue: AssignmentCacheValue): string {
+  return getMD5Hash(Object.values(cacheValue).join(';'));
 }
 
 export interface AsyncMap<K, V> {

src/client/eppo-client-assignment-details.spec.ts

@@ -5,35 +5,13 @@ import {
   MOCK_UFC_RESPONSE_FILE,
   readMockUFCResponse,
 } from '../../test/testHelpers';
-import ApiEndpoints from '../api-endpoints';
-import ConfigurationRequestor from '../configuration-requestor';
-import { IConfigurationStore } from '../configuration-store/configuration-store';
 import { MemoryOnlyConfigurationStore } from '../configuration-store/memory.store';
 import { AllocationEvaluationCode } from '../flag-evaluation-details-builder';
-import FetchHttpClient from '../http-client';
 import { Flag, ObfuscatedFlag, Variation, VariationType } from '../interfaces';
 import { OperatorType } from '../rules';
 
 import EppoClient, { IAssignmentDetails } from './eppo-client';
-
-async function init(configurationStore: IConfigurationStore<Flag | ObfuscatedFlag>) {
-  const apiEndpoints = new ApiEndpoints({
-    baseUrl: 'http://127.0.0.1:4000',
-    queryParams: {
-      apiKey: 'dummy',
-      sdkName: 'js-client-sdk-common',
-      sdkVersion: '1.0.0',
-    },
-  });
-  const httpClient = new FetchHttpClient(apiEndpoints, 1000);
-  const configurationRequestor = new ConfigurationRequestor(
-    httpClient,
-    configurationStore,
-    null,
-    null,
-  );
-  await configurationRequestor.fetchAndStoreConfigurations();
-}
+import { initConfiguration } from './test-utils';
 
 describe('EppoClient get*AssignmentDetails', () => {
   const testStart = Date.now();
@@ -50,7 +28,7 @@ describe('EppoClient get*AssignmentDetails', () => {
   const storage = new MemoryOnlyConfigurationStore<Flag | ObfuscatedFlag>();
 
   beforeAll(async () => {
-    await init(storage);
+    await initConfiguration(storage);
   });
 
   it('should set the details for a matched rule', () => {
@@ -307,7 +285,7 @@ describe('EppoClient get*AssignmentDetails', () => {
         });
       }) as jest.Mock;
 
-      await init(storage);
+      await initConfiguration(storage);
     });
 
     afterAll(() => {

src/client/eppo-client-experiment-container.spec.ts

@@ -0,0 +1,93 @@
+import { MOCK_UFC_RESPONSE_FILE, readMockUFCResponse } from '../../test/testHelpers';
+import * as applicationLogger from '../application-logger';
+import { MemoryOnlyConfigurationStore } from '../configuration-store/memory.store';
+import { Flag, ObfuscatedFlag } from '../interfaces';
+
+import EppoClient, { IContainerExperiment } from './eppo-client';
+import { initConfiguration } from './test-utils';
+
+type Container = { name: string };
+
+describe('getExperimentContainerEntry', () => {
+  global.fetch = jest.fn(() => {
+    const ufc = readMockUFCResponse(MOCK_UFC_RESPONSE_FILE);
+    return Promise.resolve({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(ufc),
+    });
+  }) as jest.Mock;
+
+  const controlContainer: Container = { name: 'Control Container' };
+  const treatment1Container: Container = { name: 'Treatment Variation 1 Container' };
+  const treatment2Container: Container = { name: 'Treatment Variation 2 Container' };
+  const treatment3Container: Container = { name: 'Treatment Variation 3 Container' };
+
+  let client: EppoClient;
+  let flagExperiment: IContainerExperiment<Container>;
+  let getStringAssignmentSpy: jest.SpyInstance;
+  let loggerWarnSpy: jest.SpyInstance;
+
+  beforeEach(async () => {
+    const storage = new MemoryOnlyConfigurationStore<Flag | ObfuscatedFlag>();
+    await initConfiguration(storage);
+    client = new EppoClient(storage);
+    client.setIsGracefulFailureMode(true);
+    flagExperiment = {
+      flagKey: 'my-key',
+      controlVariationEntry: controlContainer,
+      treatmentVariationEntries: [treatment1Container, treatment2Container, treatment3Container],
+    };
+    getStringAssignmentSpy = jest.spyOn(client, 'getStringAssignment');
+    loggerWarnSpy = jest.spyOn(applicationLogger.logger, 'warn');
+  });
+
+  afterAll(() => {
+    getStringAssignmentSpy.mockRestore();
+    loggerWarnSpy.mockRestore();
+  });
+
+  it('should return the right container when a treatment variation is assigned', async () => {
+    jest.spyOn(client, 'getStringAssignment').mockReturnValue('treatment-2');
+    expect(client.getExperimentContainerEntry(flagExperiment, 'subject-key', {})).toEqual(
+      treatment2Container,
+    );
+
+    jest.spyOn(client, 'getStringAssignment').mockReturnValue('treatment-3');
+    expect(client.getExperimentContainerEntry(flagExperiment, 'subject-key', {})).toEqual(
+      treatment3Container,
+    );
+  });
+
+  it('should return the right container when control is assigned', async () => {
+    jest.spyOn(client, 'getStringAssignment').mockReturnValue('control');
+    expect(client.getExperimentContainerEntry(flagExperiment, 'subject-key', {})).toEqual(
+      controlContainer,
+    );
+    expect(loggerWarnSpy).not.toHaveBeenCalled();
+  });
+
+  it('should default to the control container if a treatment number cannot be parsed', async () => {
+    jest.spyOn(client, 'getStringAssignment').mockReturnValue('treatment-asdf');
+    expect(client.getExperimentContainerEntry(flagExperiment, 'subject-key', {})).toEqual(
+      controlContainer,
+    );
+    expect(loggerWarnSpy).toHaveBeenCalled();
+  });
+
+  it('should default to the control container if an unknown variation is assigned', async () => {
+    jest.spyOn(client, 'getStringAssignment').mockReturnValue('adsfsadfsadf');
+    expect(client.getExperimentContainerEntry(flagExperiment, 'subject-key', {})).toEqual(
+      controlContainer,
+    );
+    expect(loggerWarnSpy).toHaveBeenCalled();
+  });
+
+  it('should default to the control container if an out-of-bounds treatment variation is assigned', async () => {
+    jest.spyOn(client, 'getStringAssignment').mockReturnValue('treatment-9');
+    expect(client.getExperimentContainerEntry(flagExperiment, 'subject-key', {})).toEqual(
+      controlContainer,
+    );
+    expect(loggerWarnSpy).toHaveBeenCalled();
+  });
+});