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.

22.1 KB
Raw Blame
import '@testing-library/jest-dom'

import { type RenderResult, cleanup, render, screen, fireEvent } from '@testing-library/react'
import userEvent from '@testing-library/user-event'

import { MAX_EXPERIMENT_VARIANTS } from 'lib/constants'

import { useMocks } from '~/mocks/jest'
import { initKeaTests } from '~/test/init'
import type { Experiment } from '~/types'

import { NEW_EXPERIMENT } from 'products/experiments/frontend/constants'
import type { ExperimentFlagVariantApi } from 'products/experiments/frontend/generated/api.schemas'

import { VariantsPanelCreateFeatureFlag } from './VariantsPanelCreateFeatureFlag'

// Draft flag config in the flag's own input shape, the source the panel reads and writes.
const flagConfig = (
    variants: ExperimentFlagVariantApi[],
    rolloutPercentage?: number
): Experiment['feature_flag_config'] => ({
    filters: {
        multivariate: { variants },
        ...(rolloutPercentage != null ? { groups: [{ properties: [], rollout_percentage: rolloutPercentage }] } : {}),
    },
})

// Mock JSONEditorInput since it uses Monaco editor which doesn't work in Jest
jest.mock('scenes/feature-flags/JSONEditorInput', () => ({
    JSONEditorInput: ({ onChange, value, placeholder, readOnly }: any) => (
        <input
            data-testid="json-editor-mock"
            value={value || ''}
            onChange={(e) => onChange?.(e.target.value)}
            placeholder={placeholder}
            readOnly={readOnly}
        />
    ),
}))

