flagsmith-nodejs 6.0.1 → 6.2.0

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

@@ -1,154 +1,182 @@
 import Flagsmith from '../../sdk/index.js';
 import { environmentJSON, environmentModel, flagsJSON, flagsmith, fetch } from './utils.js';
 import { DefaultFlag } from '../../sdk/models.js';
+import { getUserAgent } from '../../sdk/utils.js';
 
 vi.mock('../../sdk/polling_manager');
 
 test('test_get_environment_flags_calls_api_when_no_local_environment', async () => {
-  const flg = flagsmith();
-  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+    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');
+    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_default_flag_is_used_when_no_environment_flags_returned', async () => {
-  fetch.mockResolvedValue(new Response(JSON.stringify([])));
+    fetch.mockResolvedValue(new Response(JSON.stringify([])));
 
-  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 = new Flagsmith({
-      environmentKey: 'key',
-      defaultFlagHandler: defaultFlagHandler,
-      customHeaders: {
-          'X-Test-Header': '1',
-      }
-  });
+    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);
+    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 () => {
-  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,
-      enableAnalytics: true,
-  });
+    const flg = flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler,
+        enableAnalytics: true
+    });
 
-  const flags = await flg.getEnvironmentFlags();
-  const flag = flags.getFlag('some_feature');
+    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');
+    expect(flag.isDefault).toBe(false);
+    expect(flag.enabled).toBe(true);
+    expect(flag.value).toBe('some-value');
 });
 
 test('test_getFeatureValue', 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,
-      enableAnalytics: true,
-  });
+    const flg = flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler,
+        enableAnalytics: true
+    });
 
-  const flags = await flg.getEnvironmentFlags();
-  const featureValue = flags.getFeatureValue('some_feature');
+    const flags = await flg.getEnvironmentFlags();
+    const featureValue = flags.getFeatureValue('some_feature');
 
-  expect(featureValue).toBe('some-value');
+    expect(featureValue).toBe('some-value');
+});
+
+test('test_user_agent_is_set_when_fetching_environment_flags', async () => {
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+    const flg = flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler,
+        enableAnalytics: true
+    });
+    const flags = await flg.getEnvironmentFlags();
+    const featureValue = flags.getFeatureValue('some_feature');
+
+    expect(featureValue).toBe('some-value');
+    expect(fetch).toHaveBeenCalledWith(
+        `https://edge.api.flagsmith.com/api/v1/flags/`,
+        expect.objectContaining({
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Environment-Key': 'key',
+                'User-Agent': getUserAgent()
+            }
+        })
+    );
 });
 
 test('test_throws_when_no_default_flag_handler_after_multiple_API_errors', async () => {
-  fetch.mockRejectedValue('Error during fetching the API response');
+    fetch.mockRejectedValue('Error during fetching the API response');
 
-  const flg = flagsmith({
-      environmentKey: 'key',
-  });
+    const flg = flagsmith({
+        environmentKey: 'key'
+    });
 
-  await expect(async () => {
-      const flags = await flg.getEnvironmentFlags();
-      const flag = flags.getFlag('some_feature');
-  }).rejects.toThrow('getEnvironmentFlags failed and no default flag handler was provided');
+    await expect(async () => {
+        const flags = await flg.getEnvironmentFlags();
+        const flag = flags.getFlag('some_feature');
+    }).rejects.toThrow('getEnvironmentFlags failed and no default flag handler was provided');
 });
 
 test('test_non_200_response_raises_flagsmith_api_error', async () => {
-  const errorResponse403 = new Response('403 Forbidden', {
-      status: 403
-  });
-  fetch.mockResolvedValue(errorResponse403);
+    const errorResponse403 = new Response('403 Forbidden', {
+        status: 403
+    });
+    fetch.mockResolvedValue(errorResponse403);
 
-  const flg = new Flagsmith({
-      environmentKey: 'some'
-  });
+    const flg = new Flagsmith({
+        environmentKey: 'some'
+    });
 
-  await expect(flg.getEnvironmentFlags()).rejects.toThrow();
+    await expect(flg.getEnvironmentFlags()).rejects.toThrow();
 });
 test('test_default_flag_is_not_used_when_environment_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.getEnvironmentFlags();
-  const flag = flags.getFlag('some_feature');
+    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');
+    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 () => {
-  fetch.mockResolvedValue(new Response('bad-data'));
+    fetch.mockResolvedValue(new Response('bad-data'));
 
-  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 = new Flagsmith({
-      environmentKey: 'key',
-      defaultFlagHandler: defaultFlagHandler
-  });
+    const flg = new Flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler
+    });
 
-  const flags = await flg.getEnvironmentFlags();
-  const flag = flags.getFlag('some_feature');
+    const flags = await flg.getEnvironmentFlags();
+    const flag = flags.getFlag('some_feature');
 
-  expect(flag.isDefault).toBe(true);
-  expect(flag.value).toBe(defaultFlag.value);
+    expect(flag.isDefault).toBe(true);
+    expect(flag.value).toBe(defaultFlag.value);
 });
 
 test('test_local_evaluation', 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: 'ser.key',
-      enableLocalEvaluation: true,
-      defaultFlagHandler: defaultFlagHandler
-  });
+    const flg = flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true,
+        defaultFlagHandler: defaultFlagHandler
+    });
 
-  const flags = await flg.getEnvironmentFlags();
-  const flag = flags.getFlag('some_feature');
+    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');
+    expect(flag.isDefault).toBe(false);
+    expect(flag.value).not.toBe(defaultFlag.value);
+    expect(flag.value).toBe('some-value');
 });

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

@@ -1,213 +1,219 @@
 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';
+import { getUserAgent } from '../../sdk/utils.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',
+                'User-Agent': getUserAgent()
+            },
+            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',
+                'User-Agent': getUserAgent()
+            },
+            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'
+    );
+});