feat: added-unit-tests

Author: Zaimwa9

flagsmith-engine/index.ts

@@ -9,11 +9,13 @@ export { IdentityModel } from './identities/models.js';
 export { TraitModel } from './identities/traits/models.js';
 export { SegmentModel } from './segments/models.js';
 
-type segmentOverride = {
+type SegmentOverride = {
     feature: FeatureContext;
     segmentName: string;
 };
 
+export type SegmentOverrides = Record<string, SegmentOverride>;
+
 /**
  * Evaluates flags and segments for the given context.
  *
@@ -40,9 +42,9 @@ export function getEvaluationResult(context: EvaluationContext): EvaluationResul
  * @param context - EvaluationContext containing identity and segment definitions
  * @returns Object containing segments the identity belongs to and any feature overrides
  */
-function evaluateSegments(context: EvaluationContext): {
+export function evaluateSegments(context: EvaluationContext): {
     segments: EvaluationResult['segments'];
-    segmentOverrides: Record<string, segmentOverride>;
+    segmentOverrides: Record<string, SegmentOverride>;
 } {
     if (!context.identity || !context.segments) {
         return { segments: [], segmentOverrides: {} };
@@ -67,8 +69,8 @@ function evaluateSegments(context: EvaluationContext): {
  * @param identitySegments - Segments that the identity belongs to
  * @returns Map of feature keys to their highest-priority segment overrides
  */
-function processSegmentOverrides(identitySegments: any[]): Record<string, segmentOverride> {
-    const segmentOverrides: Record<string, segmentOverride> = {};
+export function processSegmentOverrides(identitySegments: any[]): Record<string, SegmentOverride> {
+    const segmentOverrides: Record<string, SegmentOverride> = {};
 
     for (const segment of identitySegments) {
         if (!segment.overrides) continue;
@@ -100,9 +102,9 @@ function processSegmentOverrides(identitySegments: any[]): Record<string, segmen
  * @param segmentOverrides - Map of feature keys to their segment overrides
  * @returns EvaluationResultFlags containing evaluated flag results
  */
-function evaluateFeatures(
+export function evaluateFeatures(
     context: EvaluationContext,
-    segmentOverrides: Record<string, segmentOverride>
+    segmentOverrides: Record<string, SegmentOverride>
 ): EvaluationResultFlags {
     const flags: EvaluationResultFlags = [];
 
@@ -126,21 +128,24 @@ function evaluateFeatures(
     return flags;
 }
 
-function shouldApplyOverride(
+export function shouldApplyOverride(
     override: any,
-    existingOverrides: Record<string, segmentOverride>
+    existingOverrides: Record<string, SegmentOverride>
 ): boolean {
     const currentOverride = existingOverrides[override.feature_key];
     return (
         !currentOverride || isHigherPriority(override.priority, currentOverride.feature.priority)
     );
 }
 
-function isHigherPriority(priorityA: number | undefined, priorityB: number | undefined): boolean {
+export function isHigherPriority(
+    priorityA: number | undefined,
+    priorityB: number | undefined
+): boolean {
     return (priorityA ?? Infinity) < (priorityB ?? Infinity);
 }
 
-const getTargetingMatchReason = (segmentOverride: segmentOverride) => {
+const getTargetingMatchReason = (segmentOverride: SegmentOverride) => {
     if (segmentOverride) {
         return segmentOverride.segmentName === IDENTITY_OVERRIDE_SEGMENT_NAME
             ? TARGETING_REASONS.IDENTITY_OVERRIDE

tests/engine/unit/engine.test.ts

@@ -1,4 +1,11 @@
-import { getEvaluationResult } from '../../../flagsmith-engine/index.js';
+import {
+    evaluateFeatures,
+    evaluateSegments,
+    getEvaluationResult,
+    isHigherPriority,
+    SegmentOverrides,
+    shouldApplyOverride
+} from '../../../flagsmith-engine/index.js';
 import { CONSTANTS } from '../../../flagsmith-engine/features/constants.js';
 import { FeatureModel, FeatureStateModel } from '../../../flagsmith-engine/features/models.js';
 import { TraitModel } from '../../../flagsmith-engine/identities/traits/models.js';
@@ -13,6 +20,9 @@ import {
 } from './utils.js';
 import { getEvaluationContext } from '../../../flagsmith-engine/evaluationContext/mappers.js';
 import { TARGETING_REASONS } from '../../../flagsmith-engine/features/types.js';
+import { flagsmith } from '../../sdk/utils.js';
+import { getIdentitySegments } from '../../../flagsmith-engine/segments/evaluators.js';
+import { EvaluationContext } from '../../../flagsmith-engine/evaluationContext/evaluationContext.types.js';
 
 test('test_get_evaluation_result_without_any_override', () => {
     const context = getEvaluationContext(environment(), identity());
@@ -146,3 +156,270 @@ test('test_environment_get_all_feature_states', () => {
 //         getEnvironmentFeatureStateFromContext(context, 'not_a_feature_name');
 //     }).toThrowError('Feature State Not Found');
 // });
+
+test('isHigherPriority should handle undefined priorities correctly', () => {
+    expect(isHigherPriority(1, 2)).toBe(true);
+    expect(isHigherPriority(2, 1)).toBe(false);
+    expect(isHigherPriority(undefined, 5)).toBe(false);
+    expect(isHigherPriority(5, undefined)).toBe(true);
+    expect(isHigherPriority(undefined, undefined)).toBe(false);
+});
+
+test('shouldApplyOverride with priority conflicts', () => {
+    const existingOverrides: SegmentOverrides = {
+        feature1: {
+            feature: {
+                key: 'key',
+                feature_key: 'feature1',
+                name: 'name',
+                enabled: true,
+                value: 'value',
+                priority: 5
+            },
+            segmentName: 'segment1'
+        }
+    };
+
+    expect(shouldApplyOverride({ feature_key: 'feature1', priority: 2 }, existingOverrides)).toBe(
+        true
+    );
+    expect(shouldApplyOverride({ feature_key: 'feature1', priority: 10 }, existingOverrides)).toBe(
+        false
+    );
+});
+
+test('evaluateSegments handles segments with identity identifier matching', () => {
+    const context: EvaluationContext = {
+        environment: {
+            key: 'test-env',
+            name: 'Test Environment'
+        },
+        identity: {
+            key: 'test-user',
+            identifier: 'test-user'
+        },
+        segments: {
+            '1': {
+                key: '1',
+                name: 'segment_with_no_overrides',
+                rules: [
+                    {
+                        type: 'ALL',
+                        conditions: [
+                            {
+                                property: '$.identity.identifier',
+                                operator: 'EQUAL',
+                                value: 'test-user'
+                            }
+                        ]
+                    }
+                ],
+                overrides: []
+            },
+            '2': {
+                key: '2',
+                name: 'segment_with_overrides',
+                rules: [
+                    {
+                        type: 'ALL',
+                        conditions: [
+                            {
+                                property: '$.identity.identifier',
+                                operator: 'EQUAL',
+                                value: 'test-user'
+                            }
+                        ]
+                    }
+                ],
+                overrides: [
+                    {
+                        key: 'override1',
+                        feature_key: 'feature1',
+                        name: 'feature1',
+                        enabled: true,
+                        value: 'overridden_value',
+                        priority: 1
+                    }
+                ]
+            }
+        },
+        features: {
+            feature1: {
+                key: 'fs1',
+                feature_key: 'feature1',
+                name: 'feature1',
+                enabled: false,
+                value: 'default_value'
+            }
+        }
+    };
+
+    const result = evaluateSegments(context);
+
+    expect(result.segments).toHaveLength(2);
+    expect(result.segments).toEqual(
+        expect.arrayContaining([
+            { key: '1', name: 'segment_with_no_overrides' },
+            { key: '2', name: 'segment_with_overrides' }
+        ])
+    );
+
+    expect(Object.keys(result.segmentOverrides)).toEqual(['feature1']);
+    expect(result.segmentOverrides.feature1.segmentName).toBe('segment_with_overrides');
+});
+
+test('evaluateSegments handles priority conflicts correctly', () => {
+    const context: EvaluationContext = {
+        environment: {
+            key: 'test-env',
+            name: 'Test Environment'
+        },
+        identity: {
+            key: 'test-user',
+            identifier: 'test-user'
+        },
+        segments: {
+            '1': {
+                key: '1',
+                name: 'low_priority_segment',
+                rules: [
+                    {
+                        type: 'ALL',
+                        conditions: [
+                            {
+                                property: '$.identity.identifier',
+                                operator: 'EQUAL',
+                                value: 'test-user'
+                            }
+                        ]
+                    }
+                ],
+                overrides: [
+                    {
+                        key: 'override1',
+                        feature_key: 'feature1',
+                        name: 'feature1',
+                        enabled: true,
+                        value: 'low_priority_value',
+                        priority: 10
+                    }
+                ]
+            },
+            '2': {
+                key: '2',
+                name: 'high_priority_segment',
+                rules: [
+                    {
+                        type: 'ALL',
+                        conditions: [
+                            {
+                                property: '$.identity.identifier',
+                                operator: 'EQUAL',
+                                value: 'test-user'
+                            }
+                        ]
+                    }
+                ],
+                overrides: [
+                    {
+                        key: 'override2',
+                        feature_key: 'feature1',
+                        name: 'feature1',
+                        enabled: false,
+                        value: 'high_priority_value',
+                        priority: 1
+                    }
+                ]
+            }
+        },
+        features: {
+            feature1: {
+                key: 'fs1',
+                feature_key: 'feature1',
+                name: 'feature1',
+                enabled: false,
+                value: 'default_value'
+            }
+        }
+    };
+
+    const result = evaluateSegments(context);
+
+    expect(result.segments).toHaveLength(2);
+
+    expect(result.segmentOverrides.feature1.segmentName).toBe('high_priority_segment');
+    expect(result.segmentOverrides.feature1.feature.value).toBe('high_priority_value');
+    expect(result.segmentOverrides.feature1.feature.priority).toBe(1);
+});
+
+test('evaluateSegments with non-matching identity returns empty', () => {
+    const context: EvaluationContext = {
+        environment: {
+            key: 'test-env',
+            name: 'Test Environment'
+        },
+        identity: {
+            key: 'test-user',
+            identifier: 'test-user'
+        },
+        segments: {
+            '1': {
+                key: '1',
+                name: 'segment_for_specific_user',
+                rules: [
+                    {
+                        type: 'ALL',
+                        conditions: [
+                            {
+                                property: '$.identity.identifier',
+                                operator: 'EQUAL',
+                                value: 'test-user-123'
+                            }
+                        ]
+                    }
+                ],
+                overrides: [
+                    {
+                        key: 'override1',
+                        feature_key: 'feature1',
+                        name: 'feature1',
+                        enabled: true,
+                        value: 'overridden_value'
+                    }
+                ]
+            }
+        },
+        features: {}
+    };
+
+    const result = evaluateSegments(context);
+
+    expect(result.segments).toEqual([]);
+    expect(result.segmentOverrides).toEqual({});
+});
+
+test('evaluateFeatures with multivariate evaluation', () => {
+    const context = {
+        features: {
+            mv_feature: {
+                key: 'mv',
+                feature_key: 'mv_feature',
+                name: 'Multivariate Feature',
+                enabled: true,
+                value: 'default',
+                variants: [
+                    { value: 'variant_a', weight: 0 },
+                    { value: 'variant_b', weight: 100 }
+                ]
+            }
+        },
+        identity: { key: 'test_user', identifier: 'test_user' },
+        environment: {
+            key: 'test_env',
+            name: 'Test Environment'
+        }
+    };
+
+    const result = evaluateFeatures(context, {});
+    expect(result[0].value).toBe('variant_b');
+});