describe('VariantsPanelCreateFeatureFlag', () => {
    const mockOnChange = jest.fn()

    const defaultExperiment: Experiment = {
        ...NEW_EXPERIMENT,
        name: 'Test Experiment',
        feature_flag_key: 'test-experiment',
        feature_flag_config: flagConfig([
            { key: 'control', rollout_percentage: 50 },
            { key: 'test', rollout_percentage: 50 },
        ]),
    }

    const renderComponent = (experiment: Experiment): RenderResult => {
        return render(<VariantsPanelCreateFeatureFlag experiment={experiment} onChange={mockOnChange} />)
    }

    beforeEach(() => {
        useMocks({
            get: {
                '/api/projects/:team_id/feature_flags/': ({ request }) => {
                    const url = new URL(request.url)
                    const search = url.searchParams.get('search')

                    // Return existing key if searching for it
                    if (search === 'existing-key') {
                        return [
                            200,
                            {
                                results: [{ id: 1, key: 'existing-key', name: 'Existing' }],
                                count: 1,
                            },
                        ]
                    }

                    return [200, { results: [], count: 0 }]
                },
                '/api/projects/:team_id/experiments': () => [200, { results: [], count: 0 }],
            },
        })
        initKeaTests()
        jest.clearAllMocks()
    })

    afterEach(() => {
        cleanup()
    })

    describe('rendering', () => {
        it('renders variant keys section', () => {
            renderComponent(defaultExperiment)

            expect(screen.getByText('Variant key')).toBeInTheDocument()
        })

        it('renders default variants (control and test)', () => {
            renderComponent(defaultExperiment)

            const controlInput = screen.getByDisplayValue('control')
            const testInput = screen.getByDisplayValue('test')

            expect(controlInput).toBeInTheDocument()
            expect(testInput).toBeInTheDocument()
        })

        it('allows renaming the control variant for product experiments', () => {
            renderComponent(defaultExperiment)

            const controlInput = screen.getByDisplayValue('control')
            expect(controlInput).toBeEnabled()

            fireEvent.change(controlInput, { target: { value: 'baseline' } })

            expect(mockOnChange).toHaveBeenCalledWith(
                expect.objectContaining({
                    variants: [expect.objectContaining({ key: 'baseline' }), expect.objectContaining({ key: 'test' })],
                })
            )
        })

        it('locks the control variant key for web experiments', () => {
            renderComponent({ ...defaultExperiment, type: 'web' })

            expect(screen.getByDisplayValue('control')).toBeDisabled()
            expect(screen.getByDisplayValue('test')).toBeEnabled()
        })

        it('renders variant split labels by default', () => {
            renderComponent(defaultExperiment)

            const splitLabels = screen.getAllByText('50%')
            // 2 from the variants table + 2 from the distribution bar preview
            expect(splitLabels).toHaveLength(4)
        })

        it('renders add variant button', () => {
            renderComponent(defaultExperiment)

            expect(screen.getByText(/add variant/i)).toBeInTheDocument()
        })

        it('renders experience continuity checkbox', () => {
            renderComponent(defaultExperiment)

            expect(screen.getByText(/persist flag across authentication steps/i)).toBeInTheDocument()
            expect(screen.getByRole('checkbox')).toBeInTheDocument()
        })
    })

    describe('variant management', () => {
        it('adds a new variant when clicking add button', async () => {
            renderComponent(defaultExperiment)

            const addButton = screen.getByText(/add variant/i)
            await userEvent.click(addButton)

            expect(mockOnChange).toHaveBeenCalledWith(
                expect.objectContaining({
                    variants: expect.arrayContaining([
                        expect.objectContaining({ key: 'control' }),
                        expect.objectContaining({ key: 'test' }),
                        expect.objectContaining({ key: 'test-2' }),
                    ]),
                })
            )
        })

        it('redistributes percentages equally when adding variant', async () => {
            renderComponent(defaultExperiment)

            const addButton = screen.getByText(/add variant/i)
            await userEvent.click(addButton)

            expect(mockOnChange).toHaveBeenCalledWith(
                expect.objectContaining({
                    variants: expect.arrayContaining([
                        expect.objectContaining({ rollout_percentage: expect.any(Number) }),
                    ]),
                })
            )

            // Check that percentages sum to 100
            const call = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1][0]
            const sum = call.variants.reduce((acc: number, v: any) => acc + v.rollout_percentage, 0)
            expect(sum).toBe(100)
        })

        it('updates variant key when typing', async () => {
            const experimentWithEmptyVariantKey = {
                ...defaultExperiment,
                feature_flag_config: flagConfig([
                    { key: 'control', rollout_percentage: 50 },
                    { key: '', rollout_percentage: 50 },
                ]),
            }

            renderComponent(experimentWithEmptyVariantKey)

            const variantInputs = screen.getAllByPlaceholderText(/example-variant/)
            await userEvent.type(variantInputs[1], 'treatment')

            // Verify onChange was called with variant updates
            expect(mockOnChange).toHaveBeenCalled()
            const hasVariantUpdate = mockOnChange.mock.calls.some((call) => call[0].variants)
            expect(hasVariantUpdate).toBe(true)
        })

        it('updates rollout percentage after enabling custom split', async () => {
            const { container } = renderComponent(defaultExperiment)

            // Click pencil button to enable custom split editing
            await userEvent.click(screen.getByLabelText(/customize split/i))

            const percentageInputs = container.querySelectorAll(
                '[data-attr="experiment-variant-rollout-percentage-input"]'
            )
            const percentageInput = percentageInputs[0]

            await userEvent.clear(percentageInput)
            // Setting the value on type=number inputs with userEvent.type can be flaky
            // https://github.com/testing-library/user-event/issues/411
            await fireEvent.change(percentageInput, { target: { value: '70' } })

            // Check the last call
            const lastCall = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1]
            expect(lastCall[0]).toEqual(
                expect.objectContaining({
                    variants: expect.arrayContaining([
                        expect.objectContaining({ key: 'control', rollout_percentage: 70 }),
                    ]),
                })
            )
        })

        it('shows error when percentages do not sum to 100', () => {
            const invalidExperiment = {
                ...defaultExperiment,
                feature_flag_config: flagConfig([
                    { key: 'control', rollout_percentage: 40 },
                    { key: 'test', rollout_percentage: 40 },
                ]),
            }

            renderComponent(invalidExperiment)

            expect(screen.getByText(/must sum to 100 \(currently 80\)/i)).toBeInTheDocument()
        })

        it('removes variant when clicking delete button', async () => {
            const experimentWithThreeVariants = {
                ...defaultExperiment,
                feature_flag_config: flagConfig([
                    { key: 'control', rollout_percentage: 33 },
                    { key: 'test', rollout_percentage: 33 },
                    { key: 'test-2', rollout_percentage: 34 },
                ]),
            }

            const { container } = renderComponent(experimentWithThreeVariants)

            const deleteButtons = container.querySelectorAll('[data-attr^="delete-prop-filter"]')

            // Click the first delete button (which is for the second variant, since control has no delete button)
            await userEvent.click(deleteButtons[0] as Element)

            expect(mockOnChange).toHaveBeenCalledWith(
                expect.objectContaining({
                    variants: expect.arrayContaining([
                        expect.objectContaining({ key: 'control' }),
                        expect.objectContaining({ key: 'test-2' }),
                    ]),
                })
            )
        })

        it('does not show delete button for control variant', () => {
            const experimentWithThreeVariants = {
                ...defaultExperiment,
                feature_flag_config: flagConfig([
                    { key: 'control', rollout_percentage: 33 },
                    { key: 'test', rollout_percentage: 33 },
                    { key: 'test-2', rollout_percentage: 34 },
                ]),
            }

            const { container } = render(
                <VariantsPanelCreateFeatureFlag experiment={experimentWithThreeVariants} onChange={mockOnChange} />
            )

            const rows = container.querySelectorAll('tbody tr')
            const controlRow = rows[0] // First row (control variant)

            // Control variant should not have a delete button
            const deleteButton = controlRow.querySelector('[data-attr^="delete-prop-filter"]')
            expect(deleteButton).not.toBeInTheDocument()
        })
    })

    describe('rollout distribution', () => {
        it('redistributes percentages equally when clicking balance button', async () => {
            const unevenExperiment = {
                ...defaultExperiment,
                feature_flag_config: flagConfig([
                    { key: 'control', rollout_percentage: 20 },
                    { key: 'test', rollout_percentage: 80 },
                ]),
            }

            renderComponent(unevenExperiment)

            const balanceButton = screen.getByTestId('distribute-variants-equally')
            await userEvent.click(balanceButton)

            expect(mockOnChange).toHaveBeenCalledWith(
                expect.objectContaining({
                    variants: [
                        expect.objectContaining({ key: 'control', rollout_percentage: 50 }),
                        expect.objectContaining({ key: 'test', rollout_percentage: 50 }),
                    ],
                })
            )
        })

        it.each([
            { inputValue: '70', expectedControl: 70, expectedTest: 30 },
            { inputValue: '90', expectedControl: 90, expectedTest: 10 },
            { inputValue: '0', expectedControl: 0, expectedTest: 100 },
            { inputValue: '100', expectedControl: 100, expectedTest: 0 },
        ])(
            'auto-balances second variant to $expectedTest% when control is set to $expectedControl% with 2 variants',
            async ({ inputValue, expectedControl, expectedTest }) => {
                const { container } = renderComponent(defaultExperiment)

                const customizeButton = screen.getByLabelText(/customize split/i)
                await userEvent.click(customizeButton)

                const percentageInputs = container.querySelectorAll(
                    '[data-attr="experiment-variant-rollout-percentage-input"]'
                )

                await userEvent.clear(percentageInputs[0] as Element)
                await fireEvent.change(percentageInputs[0] as Element, { target: { value: inputValue } })

                const lastCall = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1][0]
                expect(lastCall.variants).toEqual([
                    expect.objectContaining({ key: 'control', rollout_percentage: expectedControl }),
                    expect.objectContaining({ key: 'test', rollout_percentage: expectedTest }),
                ])
            }
        )

        it('does not auto-balance other variants when there are more than 2', async () => {
            const threeVariantExperiment = {
                ...defaultExperiment,
                feature_flag_config: flagConfig([
                    { key: 'control', rollout_percentage: 34 },
                    { key: 'test', rollout_percentage: 33 },
                    { key: 'test-2', rollout_percentage: 33 },
                ]),
            }

            const { container } = renderComponent(threeVariantExperiment)

            const customizeButton = screen.getByLabelText(/customize split/i)
            await userEvent.click(customizeButton)

            const percentageInputs = container.querySelectorAll(
                '[data-attr="experiment-variant-rollout-percentage-input"]'
            )

            await userEvent.clear(percentageInputs[0] as Element)
            await fireEvent.change(percentageInputs[0] as Element, { target: { value: '10' } })

            const lastCall = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1][0]
            expect(lastCall.variants).toEqual([
                expect.objectContaining({ key: 'control', rollout_percentage: 10 }),
                expect.objectContaining({ key: 'test', rollout_percentage: 33 }),
                expect.objectContaining({ key: 'test-2', rollout_percentage: 33 }),
            ])
        })
    })

    describe('experience continuity', () => {
        it('toggles experience continuity checkbox', async () => {
            renderComponent(defaultExperiment)

            const checkbox = screen.getByRole('checkbox')
            await userEvent.click(checkbox)

            expect(mockOnChange).toHaveBeenCalledWith(
                expect.objectContaining({
                    ensure_experience_continuity: true,
                })
            )
        })

        it('defaults to unchecked', () => {
            renderComponent(defaultExperiment)

            const checkbox = screen.getByRole('checkbox') as HTMLInputElement
            expect(checkbox.checked).toBe(false)
        })
    })

    describe('rollout percentage', () => {
        it('renders rollout percentage section with default value of 100', () => {
            renderComponent(defaultExperiment)

            expect(screen.getByText('Rollout')).toBeInTheDocument()
            const slider = screen.getByRole('slider')
            expect(slider).toHaveAttribute('aria-valuenow', '100')
        })

        it('renders rollout percentage from the draft flag config', () => {
            const experimentWithRollout = {
                ...defaultExperiment,
                feature_flag_config: flagConfig(
                    [
                        { key: 'control', rollout_percentage: 50 },
                        { key: 'test', rollout_percentage: 50 },
                    ],
                    75
                ),
            }

            renderComponent(experimentWithRollout)

            const slider = screen.getByRole('slider')
            expect(slider).toHaveAttribute('aria-valuenow', '75')
        })

        it('calls onChange with rollout_percentage when input value changes', async () => {
            const { container } = renderComponent(defaultExperiment)

            const rolloutInput = container.querySelector(
                '[data-attr="experiment-rollout-percentage-input"]'
            ) as HTMLInputElement

            await userEvent.clear(rolloutInput)
            await fireEvent.change(rolloutInput, { target: { value: '50' } })

            const lastCall = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1][0]
            expect(lastCall).toEqual(
                expect.objectContaining({
                    rollout_percentage: 50,
                })
            )
        })

        it('preserves rollout_percentage when variants are modified', async () => {
            const experimentWithRollout = {
                ...defaultExperiment,
                feature_flag_config: flagConfig(
                    [
                        { key: 'control', rollout_percentage: 50 },
                        { key: 'test', rollout_percentage: 50 },
                    ],
                    75
                ),
            }

            renderComponent(experimentWithRollout)

            const addButton = screen.getByText(/add variant/i)
            await userEvent.click(addButton)

            const lastCall = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1][0]
            expect(lastCall.rollout_percentage).toBe(75)
        })

        it('preserves rollout_percentage when experience continuity is toggled', async () => {
            const experimentWithRollout = {
                ...defaultExperiment,
                feature_flag_config: flagConfig(
                    [
                        { key: 'control', rollout_percentage: 50 },
                        { key: 'test', rollout_percentage: 50 },
                    ],
                    60
                ),
            }

            renderComponent(experimentWithRollout)

            const checkbox = screen.getByRole('checkbox')
            await userEvent.click(checkbox)

            const lastCall = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1][0]
            expect(lastCall.rollout_percentage).toBe(60)
        })
    })

    describe('traffic preview with uneven splits', () => {
        it.each([
            {
                name: '30/70 split at 50% rollout',
                variants: [
                    { key: 'control', rollout_percentage: 30 },
                    { key: 'test', rollout_percentage: 70 },
                ],
                rolloutPercentage: 50,
                expectedSlotWidths: ['30%', '70%'],
                expectedLabels: ['15%', '35%'],
            },
            {
                name: '90/10 split at 50% rollout',
                variants: [
                    { key: 'control', rollout_percentage: 90 },
                    { key: 'test', rollout_percentage: 10 },
                ],
                rolloutPercentage: 50,
                expectedSlotWidths: ['90%', '10%'],
                expectedLabels: ['45%', '5%'],
            },
            {
                name: '90/10 split at 80% rollout',
                variants: [
                    { key: 'control', rollout_percentage: 90 },
                    { key: 'test', rollout_percentage: 10 },
                ],
                rolloutPercentage: 80,
                expectedSlotWidths: ['90%', '10%'],
                expectedLabels: ['72%', '8%'],
            },
        ])(
            'renders correct slot widths and labels for $name',
            ({ variants, rolloutPercentage, expectedSlotWidths, expectedLabels }) => {
                const experiment = {
                    ...defaultExperiment,
                    feature_flag_config: flagConfig(variants, rolloutPercentage),
                }

                const { container } = renderComponent(experiment)

                const barSlots = container.querySelectorAll('.h-10 > .h-full.flex')
                expect(barSlots).toHaveLength(variants.length)
                expectedSlotWidths.forEach((width, i) => {
                    expect((barSlots[i] as HTMLElement).style.width).toBe(width)
                })

                expectedLabels.forEach((label) => {
                    expect(screen.getByText(label)).toBeInTheDocument()
                })
            }
        )
    })

    describe('edge cases', () => {
        it('handles experiment without draft flag config', () => {
            const experimentWithoutConfig = {
                ...NEW_EXPERIMENT,
                name: 'Test',
                feature_flag_key: '',
                feature_flag_config: undefined,
            }

            renderComponent(experimentWithoutConfig)

            // Should render with default variants
            expect(screen.getByDisplayValue('control')).toBeInTheDocument()
            expect(screen.getByDisplayValue('test')).toBeInTheDocument()
        })

        it('prevents adding more than maximum variants', async () => {
            const maxVariants = Array.from({ length: MAX_EXPERIMENT_VARIANTS }, (_, i) => ({
                key: `variant-${i}`,
                rollout_percentage: 5,
            }))

            const experimentWithMaxVariants = {
                ...defaultExperiment,
                feature_flag_config: flagConfig(maxVariants),
            }

            renderComponent(experimentWithMaxVariants)

            const addButton = screen.queryByText(/add variant/i)
            expect(addButton).not.toBeInTheDocument()
        })
    })
})