flagsmith-nodejs 6.0.1 → 6.1.0

package/tests/engine/unit/utils/utils.test.ts

@@ -2,60 +2,58 @@ import { randomUUID as uuidv4 } from 'node:crypto';
 import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing/index.js';
 
 describe('getHashedPercentageForObjIds', () => {
-    it.each([
-        [[12, 93]],
-        [[uuidv4(), 99]],
-        [[99, uuidv4()]],
-        [[uuidv4(), uuidv4()]]
-    ])('returns x where 0 <= x < 100', (objIds: (string|number)[]) => {
-        let result = getHashedPercentateForObjIds(objIds);
-        expect(result).toBeLessThan(100);
-        expect(result).toBeGreaterThanOrEqual(0);
-    });
-
-    it.each([
-        [[12, 93]],
-        [[uuidv4(), 99]],
-        [[99, uuidv4()]],
-        [[uuidv4(), uuidv4()]]
-    ])('returns the same value each time', (objIds: (string|number)[]) => {
-        let resultOne = getHashedPercentateForObjIds(objIds);
-        let resultTwo = getHashedPercentateForObjIds(objIds);
-        expect(resultOne).toEqual(resultTwo);
-    })
+    it.each([[[12, 93]], [[uuidv4(), 99]], [[99, uuidv4()]], [[uuidv4(), uuidv4()]]])(
+        'returns x where 0 <= x < 100',
+        (objIds: (string | number)[]) => {
+            let result = getHashedPercentateForObjIds(objIds);
+            expect(result).toBeLessThan(100);
+            expect(result).toBeGreaterThanOrEqual(0);
+        }
+    );
+
+    it.each([[[12, 93]], [[uuidv4(), 99]], [[99, uuidv4()]], [[uuidv4(), uuidv4()]]])(
+        'returns the same value each time',
+        (objIds: (string | number)[]) => {
+            let resultOne = getHashedPercentateForObjIds(objIds);
+            let resultTwo = getHashedPercentateForObjIds(objIds);
+            expect(resultOne).toEqual(resultTwo);
+        }
+    );
 
     it('is unique for different object ids', () => {
         let resultOne = getHashedPercentateForObjIds([14, 106]);
         let resultTwo = getHashedPercentateForObjIds([53, 200]);
         expect(resultOne).not.toEqual(resultTwo);
-    })
+    });
 
     it('is evenly distributed', () => {
         // copied from python test here:
         // https://github.com/Flagsmith/flagsmith-engine/blob/main/tests/unit/utils/test_utils_hashing.py#L56
         const testSample = 500;
         const numTestBuckets = 50;
-        const testBucketSize = Math.floor(testSample / numTestBuckets)
-        const errorFactor = 0.1
+        const testBucketSize = Math.floor(testSample / numTestBuckets);
+        const errorFactor = 0.1;
 
         // Given
-        let objectIdPairs = Array.from(Array(testSample).keys()).flatMap(d => Array.from(Array(testSample).keys()).map(e => [d, e].flat()))
+        let objectIdPairs = Array.from(Array(testSample).keys()).flatMap(d =>
+            Array.from(Array(testSample).keys()).map(e => [d, e].flat())
+        );
 
         // When
-        let values = objectIdPairs.map((objIds) => getHashedPercentateForObjIds(objIds));
+        let values = objectIdPairs.map(objIds => getHashedPercentateForObjIds(objIds));
 
         // Then
         for (let i = 0; i++; i < numTestBuckets) {
             let bucketStart = i * testBucketSize;
             let bucketEnd = (i + 1) * testBucketSize;
             let bucketValueLimit = Math.min(
-                (i + 1) / numTestBuckets + errorFactor + ((i + 1) / numTestBuckets),
+                (i + 1) / numTestBuckets + errorFactor + (i + 1) / numTestBuckets,
                 1
-            )
+            );
 
             for (let i = bucketStart; i++; i < bucketEnd) {
                 expect(values[i]).toBeLessThanOrEqual(bucketValueLimit);
             }
         }
-    })
-})
+    });
+});

package/tests/sdk/analytics.test.ts

