feat: fixed-tests

Author: Zaimwa9

flagsmith-engine/evaluation/evaluationContext/evaluationContext.types.ts

@@ -175,6 +175,7 @@ export interface SegmentContext {
     name: Name1;
     rules: Rules;
     overrides?: Overrides;
+    metadata?: Metadata;
     [k: string]: unknown;
 }
 /**
@@ -225,6 +226,12 @@ export interface FeatureValue {
     weight: Weight;
     [k: string]: unknown;
 }
+/**
+ * Additional metadata associated with the segment.
+ */
+export interface Metadata {
+    [k: string]: string | number | boolean | null;
+}
 /**
  * Features to be evaluated in the context.
  */

flagsmith-engine/evaluation/evaluationContext/mappers.ts

@@ -4,7 +4,8 @@ import {
     Traits,
     EvaluationContext,
     EnvironmentContext,
-    IdentityContext
+    IdentityContext,
+    SegmentSource
 } from '../models.js';
 import { EnvironmentModel } from '../../environments/models.js';
 import { IdentityModel } from '../../identities/models.js';
@@ -74,7 +75,11 @@ function mapEnvironmentModelToEvaluationContext(environment: EnvironmentModel):
                           value: fs.getValue(),
                           priority: fs.featureSegment?.priority
                       }))
-                    : []
+                    : [],
+            metadata: {
+                source: SegmentSource.API,
+                flagsmith_id: segment.id
+            }
         };
     }
 
@@ -170,6 +175,9 @@ function mapIdentityOverridesToSegments(identityOverrides: IdentityModel[]): Seg
                     ]
                 }
             ],
+            metadata: {
+                source: SegmentSource.IDENTITY_OVERRIDE
+            },
             overrides: overrides
         };
     }

flagsmith-engine/evaluation/evaluationResult/evaluationResult.types.ts

