flagsmith-nodejs 6.0.1 → 6.1.0

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

@@ -1,213 +1,210 @@
 import Flagsmith from '../../sdk/index.js';
 import {
-  fetch,
-  environmentJSON,
-  flagsmith,
-  identitiesJSON,
-  identityWithTransientTraitsJSON,
-  transientIdentityJSON,
-  badFetch
+    fetch,
+    environmentJSON,
+    flagsmith,
+    identitiesJSON,
+    identityWithTransientTraitsJSON,
+    transientIdentityJSON,
+    badFetch
 } from './utils.js';
 import { DefaultFlag } from '../../sdk/models.js';
 
 vi.mock('../../sdk/polling_manager');
 
 test('test_get_identity_flags_calls_api_when_no_local_environment_no_traits', async () => {
-  const identifier = 'identifier';
+    const identifier = 'identifier';
 
-  const flg = flagsmith();
+    const flg = flagsmith();
 
-  const identityFlags = (await flg.getIdentityFlags(identifier)).allFlags();
+    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');
+    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_uses_environment_when_local_environment_no_traits', async () => {
-  const identifier = 'identifier';
+    const identifier = 'identifier';
 
-  const flg = flagsmith({
-    environmentKey: 'ser.key',
-    enableLocalEvaluation: true,
-  });
+    const flg = flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
 
+    const identityFlags = (await flg.getIdentityFlags(identifier)).allFlags();
 
-  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');
+    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 () => {
-  const identifier = 'identifier';
-  const traits = { some_trait: 'some_value' };
-  const flg = flagsmith();
+    const identifier = 'identifier';
+    const traits = { some_trait: 'some_value' };
+    const flg = flagsmith();
 
-  const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+    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');
+    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_not_used_when_identity_flags_returned', async () => {
-  const defaultFlag = new DefaultFlag('some-default-value', true);
+    const defaultFlag = new DefaultFlag('some-default-value', true);
 
-  const defaultFlagHandler = (featureName: string) => defaultFlag;
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
 
-  const flg = flagsmith({
-      environmentKey: 'key',
-      defaultFlagHandler: defaultFlagHandler
-  });
+    const flg = flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
 
-  const flags = await flg.getIdentityFlags('identifier');
-  const flag = flags.getFlag('some_feature');
+    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');
+    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 () => {
-  fetch.mockResolvedValue(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;
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
 
-  const flg = new Flagsmith({
-      environmentKey: 'key',
-      defaultFlagHandler: defaultFlagHandler
-  });
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
 
-  const flags = await flg.getIdentityFlags('identifier');
-  const flag = flags.getFlag('some_feature');
+    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);
+    expect(flag.isDefault).toBe(true);
+    expect(flag.value).toBe(defaultFlag.value);
+    expect(flag.enabled).toBe(defaultFlag.enabled);
 });
 
 test('test_default_flag_is_used_when_no_identity_flags_returned_due_to_error', async () => {
-  fetch.mockResolvedValue(new Response('bad data'))
+    fetch.mockResolvedValue(new Response('bad data'));
 
-  const defaultFlag = new DefaultFlag('some-default-value', true);
-  const defaultFlagHandler = (featureName: string) => defaultFlag;
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
 
-  const flg = new Flagsmith({
-      environmentKey: 'key',
-      defaultFlagHandler: defaultFlagHandler
-  });
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
 
-  const flags = await flg.getIdentityFlags('identifier');
-  const flag = flags.getFlag('some_feature');
+    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);
+    expect(flag.isDefault).toBe(true);
+    expect(flag.value).toBe(defaultFlag.value);
+    expect(flag.enabled).toBe(defaultFlag.enabled);
 });
 
 test('test_default_flag_is_used_when_no_identity_flags_returned_and_no_custom_default_flag_handler', async () => {
-  fetch.mockResolvedValue(new Response(JSON.stringify({ flags: [], traits: [] })))
+    fetch.mockResolvedValue(new Response(JSON.stringify({ flags: [], traits: [] })));
 
-  const flg = flagsmith({
-    environmentKey: 'key',
-  });
+    const flg = flagsmith({
+        environmentKey: 'key'
+    });
 
-  const flags = await flg.getIdentityFlags('identifier');
-  const flag = flags.getFlag('some_feature');
+    const flags = await flg.getIdentityFlags('identifier');
+    const flag = flags.getFlag('some_feature');
 
-  expect(flag.isDefault).toBe(true);
-  expect(flag.value).toBe(undefined);
-  expect(flag.enabled).toBe(false);
+    expect(flag.isDefault).toBe(true);
+    expect(flag.value).toBe(undefined);
+    expect(flag.enabled).toBe(false);
 });
 
 test('test_get_identity_flags_multivariate_value_with_local_evaluation_enabled', async () => {
-  fetch.mockResolvedValue(new Response(environmentJSON));
-  const identifier = 'identifier';
+    fetch.mockResolvedValue(new Response(environmentJSON));
+    const identifier = 'identifier';
 
-  const flg = flagsmith({
-      environmentKey: 'ser.key',
-      enableLocalEvaluation: true,
-  });
+    const flg = flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
 
-  const identityFlags = (await flg.getIdentityFlags(identifier))
+    const identityFlags = await flg.getIdentityFlags(identifier);
 
-  expect(identityFlags.getFeatureValue('mv_feature')).toBe('bar');
-  expect(identityFlags.isFeatureEnabled('mv_feature')).toBe(false);
+    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');
+    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');
+    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');
 });
 
 test('getIdentityFlags fails if API call failed and no default flag handler was provided', async () => {
-  const flg = flagsmith({
-    fetch: badFetch,
-  })
-  await expect(flg.getIdentityFlags('user'))
-      .rejects
-      .toThrow('getIdentityFlags failed and no default flag handler was provided')
-})
+    const flg = flagsmith({
+        fetch: badFetch
+    });
+    await expect(flg.getIdentityFlags('user')).rejects.toThrow(
+        'getIdentityFlags failed and no default flag handler was provided'
+    );
+});