@@ -1,40 +1,43 @@
-import {analyticsProcessor, fetch} from './utils.js';
+import { analyticsProcessor, fetch } from './utils.js';
 
 test('test_analytics_processor_track_feature_updates_analytics_data', () => {
     const aP = analyticsProcessor();
-    aP.trackFeature("myFeature");
-    expect(aP.analyticsData["myFeature"]).toBe(1);
+    aP.trackFeature('myFeature');
+    expect(aP.analyticsData['myFeature']).toBe(1);
 
-    aP.trackFeature("myFeature");
-    expect(aP.analyticsData["myFeature"]).toBe(2);
+    aP.trackFeature('myFeature');
+    expect(aP.analyticsData['myFeature']).toBe(2);
 });
 
 test('test_analytics_processor_flush_clears_analytics_data', async () => {
     const aP = analyticsProcessor();
-    aP.trackFeature("myFeature");
+    aP.trackFeature('myFeature');
     await aP.flush();
     expect(aP.analyticsData).toStrictEqual({});
 });
 
 test('test_analytics_processor_flush_post_request_data_match_ananlytics_data', async () => {
     const aP = analyticsProcessor();
-    aP.trackFeature("myFeature1");
-    aP.trackFeature("myFeature2");
+    aP.trackFeature('myFeature1');
+    aP.trackFeature('myFeature2');
     await aP.flush();
     expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith('http://testUrl/analytics/flags/', expect.objectContaining({
-        body: '{"myFeature1":1,"myFeature2":1}',
-        headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'test-key' },
-        method: 'POST',
-    }));
+    expect(fetch).toHaveBeenCalledWith(
+        'http://testUrl/analytics/flags/',
+        expect.objectContaining({
+            body: '{"myFeature1":1,"myFeature2":1}',
+            headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'test-key' },
+            method: 'POST'
+        })
+    );
 });
 
-vi.useFakeTimers()
+vi.useFakeTimers();
 test('test_analytics_processor_flush_post_request_data_match_ananlytics_data_test', async () => {
     const aP = analyticsProcessor();
-    aP.trackFeature("myFeature1");
+    aP.trackFeature('myFeature1');
     setTimeout(() => {
-        aP.trackFeature("myFeature2");
+        aP.trackFeature('myFeature2');
         expect(fetch).toHaveBeenCalledTimes(1);
     }, 15000);
     vi.runOnlyPendingTimers();
@@ -46,7 +49,6 @@ test('test_analytics_processor_flush_early_exit_if_analytics_data_is_empty', asy
     expect(fetch).not.toHaveBeenCalled();
 });
 
-
 test('errors in fetch sending analytics data are swallowed', async () => {
     // Given
     // we mock the fetch function to throw and error to mimick a network failure
@@ -63,21 +65,18 @@ test('errors in fetch sending analytics data are swallowed', async () => {
     // Then
     // we expect that fetch was called but the exception was handled
     expect(fetch).toHaveBeenCalled();
-})
+});
 
 test('analytics is only flushed once even if requested concurrently', async () => {
     const processor = analyticsProcessor();
     processor.trackFeature('myFeature');
     fetch.mockImplementation(() => {
         return new Promise((resolve, _) => {
-            setTimeout(resolve, 1000)
-        })
+            setTimeout(resolve, 1000);
+        });
     });
-    const flushes = Promise.all([
-        processor.flush(),
-        processor.flush(),
-    ])
+    const flushes = Promise.all([processor.flush(), processor.flush()]);
     vi.runOnlyPendingTimers();
     await flushes;
-    expect(fetch).toHaveBeenCalledTimes(1)
-})
+    expect(fetch).toHaveBeenCalledTimes(1);
+});

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

