Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

18.3 KB
Raw Blame
import { afterEach, beforeAll, describe, expect, it } from 'vitest'

import {
    type CreatedResources,
    TEST_ORG_ID,
    TEST_PROJECT_ID,
    cleanupResources,
    createTestClient,
    createTestContext,
    generateUniqueKey,
    getToolByName,
    parseToolResponse,
    setActiveProjectAndOrg,
    validateEnvironmentVariables,
} from '@/shared/test-utils'
import featureFlagGetDefinitionByKey from '@/tools/featureFlags/getDefinitionByKey'
import { GENERATED_TOOLS } from '@/tools/generated/feature_flags'
import { GENERATED_TOOLS as PERSONS_GENERATED_TOOLS } from '@/tools/generated/persons'
import type { Context } from '@/tools/types'

describe('Feature flags', { concurrent: false }, () => {
    let context: Context
    const createdResources: CreatedResources = {
        featureFlags: [],
        insights: [],
        dashboards: [],
        surveys: [],
        actions: [],
        cohorts: [],
    }

    beforeAll(async () => {
        validateEnvironmentVariables()
        const client = createTestClient()
        context = createTestContext(client)
        await setActiveProjectAndOrg(context, TEST_PROJECT_ID!, TEST_ORG_ID!)
    })

    afterEach(async () => {
        await cleanupResources(context.api, TEST_PROJECT_ID!, createdResources)
    })

    describe('create-feature-flag tool', () => {
        const createTool = GENERATED_TOOLS['create-feature-flag']!()

        it('should create a feature flag with minimal required fields', async () => {
            const params = {
                name: 'Test feature flag',
                key: generateUniqueKey('test-flag'),
                filters: {
                    groups: [
                        {
                            properties: [],
                            rollout_percentage: 100,
                        },
                    ],
                },
                active: true,
            }

            const result = await createTool.handler(context, params)
            const flagData = parseToolResponse(result)

            expect(flagData.id).toBeTruthy()
            expect(flagData.key).toBe(params.key)
            expect(flagData.name).toBe(params.name)
            expect(flagData.active).toBe(params.active)
            expect(flagData._posthogUrl).toContain('/feature-flags/')
            expect(flagData.updated_at).toBeTruthy()

            createdResources.featureFlags.push(flagData.id)
        })

        it('should create a feature flag with tags and evaluation tags', async () => {
            const params = {
                name: 'Tagged feature flag',
                key: generateUniqueKey('tagged-flag'),
                filters: {
                    groups: [
                        {
                            properties: [],
                            rollout_percentage: 100,
                        },
                    ],
                },
                active: true,
                tags: ['test', 'integration'],
                evaluation_tags: ['test'],
            }

            const result = await createTool.handler(context, params)
            const flagData = parseToolResponse(result)

            expect(flagData.id).toBeTruthy()
            expect(flagData.key).toBe(params.key)
            expect(flagData.name).toBe(params.name)

            createdResources.featureFlags.push(flagData.id)
        })

        it('should create a multivariate feature flag', async () => {
            const params = {
                name: 'Multivariate flag',
                key: generateUniqueKey('multi-flag'),
                active: true,
                filters: {
                    groups: [
                        {
                            properties: [],
                            rollout_percentage: 100,
                        },
                    ],
                    multivariate: {
                        variants: [
                            { key: 'control', rollout_percentage: 50 },
                            { key: 'test', rollout_percentage: 50 },
                        ],
                    },
                },
            }

            const result = await createTool.handler(context, params)
            const flagData = parseToolResponse(result)

            expect(flagData.id).toBeTruthy()
            expect(flagData.filters.multivariate.variants).toHaveLength(2)

            createdResources.featureFlags.push(flagData.id)
        })
    })

    describe('feature-flag-get-all tool', () => {
        const getAllTool = GENERATED_TOOLS['feature-flag-get-all']!()
        const createTool = GENERATED_TOOLS['create-feature-flag']!()
        const getTool = GENERATED_TOOLS['feature-flag-get-definition']!()

        it('should list feature flags', async () => {
            const createResult = await createTool.handler(context, {
                name: 'List test flag',
                key: generateUniqueKey('list-test'),
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)
            createdResources.featureFlags.push(createdFlag.id)

            const result = await getAllTool.handler(context, { limit: 10, offset: 0 })
            const response = parseToolResponse(result)

            expect(Array.isArray(response.results)).toBe(true)
            expect(response.results.some((flag: { id: number }) => flag.id === createdFlag.id)).toBe(true)
            expect(response._posthogUrl).toContain('/feature-flags')
        })

        it('should support search by key and use returned ID for retrieval', async () => {
            const uniqueKey = generateUniqueKey('search-key')
            const createResult = await createTool.handler(context, {
                name: 'Search test flag',
                key: uniqueKey,
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)
            createdResources.featureFlags.push(createdFlag.id)

            const searchResult = await getAllTool.handler(context, { search: uniqueKey, limit: 20, offset: 0 })
            const listResponse = parseToolResponse(searchResult)
            const found = listResponse.results.find((flag: { id: number; key: string }) => flag.key === uniqueKey)

            expect(found).toBeTruthy()
            if (!found) {
                throw new Error(`Expected to find feature flag with key ${uniqueKey}`)
            }
            expect(found.id).toBe(createdFlag.id)

            const getResult = await getTool.handler(context, { id: found.id })
            const flagData = parseToolResponse(getResult)
            expect(flagData.id).toBe(createdFlag.id)
            expect(flagData.key).toBe(uniqueKey)
        })
    })

    describe('feature-flag-get-definition tool', () => {
        const getTool = GENERATED_TOOLS['feature-flag-get-definition']!()
        const createTool = GENERATED_TOOLS['create-feature-flag']!()

        it('should get a feature flag by ID', async () => {
            const createResult = await createTool.handler(context, {
                name: 'Definition test flag',
                key: generateUniqueKey('definition-test'),
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)
            createdResources.featureFlags.push(createdFlag.id)

            const result = await getTool.handler(context, { id: createdFlag.id })
            const flagData = parseToolResponse(result)

            expect(flagData.id).toBe(createdFlag.id)
            expect(flagData.key).toBe(createdFlag.key)
            expect(flagData._posthogUrl).toContain('/feature-flags/')
        })
    })

    describe('feature-flag-get-definition-by-key tool', () => {
        const getByKeyTool = featureFlagGetDefinitionByKey()
        const createTool = GENERATED_TOOLS['create-feature-flag']!()

        it('should get a feature flag by its exact key', async () => {
            const uniqueKey = generateUniqueKey('by-key-test')
            const createResult = await createTool.handler(context, {
                name: 'By-key test flag',
                key: uniqueKey,
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)
            createdResources.featureFlags.push(createdFlag.id)

            const result = await getByKeyTool.handler(context, { key: uniqueKey })
            const flagData = parseToolResponse(result)

            expect(flagData.id).toBe(createdFlag.id)
            expect(flagData.key).toBe(uniqueKey)
            expect(flagData._posthogUrl).toContain('/feature-flags/')
            expect(flagData.found).toBe(true)
        })

        it('should return a non-error found:false result for a flag that does not exist', async () => {
            const missingKey = generateUniqueKey('does-not-exist')

            const result = await getByKeyTool.handler(context, { key: missingKey })
            const flagData = parseToolResponse(result)

            expect(flagData.found).toBe(false)
            expect(flagData.key).toBe(missingKey)
        })
    })

    describe('update-feature-flag tool', () => {
        const updateTool = GENERATED_TOOLS['update-feature-flag']!()
        const createTool = GENERATED_TOOLS['create-feature-flag']!()

        it('should update a feature flag by ID', async () => {
            const createResult = await createTool.handler(context, {
                name: 'Original name',
                key: generateUniqueKey('update-test'),
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)
            createdResources.featureFlags.push(createdFlag.id)

            const updateResult = await updateTool.handler(context, {
                id: createdFlag.id,
                name: 'Updated name',
                active: false,
            })
            const updatedFlag = parseToolResponse(updateResult)

            expect(updatedFlag.id).toBe(createdFlag.id)
            expect(updatedFlag.name).toBe('Updated name')
            expect(updatedFlag.active).toBe(false)
            expect(updatedFlag._posthogUrl).toContain('/feature-flags/')
        })

        it('keeps group targeting when partial filters omit the group fields', async () => {
            // Resolved the way production does, so the hand-written override wins. Without
            // the merge the untyped property below reaches the API as a person property.
            const overrideUpdateTool = getToolByName('update-feature-flag')

            const createResult = await createTool.handler(context, {
                name: 'Group targeted flag',
                key: generateUniqueKey('group-targeting'),
                filters: {
                    aggregation_group_type_index: 0,
                    groups: [
                        {
                            aggregation_group_type_index: 0,
                            properties: [
                                {
                                    key: 'plan',
                                    type: 'group',
                                    group_type_index: 0,
                                    operator: 'exact',
                                    value: 'enterprise',
                                },
                            ],
                            rollout_percentage: 100,
                        },
                    ],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)
            createdResources.featureFlags.push(createdFlag.id)

            // The shape agents actually send: key, operator and value only.
            const updateResult = await overrideUpdateTool.handler(context, {
                id: createdFlag.id,
                filters: {
                    groups: [
                        {
                            properties: [{ key: 'plan', operator: 'exact', value: 'pro' }],
                            rollout_percentage: 100,
                        },
                    ],
                },
            })
            const updatedFlag = parseToolResponse(updateResult)

            // Flag-level aggregation survives the backend's shallow merge on its own, so the
            // property assertions below are what actually cover the fix.
            expect(updatedFlag.filters.aggregation_group_type_index).toBe(0)
            const updatedProperty = updatedFlag.filters.groups[0].properties[0]
            expect(updatedProperty.value).toBe('pro')
            expect(updatedProperty.type).toBe('group')
            expect(updatedProperty.group_type_index).toBe(0)
        })

        it('should update feature flag filters', async () => {
            const createResult = await createTool.handler(context, {
                name: 'Filter update flag',
                key: generateUniqueKey('filter-update'),
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)
            createdResources.featureFlags.push(createdFlag.id)

            const updateResult = await updateTool.handler(context, {
                id: createdFlag.id,
                filters: {
                    groups: [{ properties: [], rollout_percentage: 50 }],
                },
            })
            const updatedFlag = parseToolResponse(updateResult)

            expect(updatedFlag.id).toBe(createdFlag.id)
        })
    })

    describe('delete-feature-flag tool', () => {
        const deleteTool = GENERATED_TOOLS['delete-feature-flag']!()
        const getAllTool = GENERATED_TOOLS['feature-flag-get-all']!()
        const createTool = GENERATED_TOOLS['create-feature-flag']!()

        it('should delete a feature flag by ID', async () => {
            const createResult = await createTool.handler(context, {
                name: 'Delete test flag',
                key: generateUniqueKey('delete-test'),
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)

            await deleteTool.handler(context, { id: createdFlag.id })

            const listResult = await getAllTool.handler(context, { limit: 100, offset: 0 })
            const listResponse = parseToolResponse(listResult)
            expect(listResponse.results.some((flag: { id: number }) => flag.id === createdFlag.id)).toBe(false)
        })
    })

    describe('feature-flags-test-evaluation-create tool', () => {
        const testEvaluationTool = GENERATED_TOOLS['feature-flags-test-evaluation-create']!()
        const createTool = GENERATED_TOOLS['create-feature-flag']!()
        const personsListTool = PERSONS_GENERATED_TOOLS['persons-list']!()

        it('should evaluate a feature flag for a real distinct_id', async () => {
            const personsResult = await personsListTool.handler(context, { limit: 100 })
            const personsResponse = parseToolResponse(personsResult)
            const personWithDistinctId = personsResponse.results.find(
                (p: { distinct_ids?: string[] }) => p.distinct_ids && p.distinct_ids.length > 0
            )

            if (!personWithDistinctId) {
                console.warn('No persons with distinct_ids found in project, skipping test')
                return
            }

            const distinctId: string = personWithDistinctId.distinct_ids[0]

            const createResult = await createTool.handler(context, {
                name: 'Test evaluation flag',
                key: generateUniqueKey('test-eval'),
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: true,
            })
            const createdFlag = parseToolResponse(createResult)
            createdResources.featureFlags.push(createdFlag.id)

            const result = await testEvaluationTool.handler(context, {
                id: createdFlag.id,
                distinct_id: distinctId,
            })
            const evaluation = parseToolResponse(result)

            expect(evaluation.flag_key).toBe(createdFlag.key)
            expect(evaluation.result).toBe(true)
            expect(typeof evaluation.reason).toBe('string')
            expect(Array.isArray(evaluation.conditions)).toBe(true)
            expect(evaluation.person_properties).toBeTruthy()
        })
    })

    describe('Feature flag workflow', () => {
        it('should support full CRUD workflow', async () => {
            const createTool = GENERATED_TOOLS['create-feature-flag']!()
            const updateTool = GENERATED_TOOLS['update-feature-flag']!()
            const getTool = GENERATED_TOOLS['feature-flag-get-definition']!()
            const deleteTool = GENERATED_TOOLS['delete-feature-flag']!()

            const createResult = await createTool.handler(context, {
                name: 'Workflow test flag',
                key: generateUniqueKey('workflow-test'),
                filters: {
                    groups: [{ properties: [], rollout_percentage: 100 }],
                },
                active: false,
            })
            const createdFlag = parseToolResponse(createResult)

            const getResult = await getTool.handler(context, { id: createdFlag.id })
            const retrievedFlag = parseToolResponse(getResult)
            expect(retrievedFlag.id).toBe(createdFlag.id)

            const updateResult = await updateTool.handler(context, {
                id: createdFlag.id,
                active: true,
                name: 'Updated workflow flag',
            })
            const updatedFlag = parseToolResponse(updateResult)
            expect(updatedFlag.active).toBe(true)
            expect(updatedFlag.name).toBe('Updated workflow flag')

            await deleteTool.handler(context, { id: createdFlag.id })
        })
    })
})