flagsmith-nodejs 6.0.1 → 6.2.0

package/tests/engine/unit/segments/segment_evaluators.test.ts

@@ -1,44 +1,70 @@
 import {
     ALL_RULE,
     CONDITION_OPERATORS,
-    PERCENTAGE_SPLIT,
+    PERCENTAGE_SPLIT
 } from '../../../../flagsmith-engine/segments/constants.js';
-import {SegmentConditionModel} from '../../../../flagsmith-engine/segments/models.js';
-import {traitsMatchSegmentCondition, evaluateIdentityInSegment} from "../../../../flagsmith-engine/segments/evaluators.js";
-import {TraitModel, IdentityModel} from "../../../../flagsmith-engine/index.js";
-import {environment} from "../utils.js";
+import { SegmentConditionModel } from '../../../../flagsmith-engine/segments/models.js';
+import {
+    traitsMatchSegmentCondition,
+    evaluateIdentityInSegment
+} from '../../../../flagsmith-engine/segments/evaluators.js';
+import { TraitModel, IdentityModel } from '../../../../flagsmith-engine/index.js';
+import { environment } from '../utils.js';
 import { buildSegmentModel } from '../../../../flagsmith-engine/segments/util.js';
 import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing/index.js';
 
-
 // todo: work out how to implement this in a test function or before hook
 vi.mock('../../../../flagsmith-engine/utils/hashing', () => ({
     getHashedPercentateForObjIds: vi.fn(() => 1)
 }));
 