@@ -63,5 +63,12 @@ export interface FlagResult {
 export interface SegmentResult {
     key: Key;
     name: Name1;
+    metadata?: Metadata;
     [k: string]: unknown;
 }
+/**
+ * Additional metadata associated with the segment.
+ */
+export interface Metadata {
+    [k: string]: string | number | boolean | null;
+}

flagsmith-engine/evaluation/models.ts

@@ -13,8 +13,7 @@ import type {
     FeatureValue as ContextFeatureValue,
     Traits,
     Features,
-    Segments,
-    EvaluationContext
+    Segments
 } from './evaluationContext/evaluationContext.types.js';
 
 import type {
@@ -54,19 +53,27 @@ export type SegmentConditionOperator = SegmentCondition['operator'];
 export type EvaluationReason = EvaluationContextResultFlagResult['reason'];
 
 export type EvaluationResultSegments = EvaluationContextResult['segments'];
-export type EvaluationResultFlags = {
-    feature_key: FeatureKey;
-    name: FeatureName;
-    enabled: FeatureEnabled;
-    value: FeatureValue;
-    reason: EvaluationReason;
-}[];
+export type EvaluationResultFlags = Record<
+    string,
+    {
+        feature_key: FeatureKey;
+        name: FeatureName;
+        enabled: FeatureEnabled;
+        value: FeatureValue;
+        reason: EvaluationReason;
+    }
+>;
 
 export type EvaluationResult = {
-    context: EvaluationContext;
     flags: EvaluationResultFlags;
     segments: EvaluationResultSegments;
 };
 
 export { FlagResult } from './evaluationResult/evaluationResult.types.js';
+
+export enum SegmentSource {
+    API = 'api',
+    IDENTITY_OVERRIDE = 'identity_override'
+}
+
 export * from './evaluationContext/evaluationContext.types.js';

flagsmith-engine/index.ts

@@ -1,4 +1,4 @@
-import { EvaluationContext, FeatureContext } from './evaluation/models.js';
+import { EvaluationContext, FeatureContext, SegmentSource } from './evaluation/models.js';
 import { getIdentitySegments } from './segments/evaluators.js';
 import { EvaluationResult, EvaluationResultFlags } from './evaluation/models.js';
 import { TARGETING_REASONS } from './features/types.js';
@@ -9,6 +9,7 @@ export { TraitModel } from './identities/traits/models.js';
 export { SegmentModel } from './segments/models.js';
 export { FeatureModel, FeatureStateModel } from './features/models.js';
 export { OrganisationModel } from './organisations/models.js';
+
 type SegmentOverride = {
     feature: FeatureContext;
     segmentName: string;
@@ -30,7 +31,7 @@ export function getEvaluationResult(context: EvaluationContext): EvaluationResul
     const { segments, segmentOverrides } = evaluateSegments(context);
     const flags = evaluateFeatures(context, segmentOverrides);
 
-    return { context, flags, segments };
+    return { flags, segments };
 }
 
 /**
@@ -50,7 +51,14 @@ export function evaluateSegments(context: EvaluationContext): {
 
     const segments = identitySegments.map(segment => ({
         key: segment.key,
-        name: segment.name
+        name: segment.name,
+        ...(segment.metadata
+            ? {
+                  metadata: {
+                      ...segment.metadata
+                  }
+              }
+            : {})
     }));
     const segmentOverrides = processSegmentOverrides(identitySegments);
 
@@ -103,7 +111,7 @@ export function evaluateFeatures(
     context: EvaluationContext,
     segmentOverrides: Record<string, SegmentOverride>
 ): EvaluationResultFlags {
-    const flags: EvaluationResultFlags = [];
+    const flags: EvaluationResultFlags = {};
 
     for (const feature of Object.values(context.features || {})) {
         const segmentOverride = segmentOverrides[feature.feature_key];
@@ -114,15 +122,15 @@ export function evaluateFeatures(
             ? { value: finalFeature.value, reason: undefined }
             : evaluateFeatureValue(finalFeature, context.identity?.key);
 
-        flags.push({
+        flags[finalFeature.name] = {
             feature_key: finalFeature.feature_key,
             name: finalFeature.name,
             enabled: finalFeature.enabled,
             value: evaluatedValue,
             reason:
                 evaluatedReason ??
                 getTargetingMatchReason({ type: 'SEGMENT', override: segmentOverride })
-        });
+        };
     }
 
     return flags;

flagsmith-engine/segments/models.ts

@@ -23,7 +23,7 @@ import {
     Overrides
 } from '../evaluation/evaluationContext/evaluationContext.types.js';
 import { CONSTANTS } from '../features/constants.js';
-import { EvaluationResultSegments } from '../evaluation/models.js';
+import { EvaluationResultSegments, SegmentSource } from '../evaluation/models.js';
 
 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;
@@ -216,17 +216,17 @@ export class SegmentModel {
         }
 
         for (const segmentResult of segmentResults) {
+            if (segmentResult.metadata?.source === SegmentSource.IDENTITY_OVERRIDE) {
+                continue;
+            }
             const segmentContext = evaluationContext.segments[segmentResult.key];
             if (segmentContext) {
                 const segment = new SegmentModel(parseInt(segmentContext.key), segmentContext.name);
                 segment.rules = segmentContext.rules.map(rule => new SegmentRuleModel(rule.type));
                 segment.featureStates = SegmentModel.createFeatureStatesFromOverrides(
                     segmentContext.overrides || []
                 );
-
-                if (!isNaN(segment.id)) {
-                    segmentModels.push(segment);
-                }
+                segmentModels.push(segment);
             }
         }
 

sdk/models.ts

@@ -123,7 +123,7 @@ export class Flags {
         analyticsProcessor?: AnalyticsProcessor
     ): Flags {
         const flags: { [key: string]: Flag } = {};
-        for (const flag of evaluationResult.flags) {
+        for (const flag of Object.values(evaluationResult.flags)) {
             flags[flag.name] = new Flag({
                 enabled: flag.enabled,
                 value: flag.value ?? null,

tests/engine/e2e/engine.test.ts

@@ -13,6 +13,7 @@ interface TestCase {
     context: EvaluationContext;
     result: {
         flags?: Record<string, any>;
+        segments?: Record<string, any>;
     };
 }
 
@@ -53,7 +54,8 @@ describe('Engine Integration Tests', () => {
             ) as any[];
 
             expect(sortedEngineFlags.length).toBe(sortedAPIFlags.length);
-
+            expect(engine_response.segments).toStrictEqual(testCase.result.segments);
+            expect(engine_response.flags).toStrictEqual(testCase.result.flags);
             for (let i = 0; i < sortedEngineFlags.length; i++) {
                 expect(sortedEngineFlags[i].value).toBe(sortedAPIFlags[i].value);
                 expect(sortedEngineFlags[i].enabled).toBe(sortedAPIFlags[i].enabled);

tests/engine/engine-tests/engine-test-data

@@ -27,7 +27,7 @@ test('test_get_evaluation_result_without_any_override', () => {
     const context = getEvaluationContext(environment(), identity());
     const result = getEvaluationResult(context);
 
-    const flag = result.flags.find(f => f.name === feature1().name);
+    const flag = Object.values(result.flags).find(f => f.name === feature1().name);
     expect(flag).toBeDefined();
     expect(flag?.name).toBe(feature1().name);
     expect(flag?.feature_key).toBe(feature1().id.toString());
@@ -46,9 +46,9 @@ test('test_get_evaluation_result_with_identity_override_and_no_segment_override'
     const context = getEvaluationContext(env, ident);
     const result = getEvaluationResult(context);
 
-    expect(result.flags.length).toBe(3);
+    expect(Object.keys(result.flags).length).toBe(3);
 
-    for (const flag of result.flags) {
+    for (const flag of Object.values(result.flags)) {
         const environmentFeature = Object.values(context.features || {}).find(
             f => f.name === flag.name
         );
@@ -73,7 +73,7 @@ test('test_identity_get_all_feature_states_with_traits', () => {
 
     const result = getEvaluationResult(context);
 
-    const overriddenFlag = result.flags.find(f => f.value === 'segment_override');
+    const overriddenFlag = Object.values(result.flags).find(f => f.value === 'segment_override');
     expect(overriddenFlag).toBeDefined();
     expect(overriddenFlag?.value).toBe('segment_override');
     expect(overriddenFlag?.reason).toEqual(
@@ -86,13 +86,13 @@ test('test_environment_get_all_feature_states', () => {
     const context = getEvaluationContext(env);
     const result = getEvaluationResult(context);
 
-    expect(result.flags.length).toBe(Object.keys(context.features || {}).length);
+    expect(Object.keys(result.flags).length).toBe(Object.keys(context.features || {}).length);
 
-    result.flags.forEach(flag => {
+    Object.values(result.flags).forEach(flag => {
         expect(flag.reason).toBe(TARGETING_REASONS.DEFAULT);
     });
 
-    for (const flag of result.flags) {
+    for (const flag of Object.values(result.flags)) {
         const envFeature = Object.values(context.features || {}).find(f => f.name === flag.name);
         expect(flag.enabled).toBe(envFeature?.enabled);
         expect(flag.value).toBe(envFeature?.value);
@@ -362,6 +362,6 @@ test('evaluateFeatures with multivariate evaluation', () => {
         }
     };
 
-    const result = evaluateFeatures(context, {});
-    expect(result[0].value).toBe('variant_b');
+    const flags = evaluateFeatures(context, {});
+    expect(flags['Multivariate Feature'].value).toBe('variant_b');
 });