flagsmith-nodejs 1.0.9 → 2.0.0-beta.1

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

@@ -0,0 +1,101 @@
+import {
+    ALL_RULE,
+    ANY_RULE,
+    CONDITION_OPERATORS,
+    NONE_RULE
+} from '../../../../flagsmith-engine/segments/constants';
+import {
+    all,
+    any,
+    SegmentConditionModel,
+    SegmentRuleModel
+} from '../../../../flagsmith-engine/segments/models';
+
+const conditionMatchCases: [string, string | number | boolean, string, boolean][] = [
+    [CONDITION_OPERATORS.EQUAL, 'bar', 'bar', true],
+    [CONDITION_OPERATORS.EQUAL, 'bar', 'baz', false],
+    [CONDITION_OPERATORS.EQUAL, 1, '1', true],
+    [CONDITION_OPERATORS.EQUAL, 1, '2', false],
+    [CONDITION_OPERATORS.EQUAL, true, 'true', true],
+    [CONDITION_OPERATORS.EQUAL, false, 'false', true],
+    [CONDITION_OPERATORS.EQUAL, false, 'true', false],
+    [CONDITION_OPERATORS.EQUAL, true, 'false', false],
+    [CONDITION_OPERATORS.EQUAL, 1.23, '1.23', true],
+    [CONDITION_OPERATORS.EQUAL, 1.23, '4.56', false],
+    [CONDITION_OPERATORS.GREATER_THAN, 2, '1', true],
+    [CONDITION_OPERATORS.GREATER_THAN, 1, '1', false],
+    [CONDITION_OPERATORS.GREATER_THAN, 0, '1', false],
+    [CONDITION_OPERATORS.GREATER_THAN, 2.1, '2.0', true],
+    [CONDITION_OPERATORS.GREATER_THAN, 2.1, '2.1', false],
+    [CONDITION_OPERATORS.GREATER_THAN, 2.0, '2.1', false],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, 2, '1', true],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, 1, '1', true],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, 0, '1', false],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, 2.1, '2.0', true],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, 2.1, '2.1', true],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, 2.0, '2.1', false],
+    [CONDITION_OPERATORS.LESS_THAN, 1, '2', true],
+    [CONDITION_OPERATORS.LESS_THAN, 1, '1', false],
+    [CONDITION_OPERATORS.LESS_THAN, 1, '0', false],
+    [CONDITION_OPERATORS.LESS_THAN, 2.0, '2.1', true],
+    [CONDITION_OPERATORS.LESS_THAN, 2.1, '2.1', false],
+    [CONDITION_OPERATORS.LESS_THAN, 2.1, '2.0', false],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, 1, '2', true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, 1, '1', true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, 1, '0', false],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, 2.0, '2.1', true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, 2.1, '2.1', true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, 2.1, '2.0', false],
+    [CONDITION_OPERATORS.NOT_EQUAL, 'bar', 'baz', true],
+    [CONDITION_OPERATORS.NOT_EQUAL, 'bar', 'bar', false],
+    [CONDITION_OPERATORS.NOT_EQUAL, 1, '2', true],
+    [CONDITION_OPERATORS.NOT_EQUAL, 1, '1', false],
+    [CONDITION_OPERATORS.NOT_EQUAL, true, 'false', true],
+    [CONDITION_OPERATORS.NOT_EQUAL, false, 'true', true],
+    [CONDITION_OPERATORS.NOT_EQUAL, false, 'false', false],
+    [CONDITION_OPERATORS.NOT_EQUAL, true, 'true', false],
+    [CONDITION_OPERATORS.CONTAINS, 'bar', 'b', true],
+    [CONDITION_OPERATORS.CONTAINS, 'bar', 'bar', true],
+    [CONDITION_OPERATORS.CONTAINS, 'bar', 'baz', false],
+    [CONDITION_OPERATORS.NOT_CONTAINS, 'bar', 'b', false],
+    [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]
+];
+
+test('test_segment_condition_matches_trait_value', () => {
+    for (const testCase of conditionMatchCases) {
+        expect(
+            new SegmentConditionModel(testCase[0], testCase[2], 'foo').matchesTraitValue(
+                testCase[1]
+            )
+        ).toBe(testCase[3]);
+    }
+});
+
+test('test_segment_rule_none', () => {
+    const testCases: [boolean[], boolean][] = [
+        [[], true],
+        [[false], true],
+        [[false, false], true],
+        [[false, true], false],
+        [[true, true], false]
+    ];
+
+    for (const testCase of testCases) {
+        expect(SegmentRuleModel.none(testCase[0])).toBe(testCase[1]);
+    }
+});
+
+test('test_segment_rule_matching_function', () => {
+    const testCases: [string, CallableFunction][] = [
+        [ALL_RULE, all],
+        [ANY_RULE, any],
+        [NONE_RULE, SegmentRuleModel.none]
+    ];
+
+    for (const testCase of testCases) {
+        expect(new SegmentRuleModel(testCase[0]).matchingFunction()).toBe(testCase[1]);
+    }
+});

