: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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()
})
})
})