flagsmith-nodejs 2.0.0-beta.6 → 2.0.0-beta.7

package/tests/sdk/flagsmith.test.ts

@@ -1,8 +1,10 @@
 import Flagsmith from '../../sdk';
 import { EnvironmentDataPollingManager } from '../../sdk/polling_manager';
-import fetch, { Headers } from 'node-fetch';
+import fetch from 'node-fetch';
 import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON } from './utils';
 import { DefaultFlag } from '../../sdk/models';
+import { delay } from '../../sdk/utils';
+import { EnvironmentModel } from '../../flagsmith-engine/environments/models';
 
 jest.mock('node-fetch');
 jest.mock('../../sdk/polling_manager');
@@ -23,6 +25,17 @@ test('test_flagsmith_starts_polling_manager_on_init_if_enabled', () => {
     expect(EnvironmentDataPollingManager).toBeCalled();
 });
 
+test('test_flagsmith_local_evaluation_key_required', () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+    console.error = jest.fn();
+    new Flagsmith({
+        environmentKey: 'bad.key',
+        enableLocalEvaluation: true
+    });
+    expect(console.error).toBeCalled();
+});
+
 test('test_update_environment_sets_environment', async () => {
     // @ts-ignore
     fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
@@ -55,62 +68,45 @@ test('test_get_identity_segments', async () => {
     const segments2 = await flg.getIdentitySegments('user', { age: 41 });
     expect(segments2.length).toEqual(0);
 });
-test('test_get_environment_flags_calls_api_when_no_local_environment', async () => {
-    // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
 
-    const flg = flagsmith();
-    const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
 
-    expect(fetch).toBeCalledTimes(1);
-    expect(allFlags[0].enabled).toBe(true);
-    expect(allFlags[0].value).toBe('some-value');
-    expect(allFlags[0].featureName).toBe('some_feature');
-});
-test('test_get_environment_flags_uses_local_environment_when_available', async () => {
+test('test_get_identity_segments_empty_without_local_eval', async () => {
     // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+    const flg = new Flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: false
+    });
+    const segments = await flg.getIdentitySegments('user', { age: 21 });
+    expect(segments.length).toBe(0);
+});
 
-    const flg = flagsmith();
-    const model = environmentModel(JSON.parse(environmentJSON()));
-    flg.environment = model;
 
-    const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
-    expect(fetch).toBeCalledTimes(0);
-    expect(allFlags[0].enabled).toBe(model.featureStates[0].enabled);
-    expect(allFlags[0].value).toBe(model.featureStates[0].getValue());
-    expect(allFlags[0].featureName).toBe(model.featureStates[0].feature.name);
-});
-test('test_get_identity_flags_calls_api_when_no_local_environment_no_traits', async () => {
-    // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
-    const identifier = 'identifier';
 
-    const flg = flagsmith();
 
-    const identityFlags = (await flg.getIdentityFlags(identifier)).allFlags();
 
-    expect(identityFlags[0].enabled).toBe(true);
-    expect(identityFlags[0].value).toBe('some-value');
-    expect(identityFlags[0].featureName).toBe('some_feature');
-});
-test('test_get_identity_flags_calls_api_when_no_local_environment_with_traits', async () => {
+
+test('test_update_environment_uses_req_when_inited', async () => {
     // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
     const identifier = 'identifier';
-    const traits = { some_trait: 'some_value' };
-    const flg = flagsmith();
 
-    const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+    const flg = flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true,
+
+    });
+
+    delay(400);
 
-    expect(identityFlags[0].enabled).toBe(true);
-    expect(identityFlags[0].value).toBe('some-value');
-    expect(identityFlags[0].featureName).toBe('some_feature');
+    expect(async () => {
+        await flg.updateEnvironment();
+    }).not.toThrow();
 });
 
