flagsmith-nodejs 3.1.1 → 3.3.0

package/tests/sdk/data/offline-environment.json

@@ -0,0 +1,93 @@
+{
+    "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": [
+        {
+          "name": "regular_segment",
+          "feature_states": [
+            {
+              "feature_state_value": "segment_override",
+              "multivariate_feature_state_values": [],
+              "django_id": 81027,
+              "feature": {
+                "name": "some_feature",
+                "type": "STANDARD",
+                "id": 1
+              },
+              "enabled": false
+            }
+          ],
+          "id": 1,
+          "rules": [
+            {
+              "type": "ALL",
+              "conditions": [],
+              "rules": [
+                {
+                  "type": "ANY",
+                  "conditions": [
+                    {
+                      "value": "40",
+                      "property_": "age",
+                      "operator": "LESS_THAN"
+                    }
+                  ],
+                  "rules": []
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    "segment_overrides": [],
+    "id": 1,
+    "feature_states": [
+      {
+        "multivariate_feature_state_values": [],
+        "feature_state_value": "offline-value",
+        "id": 1,
+        "featurestate_uuid": "40eb539d-3713-4720-bbd4-829dbef10d51",
+        "feature": {
+          "name": "some_feature",
+          "type": "STANDARD",
+          "id": 1
+        },
+        "feature_segment": null,
+        "enabled": true
+      },
+      {
+        "multivariate_feature_state_values": [
+          {
+            "percentage_allocation": 100,
+            "multivariate_feature_option": {
+              "value": "bar",
+              "id": 1
+            },
+            "mv_fs_value_uuid": "42d5cdf9-8ec9-4b8d-a3ca-fd43c64d5f05",
+            "id": 1
+          }
+        ],
+        "feature_state_value": "foo",
+        "feature": {
+          "name": "mv_feature",
+          "type": "MULTIVARIATE",
+          "id": 2
+        },
+        "feature_segment": null,
+        "featurestate_uuid": "96fc3503-09d7-48f1-a83b-2dc903d5c08a",
+        "enabled": false
+      }
+    ]
+  }
+  

package/tests/sdk/flagsmith.test.ts

@@ -1,12 +1,12 @@
 import Flagsmith from '../../sdk';
 import { EnvironmentDataPollingManager } from '../../sdk/polling_manager';
-import fetch, {RequestInit} from 'node-fetch';
+import fetch, { RequestInit } from 'node-fetch';
 import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON } from './utils';
-import { DefaultFlag } from '../../sdk/models';
-import {delay, retryFetch} from '../../sdk/utils';
-import * as utils from '../../sdk/utils';
+import { DefaultFlag, Flags } from '../../sdk/models';
+import { delay } from '../../sdk/utils';
 import { EnvironmentModel } from '../../flagsmith-engine/environments/models';
 import https from 'https'
+import { BaseOfflineHandler } from '../../sdk/offline_handlers';
 
 jest.mock('node-fetch');
 jest.mock('../../sdk/polling_manager');
@@ -47,9 +47,6 @@ test('test_update_environment_sets_environment', async () => {
 
     const model = environmentModel(JSON.parse(environmentJSON()));
 
-    wipeFeatureStateUUIDs(flg.environment)
-    wipeFeatureStateUUIDs(model)
-
     expect(flg.environment).toStrictEqual(model);
 });
 
@@ -57,8 +54,8 @@ test('test_set_agent_options', async () => {
     const agent = new https.Agent({})
 
     // @ts-ignore
-    fetch.mockImplementation((url:string, options:RequestInit)=>{
-        if(options.agent!==agent) {
+    fetch.mockImplementation((url: string, options: RequestInit) => {
+        if (options.agent !== agent) {
             throw new Error("Agent has not been set on retry fetch")
         }
         return Promise.resolve(new Response(environmentJSON()))
@@ -202,7 +199,7 @@ test('request timeout uses default if not provided', async () => {
     expect(flg.requestTimeoutMs).toBe(10000);
 })
 
-test('test_throws_when_no_identity_flags_returned_due_to_error', async () => {
+test('test_throws_when_no_identityFlags_returned_due_to_error', async () => {
     // @ts-ignore
     fetch.mockReturnValue(Promise.resolve(new Response('bad data')));
 
@@ -275,27 +272,118 @@ test('getIdentitySegments throws error if identifier is empty string', () => {
 })
 
 
-async function wipeFeatureStateUUIDs (enviromentModel: EnvironmentModel) {
-    // TODO: this has been pulled out of tests above as a helper function.
-    //  I'm not entirely sure why it's necessary, however, we should look to remove.
-    enviromentModel.featureStates.forEach(fs => {
-        // @ts-ignore
-        fs.featurestateUUID = undefined;
-        fs.multivariateFeatureStateValues.forEach(mvfsv => {
-            // @ts-ignore
-            mvfsv.mvFsValueUuid = undefined;
-        })
+test('offline_mode', async () => {
+    // Given
+    const environment: EnvironmentModel = environmentModel(JSON.parse(environmentJSON('offline-environment.json')));
+
+    class DummyOfflineHandler extends BaseOfflineHandler {
+        getEnvironment(): EnvironmentModel {
+            return environment;
+        }
+    }
+
+    // When
+    const flagsmith = new Flagsmith({ offlineMode: true, offlineHandler: new DummyOfflineHandler() });
+
+    // Then
+    // we can request the flags from the client successfully
+    const environmentFlags: Flags = await flagsmith.getEnvironmentFlags();
+    let flag = environmentFlags.getFlag('some_feature');
+    expect(flag.isDefault).toBe(false);
+    expect(flag.enabled).toBe(true);
+    expect(flag.value).toBe('offline-value');
+
+
+    const identityFlags: Flags = await flagsmith.getIdentityFlags("identity");
+    flag = identityFlags.getFlag('some_feature');
+    expect(flag.isDefault).toBe(false);
+    expect(flag.enabled).toBe(true);
+    expect(flag.value).toBe('offline-value');
+});
+
+
+test('test_flagsmith_uses_offline_handler_if_set_and_no_api_response', async () => {
+    // Given
+    const environment: EnvironmentModel = environmentModel(JSON.parse(environmentJSON('offline-environment.json')));
+    const api_url = 'http://some.flagsmith.com/api/v1/';
+    const mock_offline_handler = new BaseOfflineHandler() as jest.Mocked<BaseOfflineHandler>;
+
+    jest.spyOn(mock_offline_handler, 'getEnvironment').mockReturnValue(environment);
+
+    const flagsmith = new Flagsmith({
+        environmentKey: 'some-key',
+        apiUrl: api_url,
+        offlineHandler: mock_offline_handler,
+    });
+
+    jest.spyOn(flagsmith, 'getEnvironmentFlags');
+    jest.spyOn(flagsmith, 'getIdentityFlags');
+
+
+    flagsmith.environmentFlagsUrl = 'http://some.flagsmith.com/api/v1/environment-flags';
+    flagsmith.identitiesUrl = 'http://some.flagsmith.com/api/v1/identities';
+
+    // Mock a 500 Internal Server Error response
+    const errorResponse = new Response(null, {
+        status: 500,
+        statusText: 'Internal Server Error',
     });
-    enviromentModel.project.segments.forEach(s => {
-        s.featureStates.forEach(fs => {
-            // @ts-ignore
-            fs.featurestateUUID = undefined;
-        })
-    })
-}
+
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(errorResponse));
+
+    // When
+    const environmentFlags: Flags = await flagsmith.getEnvironmentFlags();
+    const identityFlags: Flags = await flagsmith.getIdentityFlags('identity', {});
+
+    // Then
+    expect(mock_offline_handler.getEnvironment).toHaveBeenCalledTimes(1);
+    expect(flagsmith.getEnvironmentFlags).toHaveBeenCalled();
+    expect(flagsmith.getIdentityFlags).toHaveBeenCalled();
+
+    expect(environmentFlags.isFeatureEnabled('some_feature')).toBe(true);
+    expect(environmentFlags.getFeatureValue('some_feature')).toBe('offline-value');
+
+    expect(identityFlags.isFeatureEnabled('some_feature')).toBe(true);
+    expect(identityFlags.getFeatureValue('some_feature')).toBe('offline-value');
+});
+
+test('cannot use offline mode without offline handler', () => {
+    // When and Then
+    expect(() => new Flagsmith({ offlineMode: true, offlineHandler: undefined })).toThrowError(
+        'ValueError: offlineHandler must be provided to use offline mode.'
+    );
+});
+
+test('cannot use both default handler and offline handler', () => {
+    // When and Then
+    expect(() => new Flagsmith({
+        offlineHandler: new BaseOfflineHandler(),
+        defaultFlagHandler: (flagName) => new DefaultFlag('foo', true)
+    })).toThrowError('ValueError: Cannot use both defaultFlagHandler and offlineHandler.');
+});
+
+test('cannot create Flagsmith client in remote evaluation without API key', () => {
+    // When and Then
+    // @ts-ignore
+    expect(() => new Flagsmith()).toThrowError('ValueError: environmentKey is required.');
+});
+
 
 function sleep(ms: number) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);
     });
 }
+test('test_localEvaluation_true__identity_overrides_evaluated', async () => {
+    // @ts-ignore
+    fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+
+    const flg = new Flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true,
+    });
+
+    const flags = await flg.getIdentityFlags("overridden-id");
+    expect(flags.getFeatureValue("some_feature")).toEqual("some-overridden-value");
+});

package/tests/sdk/offline-handlers.test.ts

@@ -0,0 +1,33 @@
+import * as fs from 'fs';
+import { LocalFileHandler } from '../../sdk/offline_handlers';
+import { EnvironmentModel } from '../../flagsmith-engine';
+
+const offlineEnvironment = require('./data/offline-environment.json');
+
+jest.mock('fs')
+
+const offlineEnvironmentString = JSON.stringify(offlineEnvironment)
+
+test('local file handler', () => {
+  const environmentDocumentFilePath = '/some/path/environment.json';
+
+  // Mock the fs.readFileSync function to return environmentJson
+
+  // @ts-ignore
+  const readFileSyncMock = jest.spyOn(fs, 'readFileSync');
+  readFileSyncMock.mockImplementation(() => offlineEnvironmentString);
+
+  // Given
+  const localFileHandler = new LocalFileHandler(environmentDocumentFilePath);
+
+  // When
+  const environmentModel = localFileHandler.getEnvironment();
+
+  // Then
+  expect(environmentModel).toBeInstanceOf(EnvironmentModel);
+  expect(environmentModel.apiKey).toBe('B62qaMZNwfiqT76p38ggrQ');
+  expect(readFileSyncMock).toHaveBeenCalledWith(environmentDocumentFilePath, 'utf8');
+
+  // Restore the original implementation of fs.readFileSync
+  readFileSyncMock.mockRestore();
+});

package/tests/sdk/utils.ts

@@ -42,8 +42,8 @@ export function flagsmith(params = {}) {
     });
 }
 
-export function environmentJSON() {
-    return readFileSync(DATA_DIR + 'environment.json', 'utf-8');
+export function environmentJSON(environmentFilename: string = 'environment.json') {
+    return readFileSync(DATA_DIR + environmentFilename, 'utf-8');
 }
 
 export function environmentModel(environmentJSON: any) {

package/build/flagsmith-engine/environments/integrations/models.d.ts

@@ -1,4 +0,0 @@
-export declare class IntegrationModel {
-    api_key?: string;
-    base_url?: string;
-}

package/build/flagsmith-engine/environments/integrations/models.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegrationModel = void 0;
-var IntegrationModel = /** @class */ (function () {
-    function IntegrationModel() {
-        this.api_key = undefined;
-        this.base_url = undefined;
-    }
-    return IntegrationModel;
-}());
-exports.IntegrationModel = IntegrationModel;

package/examples/README.md

@@ -1,3 +0,0 @@
-# Flagsmith NodeJS Examples
-
-Check out our [NodeJS Examples repository](https://github.com/Flagsmith/flagsmith-nodejs-examples).

package/flagsmith-engine/environments/integrations/models.ts

@@ -1,4 +0,0 @@
-export class IntegrationModel {
-    api_key?: string = undefined;
-    base_url?: string = undefined;
-}