Merge pull request #102 from Flagsmith/release/2.5.1

Release 2.5.1

Author: matthewelwell

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "description": "Flagsmith lets you manage features flags and remote config across web, mobile and server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.",
   "main": "build/index.js",
   "repository": {

package.json

@@ -173,6 +173,10 @@ export class Flagsmith {
      * @returns Flags object holding all the flags for the given identity.
      */
     async getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
+        if (!identifier) {
+            throw new Error("`identifier` argument is missing or invalid.")
+        }
+
         const cachedItem = !!this.cache && await this.cache.get(`flags-${identifier}`);
         if (!!cachedItem) {
             return cachedItem;
@@ -203,6 +207,10 @@ export class Flagsmith {
         identifier: string,
         traits?: { [key: string]: any }
     ): Promise<SegmentModel[]> {
+        if (!identifier) {
+            throw new Error("`identifier` argument is missing or invalid.")
+        }
+
         traits = traits || {};
         if (this.enableLocalEvaluation) {
             return new Promise((resolve, reject) => {
@@ -329,7 +337,7 @@ export class Flagsmith {
             featureStates: featureStates,
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler,
-            identityID: identityModel.djangoID || identityModel.identityUuid
+            identityID: identityModel.djangoID || identityModel.compositeKey
         });
 
         if (!!this.cache) {

sdk/index.ts

@@ -0,0 +1,62 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing';
+
+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('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
+
+        // Given
+        let objectIdPairs = Array.from(Array(testSample).keys()).flatMap(d => Array.from(Array(testSample).keys()).map(e => [d, e].flat()))
+
+        // When
+        console.log(objectIdPairs);
+        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),
+                1
+            )
+
+            for (let i = bucketStart; i++; i < bucketEnd) {
+                expect(values[i]).toBeLessThanOrEqual(bucketValueLimit);
+            }
+        }
+    })
+})

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

@@ -227,6 +227,23 @@ test('test onEnvironmentChange is called after error', async () => {
     expect(callbackSpy).toBeCalled();
 });
 
+test('getIdentityFlags throws error if identifier is empty string', async () => {
+    const flagsmith = new Flagsmith({
+        environmentKey: 'key',
+    });
+
+    await expect(flagsmith.getIdentityFlags('')).rejects.toThrow('`identifier` argument is missing or invalid.');
+})
+
+
+test('getIdentitySegments throws error if identifier is empty string', () => {
+    const flagsmith = new Flagsmith({
+        environmentKey: 'key',
+    });
+
+    expect(() => { flagsmith.getIdentitySegments(''); }).toThrow('`identifier` argument is missing or invalid.');
+})
+
 
 
 async function wipeFeatureStateUUIDs (enviromentModel: EnvironmentModel) {