-test('test_default_flag_is_used_when_no_environment_flags_returned', async () => {
+test('test_isFeatureEnabled_environment', async () => {
     // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify([]))));
+    fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
 
     const defaultFlag = new DefaultFlag('some-default-value', true);
 
@@ -118,33 +114,36 @@ test('test_default_flag_is_used_when_no_environment_flags_returned', async () =>
 
     const flg = new Flagsmith({
         environmentKey: 'key',
-        defaultFlagHandler: defaultFlagHandler
+        defaultFlagHandler: defaultFlagHandler,
+        enableAnalytics: true,
     });
 
     const flags = await flg.getEnvironmentFlags();
-    const flag = flags.getFlag('some_feature');
-    expect(flag.isDefault).toBe(true);
-    expect(flag.enabled).toBe(defaultFlag.enabled);
-    expect(flag.value).toBe(defaultFlag.value);
-});
+    const featureValue = flags.isFeatureEnabled('some_feature');
 
-test('test_non_200_response_raises_flagsmith_api_error', async () => {
-    const errorResponse403 = new Response('403 Forbidden', {
-        status: 403
-    });
-    // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(errorResponse403));
+    expect(featureValue).toBe(true);
+});
 
+test('test_fetch_recovers_after_single_API_error', async () => {
+    fetch
+        // @ts-ignore
+        .mockRejectedValueOnce(new Error('Error during fetching the API response'))
+        .mockReturnValue(Promise.resolve(new Response(flagsJSON())));
     const flg = new Flagsmith({
-        environmentKey: 'some'
+        environmentKey: 'key',
     });
 
-    await expect(flg.getEnvironmentFlags()).rejects.toThrow();
+    const flags = await flg.getEnvironmentFlags();
+    const flag = flags.getFlag('some_feature');
+    expect(flag.isDefault).toBe(false);
+    expect(flag.enabled).toBe(true);
+    expect(flag.value).toBe('some-value');
 });
-test('test_default_flag_is_not_used_when_environment_flags_returned', async () => {
-    // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
 
+test('test_default_flag_used_after_multiple_API_errors', async () => {
+    fetch
+        // @ts-ignore
+        .mockRejectedValue(new Error('Error during fetching the API response'));
     const defaultFlag = new DefaultFlag('some-default-value', true);
 
     const defaultFlagHandler = (featureName: string) => defaultFlag;
@@ -156,48 +155,64 @@ test('test_default_flag_is_not_used_when_environment_flags_returned', async () =
 
     const flags = await flg.getEnvironmentFlags();
     const flag = flags.getFlag('some_feature');
-
-    expect(flag.isDefault).toBe(false);
-    expect(flag.value).not.toBe(defaultFlag.value);
-    expect(flag.value).toBe('some-value');
+    expect(flag.isDefault).toBe(true);
+    expect(flag.enabled).toBe(defaultFlag.enabled);
+    expect(flag.value).toBe(defaultFlag.value);
 });
-test('test_default_flag_is_not_used_when_identity_flags_returned', async () => {
-    // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
 
-    const defaultFlag = new DefaultFlag('some-default-value', true);
 
-    const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+test('test_throws_when_no_identity_flags_returned_due_to_error', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response('bad data')));
+
 
     const flg = new Flagsmith({
         environmentKey: 'key',
-        defaultFlagHandler: defaultFlagHandler
     });
 
-    const flags = await flg.getIdentityFlags('identifier');
-    const flag = flags.getFlag('some_feature');
+    expect(async () => {
+        await flg.getIdentityFlags('identifier');
+    }).rejects.toThrow();
 
-    expect(flag.isDefault).toBe(false);
-    expect(flag.value).not.toBe(defaultFlag.value);
-    expect(flag.value).toBe('some-value');
 });
 
-test('test_default_flag_is_used_when_no_identity_flags_returned', async () => {
+test('test onEnvironmentChange is called when provided', async () => {
     // @ts-ignore
-    fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify({ flags: [], traits: [] }))));
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
 
-    const defaultFlag = new DefaultFlag('some-default-value', true);
-    const defaultFlagHandler = (featureName: string) => defaultFlag;
+    const callback = {
+        callback: (e: Error | null, result: EnvironmentModel) => { }
+    };
+    const callbackSpy = jest.spyOn(callback, 'callback');
 
     const flg = new Flagsmith({
-        environmentKey: 'key',
-        defaultFlagHandler: defaultFlagHandler
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true,
+        onEnvironmentChange: callback.callback,
     });
 
-    const flags = await flg.getIdentityFlags('identifier');
-    const flag = flags.getFlag('some_feature');
+    await delay(200);
 
-    expect(flag.isDefault).toBe(true);
-    expect(flag.value).toBe(defaultFlag.value);
-    expect(flag.enabled).toBe(defaultFlag.enabled);
+    expect(callbackSpy).toBeCalled();
 });
+
+test('test onEnvironmentChange is called after error', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response('aaa')));
+
+    const callback = {
+        callback: (e: Error | null, result: EnvironmentModel) => { }
+    };
+    const callbackSpy = jest.spyOn(callback, 'callback');
+
+    const flg = new Flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true,
+        onEnvironmentChange: callback.callback,
+    });
+
+    await delay(200);
+
+    expect(callbackSpy).toBeCalled();
+});