package/tests/sdk/flagsmith.test.ts

@@ -29,26 +29,26 @@ test('test_flagsmith_local_evaluation_key_required', () => {
             environmentKey: 'bad.key',
             enableLocalEvaluation: true
         });
-    }).toThrow('Using local evaluation requires a server-side environment key')
+    }).toThrow('Using local evaluation requires a server-side environment key');
 });
 
 test('test_update_environment_sets_environment', async () => {
     const flg = flagsmith({
-        environmentKey: 'ser.key',
+        environmentKey: 'ser.key'
     });
     const model = environmentModel(JSON.parse(environmentJSON));
     expect(await flg.getEnvironment()).toStrictEqual(model);
 });
 
 test('test_set_agent_options', async () => {
-    const agent = new Agent({})
+    const agent = new Agent({});
 
     fetch.mockImplementationOnce((url, options) => {
         //@ts-ignore I give up
         if (options.dispatcher !== agent) {
-            throw new Error("Agent has not been set on retry fetch")
+            throw new Error('Agent has not been set on retry fetch');
         }
-        return Promise.resolve(new Response(environmentJSON))
+        return Promise.resolve(new Response(environmentJSON));
     });
 
     const flg = flagsmith({
@@ -69,7 +69,6 @@ test('test_get_identity_segments', async () => {
     expect(segments2.length).toEqual(0);
 });
 
-
 test('test_get_identity_segments_empty_without_local_eval', async () => {
     const flg = new Flagsmith({
         environmentKey: 'ser.key',
@@ -82,7 +81,7 @@ test('test_get_identity_segments_empty_without_local_eval', async () => {
 test('test_update_environment_uses_req_when_inited', async () => {
     const flg = flagsmith({
         environmentKey: 'ser.key',
-        enableLocalEvaluation: true,
+        enableLocalEvaluation: true
     });
 
     delay(400);
@@ -100,7 +99,7 @@ test('test_isFeatureEnabled_environment', async () => {
     const flg = new Flagsmith({
         environmentKey: 'key',
         defaultFlagHandler: defaultFlagHandler,
-        enableAnalytics: true,
+        enableAnalytics: true
     });
 
     const flags = await flg.getEnvironmentFlags();
@@ -110,9 +109,9 @@ test('test_isFeatureEnabled_environment', async () => {
 });
 
 test('test_fetch_recovers_after_single_API_error', async () => {
-    fetch.mockRejectedValueOnce('Error during fetching the API response')
+    fetch.mockRejectedValueOnce('Error during fetching the API response');
     const flg = flagsmith({
-        environmentKey: 'key',
+        environmentKey: 'key'
     });
 
     const flags = await flg.getEnvironmentFlags();
@@ -132,7 +131,7 @@ test.each([
             enableLocalEvaluation,
             environmentKey,
             defaultFlagHandler: () => new DefaultFlag('some-default-value', true),
-            fetch: badFetch,
+            fetch: badFetch
         });
         const flags = await flg.getEnvironmentFlags();
         const flag = flags.getFlag('some_feature');
@@ -144,9 +143,9 @@ test.each([
 
 test('default flag handler used when timeout occurs', async () => {
     fetch.mockImplementation(async (...args) => {
-        const forever = new Promise(() => {})
-        await forever
-        throw new Error('waited forever')
+        const forever = new Promise(() => {});
+        await forever;
+        throw new Error('waited forever');
     });
 
     const defaultFlag = new DefaultFlag('some-default-value', true);
@@ -156,7 +155,7 @@ test('default flag handler used when timeout occurs', async () => {
     const flg = flagsmith({
         environmentKey: 'key',
         defaultFlagHandler: defaultFlagHandler,
-        requestTimeoutSeconds: 0.0001,
+        requestTimeoutSeconds: 0.0001
     });
 
     const flags = await flg.getEnvironmentFlags();
@@ -164,35 +163,32 @@ test('default flag handler used when timeout occurs', async () => {
     expect(flag.isDefault).toBe(true);
     expect(flag.enabled).toBe(defaultFlag.enabled);
     expect(flag.value).toBe(defaultFlag.value);
-})
+});
 
 test('request timeout uses default if not provided', async () => {
-
     const flg = new Flagsmith({
-        environmentKey: 'key',
+        environmentKey: 'key'
     });
 
     expect(flg.requestTimeoutMs).toBe(10000);
-})
+});
 
 test('test_throws_when_no_identityFlags_returned_due_to_error', async () => {
     const flg = flagsmith({
         environmentKey: 'key',
-        fetch: badFetch,
+        fetch: badFetch
     });
 
-    await expect(async () => await flg.getIdentityFlags('identifier'))
-        .rejects
-        .toThrow();
+    await expect(async () => await flg.getIdentityFlags('identifier')).rejects.toThrow();
 });
 
 test('test onEnvironmentChange is called when provided', async () => {
-    const callback = vi.fn()
+    const callback = vi.fn();
 
     const flg = new Flagsmith({
         environmentKey: 'ser.key',
         enableLocalEvaluation: true,
-        onEnvironmentChange: callback,
+        onEnvironmentChange: callback
     });
 
     fetch.mockRejectedValueOnce(new Error('API error'));
@@ -209,7 +205,7 @@ test('test onEnvironmentChange is called after error', async () => {
         environmentKey: 'ser.key',
         enableLocalEvaluation: true,
         onEnvironmentChange: callback,
-        fetch: badFetch,
+        fetch: badFetch
     });
     await flg.updateEnvironment();
     expect(callback).toHaveBeenCalled();
@@ -217,15 +213,17 @@ test('test onEnvironmentChange is called after error', async () => {
 
 test('getIdentityFlags throws error if identifier is empty string', async () => {
     const flg = flagsmith({
-        environmentKey: 'key',
+        environmentKey: 'key'
     });
 
-    await expect(flg.getIdentityFlags('')).rejects.toThrow('`identifier` argument is missing or invalid.');
-})
+    await expect(flg.getIdentityFlags('')).rejects.toThrow(
+        '`identifier` argument is missing or invalid.'
+    );
+});
 
 test('getIdentitySegments throws error if identifier is empty string', async () => {
     const flg = flagsmith({
-        environmentKey: 'key',
+        environmentKey: 'key'
     });
 
     await expect(flg.getIdentitySegments('')).rejects.toThrow(
@@ -254,15 +252,13 @@ test('offline_mode', async () => {
     expect(flag.enabled).toBe(true);
     expect(flag.value).toBe('offline-value');
 
-
-    const identityFlags: Flags = await flg.getIdentityFlags("identity");
+    const identityFlags: Flags = await flg.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(offlineEnvironmentJSON));
@@ -281,14 +277,13 @@ test('test_flagsmith_uses_offline_handler_if_set_and_no_api_response', async ()
     vi.spyOn(flg, 'getEnvironmentFlags');
     vi.spyOn(flg, 'getIdentityFlags');
 
-
     flg.environmentFlagsUrl = 'http://some.flagsmith.com/api/v1/environment-flags';
     flg.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',
+        statusText: 'Internal Server Error'
     });
 
     fetch.mockResolvedValue(errorResponse);
@@ -318,25 +313,28 @@ test('cannot use offline mode without offline handler', () => {
 
 test('cannot use both default handler and offline handler', () => {
     // When and Then
-    expect(() => flagsmith({
-        offlineHandler: new BaseOfflineHandler(),
-        defaultFlagHandler: () => new DefaultFlag('foo', true)
-    })).toThrowError('ValueError: Cannot use both defaultFlagHandler and offlineHandler.');
+    expect(() =>
+        flagsmith({
+            offlineHandler: new BaseOfflineHandler(),
+            defaultFlagHandler: () => 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
-    expect(() => new Flagsmith({ environmentKey: '' })).toThrowError('ValueError: environmentKey is required.');
+    expect(() => new Flagsmith({ environmentKey: '' })).toThrowError(
+        'ValueError: environmentKey is required.'
+    );
 });
 
-
 test('test_localEvaluation_true__identity_overrides_evaluated', async () => {
     const flg = flagsmith({
         environmentKey: 'ser.key',
         enableLocalEvaluation: true
     });
 
-    await flg.updateEnvironment()
+    await flg.updateEnvironment();
     const flags = await flg.getIdentityFlags('overridden-id');
     expect(flags.getFeatureValue('some_feature')).toEqual('some-overridden-value');
 });