flagsmith-nodejs 2.0.0-beta.5 → 2.0.0

package/flagsmith-engine/features/models.ts

@@ -51,6 +51,7 @@ export class FeatureStateModel {
     enabled: boolean;
     djangoID: number;
     featurestateUUID: string = uuidv4();
+    featureSegment?: FeatureSegment;
     private value: any;
     multivariateFeatureStateValues: MultivariateFeatureStateValueModel[] = [];
 
@@ -79,10 +80,23 @@ export class FeatureStateModel {
         return this.value;
     }
 
-    get_feature_state_value() {
-        return this.getValue();
+    /* 
+        Returns `True` if `this` is higher segment priority than `other`
+        (i.e. has lower value for featureSegment.priority)
+        NOTE:
+            A segment will be considered higher priority only if:
+            1. `other` does not have a feature segment(i.e: it is an environment feature state or it's a
+            feature state with feature segment but from an old document that does not have `featureSegment.priority`)
+            but `this` does.
+            2. `other` have a feature segment with high priority
+    */
+    isHigherSegmentPriority(other: FeatureStateModel): boolean {
+        if (!other.featureSegment || !this.featureSegment) {
+            return !!this.featureSegment && !other.featureSegment;
+        }
+        return this.featureSegment.priority < other.featureSegment.priority;
     }
-
+    
     getMultivariateValue(identityID: number | string) {
         const percentageValue = getHashedPercentateForObjIds([
             this.djangoID || this.featurestateUUID,
@@ -90,9 +104,9 @@ export class FeatureStateModel {
         ]);
 
         let startPercentage = 0;
-        const sortedF = this.multivariateFeatureStateValues.sort((a, b) =>
-            !!(a.id && b.id) ? a.id - b.id : a.mvFsValueUuid > b.mvFsValueUuid ? -1 : 1
-        );
+        const sortedF = this.multivariateFeatureStateValues.sort((a, b) =>{
+            return a.id - b.id;
+        });
         for (const myValue of sortedF) {
             const limit = myValue.percentageAllocation + startPercentage;
             if (startPercentage <= percentageValue && percentageValue < limit) {
@@ -103,3 +117,11 @@ export class FeatureStateModel {
         return this.value;
     }
 }
+
+export class FeatureSegment {
+    priority: number;
+
+    constructor(priority: number) {
+        this.priority = priority;
+    }
+}

package/flagsmith-engine/features/util.ts

@@ -1,5 +1,6 @@
 import {
     FeatureModel,
+    FeatureSegment,
     FeatureStateModel,
     MultivariateFeatureOptionModel,
     MultivariateFeatureStateValueModel
@@ -18,6 +19,10 @@ export function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStat
         featuresStateModelJSON.uuid
     );
 
+    featureStateModel.featureSegment = featuresStateModelJSON.feature_segment ? 
+        buildFeatureSegment(featuresStateModelJSON.feature_segment) : 
+        undefined;
+
     const multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
         ? featuresStateModelJSON.multivariate_feature_state_values.map((fsv: any) => {
               const featureOption = new MultivariateFeatureOptionModel(
@@ -36,3 +41,7 @@ export function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStat
 
     return featureStateModel;
 }
+
+export function buildFeatureSegment(featureSegmentJSON: any): FeatureSegment {
+    return new FeatureSegment(featureSegmentJSON.priority);
+}

package/flagsmith-engine/identities/models.ts

@@ -37,7 +37,7 @@ export class IdentityModel {
         return `${env_key}_${identifier}`;
     }
 
-    update_traits(traits: TraitModel[]) {
+    updateTraits(traits: TraitModel[]) {
         const existingTraits: Map<string, TraitModel> = new Map();
         for (const trait of this.identityTraits) {
             existingTraits.set(trait.traitKey, trait);

package/flagsmith-engine/index.ts

@@ -25,15 +25,17 @@ function getIdentityFeatureStatesDict(
     );
     for (const matchingSegment of identitySegments) {
         for (const featureState of matchingSegment.featureStates) {
-            // note that feature states are stored on the segment in descending priority
-            // order so we only care that the last one is added
-            // TODO: can we optimise this?
+            if (featureStates[featureState.feature.id]) {
+                if (featureStates[featureState.feature.id].isHigherSegmentPriority(featureState)) {
+                    continue;
+                }
+            }
             featureStates[featureState.feature.id] = featureState;
         }
     }
 
     // Override with any feature states defined directly the identity
-    for (const fs of identity.identityFeatures || []) {
+    for (const fs of identity.identityFeatures) {
         if (featureStates[fs.feature.id]) {
             featureStates[fs.feature.id] = fs;
         }
@@ -79,7 +81,7 @@ export function getEnvironmentFeatureState(environment: EnvironmentModel, featur
     const featuresStates = environment.featureStates.filter(f => f.feature.name === featureName);
 
     if (featuresStates.length === 0) {
-        throw new Error('Feature State Not Found');
+        throw new FeatureStateNotFound('Feature State Not Found');
     }
 
     return featuresStates[0];

package/flagsmith-engine/organisations/models.ts

@@ -19,7 +19,7 @@ export class OrganisationModel {
         this.persistTraitData = persistTraitData;
     }
 
-    get unique_slug() {
+    get uniqueSlug() {
         return this.id.toString() + '-' + this.name;
     }
 }

package/flagsmith-engine/segments/models.ts

@@ -1,3 +1,5 @@
+import semver from 'semver';
+
 import { FeatureStateModel } from '../features/models';
 import { getCastingFunction as getCastingFunction } from '../utils';
 import {
@@ -8,6 +10,7 @@ import {
     REGEX,
     CONDITION_OPERATORS
 } from './constants';
+import { isSemver } from './util';
 
 export const all = (iterable: Array<any>) => iterable.filter(e => !!e).length === iterable.length;
 export const any = (iterable: Array<any>) => iterable.filter(e => !!e).length > 0;
@@ -23,10 +26,21 @@ export const matchingFunctions = {
     [CONDITION_OPERATORS.NOT_EQUAL]: (thisValue: any, otherValue: any) => thisValue != otherValue,
     [CONDITION_OPERATORS.CONTAINS]: (thisValue: any, otherValue: any) =>
         otherValue.includes(thisValue),
-    [CONDITION_OPERATORS.NOT_CONTAINS]: (thisValue: any, otherValue: any) =>
-        !otherValue.includes(thisValue)
 };
 
+export const semverMatchingFunction = {
+    ...matchingFunctions,
+    [CONDITION_OPERATORS.EQUAL]: (thisValue: any, otherValue: any) => semver.eq(thisValue, otherValue),
+    [CONDITION_OPERATORS.GREATER_THAN]: (thisValue: any, otherValue: any) => semver.gt(otherValue, thisValue),
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue: any, otherValue: any) =>
+        semver.gte(otherValue, thisValue),
+    [CONDITION_OPERATORS.LESS_THAN]: (thisValue: any, otherValue: any) => semver.gt(thisValue, otherValue),
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue: any, otherValue: any) =>
+        semver.gte(thisValue, otherValue),
+}
+
+export const getMatchingFunctions = (semver: boolean) => (semver ? semverMatchingFunction : matchingFunctions);
+
 export class SegmentConditionModel {
     EXCEPTION_OPERATOR_METHODS: { [key: string]: string } = {
         [NOT_CONTAINS]: 'evaluateNotContains',
@@ -61,9 +75,12 @@ export class SegmentConditionModel {
 
         const defaultFunction = (x: any, y: any) => false;
 
-        const matchingFunction = matchingFunctions[this.operator] || defaultFunction;
+        const matchingFunctionSet = getMatchingFunctions(isSemver(this.value));
+        const matchingFunction = matchingFunctionSet[this.operator] || defaultFunction;
+
+        const traitType = isSemver(this.value) ? 'semver' : typeof traitValue;
+        const castToTypeOfTraitValue = getCastingFunction(traitType);
 
-        const castToTypeOfTraitValue = getCastingFunction(traitValue);
         return matchingFunction(castToTypeOfTraitValue(this.value), traitValue);
     }
 }

package/flagsmith-engine/segments/util.ts

@@ -27,3 +27,11 @@ export function buildSegmentModel(segmentModelJSON: any): SegmentModel {
 
     return model;
 }
+
+export function isSemver(value: any) {
+    return typeof value == 'string' && value.endsWith(':semver');
+}
+
+export function removeSemverSuffix(value: string) {
+    return value.replace(':semver', '');
+}

package/flagsmith-engine/utils/collections.ts

@@ -1,14 +1,3 @@
 import { FeatureStateModel } from '../features/models';
 
-export class IdentityFeaturesList extends Array<FeatureStateModel> {
-    public push(...e: FeatureStateModel[]): number {
-        for (const [_, item] of e.entries()) {
-            for (const [k, v] of this.entries()) {
-                if (v.djangoID === item.djangoID) {
-                    throw new Error('feature state for this feature already exists');
-                }
-            }
-        }
-        return super.push(...e);
-    }
-}
+export class IdentityFeaturesList extends Array<FeatureStateModel> {}

package/flagsmith-engine/utils/hashing/index.ts

@@ -39,12 +39,15 @@ function h2d(s: any): string {
  * @returns number number between 0 (inclusive) and 100 (exclusive)
  */
 export function getHashedPercentateForObjIds(objectIds: Array<any>, iterations = 1): number {
-    let to_hash = makeRepeated(objectIds, iterations).join(',');
-    const hashedValue = md5(to_hash);
+    let toHash = makeRepeated(objectIds, iterations).join(',');
+    const hashedValue = md5(toHash);
     const hashedInt = bigInt(h2d(hashedValue));
     const value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
 
+    // we ignore this for it's nearly impossible use case to catch
+    /* istanbul ignore next */
     if (value === 100) {
+        /* istanbul ignore next */
         return getHashedPercentateForObjIds(objectIds, iterations + 1);
     }
 

package/flagsmith-engine/utils/index.ts

@@ -1,9 +1,13 @@
-export function getCastingFunction(input: any): CallableFunction {
-    switch (typeof input) {
+import { removeSemverSuffix } from "../segments/util";
+
+export function getCastingFunction(traitType: 'boolean' | 'string' | 'number' | 'semver' | any): CallableFunction {
+    switch (traitType) {
         case 'boolean':
             return (x: any) => !['False', 'false'].includes(x);
         case 'number':
             return (x: any) => parseFloat(x);
+        case 'semver':
+            return (x: any) => removeSemverSuffix(x);
         default:
             return (x: any) => String(x);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "2.0.0-beta.5",
+  "version": "2.0.0",
   "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": {
@@ -46,18 +46,21 @@
     "test:watch": "jest --coverage --watch --coverageReporters='text'",
     "test:debug": "node --inspect-brk node_modules/.bin/jest --coverage --watch --coverageReporters='text'",
     "build": "tsc",
+    "prepublish": "npm run build",
     "prepare": "husky install"
   },
   "dependencies": {
     "big-integer": "^1.6.51",
     "md5": "^2.3.0",
     "node-fetch": "^2.1.2",
+    "semver": "^7.3.7",
     "uuid": "^8.3.2"
   },
   "devDependencies": {
     "@types/jest": "^27.4.1",
     "@types/md5": "^2.3.2",
     "@types/node-fetch": "^2.6.1",
+    "@types/semver": "^7.3.9",
     "@types/uuid": "^8.3.4",
     "esbuild": "^0.14.25",
     "husky": "^7.0.4",

package/sdk/analytics.ts

@@ -5,8 +5,6 @@ const ANALYTICS_ENDPOINT = 'analytics/flags/';
 // Used to control how often we send data(in seconds)
 const ANALYTICS_TIMER = 10;
 
-const delay = (ms: number) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
-
 export class AnalyticsProcessor {
     private analyticsEndpoint: string;
     private environmentKey: string;

package/sdk/index.ts

@@ -12,8 +12,9 @@ import { EnvironmentDataPollingManager } from './polling_manager';
 import { generateIdentitiesData, retryFetch } from './utils';
 import { SegmentModel } from '../flagsmith-engine/segments/models';
 import { getIdentitySegments } from '../flagsmith-engine/segments/evaluators';
+import { FlagsmithCache } from './types';
 
-const DEFAULT_API_URL = 'https://api.flagsmith.com/api/v1/';
+const DEFAULT_API_URL = 'https://edge.api.flagsmith.com/api/v1/';
 
 export class Flagsmith {
     environmentKey?: string;
@@ -26,12 +27,16 @@ export class Flagsmith {
     enableAnalytics: boolean = false;
     defaultFlagHandler?: (featureName: string) => DefaultFlag;
 
+
     environmentFlagsUrl: string;
     identitiesUrl: string;
     environmentUrl: string;
 
     environmentDataPollingManager?: EnvironmentDataPollingManager;
     environment!: EnvironmentModel;
+
+    private cache?: FlagsmithCache;
+    private onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
     private analyticsProcessor?: AnalyticsProcessor;
     /**
      * A Flagsmith client.
@@ -73,6 +78,8 @@ export class Flagsmith {
         retries?: number;
         enableAnalytics?: boolean;
         defaultFlagHandler?: (featureName: string) => DefaultFlag;
+        cache?: FlagsmithCache,
+        onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void,
     }) {
         this.environmentKey = data.environmentKey;
         this.apiUrl = data.apiUrl || this.apiUrl;
@@ -88,6 +95,20 @@ export class Flagsmith {
         this.environmentFlagsUrl = `${this.apiUrl}flags/`;
         this.identitiesUrl = `${this.apiUrl}identities/`;
         this.environmentUrl = `${this.apiUrl}environment-document/`;
+        this.onEnvironmentChange = data.onEnvironmentChange;
+
+        if (!!data.cache) {
+            const missingMethods: string[] = ['has', 'get', 'set'].filter(method => data.cache && !data.cache[method]);
+
+            if (missingMethods.length > 0) {
+                throw new Error(
+                    `Please implement the following methods in your cache: ${missingMethods.join(
+                        ', '
+                    )}`
+                );
+            }
+            this.cache = data.cache;
+        }
 
         if (this.enableLocalEvaluation) {
             if (!this.environmentKey.startsWith('ser.')) {
@@ -105,10 +126,10 @@ export class Flagsmith {
 
         this.analyticsProcessor = data.enableAnalytics
             ? new AnalyticsProcessor({
-                  environmentKey: this.environmentKey,
-                  baseApiUrl: this.apiUrl,
-                  timeout: this.requestTimeoutSeconds
-              })
+                environmentKey: this.environmentKey,
+                baseApiUrl: this.apiUrl,
+                timeout: this.requestTimeoutSeconds
+            })
             : undefined;
     }
     /**
@@ -117,8 +138,19 @@ export class Flagsmith {
      * @returns Flags object holding all the flags for the current environment.
      */
     async getEnvironmentFlags(): Promise<Flags> {
+        const cachedItem = !!this.cache && await this.cache.get(`flags`);
+        if (!!cachedItem) {
+            return cachedItem;
+        }
+        if (this.enableLocalEvaluation) {
+            return new Promise(resolve =>
+                this.environmentPromise!.then(() => {
+                    resolve(this.getEnvironmentFlagsFromDocument());
+                })
+            );
+        }
         if (this.environment) {
-            return new Promise(resolve => resolve(this.getEnvironmentFlagsFromDocument()));
+            return this.getEnvironmentFlagsFromDocument();
         }
 
         return this.getEnvironmentFlagsFromApi();
@@ -134,7 +166,11 @@ export class Flagsmith {
             Flagsmith, e.g. {"num_orders": 10}
      * @returns Flags object holding all the flags for the given identity.
      */
-    getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
+    async getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
+        const cachedItem = !!this.cache && await this.cache.get(`flags-${identifier}`);
+        if (!!cachedItem) {
+            return cachedItem;
+        }
         traits = traits || {};
         if (this.enableLocalEvaluation) {
             return new Promise(resolve =>
@@ -188,14 +224,23 @@ export class Flagsmith {
      * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
      */
     async updateEnvironment() {
-        const request = this.getEnvironmentFromApi();
-        if (!this.environmentPromise) {
-            this.environmentPromise = request.then(res => {
-                this.environment = res;
-            });
-            await this.environmentPromise;
-        } else {
-            this.environment = await request;
+        try {
+            const request = this.getEnvironmentFromApi();
+            if (!this.environmentPromise) {
+                this.environmentPromise = request.then(res => {
+                    this.environment = res;
+                });
+                await this.environmentPromise;
+            } else {
+                this.environment = await request;
+            }
+            if (this.onEnvironmentChange) {
+                this.onEnvironmentChange(null, this.environment);
+            }
+        } catch (e) {
+            if (this.onEnvironmentChange) {
+                this.onEnvironmentChange(e as Error, this.environment);
+            }
         }
     }
 
@@ -224,7 +269,6 @@ export class Flagsmith {
                 headers: headers
             },
             this.retries,
-            1000,
             (this.requestTimeoutSeconds || 10) * 1000
         );
 
@@ -247,15 +291,19 @@ export class Flagsmith {
         return buildEnvironmentModel(environment_data);
     }
 
-    private getEnvironmentFlagsFromDocument() {
-        return Flags.fromFeatureStateModels({
+    private async getEnvironmentFlagsFromDocument(): Promise<Flags> {
+        const flags = Flags.fromFeatureStateModels({
             featureStates: getEnvironmentFeatureStates(this.environment),
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler
         });
+        if (!!this.cache) {
+            await this.cache.set('flags', flags);
+        }
+        return flags;
     }
 
-    private getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }) {
+    private async getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }): Promise<Flags> {
         const identityModel = this.buildIdentityModel(
             identifier,
             Object.keys(traits).map(key => ({
@@ -266,21 +314,31 @@ export class Flagsmith {
 
         const featureStates = getIdentityFeatureStates(this.environment, identityModel);
 
-        return Flags.fromFeatureStateModels({
+        const flags = Flags.fromFeatureStateModels({
             featureStates: featureStates,
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler
         });
+
+        if (!!this.cache) {
+            await this.cache.set(`flags-${identifier}`, flags);
+        }
+
+        return flags;
     }
 
     private async getEnvironmentFlagsFromApi() {
         try {
             const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
-            return Flags.fromAPIFlags({
+            const flags = Flags.fromAPIFlags({
                 apiFlags: apiFlags,
                 analyticsProcessor: this.analyticsProcessor,
                 defaultFlagHandler: this.defaultFlagHandler
             });
+            if (!!this.cache) {
+                await this.cache.set('flags', flags);
+            }
+            return flags;
         } catch (e) {
             if (this.defaultFlagHandler) {
                 return new Flags({
@@ -297,11 +355,15 @@ export class Flagsmith {
         try {
             const data = generateIdentitiesData(identifier, traits);
             const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
-            return Flags.fromAPIFlags({
+            const flags = Flags.fromAPIFlags({
                 apiFlags: jsonResponse['flags'],
                 analyticsProcessor: this.analyticsProcessor,
                 defaultFlagHandler: this.defaultFlagHandler
             });
+            if (!!this.cache) {
+                await this.cache.set(`flags-${identifier}`, flags);
+            }
+            return flags;
         } catch (e) {
             if (this.defaultFlagHandler) {
                 return new Flags({
@@ -315,12 +377,6 @@ export class Flagsmith {
     }
 
     private buildIdentityModel(identifier: string, traits: { key: string; value: any }[]) {
-        if (!this.environment) {
-            throw new FlagsmithClientError(
-                'Unable to build identity model when no local environment present.'
-            );
-        }
-
         const traitModels = traits.map(trait => new TraitModel(trait.key, trait.value));
         return new IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
     }

package/sdk/polling_manager.ts

@@ -17,7 +17,6 @@ export class EnvironmentDataPollingManager {
                 await this.main.updateEnvironment();
             }, this.refreshIntervalSeconds * 1000);
         };
-        // todo: this call should be awaited for getIdentityFlags/getEnvironmentFlags when enableLocalEvaluation is true
         this.main.updateEnvironment();
         updateEnvironment();
     }

package/sdk/types.ts

@@ -0,0 +1,8 @@
+import { Flags } from "./models";
+
+export interface FlagsmithCache {
+  get(key: string): Promise<Flags>;
+  set(key: string, value: Flags): Promise<void>;
+  has(key: string): Promise<boolean>;
+  [key: string]: any;
+}

package/sdk/utils.ts

@@ -2,8 +2,8 @@ import fetch, { Response } from 'node-fetch';
 // @ts-ignore
 if (typeof fetch.default !== 'undefined') fetch = fetch.default;
 
-export function generateIdentitiesData(identifier: string, traits?: { [key: string]: any }) {
-    const traitsGenerated = Object.entries(traits || {}).map(trait => ({
+export function generateIdentitiesData(identifier: string, traits: { [key: string]: any }) {
+    const traitsGenerated = Object.entries(traits).map(trait => ({
         trait_key: trait[0],
         trait_value: trait[1]
     }));
@@ -18,9 +18,8 @@ export const delay = (ms: number) =>
 
 export const retryFetch = (
     url: string,
-    fetchOptions = {},
+    fetchOptions: any,
     retries = 3,
-    retryDelay = 1000,
     timeout: number
 ): Promise<Response> => {
     return new Promise((resolve, reject) => {
@@ -32,7 +31,7 @@ export const retryFetch = (
                 .then(res => resolve(res))
                 .catch(async err => {
                     if (n > 0) {
-                        await delay(retryDelay);
+                        await delay(1000);
                         wrapper(--n);
                     } else {
                         reject(err);

package/tests/engine/unit/{egine.test.ts → engine.test.ts}

@@ -25,6 +25,12 @@ test('test_identity_get_feature_state_without_any_override', () => {
     expect(feature_state.feature).toStrictEqual(feature1());
 });
 
+test('test_identity_get_feature_state_without_any_override_no_fs', () => {
+    expect(() => {
+        getIdentityFeatureState(environment(), identity(), 'nonExistentName');
+    }).toThrowError('Feature State Not Found');
+});
+
 test('test_identity_get_all_feature_states_no_segments', () => {
     const env = environment();
     const ident = identity();
@@ -61,6 +67,20 @@ test('test_identity_get_all_feature_states_with_traits', () => {
     expect(featureStates[0].getValue()).toBe('segment_override');
 });
 
+test('test_identity_get_all_feature_states_with_traits_hideDisabledFlags', () => {
+    const trait_models = new TraitModel(segmentConditionProperty, segmentConditionStringValue);
+
+    const env = environmentWithSegmentOverride();
+    env.project.hideDisabledFlags = true;
+
+    const featureStates = getIdentityFeatureStates(
+        env,
+        identityInSegment(),
+        [trait_models]
+    );
+    expect(featureStates.length).toBe(0);
+});
+
 test('test_environment_get_all_feature_states', () => {
     const env = environment();
     const featureStates = getEnvironmentFeatureStates(env);

package/tests/engine/unit/features/models.test.ts

@@ -7,6 +7,12 @@ import {
 } from '../../../../flagsmith-engine/features/models';
 import { feature1 } from '../utils';
 
+test('test_compare_feature_model', () => {
+    const fm1 = new FeatureModel(1, 'a', 'test');
+    const fm2 = new FeatureModel(1, 'a', 'test');
+    expect(fm1.eq(fm2)).toBe(true);
+});
+
 test('test_initializing_feature_state_creates_default_feature_state_uuid', () => {
     const featureState = new FeatureStateModel(feature1(), true, 1);
     expect(featureState.featurestateUUID).toBeDefined();
@@ -60,13 +66,11 @@ test('test_feature_state_get_value_mv_values', () => {
         const mvFeatureState = new FeatureStateModel(myFeature, true, 1);
         mvFeatureState.multivariateFeatureStateValues = [
             mvFeatureStateValue1,
-            mvFeatureStateValue2
+            mvFeatureStateValue2,
         ];
 
         mvFeatureState.setValue(mvFeatureControlValue);
 
-        // TODO
-        // expect(mvFeatureState.getValue(3)).toBe(testCase[1]);
-        expect(1).toBe(1);
+        expect(mvFeatureState.getValue("test")).toBe(mvFeatureValue2);
     }
 });

package/tests/engine/unit/identities/identities_builders.test.ts

@@ -42,6 +42,19 @@ test('test_build_identity_model_from_dictionary_uses_identity_feature_list_for_i
     expect(identityModel.identityFeatures?.length).toBe(1);
 });
 
+test('test_build_identity_model_from_dictionary_uses_identity_feature_list_for_identity_features', () => {
+    const identity_dict = {
+        id: 1,
+        identifier: 'test-identity',
+        environment_api_key: 'api-key',
+        created_date: '2021-08-22T06:25:23.406995Z',
+    };
+
+    const identityModel = buildIdentityModel(identity_dict);
+
+    expect(identityModel.identityFeatures?.length).toBe(0);
+});
+
 test('test_build_build_identity_model_from_dict_creates_identity_uuid', () => {
     const identity_model = buildIdentityModel({
         identifier: 'test_user',