package/tests/sdk/polling.test.ts

@@ -9,6 +9,16 @@ beforeEach(() => {
     Flagsmith.mockClear();
 });
 
+test('test_polling_manager_correctly_stops_if_never_started', async () => {
+    const flagsmith = new Flagsmith({
+        environmentKey: 'key'
+    });
+
+    const pollingManager = new EnvironmentDataPollingManager(flagsmith, 0.1);
+    pollingManager.stop();
+    expect(flagsmith.updateEnvironment).not.toHaveBeenCalled();
+});
+
 test('test_polling_manager_calls_update_environment_on_start', async () => {
     const flagsmith = new Flagsmith({
         environmentKey: 'key'
@@ -21,6 +31,21 @@ test('test_polling_manager_calls_update_environment_on_start', async () => {
     expect(flagsmith.updateEnvironment).toHaveBeenCalled();
 });
 
+test('test_polling_manager_handles_double_start', async () => {
+    const flagsmith = new Flagsmith({
+        environmentKey: 'key'
+    });
+
+    const pollingManager = new EnvironmentDataPollingManager(flagsmith, 0.1);
+    pollingManager.start();
+    await delay(100);
+    pollingManager.start();
+    await delay(500);
+    pollingManager.stop();
+    expect(flagsmith.updateEnvironment).toHaveBeenCalled();
+});
+
+
 test('test_polling_manager_calls_update_environment_on_each_refresh', async () => {
     const flagsmith = new Flagsmith({
         environmentKey: 'key'

package/tests/sdk/utils.ts

@@ -2,9 +2,27 @@ import { readFileSync } from 'fs';
 import { buildEnvironmentModel } from '../../flagsmith-engine/environments/util';
 import { AnalyticsProcessor } from '../../sdk/analytics';
 import Flagsmith from '../../sdk';
+import { FlagsmithCache } from '../../sdk/types';
+import { Flag, Flags } from '../../sdk/models';
 
 const DATA_DIR = __dirname + '/data/';
 
+export class TestCache implements FlagsmithCache {
+    cache: Record<string, Flags> = {};
+
+    async get(name: string): Promise<Flags> {
+        return this.cache[name];
+    }
+
+    async has(name: string): Promise<boolean> {
+        return !!this.cache[name];
+    }
+
+    async set(name: string, value: Flags) {
+        this.cache[name] = value;
+    }
+}
+
 export function analyticsProcessor() {
     return new AnalyticsProcessor({
         environmentKey: 'test-key',
@@ -16,9 +34,10 @@ export function apiKey(): string {
     return 'sometestfakekey';
 }
 
-export function flagsmith() {
+export function flagsmith(params = {}) {
     return new Flagsmith({
-        environmentKey: apiKey()
+        environmentKey: apiKey(),
+        ...params,
     });
 }
 

package/tsconfig.json

@@ -7,7 +7,7 @@
   "compilerOptions": {
     "outDir": "./build",
     "target": "es5",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    "downlevelIteration": true,
+    "downlevelIteration": true,  // Used to allow typescript to interpret Object.entries
     /* Modules */
     "module": "commonjs",                                /* Specify what module code is generated. */
     "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */