unleash-server 7.6.2 → 7.6.4

package/dist/lib/features/client-feature-toggles/delta/client-feature-toggle-delta.test.js

@@ -1,7 +1,17 @@
 import { EventEmitter } from 'events';
+import { register } from 'prom-client';
 import { ClientFeatureToggleDelta, filterEventsByQuery, } from './client-feature-toggle-delta.js';
 import { DeltaCache } from './delta-cache.js';
-import { FEATURE_PROJECT_CHANGE } from '../../../events/index.js';
+import { FEATURE_PROJECT_CHANGE, SEGMENT_DELETED, } from '../../../events/index.js';
+const createLogger = () => ({
+    error: () => undefined,
+    info: () => undefined,
+    warn: () => undefined,
+});
+const createDeltaConfig = () => ({
+    eventBus: new EventEmitter(),
+    getLogger: () => createLogger(),
+});
 describe('filterEventsByQuery', () => {
     const mockEvents = [
         {
@@ -37,7 +47,7 @@ describe('filterEventsByQuery', () => {
     ];
     test('filters events based on eventId', () => {
         const requiredRevisionId = 2;
-        const result = filterEventsByQuery(mockEvents, requiredRevisionId, ['project3'], '');
+        const result = filterEventsByQuery(mockEvents, requiredRevisionId, ['project3'], '', new Set([1, 2]));
         expect(result).toEqual([
             {
                 eventId: 3,
@@ -54,11 +64,11 @@ describe('filterEventsByQuery', () => {
         ]);
     });
     test('returns all projects', () => {
-        const result = filterEventsByQuery(mockEvents, 0, ['*'], '');
+        const result = filterEventsByQuery(mockEvents, 0, ['*'], '', new Set([1]));
         expect(result).toEqual(mockEvents);
     });
     test('filters by name prefix', () => {
-        const result = filterEventsByQuery(mockEvents, 0, ['project1', 'project2'], 'alpha');
+        const result = filterEventsByQuery(mockEvents, 0, ['project1', 'project2'], 'alpha', new Set([1, 2]));
         expect(result).toEqual([
             {
                 eventId: 2,
@@ -78,7 +88,8 @@ describe('filterEventsByQuery', () => {
         ]);
     });
     test('filters by project list', () => {
-        const result = filterEventsByQuery(mockEvents, 0, ['project3'], 'beta');
+        const referencedSegmentIds = new Set([1, 2]);
+        const result = filterEventsByQuery(mockEvents, 0, ['project3'], 'beta', referencedSegmentIds);
         expect(result).toEqual([
             {
                 eventId: 3,
@@ -91,6 +102,7 @@ describe('filterEventsByQuery', () => {
                 type: 'segment-updated',
                 segment: { id: 1, name: 'my-segment', constraints: [] },
             },
+            // we propagate segment removed. Once dereferenced removing them should save memory
             { eventId: 5, type: 'segment-removed', segmentId: 2 },
         ]);
     });
@@ -149,6 +161,457 @@ describe('DeltaCache hydration ordering', () => {
     });
 });
 describe('ClientFeatureToggleDelta bootstrap behavior', () => {
+    test('segment-created alone does not advance visible revision for an environment where it is unused', async () => {
+        let currentRevisionId = 1;
+        const delta = new ClientFeatureToggleDelta({
+            getAll: async ({ environment, toggleNames = [], }) => {
+                const developmentFeature = {
+                    name: 'first',
+                    project: 'default',
+                    enabled: false,
+                };
+                if (environment !== 'development') {
+                    return [];
+                }
+                if (toggleNames.length === 0) {
+                    return [developmentFeature];
+                }
+                return toggleNames.includes('first')
+                    ? [developmentFeature]
+                    : [];
+            },
+        }, {
+            getAllForClientIds: async (ids) => ids?.includes(101)
+                ? [{ id: 101, name: 'segment-a', constraints: [] }]
+                : [],
+        }, {
+            getDeltaRevisionState: async () => ({
+                projectRevisions: new Map([['default', 1]]),
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
+            }),
+            getRevisionRange: async () => [
+                {
+                    id: 2,
+                    type: 'segment-created',
+                    data: { id: 101, name: 'segment-a' },
+                    createdAt: new Date(),
+                },
+            ],
+            getMaxRevisionId: async () => currentRevisionId,
+        }, {
+            on: () => undefined,
+        }, {
+            isEnabled: (name) => name === 'deltaApi',
+        }, createDeltaConfig());
+        const baseline = await delta.getDelta(undefined, {
+            environment: 'development',
+            project: ['default'],
+        });
+        currentRevisionId = 2;
+        await delta.onUpdateRevisionEvent();
+        const result = await delta.getDelta(1, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(baseline?.events[0]?.eventId).toBe(1);
+        expect(result).toBeUndefined();
+    });
+    test('segment-created followed by unrelated environment change does not advance visible revision and hydration stays in parity', async () => {
+        const currentRevisionId = 1;
+        const createReadModel = () => ({
+            getAll: async ({ environment, toggleNames = [], }) => {
+                const featureByEnvironment = {
+                    development: {
+                        name: 'first',
+                        project: 'default',
+                        enabled: false,
+                    },
+                    production: {
+                        name: 'first',
+                        project: 'default',
+                        enabled: true,
+                    },
+                };
+                const feature = featureByEnvironment[environment];
+                if (!feature) {
+                    return [];
+                }
+                if (toggleNames.length === 0) {
+                    return [feature];
+                }
+                return toggleNames.includes('first') ? [feature] : [];
+            },
+        });
+        const createSegmentModel = () => ({
+            getAllForClientIds: async (ids) => ids?.includes(101)
+                ? [{ id: 101, name: 'segment-a', constraints: [] }]
+                : [],
+        });
+        const createEventStore = () => ({
+            getDeltaRevisionState: async () => ({
+                projectRevisions: new Map([['default', 1]]),
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
+            }),
+            getRevisionRange: async () => [
+                {
+                    id: 2,
+                    type: 'segment-created',
+                    data: { id: 101, name: 'segment-a' },
+                    createdAt: new Date(),
+                },
+                {
+                    id: 3,
+                    type: 'feature-updated',
+                    featureName: 'first',
+                    project: 'default',
+                    environment: 'production',
+                },
+            ],
+            getMaxRevisionId: async () => currentRevisionId,
+        });
+        const liveDelta = new ClientFeatureToggleDelta(createReadModel(), createSegmentModel(), createEventStore(), {
+            on: () => undefined,
+        }, {
+            isEnabled: (name) => name === 'deltaApi',
+        }, createDeltaConfig());
+        const initialHydration = await liveDelta.getDelta(undefined, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(initialHydration?.events[0]?.eventId).toBe(1);
+        await liveDelta.onUpdateRevisionEvent();
+        const liveResult = await liveDelta.getDelta(1, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(liveResult).toBeUndefined();
+        const freshDelta = new ClientFeatureToggleDelta(createReadModel(), createSegmentModel(), createEventStore(), {
+            on: () => undefined,
+        }, {}, createDeltaConfig());
+        const freshHydration = await freshDelta.getDelta(undefined, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(freshHydration?.events[0]?.eventId).toBe(1);
+    });
+    test('segment-updated only advances visible revision when the segment is referenced by a visible feature', async () => {
+        let currentRevisionId = 1;
+        const createEventStore = () => ({
+            getDeltaRevisionState: async () => ({
+                projectRevisions: new Map([['default', 1]]),
+                maxReferencedSegmentRevision: 1,
+                segmentRevisions: new Map(),
+            }),
+            getRevisionRange: async () => [
+                {
+                    id: 2,
+                    type: 'segment-updated',
+                    data: { id: 101, name: 'segment-a' },
+                    createdAt: new Date(),
+                },
+            ],
+            getMaxRevisionId: async () => currentRevisionId,
+        });
+        const createSegmentModel = () => ({
+            getAllForClientIds: async (ids) => ids?.includes(101)
+                ? [{ id: 101, name: 'segment-a', constraints: [] }]
+                : [],
+        });
+        const unreferencedSegment = new ClientFeatureToggleDelta({
+            getAll: async () => [
+                {
+                    name: 'first',
+                    project: 'default',
+                    enabled: false,
+                },
+            ],
+        }, createSegmentModel(), createEventStore(), {
+            on: () => undefined,
+        }, {
+            isEnabled: (name) => name === 'deltaApi',
+        }, createDeltaConfig());
+        await unreferencedSegment.getDelta(undefined, {
+            environment: 'development',
+            project: ['default'],
+        });
+        currentRevisionId = 2;
+        await unreferencedSegment.onUpdateRevisionEvent();
+        const unusedResult = await unreferencedSegment.getDelta(1, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(unusedResult).toBeUndefined();
+        const usedDelta = new ClientFeatureToggleDelta({
+            getAll: async () => [
+                {
+                    name: 'first',
+                    project: 'default',
+                    enabled: false,
+                    strategies: [{ name: 'default', segments: [101] }],
+                },
+            ],
+        }, createSegmentModel(), createEventStore(), {
+            on: () => undefined,
+        }, {
+            isEnabled: (name) => name === 'deltaApi',
+        }, createDeltaConfig());
+        await usedDelta.getDelta(undefined, {
+            environment: 'development',
+            project: ['default'],
+        });
+        currentRevisionId = 2;
+        await usedDelta.onUpdateRevisionEvent();
+        const usedResult = await usedDelta.getDelta(1, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(usedResult).toEqual({
+            events: [
+                {
+                    eventId: 2,
+                    type: 'segment-updated',
+                    segment: { id: 101, name: 'segment-a', constraints: [] },
+                },
+            ],
+        });
+    });
+    test('segment-removed is delivered with the feature update that dereferences it', async () => {
+        let currentRevisionId = 1;
+        let featureReferencesSegment = true;
+        const delta = new ClientFeatureToggleDelta({
+            getAll: async () => [
+                {
+                    name: 'first',
+                    project: 'default',
+                    enabled: false,
+                    strategies: [
+                        featureReferencesSegment
+                            ? { name: 'default', segments: [101] }
+                            : { name: 'default' },
+                    ],
+                },
+            ],
+        }, {
+            getAllForClientIds: async (ids) => ids === undefined || ids.includes(101)
+                ? [{ id: 101, name: 'segment-a', constraints: [] }]
+                : [],
+        }, {
+            getDeltaRevisionState: async () => ({
+                projectRevisions: new Map([['default', 1]]),
+                maxReferencedSegmentRevision: 1,
+                segmentRevisions: new Map([[101, 1]]),
+            }),
+            getRevisionRange: async () => [
+                {
+                    id: 2,
+                    type: 'feature-updated',
+                    featureName: 'first',
+                    project: 'default',
+                    environment: 'development',
+                    createdAt: new Date(),
+                },
+                {
+                    id: 3,
+                    type: SEGMENT_DELETED,
+                    preData: { id: 101, name: 'segment-a' },
+                    createdAt: new Date(),
+                },
+            ],
+            getMaxRevisionId: async () => currentRevisionId,
+        }, {
+            on: () => undefined,
+        }, {
+            isEnabled: (name) => name === 'deltaApi',
+        }, createDeltaConfig());
+        await delta.getDelta(undefined, {
+            environment: 'development',
+            project: ['default'],
+        });
+        featureReferencesSegment = false;
+        currentRevisionId = 3;
+        await delta.onUpdateRevisionEvent();
+        const result = await delta.getDelta(1, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(result).toEqual({
+            events: [
+                {
+                    eventId: 2,
+                    type: 'feature-updated',
+                    feature: {
+                        name: 'first',
+                        project: 'default',
+                        enabled: false,
+                        strategies: [{ name: 'default' }],
+                    },
+                },
+                {
+                    eventId: 3,
+                    type: 'segment-removed',
+                    segmentId: 101,
+                },
+            ],
+        });
+    });
+    test('returns segment payload when a feature newly references a previously hidden segment update', async () => {
+        let currentRevisionId = 7;
+        const eventStore = {
+            getDeltaRevisionState: async () => ({
+                projectRevisions: new Map([['default', 7]]),
+                maxReferencedSegmentRevision: 7,
+                segmentRevisions: new Map(),
+            }),
+            getRevisionRange: async (from, to) => {
+                if (from === 7 && to === 14) {
+                    return [
+                        {
+                            id: 12,
+                            type: 'segment-updated',
+                            data: { id: 1, name: 'segment-a' },
+                            createdAt: new Date(),
+                        },
+                        {
+                            id: 14,
+                            type: 'feature-updated',
+                            featureName: 'test-flag',
+                            project: 'default',
+                            environment: 'development',
+                            data: { name: 'test-flag', enabled: true },
+                            createdAt: new Date(),
+                        },
+                    ];
+                }
+                return [
+                    {
+                        id: 15,
+                        type: 'feature-updated',
+                        featureName: 'test-flag',
+                        project: 'default',
+                        environment: 'development',
+                        data: { name: 'test-flag', enabled: true },
+                        createdAt: new Date(),
+                    },
+                ];
+            },
+            getMaxRevisionId: async () => currentRevisionId,
+        };
+        const readModel = {
+            getAll: async ({ toggleNames = [], }) => {
+                if (toggleNames.includes('test-flag') &&
+                    currentRevisionId >= 15) {
+                    return [
+                        {
+                            name: 'test-flag',
+                            project: 'default',
+                            enabled: true,
+                            strategies: [{ name: 'default', segments: [1] }],
+                        },
+                    ];
+                }
+                return [
+                    {
+                        name: 'test-flag',
+                        project: 'default',
+                        enabled: true,
+                        strategies: [{ name: 'default' }],
+                    },
+                ];
+            },
+        };
+        const segmentReadModel = {
+            getAllForClientIds: async (ids) => ids?.includes(1)
+                ? [{ id: 1, name: 'segment-a', constraints: [] }]
+                : [],
+        };
+        const delta = new ClientFeatureToggleDelta(readModel, segmentReadModel, eventStore, {
+            on: () => undefined,
+        }, {
+            isEnabled: (name) => name === 'deltaApi',
+        }, createDeltaConfig());
+        const hydration = await delta.getDelta(undefined, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(hydration?.events[0]?.eventId).toBe(7);
+        currentRevisionId = 14;
+        await delta.onUpdateRevisionEvent();
+        const unrelatedUpdate = await delta.getDelta(7, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(unrelatedUpdate).toEqual({
+            events: [
+                {
+                    eventId: 14,
+                    type: 'feature-updated',
+                    feature: {
+                        name: 'test-flag',
+                        project: 'default',
+                        enabled: true,
+                        strategies: [{ name: 'default' }],
+                    },
+                },
+            ],
+        });
+        currentRevisionId = 15;
+        await delta.onUpdateRevisionEvent();
+        const newlyReferencedSegment = await delta.getDelta(14, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(newlyReferencedSegment).toEqual({
+            events: [
+                {
+                    eventId: 15,
+                    type: 'segment-updated',
+                    segment: { id: 1, name: 'segment-a', constraints: [] },
+                },
+                {
+                    eventId: 15,
+                    type: 'feature-updated',
+                    feature: {
+                        name: 'test-flag',
+                        project: 'default',
+                        enabled: true,
+                        strategies: [{ name: 'default', segments: [1] }],
+                    },
+                },
+            ],
+        });
+    });
+    test('materializes delta_environment_revision_id on first hydration request', async () => {
+        const environment = 'metric-materialization-test';
+        const delta = new ClientFeatureToggleDelta({
+            getAll: async () => [
+                {
+                    name: 'first',
+                    project: 'default',
+                    enabled: false,
+                },
+            ],
+        }, {
+            getAllForClientIds: async () => [],
+        }, {
+            getDeltaRevisionState: async () => ({
+                projectRevisions: new Map([['default', 7]]),
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
+            }),
+            getMaxRevisionId: async () => 7,
+        }, {
+            on: () => undefined,
+        }, {}, createDeltaConfig());
+        const result = await delta.getDelta(undefined, {
+            environment,
+            project: ['default'],
+        });
+        const metrics = await register.metrics();
+        expect(result?.events[0]?.eventId).toBe(7);
+        expect(metrics).toMatch(new RegExp(`delta_environment_revision_id\\{environment="${environment}"\\} 7`));
+    });
     test('returns the same wildcard hydration revision for identical environment state across pods', async () => {
         const createDelta = (globalRevisionId) => new ClientFeatureToggleDelta({
             getAll: async ({ environment, }) => environment === 'production'
@@ -165,7 +628,8 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
         }, {
             getDeltaRevisionState: async () => ({
                 projectRevisions: new Map([['default', 85815]]),
-                globalSegmentRevision: 0,
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
             }),
             getMaxRevisionId: async () => globalRevisionId,
         }, {
@@ -199,7 +663,8 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
         }, {
             getDeltaRevisionState: async () => ({
                 projectRevisions: new Map(),
-                globalSegmentRevision: 0,
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
             }),
             getMaxRevisionId: async () => 0,
         }, {
@@ -233,7 +698,8 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
         }, {
             getDeltaRevisionState: async () => ({
                 projectRevisions: new Map(),
-                globalSegmentRevision: 0,
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
             }),
             getMaxRevisionId: async () => 0,
         }, {
@@ -253,7 +719,7 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
     test('does not emit a no-op delta for an unrelated environment change', async () => {
         let currentRevisionId = 1;
         const delta = new ClientFeatureToggleDelta({
-            getAll: async ({ environment, toggleNames = [] }) => {
+            getAll: async ({ environment, toggleNames = [], }) => {
                 const developmentFeature = {
                     name: 'first',
                     project: 'default',
@@ -265,7 +731,6 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
                 if (toggleNames.length === 0) {
                     return [developmentFeature];
                 }
-                // @ts-expect-error - toggle name not defined
                 return toggleNames.includes('first')
                     ? [developmentFeature]
                     : [];
@@ -275,7 +740,8 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
         }, {
             getDeltaRevisionState: async () => ({
                 projectRevisions: new Map([['default', 1]]),
-                globalSegmentRevision: 0,
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
             }),
             getRevisionRange: async () => [
                 {
@@ -313,7 +779,7 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
     test('applies global events without environment to all initialized environments', async () => {
         let currentRevisionId = 1;
         const delta = new ClientFeatureToggleDelta({
-            getAll: async ({ environment, toggleNames = [] }) => {
+            getAll: async ({ environment, toggleNames = [], }) => {
                 const featuresByEnvironment = {
                     development: {
                         name: 'first',
@@ -333,7 +799,6 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
                 if (toggleNames.length === 0) {
                     return [feature];
                 }
-                // @ts-expect-error - toggle name not defined
                 return toggleNames.includes('first') ? [feature] : [];
             },
         }, {
@@ -341,7 +806,8 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
         }, {
             getDeltaRevisionState: async () => ({
                 projectRevisions: new Map([['default', 1]]),
-                globalSegmentRevision: 0,
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
             }),
             getRevisionRange: async () => [
                 {
@@ -412,7 +878,7 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
     test('feature project move emits feature-removed for old project and feature-updated for new project', async () => {
         let currentRevisionId = 1;
         const delta = new ClientFeatureToggleDelta({
-            getAll: async ({ environment, toggleNames = [] }) => {
+            getAll: async ({ environment, toggleNames = [], }) => {
                 const feature = {
                     name: 'moved-feature',
                     project: 'new-project',
@@ -422,7 +888,6 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
                     return [];
                 if (toggleNames.length === 0)
                     return [feature];
-                // @ts-expect-error - toggle name not defined
                 return toggleNames.includes('moved-feature')
                     ? [feature]
                     : [];
@@ -432,7 +897,8 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
         }, {
             getDeltaRevisionState: async () => ({
                 projectRevisions: new Map([['old-project', 1]]),
-                globalSegmentRevision: 0,
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
             }),
             getRevisionRange: async () => [
                 {
@@ -523,7 +989,7 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
     test('bulk events pick the max revision id for the envelope', async () => {
         let currentRevisionId = 1;
         const delta = new ClientFeatureToggleDelta({
-            getAll: async ({ environment, toggleNames = [] }) => {
+            getAll: async ({ environment, toggleNames = [], }) => {
                 const featuresByEnvironment = {
                     development: {
                         name: 'first',
@@ -543,7 +1009,6 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
                 if (toggleNames.length === 0) {
                     return [feature];
                 }
-                // @ts-expect-error - toggle name not defined
                 return toggleNames.includes('first') ? [feature] : [];
             },
         }, {
@@ -551,7 +1016,8 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
         }, {
             getDeltaRevisionState: async () => ({
                 projectRevisions: new Map([['default', 1]]),
-                globalSegmentRevision: 0,
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
             }),
             getRevisionRange: async () => [
                 {
@@ -619,5 +1085,85 @@ describe('ClientFeatureToggleDelta bootstrap behavior', () => {
             ],
         });
     });
+    test('returns delta events in revision order even when cached by event type', async () => {
+        let currentRevisionId = 24;
+        const delta = new ClientFeatureToggleDelta({
+            getAll: async ({ toggleNames = [], }) => {
+                const feature = {
+                    name: 'first',
+                    project: 'default',
+                    enabled: false,
+                    strategies: currentRevisionId >= 26
+                        ? [{ name: 'default', segments: [101] }]
+                        : [],
+                };
+                if (toggleNames.length === 0) {
+                    return [feature];
+                }
+                return toggleNames.includes('first') ? [feature] : [];
+            },
+        }, {
+            getAllForClientIds: async (ids) => ids === undefined || ids.includes(101)
+                ? [{ id: 101, name: 'segment-a', constraints: [] }]
+                : [],
+        }, {
+            getDeltaRevisionState: async () => ({
+                projectRevisions: new Map([['default', 24]]),
+                maxReferencedSegmentRevision: 0,
+                segmentRevisions: new Map(),
+            }),
+            getRevisionRange: async () => [
+                {
+                    id: 25,
+                    type: 'segment-created',
+                    data: { id: 101, name: 'segment-a' },
+                    createdAt: new Date(),
+                },
+                {
+                    id: 26,
+                    type: 'feature-updated',
+                    featureName: 'first',
+                    project: 'default',
+                    environment: 'development',
+                    createdAt: new Date(),
+                },
+            ],
+            getMaxRevisionId: async () => currentRevisionId,
+        }, {
+            on: () => undefined,
+        }, {
+            isEnabled: (name) => name === 'deltaApi',
+        }, createDeltaConfig());
+        await delta.getDelta(undefined, {
+            environment: 'development',
+            project: ['default'],
+        });
+        currentRevisionId = 26;
+        await delta.onUpdateRevisionEvent();
+        const result = await delta.getDelta(24, {
+            environment: 'development',
+            project: ['default'],
+        });
+        expect(result?.events.map((event) => event.eventId)).toEqual([25, 26]);
+        expect(result).toEqual({
+            events: [
+                {
+                    eventId: 25,
+                    type: 'segment-updated',
+                    segment: { id: 101, name: 'segment-a', constraints: [] },
+                },
+                {
+                    eventId: 26,
+                    type: 'feature-updated',
+                    feature: {
+                        name: 'first',
+                        project: 'default',
+                        enabled: false,
+                        strategies: [{ name: 'default', segments: [101] }],
+                    },
+                },
+            ],
+        });
+    });
 });
 //# sourceMappingURL=client-feature-toggle-delta.test.js.map