@@ -1,113 +1,121 @@
-import { fetch, environmentJSON, environmentModel, flagsJSON, flagsmith, identitiesJSON, TestCache } from './utils.js';
+import {
+    fetch,
+    environmentJSON,
+    environmentModel,
+    flagsJSON,
+    flagsmith,
+    identitiesJSON,
+    TestCache
+} from './utils.js';
 
 test('test_empty_cache_not_read_but_populated', async () => {
-  const cache = new TestCache();
-  const set = vi.spyOn(cache, 'set');
+    const cache = new TestCache();
+    const set = vi.spyOn(cache, 'set');
 
-  const flg = flagsmith({ cache });
-  const allFlags = (await flg.getEnvironmentFlags()).allFlags();
+    const flg = flagsmith({ cache });
+    const allFlags = (await flg.getEnvironmentFlags()).allFlags();
 
-  expect(set).toBeCalled();
-  expect(await cache.get('flags')).toBeTruthy();
+    expect(set).toBeCalled();
+    expect(await cache.get('flags')).toBeTruthy();
 
-  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_api_not_called_when_cache_present', async () => {
-  const cache = new TestCache();
-  const set = vi.spyOn(cache, 'set');
+    const cache = new TestCache();
+    const set = vi.spyOn(cache, 'set');
 
-  const flg = flagsmith({ cache });
-  await (await flg.getEnvironmentFlags()).allFlags();
-  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+    const flg = flagsmith({ cache });
+    await (await flg.getEnvironmentFlags()).allFlags();
+    const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
 
-  expect(set).toBeCalled();
-  expect(await cache.get('flags')).toBeTruthy();
+    expect(set).toBeCalled();
+    expect(await cache.get('flags')).toBeTruthy();
 
-  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_api_called_twice_when_no_cache', async () => {
-  fetch.mockImplementation(() => Promise.resolve(new Response(flagsJSON)));
+    fetch.mockImplementation(() => Promise.resolve(new Response(flagsJSON)));
 
-  const flg = flagsmith();
-  await (await flg.getEnvironmentFlags()).allFlags();
+    const flg = flagsmith();
+    await (await flg.getEnvironmentFlags()).allFlags();
 
-  const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
+    const allFlags = await (await flg.getEnvironmentFlags()).allFlags();
 
-  expect(fetch).toBeCalledTimes(2);
-  expect(allFlags[0].enabled).toBe(true);
-  expect(allFlags[0].value).toBe('some-value');
-  expect(allFlags[0].featureName).toBe('some_feature');
+    expect(fetch).toBeCalledTimes(2);
+    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 () => {
-  const cache = new TestCache();
-  const set = vi.spyOn(cache, 'set');
-
-  const flg = flagsmith({ cache, environmentKey: 'ser.key', enableLocalEvaluation: true });
-  const model = environmentModel(JSON.parse(environmentJSON));
-  const getEnvironment = vi.spyOn(flg, 'getEnvironment')
-  getEnvironment.mockResolvedValue(model)
-
-  const allFlags = (await flg.getEnvironmentFlags()).allFlags();
-
-  expect(set).toBeCalled();
-  expect(fetch).toBeCalledTimes(0);
-  expect(getEnvironment).toBeCalledTimes(1);
-  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);
+    const cache = new TestCache();
+    const set = vi.spyOn(cache, 'set');
+
+    const flg = flagsmith({ cache, environmentKey: 'ser.key', enableLocalEvaluation: true });
+    const model = environmentModel(JSON.parse(environmentJSON));
+    const getEnvironment = vi.spyOn(flg, 'getEnvironment');
+    getEnvironment.mockResolvedValue(model);
+
+    const allFlags = (await flg.getEnvironmentFlags()).allFlags();
+
+    expect(set).toBeCalled();
+    expect(fetch).toBeCalledTimes(0);
+    expect(getEnvironment).toBeCalledTimes(1);
+    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_cache_used_for_identity_flags', async () => {
-  const cache = new TestCache();
-  const set = vi.spyOn(cache, 'set');
+    const cache = new TestCache();
+    const set = vi.spyOn(cache, 'set');
 
-  const identifier = 'identifier';
-  const traits = { some_trait: 'some_value' };
-  const flg = flagsmith({ cache });
+    const identifier = 'identifier';
+    const traits = { some_trait: 'some_value' };
+    const flg = flagsmith({ cache });
 
-  (await flg.getIdentityFlags(identifier, traits)).allFlags();
-  const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+    (await flg.getIdentityFlags(identifier, traits)).allFlags();
+    const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
 
-  expect(set).toBeCalled();
-  expect(await cache.get('flags-identifier')).toBeTruthy();
+    expect(set).toBeCalled();
+    expect(await cache.get('flags-identifier')).toBeTruthy();
 
-  expect(fetch).toBeCalledTimes(1);
+    expect(fetch).toBeCalledTimes(1);
 
-  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_cache_used_for_identity_flags_local_evaluation', async () => {
-  const cache = new TestCache();
-  const set = vi.spyOn(cache, 'set');
+    const cache = new TestCache();
+    const set = vi.spyOn(cache, 'set');
 
-  const identifier = 'identifier';
-  const traits = { some_trait: 'some_value' };
-  const flg = flagsmith({
-    cache,
-    environmentKey: 'ser.key',
-    enableLocalEvaluation: true,
-  });
+    const identifier = 'identifier';
+    const traits = { some_trait: 'some_value' };
+    const flg = flagsmith({
+        cache,
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
 
-  (await flg.getIdentityFlags(identifier, traits)).allFlags();
-  const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
+    (await flg.getIdentityFlags(identifier, traits)).allFlags();
+    const identityFlags = (await flg.getIdentityFlags(identifier, traits)).allFlags();
 
-  expect(set).toBeCalled();
-  expect(await cache.get('flags-identifier')).toBeTruthy();
+    expect(set).toBeCalled();
+    expect(await cache.get('flags-identifier')).toBeTruthy();
 
-  expect(fetch).toBeCalledTimes(1);
+    expect(fetch).toBeCalledTimes(1);
 
-  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');
 });

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

@@ -5,150 +5,150 @@ import { DefaultFlag } from '../../sdk/models.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_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');
 });