: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 {
ExperimentEventExposureConfig,
ExperimentExposureConfig,
ExperimentExposureCriteria,
HogQLQueryModifiers,
NodeKind,
} from '~/queries/schema/schema-general'
import { AnyPropertyFilter, PropertyFilterType, PropertyOperator } from '~/types'
import {
exposureEventLabel,
getActivationConfig,
getExposureEventAndProperty,
hasNegatedEventFilter,
isDefaultExposureConfig,
resolvedExposureEvent,
} from './exposureContract'
describe('exposureContract', () => {
it('uses the rollout event for a local draft without a server-resolved event', () => {
expect(resolvedExposureEvent({}, '$experiment_exposure')).toBe('$experiment_exposure')
})
it('prefers the server-resolved event over the local draft fallback', () => {
expect(resolvedExposureEvent({ resolved_exposure_event: '$feature_flag_called' }, '$experiment_exposure')).toBe(
'$feature_flag_called'
)
})
it.each([
['$experiment_exposure', 'Experiment exposure'],
['$feature_flag_called', 'Feature flag is called'],
])('labels %s as %s', (event, expectedLabel) => {
expect(exposureEventLabel(event)).toBe(expectedLabel)
})
it.each([
[
'stored default config',
{
kind: NodeKind.ExperimentEventExposureConfig,
event: '$feature_flag_called',
properties: [],
},
true,
],
[
'custom event config',
{ kind: NodeKind.ExperimentEventExposureConfig, event: 'checkout_started', properties: [] },
false,
],
['action config', { kind: NodeKind.ActionsNode, id: 42 }, false],
])('identifies %s for exposure labels', (_name, exposureConfig, expected) => {
expect(
isDefaultExposureConfig(exposureConfig as NonNullable<ExperimentExposureCriteria['exposure_config']>)
).toBe(expected)
})
// Guards the three-way branch that mirrors the backend `get_exposure_event_and_property`:
// action configs must yield `event: null` (actions match multiple events) so callers never
// filter action-based exposures down to a single event name.
it.each<[string, ExperimentExposureCriteria | undefined, { event: string | null; variantProperty: string }]>([
['no exposure config', undefined, { event: '$feature_flag_called', variantProperty: '$feature_flag_response' }],
[
'default $feature_flag_called config',
{
exposure_config: {
kind: NodeKind.ExperimentEventExposureConfig,
event: '$feature_flag_called',
properties: [],
},
},
{ event: '$feature_flag_called', variantProperty: '$feature_flag_response' },
],
[
'custom event config',
{
exposure_config: {
kind: NodeKind.ExperimentEventExposureConfig,
event: 'checkout_started',
properties: [],
},
},
{ event: 'checkout_started', variantProperty: '$feature/my-flag' },
],
[
'action config',
{ exposure_config: { kind: NodeKind.ActionsNode, id: 42 } },
{ event: null, variantProperty: '$feature/my-flag' },
],
])('resolves the exposure event and variant property for %s', (_name, exposureCriteria, expected) => {
expect(getExposureEventAndProperty({ featureFlagKey: 'my-flag', exposureCriteria })).toEqual(expected)
})
// The rollout swaps the default event server-side, so the default branches must name the
// resolved event while a custom event stays untouched.
it.each<[string, ExperimentExposureCriteria | undefined, string | null]>([
['no exposure config', undefined, '$experiment_exposure'],
[
'default $feature_flag_called config',
{
exposure_config: {
kind: NodeKind.ExperimentEventExposureConfig,
event: '$feature_flag_called',
properties: [],
},
},
'$experiment_exposure',
],
[
'custom event config',
{
exposure_config: {
kind: NodeKind.ExperimentEventExposureConfig,
event: 'checkout_started',
properties: [],
},
},
'checkout_started',
],
['action config', { exposure_config: { kind: NodeKind.ActionsNode, id: 42 } }, null],
])('uses the resolved default event for %s', (_name, exposureCriteria, expectedEvent) => {
expect(
getExposureEventAndProperty({
featureFlagKey: 'my-flag',
exposureCriteria,
resolvedExposureEvent: '$experiment_exposure',
}).event
).toBe(expectedEvent)
})
// Mirrors the backend `has_activation_config` gate: activation only composes with the
// default exposure, so a custom exposure_config must disable it.
const activationConfig: ExperimentEventExposureConfig = {
kind: NodeKind.ExperimentEventExposureConfig,
event: 'activated',
properties: [],
}
it.each<[string, ExperimentExposureCriteria | undefined, boolean]>([
['no criteria', undefined, false],
['activation alone', { activation_config: activationConfig }, true],
[
'activation with the stored default exposure config',
{
exposure_config: {
kind: NodeKind.ExperimentEventExposureConfig,
event: '$feature_flag_called',
properties: [],
},
activation_config: activationConfig,
},
true,
],
[
'activation with a pinned $experiment_exposure config',
{
exposure_config: {
kind: NodeKind.ExperimentEventExposureConfig,
event: '$experiment_exposure',
properties: [],
},
activation_config: activationConfig,
},
true,
],
[
'activation ignored under a custom exposure config',
{
exposure_config: {
kind: NodeKind.ExperimentEventExposureConfig,
event: 'checkout_started',
properties: [],
},
activation_config: activationConfig,
},
false,
],
[
'activation ignored under an action exposure config',
{
exposure_config: { kind: NodeKind.ActionsNode, id: 42 },
activation_config: activationConfig,
},
false,
],
])('resolves the activation config for %s', (_name, exposureCriteria, expectActive) => {
expect(getActivationConfig(exposureCriteria)).toEqual(expectActive ? activationConfig : undefined)
})
const eventConfig = (...properties: AnyPropertyFilter[]): ExperimentEventExposureConfig => ({
kind: NodeKind.ExperimentEventExposureConfig,
event: '$pageview',
properties,
})
const eventFilter = (key: string, operator: PropertyOperator): AnyPropertyFilter => ({
type: PropertyFilterType.Event,
key,
operator,
value: 'x',
})
const negatedPersonFilter: AnyPropertyFilter = {
type: PropertyFilterType.Person,
key: 'email',
operator: PropertyOperator.NotIContains,
value: 'x',
}
it.each<
[
string,
ExperimentExposureConfig | undefined,
boolean,
(number | null)?,
HogQLQueryModifiers['personsOnEventsMode']?,
]
>([
['no config', undefined, false],
['no filters', eventConfig(), false],
['a negated event filter', eventConfig(eventFilter('$current_url', PropertyOperator.NotIContains)), true],
['a negated filter without a value', eventConfig(eventFilter('step', PropertyOperator.IsNotSet)), true],
['a filter that selects', eventConfig(eventFilter('$current_url', PropertyOperator.IContains)), false],
['a negated filter on the flag key', eventConfig(eventFilter('$feature_flag', PropertyOperator.IsNot)), false],
[
'a negated filter on the group a group experiment counts',
eventConfig(eventFilter('$group_2', PropertyOperator.IsNot)),
false,
2,
],
[
'a negated filter on a group key in a person experiment',
eventConfig(eventFilter('$group_2', PropertyOperator.IsNot)),
true,
null,
],
['a negated person filter read from the persons table', eventConfig(negatedPersonFilter), false],
[
'a negated person filter read from the events',
eventConfig(negatedPersonFilter),
true,
null,
'person_id_override_properties_on_events',
],
['a negated person filter in a group experiment', eventConfig(negatedPersonFilter), true, 2],
[
'a negated session filter',
eventConfig({
type: PropertyFilterType.Session,
key: '$entry_current_url',
operator: PropertyOperator.NotIContains,
value: 'x',
}),
true,
],
[
'an action with a negated event filter',
{
kind: NodeKind.ActionsNode,
id: 1,
properties: [eventFilter('$current_url', PropertyOperator.IsNot)],
},
true,
],
[
'a warehouse exposure',
{
kind: NodeKind.ExperimentWarehouseNativeExposureConfig,
connection_id: 'x',
query: 'SELECT 1',
unit: { unit_type: 'customer', id_namespace: 'billing_customer_id' },
},
false,
],
])(
'reads whether the config leaves out events for %s',
(
_name,
config,
expected,
groupTypeIndex = null,
personsOnEventsMode = 'person_id_override_properties_joined'
) => {
expect(hasNegatedEventFilter(config, groupTypeIndex, personsOnEventsMode)).toBe(expected)
}
)
})