flagsmith-nodejs 3.3.3 → 4.0.0

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

@@ -1,14 +1,7 @@
-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');
+import { fetch, environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON, TestCache } from './utils.js';
 
 beforeEach(() => {
-  // @ts-ignore
-  jest.clearAllMocks();
+  vi.clearAllMocks();
 });
 
 test('test_wrong_cache_interface_throws_an_error', async () => {
@@ -21,14 +14,13 @@ test('test_wrong_cache_interface_throws_an_error', async () => {
 });
 
 test('test_empty_cache_not_read_but_populated', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const flg = flagsmith({ cache });
-  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+  const allFlags = (await flg.getEnvironmentFlags()).allFlags();
 
   expect(set).toBeCalled();
   expect(await cache.has('flags')).toBe(true);
@@ -40,11 +32,10 @@ test('test_empty_cache_not_read_but_populated', async () => {
 });
 
 test('test_api_not_called_when_cache_present', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const flg = flagsmith({ cache });
   await (await flg.getEnvironmentFlags()).allFlags();
@@ -60,13 +51,11 @@ test('test_api_not_called_when_cache_present', async () => {
 });
 
 test('test_api_called_twice_when_no_cache', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockImplementation(() => 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);
@@ -76,14 +65,13 @@ test('test_api_called_twice_when_no_cache', async () => {
 });
 
 test('test_get_environment_flags_uses_local_environment_when_available', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const flg = flagsmith({ cache });
-  const model = environmentModel(JSON.parse(environmentJSON()));
+  const model = environmentModel(JSON.parse(environmentJSON));
   flg.environment = model;
 
   const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
@@ -96,11 +84,10 @@ test('test_get_environment_flags_uses_local_environment_when_available', async (
 });
 
 test('test_cache_used_for_identity_flags', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+  fetch.mockResolvedValue(new Response(identitiesJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const identifier = 'identifier';
   const traits = { some_trait: 'some_value' };
@@ -120,11 +107,10 @@ test('test_cache_used_for_identity_flags', async () => {
 });
 
 test('test_cache_used_for_identity_flags_local_evaluation', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+  fetch.mockResolvedValue(new Response(environmentJSON));
 
   const cache = new TestCache();
-  const set = jest.spyOn(cache, 'set');
+  const set = vi.spyOn(cache, 'set');
 
   const identifier = 'identifier';
   const traits = { some_trait: 'some_value' };
@@ -146,5 +132,3 @@ test('test_cache_used_for_identity_flags_local_evaluation', async () => {
   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

@@ -1,20 +1,15 @@
-import Flagsmith from '../../sdk';
-import fetch from 'node-fetch';
-import { environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON } from './utils';
-import { DefaultFlag } from '../../sdk/models';
+import Flagsmith from '../../sdk/index.js';
+import { environmentJSON, environmentModel, flagsJSON, flagsmith, fetch } from './utils.js';
+import { DefaultFlag } from '../../sdk/models.js';
 
-jest.mock('node-fetch');
-jest.mock('../../sdk/polling_manager');
-const { Response } = jest.requireActual('node-fetch');
+vi.mock('../../sdk/polling_manager');
 
 beforeEach(() => {
-    // @ts-ignore
-    jest.clearAllMocks();
+    vi.clearAllMocks();
 });
 
 test('test_get_environment_flags_calls_api_when_no_local_environment', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const flg = flagsmith();
   const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
@@ -26,11 +21,10 @@ test('test_get_environment_flags_calls_api_when_no_local_environment', async ()
 });
 
 test('test_get_environment_flags_uses_local_environment_when_available', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const flg = flagsmith();
-  const model = environmentModel(JSON.parse(environmentJSON()));
+  const model = environmentModel(JSON.parse(environmentJSON));
   flg.environment = model;
 
   const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
@@ -41,8 +35,7 @@ test('test_get_environment_flags_uses_local_environment_when_available', async (
 });
 
 test('test_default_flag_is_used_when_no_environment_flags_returned', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify([]))));
+  fetch.mockResolvedValue(new Response(JSON.stringify([])));
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
 
@@ -64,14 +57,13 @@ test('test_default_flag_is_used_when_no_environment_flags_returned', async () =>
 });
 
 test('test_analytics_processor_tracks_flags', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
 
   const defaultFlagHandler = (featureName: string) => defaultFlag;
 
-  const flg = new Flagsmith({
+  const flg = flagsmith({
       environmentKey: 'key',
       defaultFlagHandler: defaultFlagHandler,
       enableAnalytics: true,
@@ -86,14 +78,13 @@ test('test_analytics_processor_tracks_flags', async () => {
 });
 
 test('test_getFeatureValue', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(flagsJSON())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
 
   const defaultFlagHandler = (featureName: string) => defaultFlag;
 
-  const flg = new Flagsmith({
+  const flg = flagsmith({
       environmentKey: 'key',
       defaultFlagHandler: defaultFlagHandler,
       enableAnalytics: true,
@@ -106,11 +97,9 @@ test('test_getFeatureValue', async () => {
 });
 
 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'));
+  fetch.mockRejectedValue('Error during fetching the API response');
 
-  const flg = new Flagsmith({
+  const flg = flagsmith({
       environmentKey: 'key',
   });
 
@@ -124,8 +113,7 @@ 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));
+  fetch.mockResolvedValue(errorResponse403);
 
   const flg = new Flagsmith({
       environmentKey: 'some'
@@ -134,14 +122,13 @@ test('test_non_200_response_raises_flagsmith_api_error', async () => {
   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())));
+  fetch.mockResolvedValue(new Response(flagsJSON));
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
 
   const defaultFlagHandler = (featureName: string) => defaultFlag;
 
-  const flg = new Flagsmith({
+  const flg = flagsmith({
       environmentKey: 'key',
       defaultFlagHandler: defaultFlagHandler
   });
@@ -155,8 +142,7 @@ test('test_default_flag_is_not_used_when_environment_flags_returned', async () =
 });
 
 test('test_default_flag_is_used_when_bad_api_response_happens', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response('bad-data')));
+  fetch.mockResolvedValue(new Response('bad-data'));
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
 
@@ -175,14 +161,13 @@ test('test_default_flag_is_used_when_bad_api_response_happens', async () => {
 });
 
 test('test_local_evaluation', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+  fetch.mockResolvedValue(new Response(environmentJSON));
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
 
   const defaultFlagHandler = (featureName: string) => defaultFlag;
 
-  const flg = new Flagsmith({
+  const flg = flagsmith({
       environmentKey: 'ser.key',
       enableLocalEvaluation: true,
       defaultFlagHandler: defaultFlagHandler

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

@@ -1,21 +1,16 @@
-import Flagsmith from '../../sdk';
-import fetch from 'node-fetch';
-import { environmentJSON, flagsmith, identitiesJSON } from './utils';
-import { DefaultFlag } from '../../sdk/models';
+import Flagsmith from '../../sdk/index.js';
+import { fetch, environmentJSON, flagsmith, identitiesJSON, identityWithTransientTraitsJSON, transientIdentityJSON } from './utils.js';
+import { DefaultFlag } from '../../sdk/models.js';
 
-jest.mock('node-fetch');
-jest.mock('../../sdk/polling_manager');
-const { Response } = jest.requireActual('node-fetch');
+vi.mock('../../sdk/polling_manager');
 
 beforeEach(() => {
-    // @ts-ignore
-    jest.clearAllMocks();
+  vi.clearAllMocks();
 });
 
 
 test('test_get_identity_flags_calls_api_when_no_local_environment_no_traits', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+  fetch.mockResolvedValue(new Response(identitiesJSON));
   const identifier = 'identifier';
 
   const flg = flagsmith();
@@ -28,14 +23,12 @@ test('test_get_identity_flags_calls_api_when_no_local_environment_no_traits', as
 });
 
 test('test_get_identity_flags_uses_environment_when_local_environment_no_traits', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+  fetch.mockResolvedValue(new Response(environmentJSON))
   const identifier = 'identifier';
 
   const flg = flagsmith({
-      environmentKey: 'ser.key',
-      enableLocalEvaluation: true,
-
+    environmentKey: 'ser.key',
+    enableLocalEvaluation: true,
   });
 
 
@@ -47,8 +40,7 @@ test('test_get_identity_flags_uses_environment_when_local_environment_no_traits'
 });
 
 test('test_get_identity_flags_calls_api_when_no_local_environment_with_traits', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+  fetch.mockResolvedValue(new Response(identitiesJSON))
   const identifier = 'identifier';
   const traits = { some_trait: 'some_value' };
   const flg = flagsmith();
@@ -61,14 +53,13 @@ test('test_get_identity_flags_calls_api_when_no_local_environment_with_traits',
 });
 
 test('test_default_flag_is_not_used_when_identity_flags_returned', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(identitiesJSON())));
+  fetch.mockResolvedValue(new Response(identitiesJSON))
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
 
   const defaultFlagHandler = (featureName: string) => defaultFlag;
 
-  const flg = new Flagsmith({
+  const flg = flagsmith({
       environmentKey: 'key',
       defaultFlagHandler: defaultFlagHandler
   });
@@ -82,8 +73,7 @@ test('test_default_flag_is_not_used_when_identity_flags_returned', async () => {
 });
 
 test('test_default_flag_is_used_when_no_identity_flags_returned', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify({ flags: [], traits: [] }))));
+  fetch.mockResolvedValue(new Response(JSON.stringify({ flags: [], traits: [] })));
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
   const defaultFlagHandler = (featureName: string) => defaultFlag;
@@ -102,8 +92,7 @@ test('test_default_flag_is_used_when_no_identity_flags_returned', async () => {
 });
 
 test('test_default_flag_is_used_when_no_identity_flags_returned_due_to_error', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response('bad data')));
+  fetch.mockResolvedValue(new Response('bad data'))
 
   const defaultFlag = new DefaultFlag('some-default-value', true);
   const defaultFlagHandler = (featureName: string) => defaultFlag;
@@ -122,12 +111,10 @@ test('test_default_flag_is_used_when_no_identity_flags_returned_due_to_error', a
 });
 
 test('test_default_flag_is_used_when_no_identity_flags_returned_and_no_custom_default_flag_handler', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(JSON.stringify({ flags: [], traits: [] }))));
-
+  fetch.mockResolvedValue(new Response(JSON.stringify({ flags: [], traits: [] })))
 
-  const flg = new Flagsmith({
-      environmentKey: 'key',
+  const flg = flagsmith({
+    environmentKey: 'key',
   });
 
   const flags = await flg.getIdentityFlags('identifier');
@@ -140,8 +127,7 @@ test('test_default_flag_is_used_when_no_identity_flags_returned_and_no_custom_de
 
 
 test('test_get_identity_flags_multivariate_value_with_local_evaluation_enabled', async () => {
-  // @ts-ignore
-  fetch.mockReturnValue(Promise.resolve(new Response(environmentJSON())));
+  fetch.mockResolvedValue(new Response(environmentJSON));
   const identifier = 'identifier';
 
   const flg = flagsmith({
@@ -155,3 +141,68 @@ test('test_get_identity_flags_multivariate_value_with_local_evaluation_enabled',
   expect(identityFlags.getFeatureValue('mv_feature')).toBe('bar');
   expect(identityFlags.isFeatureEnabled('mv_feature')).toBe(false);
 });
+
+
+test('test_transient_identity', async () => {
+  fetch.mockResolvedValue(new Response(transientIdentityJSON));
+  const identifier = 'transient_identifier';
+  const traits = { some_trait: 'some_value' };
+  const traitsInRequest = [{trait_key:Object.keys(traits)[0],trait_value:traits.some_trait}]
+  const transient = true;
+  const flg = flagsmith();
+  const identityFlags = (await flg.getIdentityFlags(identifier, traits, transient)).allFlags();
+
+  expect(fetch).toHaveBeenCalledWith(
+    `https://edge.api.flagsmith.com/api/v1/identities/`,
+    expect.objectContaining({
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'sometestfakekey' },
+      body: JSON.stringify({identifier, traits: traitsInRequest, transient })
+    }
+  ));
+
+  expect(identityFlags[0].enabled).toBe(false);
+  expect(identityFlags[0].value).toBe('some-transient-identity-value');
+  expect(identityFlags[0].featureName).toBe('some_feature');
+});
+
+
+test('test_identity_with_transient_traits', async () => {
+  fetch.mockResolvedValue(new Response(identityWithTransientTraitsJSON));
+  const identifier = 'transient_trait_identifier';
+  const traits = { 
+    some_trait: 'some_value',
+    another_trait: {value: 'another_value', transient: true},
+    explicitly_non_transient_trait: {value: 'non_transient_value', transient: false} 
+  }
+  const traitsInRequest = [
+    {
+      trait_key:Object.keys(traits)[0],
+      trait_value:traits.some_trait,
+    },
+    {
+      trait_key:Object.keys(traits)[1],
+      trait_value:traits.another_trait.value,
+      transient: true,
+    },
+    {
+      trait_key:Object.keys(traits)[2],
+      trait_value:traits.explicitly_non_transient_trait.value,
+      transient: false,
+    },
+  ]
+  const flg = flagsmith();
+
+  const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+  expect(fetch).toHaveBeenCalledWith(
+    `https://edge.api.flagsmith.com/api/v1/identities/`,
+    expect.objectContaining({
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'sometestfakekey' },
+      body: JSON.stringify({identifier, traits: traitsInRequest})
+    })
+  );
+  expect(identityFlags[0].enabled).toBe(true);
+  expect(identityFlags[0].value).toBe('some-identity-with-transient-trait-value');
+  expect(identityFlags[0].featureName).toBe('some_feature');
+});