-
-let traitExistenceTestCases: [string, string | null | undefined, string | null | undefined, TraitModel [],boolean][] = [
-    [CONDITION_OPERATORS.IS_SET,'foo', null,[] , false],
-    [CONDITION_OPERATORS.IS_SET, 'foo',undefined , [new TraitModel('foo','bar')], true],
-    [CONDITION_OPERATORS.IS_SET, 'foo',undefined , [new TraitModel('foo','bar'), new TraitModel('fooBaz','baz')], true],
+let traitExistenceTestCases: [
+    string,
+    string | null | undefined,
+    string | null | undefined,
+    TraitModel[],
+    boolean
+][] = [
+    [CONDITION_OPERATORS.IS_SET, 'foo', null, [], false],
+    [CONDITION_OPERATORS.IS_SET, 'foo', undefined, [new TraitModel('foo', 'bar')], true],
+    [
+        CONDITION_OPERATORS.IS_SET,
+        'foo',
+        undefined,
+        [new TraitModel('foo', 'bar'), new TraitModel('fooBaz', 'baz')],
+        true
+    ],
     [CONDITION_OPERATORS.IS_NOT_SET, 'foo', undefined, [], true],
-    [CONDITION_OPERATORS.IS_NOT_SET, 'foo', null, [new TraitModel('foo','bar')], false],
-    [CONDITION_OPERATORS.IS_NOT_SET, 'foo', null, [new TraitModel('foo','bar'), new TraitModel('fooBaz','baz')], false]
+    [CONDITION_OPERATORS.IS_NOT_SET, 'foo', null, [new TraitModel('foo', 'bar')], false],
+    [
+        CONDITION_OPERATORS.IS_NOT_SET,
+        'foo',
+        null,
+        [new TraitModel('foo', 'bar'), new TraitModel('fooBaz', 'baz')],
+        false
+    ]
 ];
 
 test('test_traits_match_segment_condition_for_trait_existence_operators', () => {
     for (const testCase of traitExistenceTestCases) {
-        const [operator, conditionProperty, conditionValue, traits, expectedResult] = testCase
-        let segmentModel = new SegmentConditionModel(operator, conditionValue, conditionProperty)
-        expect(
-           traitsMatchSegmentCondition (traits, segmentModel, 'any','any')
-        ).toBe(expectedResult);
+        const [operator, conditionProperty, conditionValue, traits, expectedResult] = testCase;
+        let segmentModel = new SegmentConditionModel(operator, conditionValue, conditionProperty);
+        expect(traitsMatchSegmentCondition(traits, segmentModel, 'any', 'any')).toBe(
+            expectedResult
+        );
     }
 });
 
-
 test('evaluateIdentityInSegment uses django ID for hashed percentage when present', () => {
-    var identityModel = new IdentityModel(Date.now().toString(), [], [], environment().apiKey, 'identity_1', undefined, 1);
+    var identityModel = new IdentityModel(
+        Date.now().toString(),
+        [],
+        [],
+        environment().apiKey,
+        'identity_1',
+        undefined,
+        1
+    );
     const segmentDefinition = {
         id: 1,
         name: 'percentage_split_segment',
@@ -49,7 +75,7 @@ test('evaluateIdentityInSegment uses django ID for hashed percentage when presen
                     {
                         operator: PERCENTAGE_SPLIT,
                         property_: null,
-                        value: "10"
+                        value: '10'
                     }
                 ],
                 rules: []
@@ -62,6 +88,9 @@ test('evaluateIdentityInSegment uses django ID for hashed percentage when presen
     var result = evaluateIdentityInSegment(identityModel, segmentModel);
 
     expect(result).toBe(true);
-    expect(getHashedPercentateForObjIds).toHaveBeenCalledTimes(1)
-    expect(getHashedPercentateForObjIds).toHaveBeenCalledWith([segmentModel.id, identityModel.djangoID])
+    expect(getHashedPercentateForObjIds).toHaveBeenCalledTimes(1);
+    expect(getHashedPercentateForObjIds).toHaveBeenCalledWith([
+        segmentModel.id,
+        identityModel.djangoID
+    ]);
 });

package/tests/engine/unit/segments/segments_model.test.ts

@@ -65,49 +65,47 @@ const conditionMatchCases: [string, string | number | boolean | null, string, bo
     [CONDITION_OPERATORS.REGEX, 'foo', '[a-z]+', true],
     [CONDITION_OPERATORS.REGEX, 'FOO', '[a-z]+', false],
     [CONDITION_OPERATORS.REGEX, null, '[a-z]+', false],
-    [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.0:semver", true],
-    [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.0:semver", true],
-    [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.1:semver", false],
-    [CONDITION_OPERATORS.NOT_EQUAL, "1.0.0", "1.0.0:semver", false],
-    [CONDITION_OPERATORS.NOT_EQUAL, "1.0.0", "1.0.1:semver", true],
-    [CONDITION_OPERATORS.GREATER_THAN, "1.0.1", "1.0.0:semver", true],
-    [CONDITION_OPERATORS.GREATER_THAN, "1.0.0", "1.0.0-beta:semver", true],
-    [CONDITION_OPERATORS.GREATER_THAN, "1.0.1", "1.2.0:semver", false],
-    [CONDITION_OPERATORS.GREATER_THAN, "1.0.1", "1.0.1:semver", false],
-    [CONDITION_OPERATORS.GREATER_THAN, "1.2.4", "1.2.3-pre.2+build.4:semver", true],
-    [CONDITION_OPERATORS.LESS_THAN, "1.0.0", "1.0.1:semver", true],
-    [CONDITION_OPERATORS.LESS_THAN, "1.0.0", "1.0.0:semver", false],
-    [CONDITION_OPERATORS.LESS_THAN, "1.0.1", "1.0.0:semver", false],
-    [CONDITION_OPERATORS.LESS_THAN, "1.0.0-rc.2", "1.0.0-rc.3:semver", true],
-    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, "1.0.1", "1.0.0:semver", true],
-    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, "1.0.1", "1.2.0:semver", false],
-    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, "1.0.1", "1.0.1:semver", true],
-    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, "1.0.0", "1.0.1:semver", true],
-    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, "1.0.0", "1.0.0:semver", true],
-    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, "1.0.1", "1.0.0:semver", false],
-    [CONDITION_OPERATORS.MODULO, 1, "2|0", false],
-    [CONDITION_OPERATORS.MODULO, 2, "2|0", true],
-    [CONDITION_OPERATORS.MODULO, 3, "2|0", false],
-    [CONDITION_OPERATORS.MODULO, 34.2, "4|3", false],
-    [CONDITION_OPERATORS.MODULO, 35.0, "4|3", true],
-    [CONDITION_OPERATORS.MODULO, "foo", "4|3", false],
-    [CONDITION_OPERATORS.MODULO, 35.0, "foo|bar", false],
-    [CONDITION_OPERATORS.IN, "foo", "", false],
-    [CONDITION_OPERATORS.IN, "foo", "foo, bar", true],
-    [CONDITION_OPERATORS.IN, "foo", "foo", true],
-    [CONDITION_OPERATORS.IN, 1, "1,2,3,4", true],
-    [CONDITION_OPERATORS.IN, 1, "", false],
-    [CONDITION_OPERATORS.IN, 1, "1", true],
+    [CONDITION_OPERATORS.EQUAL, '1.0.0', '1.0.0:semver', true],
+    [CONDITION_OPERATORS.EQUAL, '1.0.0', '1.0.0:semver', true],
+    [CONDITION_OPERATORS.EQUAL, '1.0.0', '1.0.1:semver', false],
+    [CONDITION_OPERATORS.NOT_EQUAL, '1.0.0', '1.0.0:semver', false],
+    [CONDITION_OPERATORS.NOT_EQUAL, '1.0.0', '1.0.1:semver', true],
+    [CONDITION_OPERATORS.GREATER_THAN, '1.0.1', '1.0.0:semver', true],
+    [CONDITION_OPERATORS.GREATER_THAN, '1.0.0', '1.0.0-beta:semver', true],
+    [CONDITION_OPERATORS.GREATER_THAN, '1.0.1', '1.2.0:semver', false],
+    [CONDITION_OPERATORS.GREATER_THAN, '1.0.1', '1.0.1:semver', false],
+    [CONDITION_OPERATORS.GREATER_THAN, '1.2.4', '1.2.3-pre.2+build.4:semver', true],
+    [CONDITION_OPERATORS.LESS_THAN, '1.0.0', '1.0.1:semver', true],
+    [CONDITION_OPERATORS.LESS_THAN, '1.0.0', '1.0.0:semver', false],
+    [CONDITION_OPERATORS.LESS_THAN, '1.0.1', '1.0.0:semver', false],
+    [CONDITION_OPERATORS.LESS_THAN, '1.0.0-rc.2', '1.0.0-rc.3:semver', true],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, '1.0.1', '1.0.0:semver', true],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, '1.0.1', '1.2.0:semver', false],
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE, '1.0.1', '1.0.1:semver', true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, '1.0.0', '1.0.1:semver', true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, '1.0.0', '1.0.0:semver', true],
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE, '1.0.1', '1.0.0:semver', false],
+    [CONDITION_OPERATORS.MODULO, 1, '2|0', false],
+    [CONDITION_OPERATORS.MODULO, 2, '2|0', true],
+    [CONDITION_OPERATORS.MODULO, 3, '2|0', false],
+    [CONDITION_OPERATORS.MODULO, 34.2, '4|3', false],
+    [CONDITION_OPERATORS.MODULO, 35.0, '4|3', true],
+    [CONDITION_OPERATORS.MODULO, 'foo', '4|3', false],
+    [CONDITION_OPERATORS.MODULO, 35.0, 'foo|bar', false],
+    [CONDITION_OPERATORS.IN, 'foo', '', false],
+    [CONDITION_OPERATORS.IN, 'foo', 'foo, bar', true],
+    [CONDITION_OPERATORS.IN, 'foo', 'foo', true],
+    [CONDITION_OPERATORS.IN, 1, '1,2,3,4', true],
+    [CONDITION_OPERATORS.IN, 1, '', false],
+    [CONDITION_OPERATORS.IN, 1, '1', true],
     ['BAD_OP', 'a', 'a', false]
 ];
 
 test('test_segment_condition_matches_trait_value', () => {
     for (const testCase of conditionMatchCases) {
-        const [operator, traitValue, conditionValue, expectedResult] = testCase
+        const [operator, traitValue, conditionValue, expectedResult] = testCase;
         expect(
-            new SegmentConditionModel(operator, conditionValue, 'foo').matchesTraitValue(
-                traitValue
-            )
+            new SegmentConditionModel(operator, conditionValue, 'foo').matchesTraitValue(traitValue)
         ).toBe(expectedResult);
     }
 });

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,48 @@
-import {analyticsProcessor, fetch} from './utils.js';
+import { getUserAgent } from '../../sdk/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',
+                'User-Agent': getUserAgent()
+            },
+            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 +54,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 +70,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');
 });