package/tests/engine/unit/segments/util.ts

@@ -0,0 +1,151 @@
+import { ALL_RULE, ANY_RULE, EQUAL } from '../../../../flagsmith-engine/segments/constants';
+import { SegmentModel } from '../../../../flagsmith-engine/segments/models';
+import { buildSegmentModel } from '../../../../flagsmith-engine/segments/util';
+
+export const traitKey1 = 'email';
+export const traitValue1 = 'user@example.com';
+
+export const traitKey2 = 'num_purchase';
+export const traitValue2 = '12';
+
+export const traitKey_3 = 'date_joined';
+export const traitValue3 = '2021-01-01';
+
+export const emptySegment = new SegmentModel(1, 'empty_segment');
+
+export const segmentSingleCondition = buildSegmentModel({
+    id: 2,
+    name: 'segment_one_condition',
+    rules: [
+        {
+            type: ALL_RULE,
+            conditions: [
+                {
+                    operator: EQUAL,
+                    property_: traitKey1,
+                    value: traitValue1
+                }
+            ]
+        }
+    ]
+});
+
+export const segmentMultipleConditionsAll = buildSegmentModel({
+    id: 3,
+    name: 'segment_multiple_conditions_all',
+    rules: [
+        {
+            type: ALL_RULE,
+            conditions: [
+                {
+                    operator: EQUAL,
+                    property_: traitKey1,
+                    value: traitValue1
+                },
+                {
+                    operator: EQUAL,
+                    property_: traitKey2,
+                    value: traitValue2
+                }
+            ]
+        }
+    ]
+});
+
+export const segmentMultipleConditionsAny = buildSegmentModel({
+    id: 4,
+    name: 'segment_multiple_conditions_any',
+    rules: [
+        {
+            type: ANY_RULE,
+            conditions: [
+                {
+                    operator: EQUAL,
+                    property_: traitKey1,
+                    value: traitValue1
+                },
+                {
+                    operator: EQUAL,
+                    property_: traitKey2,
+                    value: traitValue2
+                }
+            ]
+        }
+    ]
+});
+
+export const segmentNestedRules = buildSegmentModel({
+    id: 5,
+    name: 'segment_nested_rules_all',
+    rules: [
+        {
+            type: ALL_RULE,
+            rules: [
+                {
+                    type: ALL_RULE,
+                    conditions: [
+                        {
+                            operator: EQUAL,
+                            property_: traitKey1,
+                            value: traitValue1
+                        },
+                        {
+                            operator: EQUAL,
+                            property_: traitKey2,
+                            value: traitValue2
+                        }
+                    ]
+                },
+                {
+                    type: ALL_RULE,
+                    conditions: [
+                        {
+                            operator: EQUAL,
+                            property_: traitKey_3,
+                            value: traitValue3
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+});
+
+export const segmentConditionsAndNestedRules = buildSegmentModel({
+    id: 6,
+    name: 'segment_multiple_conditions_all_and_nested_rules',
+    rules: [
+        {
+            type: ALL_RULE,
+            conditions: [
+                {
+                    operator: EQUAL,
+                    property_: traitKey1,
+                    value: traitValue1
+                }
+            ],
+            rules: [
+                {
+                    type: ALL_RULE,
+                    conditions: [
+                        {
+                            operator: EQUAL,
+                            property_: traitKey2,
+                            value: traitValue2
+                        }
+                    ]
+                },
+                {
+                    type: ALL_RULE,
+                    conditions: [
+                        {
+                            operator: EQUAL,
+                            property_: traitKey_3,
+                            value: traitValue3
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+});

package/tests/engine/unit/utils.ts

@@ -0,0 +1,114 @@
+import { EnvironmentModel } from '../../../flagsmith-engine/environments/models';
+import { CONSTANTS } from '../../../flagsmith-engine/features/constants';
+import { FeatureModel, FeatureStateModel } from '../../../flagsmith-engine/features/models';
+import { IdentityModel } from '../../../flagsmith-engine/identities/models';
+import { TraitModel } from '../../../flagsmith-engine/identities/traits/models';
+import { OrganisationModel } from '../../../flagsmith-engine/organisations/models';
+import { ProjectModel } from '../../../flagsmith-engine/projects/models';
+import { ALL_RULE, EQUAL } from '../../../flagsmith-engine/segments/constants';
+import {
+    SegmentConditionModel,
+    SegmentModel,
+    SegmentRuleModel
+} from '../../../flagsmith-engine/segments/models';
+
+export const segmentConditionProperty = 'foo';
+export const segmentConditionStringValue = 'bar';
+
+export function segmentCondition() {
+    return new SegmentConditionModel(EQUAL, segmentConditionStringValue, segmentConditionProperty);
+}
+
+export function traitMatchingSegment() {
+    return new TraitModel(segmentCondition().property_ as string, segmentCondition().value);
+}
+
+export function organisation() {
+    return new OrganisationModel(1, 'test Org', true, false, true);
+}
+
+export function segmentRule() {
+    const rule = new SegmentRuleModel(ALL_RULE);
+    rule.conditions = [segmentCondition()];
+    return rule;
+}
+
+export function segment() {
+    const segment = new SegmentModel(1, 'test name');
+    segment.rules = [segmentRule()];
+    return segment;
+}
+
+export function project() {
+    const project = new ProjectModel(1, 'test project', false, organisation());
+    project.segments = [segment()];
+    return project;
+}
+
+export function feature1() {
+    return new FeatureModel(1, 'feature_1', CONSTANTS.STANDARD);
+}
+
+export function feature2() {
+    return new FeatureModel(2, 'feature_2', CONSTANTS.STANDARD);
+}
+
+export function environment() {
+    const env = new EnvironmentModel(1, 'api-key', project());
+
+    env.featureStates = [
+        new FeatureStateModel(feature1(), true, 1),
+        new FeatureStateModel(feature2(), false, 2)
+    ];
+
+    return env;
+}
+
+export function identity() {
+    return new IdentityModel(Date.now().toString(), [], [], environment().apiKey, 'identity_1');
+}
+
+export function identityInSegment() {
+    const identity = new IdentityModel(
+        Date.now().toString(),
+        [],
+        [],
+        environment().apiKey,
+        'identity_2'
+    );
+
+    identity.identityTraits = [traitMatchingSegment()];
+
+    return identity;
+}
+
+export function getEnvironmentFeatureStateForFeatureByName(
+    environment: EnvironmentModel,
+    feature_name: string
+): FeatureStateModel | undefined {
+    const features = environment.featureStates.filter(fs => fs.feature.name === feature_name);
+    return features.length > 0 ? features[0] : undefined;
+}
+
+export function getEnvironmentFeatureStateForFeature(
+    environment: EnvironmentModel,
+    feature: FeatureModel
+): FeatureStateModel | undefined {
+    const f = environment.featureStates.find(f => f.feature === feature);
+    return f;
+}
+
+export function segmentOverrideFs() {
+    const fs = new FeatureStateModel(feature1(), false, 4);
+    fs.setValue('segment_override');
+    return fs;
+}
+
+export function environmentWithSegmentOverride(): EnvironmentModel {
+    const env = environment();
+    const segm = segment();
+
+    segm.featureStates.push(segmentOverrideFs());
+    env.project.segments.push(segm);
+    return env;
+}

package/tests/sdk/analytics.test.ts

@@ -0,0 +1,43 @@
+jest.mock('node-fetch');
+import fetch from 'node-fetch';
+import { analyticsProcessor } from './utils';
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+test('test_analytics_processor_track_feature_updates_analytics_data', () => {
+    const aP = analyticsProcessor();
+    aP.trackFeature(1);
+    expect(aP.analyticsData[1]).toBe(1);
+
+    aP.trackFeature(1);
+    expect(aP.analyticsData[1]).toBe(2);
+});
+
+test('test_analytics_processor_flush_clears_analytics_data', async () => {
+    const aP = analyticsProcessor();
+    aP.trackFeature(1);
+    await aP.flush();
+    expect(aP.analyticsData).toStrictEqual({});
+});
+
+test('test_analytics_processor_flush_post_request_data_match_ananlytics_data', async () => {
+    const aP = analyticsProcessor();
+    aP.trackFeature(1);
+    aP.trackFeature(2);
+    await aP.flush();
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith('http://testUrlanalytics/flags/', {
+        body: '{"1":1,"2":1}',
+        headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'test-key' },
+        method: 'POST',
+        timeout: 3
+    });
+});
+
+test('test_analytics_processor_flush_early_exit_if_analytics_data_is_empty', async () => {
+    const aP = analyticsProcessor();
+    await aP.flush();
+    expect(fetch).not.toHaveBeenCalled();
+});

package/tests/sdk/data/environment.json

@@ -0,0 +1,33 @@
+{
+  "api_key": "B62qaMZNwfiqT76p38ggrQ",
+  "project": {
+    "name": "Test project",
+    "organisation": {
+      "feature_analytics": false,
+      "name": "Test Org",
+      "id": 1,
+      "persist_trait_data": true,
+      "stop_serving_flags": false
+    },
+    "id": 1,
+    "hide_disabled_flags": false,
+    "segments": []
+  },
+  "segment_overrides": [],
+  "id": 1,
+  "feature_states": [
+    {
+      "multivariate_feature_state_values": [],
+      "feature_state_value": "some-value",
+      "id": 1,
+      "featurestate_uuid": "40eb539d-3713-4720-bbd4-829dbef10d51",
+      "feature": {
+        "name": "some_feature",
+        "type": "STANDARD",
+        "id": 1
+      },
+      "segment_id": null,
+      "enabled": true
+    }
+  ]
+}

package/tests/sdk/data/flags.json

@@ -0,0 +1,20 @@
+[
+    {
+        "id": 1,
+        "feature": {
+            "id": 1,
+            "name": "some_feature",
+            "created_date": "2019-08-27T14:53:45.698555Z",
+            "initial_value": null,
+            "description": null,
+            "default_enabled": false,
+            "type": "STANDARD",
+            "project": 1
+        },
+        "feature_state_value": "some-value",
+        "enabled": true,
+        "environment": 1,
+        "identity": null,
+        "feature_segment": null
+    }
+]

package/tests/sdk/data/identities.json

@@ -0,0 +1,29 @@
+{
+    "traits": [
+        {
+            "id": 1,
+            "trait_key": "some_trait",
+            "trait_value": "some_value"
+        }
+    ],
+    "flags": [
+        {
+            "id": 1,
+            "feature": {
+                "id": 1,
+                "name": "some_feature",
+                "created_date": "2019-08-27T14:53:45.698555Z",
+                "initial_value": null,
+                "description": null,
+                "default_enabled": false,
+                "type": "STANDARD",
+                "project": 1
+            },
+            "feature_state_value": "some-value",
+            "enabled": true,
+            "environment": 1,
+            "identity": null,
+            "feature_segment": null
+        }
+    ]
+}

package/tests/sdk/flagsmith.test.ts

@@ -0,0 +1,184 @@
+import { Flagsmith } from '../../sdk';
+import { EnvironmentDataPollingManager } from '../../sdk/polling_manager';
+import fetch, { Headers } 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_flagsmith_starts_polling_manager_on_init_if_enabled', () => {
+    new Flagsmith({
+        environmentKey: 'key',
+        enableLocalEvaluation: true
+    });
+    expect(EnvironmentDataPollingManager).toBeCalled();
+});
+
+test('test_update_environment_sets_environment', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+    const flg = flagsmith();
+    await flg.updateEnvironment();
+    expect(flg.environment).toBeDefined();
+
+    // @ts-ignore
+    flg.environment.featureStates[0].featurestateUUID = undefined;
+    // @ts-ignore
+    const model = environmentModel(JSON.parse(environmentJSON()));
+    // @ts-ignore
+    model.featureStates[0].featurestateUUID = undefined;
+    expect(flg.environment).toStrictEqual(model);
+});
+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_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 () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+    const identifier = 'identifier';
+    const traits = { some_trait: 'some_value' };
+    const flg = flagsmith();
+
+    const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+
+    expect(identityFlags[0].enabled).toBe(true);
+    expect(identityFlags[0].value).toBe('some-value');
+    expect(identityFlags[0].featureName).toBe('some_feature');
+});
+
+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
+    });
+
+    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_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_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;
+
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
+
+    const flags = await flg.getIdentityFlags('identifier');
+    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_no_identity_flags_returned', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify({ flags: [], traits: [] }))));
+
+    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.getIdentityFlags('identifier');
+    const flag = flags.getFlag('some_feature');
+
+    expect(flag.isDefault).toBe(true);
+    expect(flag.value).toBe(defaultFlag.value);
+    expect(flag.enabled).toBe(defaultFlag.enabled);
+});