flagsmith-nodejs 2.0.0-beta.6 → 2.0.1

package/sdk/utils.ts

@@ -2,8 +2,8 @@ import fetch, { Response } from 'node-fetch';
 // @ts-ignore
 if (typeof fetch.default !== 'undefined') fetch = fetch.default;
 
-export function generateIdentitiesData(identifier: string, traits?: { [key: string]: any }) {
-    const traitsGenerated = Object.entries(traits || {}).map(trait => ({
+export function generateIdentitiesData(identifier: string, traits: { [key: string]: any }) {
+    const traitsGenerated = Object.entries(traits).map(trait => ({
         trait_key: trait[0],
         trait_value: trait[1]
     }));
@@ -18,9 +18,8 @@ export const delay = (ms: number) =>
 
 export const retryFetch = (
     url: string,
-    fetchOptions = {},
+    fetchOptions: any,
     retries = 3,
-    retryDelay = 1000,
     timeout: number
 ): Promise<Response> => {
     return new Promise((resolve, reject) => {
@@ -32,7 +31,7 @@ export const retryFetch = (
                 .then(res => resolve(res))
                 .catch(async err => {
                     if (n > 0) {
-                        await delay(retryDelay);
+                        await delay(1000);
                         wrapper(--n);
                     } else {
                         reject(err);

package/tests/engine/unit/{egine.test.ts → engine.test.ts}

@@ -25,6 +25,12 @@ test('test_identity_get_feature_state_without_any_override', () => {
     expect(feature_state.feature).toStrictEqual(feature1());
 });
 
+test('test_identity_get_feature_state_without_any_override_no_fs', () => {
+    expect(() => {
+        getIdentityFeatureState(environment(), identity(), 'nonExistentName');
+    }).toThrowError('Feature State Not Found');
+});
+
 test('test_identity_get_all_feature_states_no_segments', () => {
     const env = environment();
     const ident = identity();
@@ -61,6 +67,20 @@ test('test_identity_get_all_feature_states_with_traits', () => {
     expect(featureStates[0].getValue()).toBe('segment_override');
 });
 
+test('test_identity_get_all_feature_states_with_traits_hideDisabledFlags', () => {
+    const trait_models = new TraitModel(segmentConditionProperty, segmentConditionStringValue);
+
+    const env = environmentWithSegmentOverride();
+    env.project.hideDisabledFlags = true;
+
+    const featureStates = getIdentityFeatureStates(
+        env,
+        identityInSegment(),
+        [trait_models]
+    );
+    expect(featureStates.length).toBe(0);
+});
+
 test('test_environment_get_all_feature_states', () => {
     const env = environment();
     const featureStates = getEnvironmentFeatureStates(env);

package/tests/engine/unit/features/models.test.ts

@@ -7,6 +7,12 @@ import {
 } from '../../../../flagsmith-engine/features/models';
 import { feature1 } from '../utils';
 
+test('test_compare_feature_model', () => {
+    const fm1 = new FeatureModel(1, 'a', 'test');
+    const fm2 = new FeatureModel(1, 'a', 'test');
+    expect(fm1.eq(fm2)).toBe(true);
+});
+
 test('test_initializing_feature_state_creates_default_feature_state_uuid', () => {
     const featureState = new FeatureStateModel(feature1(), true, 1);
     expect(featureState.featurestateUUID).toBeDefined();
@@ -60,13 +66,11 @@ test('test_feature_state_get_value_mv_values', () => {
         const mvFeatureState = new FeatureStateModel(myFeature, true, 1);
         mvFeatureState.multivariateFeatureStateValues = [
             mvFeatureStateValue1,
-            mvFeatureStateValue2
+            mvFeatureStateValue2,
         ];
 
         mvFeatureState.setValue(mvFeatureControlValue);
 
-        // TODO
-        // expect(mvFeatureState.getValue(3)).toBe(testCase[1]);
-        expect(1).toBe(1);
+        expect(mvFeatureState.getValue("test")).toBe(mvFeatureValue2);
     }
 });

package/tests/engine/unit/identities/identities_builders.test.ts

@@ -42,6 +42,19 @@ test('test_build_identity_model_from_dictionary_uses_identity_feature_list_for_i
     expect(identityModel.identityFeatures?.length).toBe(1);
 });
 
+test('test_build_identity_model_from_dictionary_uses_identity_feature_list_for_identity_features', () => {
+    const identity_dict = {
+        id: 1,
+        identifier: 'test-identity',
+        environment_api_key: 'api-key',
+        created_date: '2021-08-22T06:25:23.406995Z',
+    };
+
+    const identityModel = buildIdentityModel(identity_dict);
+
+    expect(identityModel.identityFeatures?.length).toBe(0);
+});
+
 test('test_build_build_identity_model_from_dict_creates_identity_uuid', () => {
     const identity_model = buildIdentityModel({
         identifier: 'test_user',

package/tests/engine/unit/identities/identities_models.test.ts

@@ -54,7 +54,7 @@ test('test_update_traits_remove_traits_with_none_value', () => {
     const trait_key = ident.identityTraits[0].traitKey;
     const trait_to_remove = new TraitModel(trait_key, undefined);
 
-    ident.update_traits([trait_to_remove]);
+    ident.updateTraits([trait_to_remove]);
 
     expect(ident.identityTraits.length).toBe(0);
 });
@@ -66,7 +66,7 @@ test('test_update_identity_traits_updates_trait_value', () => {
     const traitValue = 'updated_trait_value';
     const traitToUpdate = new TraitModel(traitKey, traitValue);
 
-    identity.update_traits([traitToUpdate]);
+    identity.updateTraits([traitToUpdate]);
 
     expect(identity.identityTraits.length).toBe(1);
     expect(identity.identityTraits[0]).toBe(traitToUpdate);
@@ -77,7 +77,7 @@ test('test_update_traits_adds_new_traits', () => {
 
     const newTrait = new TraitModel('new_key', 'foobar');
 
-    identity.update_traits([newTrait]);
+    identity.updateTraits([newTrait]);
 
     expect(identity.identityTraits.length).toBe(2);
     expect(identity.identityTraits).toContain(newTrait);
@@ -92,14 +92,3 @@ test('test_append_feature_state', () => {
 
     expect(ident.identityFeatures).toContain(fs1);
 });
-
-test('test_appending_feature_states_raises_duplicate_feature_state_if_fs_for_the_feature_already_exists', () => {
-    const ident = identityInSegment();
-
-    const fs1 = new FeatureStateModel(feature1(), false, 1);
-    const fs2 = new FeatureStateModel(feature1(), true, 1);
-    ident.identityFeatures.push(fs1);
-    expect(() => {
-        ident.identityFeatures.push(fs2);
-    }).toThrowError();
-});

package/tests/engine/unit/organization/models.test.ts

@@ -8,5 +8,5 @@ test('Test builder', () => {
         stop_serving_flags: false,
         id: 13
     });
-    expect(model.unique_slug).toBe('13-Flagsmith');
+    expect(model.uniqueSlug).toBe('13-Flagsmith');
 });

package/tests/engine/unit/segments/segments_model.test.ts

@@ -61,7 +61,28 @@ const conditionMatchCases: [string, string | number | boolean, string, boolean][
     [CONDITION_OPERATORS.NOT_CONTAINS, 'bar', 'bar', false],
     [CONDITION_OPERATORS.NOT_CONTAINS, 'bar', 'baz', true],
     [CONDITION_OPERATORS.REGEX, 'foo', '[a-z]+', true],
-    [CONDITION_OPERATORS.REGEX, 'FOO', '[a-z]+', false]
+    [CONDITION_OPERATORS.REGEX, 'FOO', '[a-z]+', false],
+    [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.0:semver", true],
+    [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.0:semver", true],
+    [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.1:semver", false],
+    [CONDITION_OPERATORS.NOT_EQUAL, "1.0.0", "1.0.0:semver", false],
+    [CONDITION_OPERATORS.NOT_EQUAL, "1.0.0", "1.0.1:semver", true],
+    [CONDITION_OPERATORS.GREATER_THAN, "1.0.1", "1.0.0:semver", true],
+    [CONDITION_OPERATORS.GREATER_THAN, "1.0.0", "1.0.0-beta:semver", true],
+    [CONDITION_OPERATORS.GREATER_THAN, "1.0.1", "1.2.0:semver", false],
+    [CONDITION_OPERATORS.GREATER_THAN, "1.0.1", "1.0.1:semver", false],
+    [CONDITION_OPERATORS.GREATER_THAN, "1.2.4", "1.2.3-pre.2+build.4:semver", true],
+    [CONDITION_OPERATORS.LESS_THAN, "1.0.0", "1.0.1:semver", true],
+    [CONDITION_OPERATORS.LESS_THAN, "1.0.0", "1.0.0:semver", false],
+    [CONDITION_OPERATORS.LESS_THAN, "1.0.1", "1.0.0:semver", false],
+    [CONDITION_OPERATORS.LESS_THAN, "1.0.0-rc.2", "1.0.0-rc.3:semver", true],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, "1.0.1", "1.0.0:semver", true],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, "1.0.1", "1.2.0:semver", false],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, "1.0.1", "1.0.1:semver", true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, "1.0.0", "1.0.1:semver", true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, "1.0.0", "1.0.0:semver", true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, "1.0.1", "1.0.0:semver", false],
+    ['BAD_OP', 'a', 'a', false]
 ];
 
 test('test_segment_condition_matches_trait_value', () => {

package/tests/engine/unit/utils.ts

@@ -87,7 +87,7 @@ export function getEnvironmentFeatureStateForFeatureByName(
     feature_name: string
 ): FeatureStateModel | undefined {
     const features = environment.featureStates.filter(fs => fs.feature.name === feature_name);
-    return features.length > 0 ? features[0] : undefined;
+    return features[0];
 }
 
 export function getEnvironmentFeatureStateForFeature(

package/tests/sdk/analytics.test.ts

@@ -36,6 +36,17 @@ test('test_analytics_processor_flush_post_request_data_match_ananlytics_data', a
     });
 });
 
+jest.useFakeTimers()
+test('test_analytics_processor_flush_post_request_data_match_ananlytics_data_test', async () => {
+    const aP = analyticsProcessor();
+    aP.trackFeature(1);
+    setTimeout(() => {
+        aP.trackFeature(2);
+        expect(fetch).toHaveBeenCalledTimes(1);
+    }, 15000);
+    jest.runOnlyPendingTimers();
+});
+
 test('test_analytics_processor_flush_early_exit_if_analytics_data_is_empty', async () => {
     const aP = analyticsProcessor();
     await aP.flush();

package/tests/sdk/flagsmith-cache.test.ts

@@ -0,0 +1,150 @@
+import fetch, { Headers } from 'node-fetch';
+import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON, TestCache } from './utils';
+
+jest.mock('node-fetch');
+jest.mock('../../sdk/polling_manager');
+
+const { Response } = jest.requireActual('node-fetch');
+
+beforeEach(() => {
+  // @ts-ignore
+  jest.clearAllMocks();
+});
+
+test('test_wrong_cache_interface_throws_an_error', async () => {
+  const cache = {
+    set: () => { },
+    get: () => { },
+  };
+
+  expect(() => { const flg = flagsmith({ cache }); }).toThrow();
+});
+
+test('test_empty_cache_not_read_but_populated', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+  const cache = new TestCache();
+  const set = jest.spyOn(cache, 'set');
+
+  const flg = flagsmith({ cache });
+  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+
+  expect(set).toBeCalled();
+  expect(await cache.has('flags')).toBe(true);
+
+  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_api_not_called_when_cache_present', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+  const cache = new TestCache();
+  const set = jest.spyOn(cache, 'set');
+
+  const flg = flagsmith({ cache });
+  await (await flg.getEnvironmentFlags()).allFlags();
+  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+
+  expect(set).toBeCalled();
+  expect(await cache.has('flags')).toBe(true);
+
+  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_api_called_twice_when_no_cache', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+  const flg = flagsmith();
+  await (await flg.getEnvironmentFlags()).allFlags();
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+
+  expect(fetch).toBeCalledTimes(2);
+  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 () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+  const cache = new TestCache();
+  const set = jest.spyOn(cache, 'set');
+
+  const flg = flagsmith({ cache });
+  const model = environmentModel(JSON.parse(environmentJSON()));
+  flg.environment = model;
+
+  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+
+  expect(set).toBeCalled();
+  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_cache_used_for_identity_flags', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+
+  const cache = new TestCache();
+  const set = jest.spyOn(cache, 'set');
+
+  const identifier = 'identifier';
+  const traits = { some_trait: 'some_value' };
+  const flg = flagsmith({ cache });
+
+  (await flg.getIdentityFlags(identifier, traits)).allFlags();
+  const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+
+  expect(set).toBeCalled();
+  expect(await cache.has('flags-identifier')).toBe(true);
+
+  expect(fetch).toBeCalledTimes(1);
+
+  expect(identityFlags[0].enabled).toBe(true);
+  expect(identityFlags[0].value).toBe('some-value');
+  expect(identityFlags[0].featureName).toBe('some_feature');
+});
+
+test('test_cache_used_for_identity_flags_local_evaluation', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+
+  const cache = new TestCache();
+  const set = jest.spyOn(cache, 'set');
+
+  const identifier = 'identifier';
+  const traits = { some_trait: 'some_value' };
+  const flg = flagsmith({
+    cache,
+    environmentKey: 'ser.key',
+    enableLocalEvaluation: true,
+  });
+
+  (await flg.getIdentityFlags(identifier, traits)).allFlags();
+  const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+
+  expect(set).toBeCalled();
+  expect(await cache.has('flags-identifier')).toBe(true);
+
+  expect(fetch).toBeCalledTimes(1);
+
+  expect(identityFlags[0].enabled).toBe(true);
+  expect(identityFlags[0].value).toBe('some-value');
+  expect(identityFlags[0].featureName).toBe('some_feature');
+});
+
+test('test_cache_used_for_all_flags', async () => { });

package/tests/sdk/flagsmith-environment-flags.test.ts

@@ -0,0 +1,197 @@
+import Flagsmith from '../../sdk';
+import fetch from 'node-fetch';
+import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON } from './utils';
+import { DefaultFlag } from '../../sdk/models';
+
+jest.mock('node-fetch');
+jest.mock('../../sdk/polling_manager');
+const { Response } = jest.requireActual('node-fetch');
+
+beforeEach(() => {
+    // @ts-ignore
+    jest.clearAllMocks();
+});
+
+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 () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+  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_default_flag_is_used_when_no_environment_flags_returned', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify([]))));
+
+  const defaultFlag = new DefaultFlag('some-default-value', true);
+
+  const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+  const flg = new Flagsmith({
+      environmentKey: 'key',
+      defaultFlagHandler: defaultFlagHandler,
+      customHeaders: {
+          'X-Test-Header': '1',
+      }
+  });
+
+  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);
+});
+
+test('test_analytics_processor_tracks_flags', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+  const defaultFlag = new DefaultFlag('some-default-value', true);
+
+  const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+  const flg = new Flagsmith({
+      environmentKey: 'key',
+      defaultFlagHandler: defaultFlagHandler,
+      enableAnalytics: true,
+  });
+
+  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_getFeatureValue', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+  const defaultFlag = new DefaultFlag('some-default-value', true);
+
+  const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+  const flg = new Flagsmith({
+      environmentKey: 'key',
+      defaultFlagHandler: defaultFlagHandler,
+      enableAnalytics: true,
+  });
+
+  const flags = await flg.getEnvironmentFlags();
+  const featureValue = flags.getFeatureValue('some_feature');
+
+  expect(featureValue).toBe('some-value');
+});
+
+test('test_throws_when_no_default_flag_handler_after_multiple_API_errors', async () => {
+  fetch
+      // @ts-ignore
+      .mockRejectedValue(new Error('Error during fetching the API response'));
+
+  const flg = new Flagsmith({
+      environmentKey: 'key',
+  });
+
+  await expect(async () => {
+      const flags = await flg.getEnvironmentFlags();
+      const flag = flags.getFlag('some_feature');
+  }).rejects.toThrow('Error during fetching the API response');
+});
+
+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));
+
+  const flg = new Flagsmith({
+      environmentKey: 'some'
+  });
+
+  await expect(flg.getEnvironmentFlags()).rejects.toThrow();
+});
+test('test_default_flag_is_not_used_when_environment_flags_returned', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+
+  const defaultFlag = new DefaultFlag('some-default-value', true);
+
+  const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+  const flg = new Flagsmith({
+      environmentKey: 'key',
+      defaultFlagHandler: defaultFlagHandler
+  });
+
+  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');
+});
+
+test('test_default_flag_is_used_when_bad_api_response_happens', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response('bad-data')));
+
+  const defaultFlag = new DefaultFlag('some-default-value', true);
+
+  const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+  const flg = new Flagsmith({
+      environmentKey: 'key',
+      defaultFlagHandler: defaultFlagHandler
+  });
+
+  const flags = await flg.getEnvironmentFlags();
+  const flag = flags.getFlag('some_feature');
+
+  expect(flag.isDefault).toBe(true);
+  expect(flag.value).toBe(defaultFlag.value);
+});
+
+test('test_local_evaluation', async () => {
+  // @ts-ignore
+  fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+
+  const defaultFlag = new DefaultFlag('some-default-value', true);
+
+  const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+  const flg = new Flagsmith({
+      environmentKey: 'ser.key',
+      enableLocalEvaluation: true,
+      defaultFlagHandler: defaultFlagHandler
+  });
+
+  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');
+});