: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 { MOCK_DEFAULT_TEAM } from 'lib/api.mock'
import { combineUrl, router } from 'kea-router'
import { expectLogic } from 'kea-test-utils'
import { tabUiStateLogic } from 'lib/logic/tabUiStateLogic'
import { teamLogic } from 'scenes/teamLogic'
import { urls } from 'scenes/urls'
import { FlagEvaluationsModeEnumApi } from '~/generated/core/api.schemas'
import { useMocks } from '~/mocks/jest'
import { DataTableNode, EventsQuery, NodeKind } from '~/queries/schema/schema-general'
import { initKeaTests } from '~/test/init'
import { ActivityTab, PropertyFilterType, PropertyOperator } from '~/types'
import { getEventLookupQuery } from './defaults'
import { FlagCallsNote, eventsSceneLogic } from './eventsSceneLogic'
const LOOKUP_UUID = '018f0000-0000-7000-8000-000000000002'
describe('eventsSceneLogic', () => {
let logic: ReturnType<typeof eventsSceneLogic.build>
beforeEach(() => {
useMocks({
get: {
'/api/environments/:team_id/query': () => [200, { results: [] }],
},
})
initKeaTests()
logic = eventsSceneLogic()
logic.mount()
})
it('picks up a drill-down events query from the #q= hash', async () => {
// The "View events" persons-modal action deep-links here with an events DataTableNode in the hash.
const query: DataTableNode = {
kind: NodeKind.DataTableNode,
source: {
kind: NodeKind.EventsQuery,
select: ['*', 'event', 'person', 'timestamp'],
event: '$pageview',
after: 'all',
} as any,
full: true,
}
router.actions.push(combineUrl(urls.activity(ActivityTab.ExploreEvents), {}, { q: query }).url)
await expectLogic(logic).toFinishAllListeners()
expect(logic.values.query).toEqual(query)
})
test.each<[string, FlagEvaluationsModeEnumApi, Partial<EventsQuery>, FlagCallsNote | null]>([
['an unfiltered list', FlagEvaluationsModeEnumApi.Number2, {}, 'stored-separately'],
[
'a list filtered to another event',
FlagEvaluationsModeEnumApi.Number2,
{ events: ['$pageview'] },
'stored-separately',
],
[
'a list filtered to flag calls and another event',
FlagEvaluationsModeEnumApi.Number2,
{ events: ['$feature_flag_called', '$pageview'] },
'stored-separately',
],
[
'a list filtered to flag calls',
FlagEvaluationsModeEnumApi.Number2,
{ events: ['$feature_flag_called'] },
null,
],
[
'a list filtered to flag calls by the single event field',
FlagEvaluationsModeEnumApi.Number2,
{ event: '$feature_flag_called' },
null,
],
[
'a list filtered to flag calls and an action',
FlagEvaluationsModeEnumApi.Number2,
{ event: '$feature_flag_called', actionId: 1 },
'stored-separately',
],
[
'a list filtered to flag calls and action steps',
FlagEvaluationsModeEnumApi.Number2,
{ event: '$feature_flag_called', actionSteps: [{ event: '$feature_flag_called' }] },
'stored-separately',
],
['an unfiltered list on the read flag evaluations mode', FlagEvaluationsModeEnumApi.Number1, {}, null],
[
'flag calls over a range older than the retention window',
FlagEvaluationsModeEnumApi.Number1,
{ event: '$feature_flag_called', after: '-180d' },
'retention',
],
[
'flag calls over all time',
FlagEvaluationsModeEnumApi.Number2,
{ events: ['$feature_flag_called'], after: 'all' },
'retention',
],
[
'flag calls over a range inside the retention window',
FlagEvaluationsModeEnumApi.Number1,
{ event: '$feature_flag_called', after: '-30d' },
null,
],
[
'flag calls over all time on the events mode',
FlagEvaluationsModeEnumApi.Number0,
{ event: '$feature_flag_called', after: 'all' },
null,
],
])('decides which flag calls note shows for %s', (_name, mode, eventFilter, expected) => {
teamLogic.actions.loadCurrentTeamSuccess({ ...MOCK_DEFAULT_TEAM, flag_evaluations_mode: mode })
const query: DataTableNode = {
kind: NodeKind.DataTableNode,
source: { kind: NodeKind.EventsQuery, select: ['*', 'event', 'timestamp'], ...eventFilter },
}
logic.actions.setQuery(query)
expect(logic.values.flagCallsNote).toBe(expected)
})
test.each<
[
string,
FlagEvaluationsModeEnumApi,
Partial<EventsQuery>,
'row' | 'no row' | 'error',
'link' | 'link, then edit' | 'edit' | 'restore',
string | undefined,
]
>([
[
'a link to a flag call on mode 2',
FlagEvaluationsModeEnumApi.Number2,
{},
'row',
'link',
'$feature_flag_called',
],
[
'a link on mode 2 that flag_evaluations does not hold',
FlagEvaluationsModeEnumApi.Number2,
{},
'no row',
'link',
undefined,
],
[
'a link on mode 2 whose flag call query fails',
FlagEvaluationsModeEnumApi.Number2,
{},
'error',
'link',
undefined,
],
['a link on mode 1', FlagEvaluationsModeEnumApi.Number1, {}, 'row', 'link', undefined],
[
'a link that names its event',
FlagEvaluationsModeEnumApi.Number2,
{ event: '$pageview' },
'row',
'link',
'$pageview',
],
[
'a link with another filter',
FlagEvaluationsModeEnumApi.Number2,
{
properties: [
...(getEventLookupQuery(LOOKUP_UUID).source as EventsQuery).properties!,
{
type: PropertyFilterType.Event,
key: '$browser',
operator: PropertyOperator.Exact,
value: 'Chrome',
},
],
},
'row',
'link',
undefined,
],
[
'a link whose query the user edits before the check answers',
FlagEvaluationsModeEnumApi.Number2,
{},
'row',
'link, then edit',
undefined,
],
['an edit that clears the event of a lookup', FlagEvaluationsModeEnumApi.Number2, {}, 'row', 'edit', undefined],
[
'a restored tab whose lookup names no event',
FlagEvaluationsModeEnumApi.Number2,
{},
'row',
'restore',
undefined,
],
])(
'resolves the event name for %s',
async (_name, mode, sourceOverrides, flagCallQuery, arrival, expectedEvent) => {
const after = '2026-08-24T00:00:00.000Z'
const before = '2026-08-24T00:00:30.000Z'
useMocks({
post: {
'/api/environments/:team_id/query/:kind': async ({ request }) => {
const { query } = (await request.json()) as Record<string, any>
const asksForTheFlagCall =
query.kind === NodeKind.EventsQuery &&
query.event === '$feature_flag_called' &&
JSON.stringify(query.properties).includes(LOOKUP_UUID) &&
query.after === after &&
query.before === before
if (asksForTheFlagCall && flagCallQuery === 'error') {
return [500, { detail: 'Query failed' }]
}
return [200, { results: asksForTheFlagCall && flagCallQuery === 'row' ? [[LOOKUP_UUID]] : [] }]
},
},
})
teamLogic.actions.loadCurrentTeamSuccess({ ...MOCK_DEFAULT_TEAM, flag_evaluations_mode: mode })
const lookup = getEventLookupQuery(LOOKUP_UUID)
const query: DataTableNode = {
...lookup,
source: { ...(lookup.source as EventsQuery), after, before, ...sourceOverrides },
}
const linkUrl = combineUrl(urls.activity(ActivityTab.ExploreEvents), {}, { q: query }).url
switch (arrival) {
case 'link':
router.actions.push(linkUrl)
break
case 'link, then edit': {
router.actions.push(linkUrl)
const edited: DataTableNode = {
...query,
source: { ...(query.source as EventsQuery), after: '-7d' },
}
logic.actions.setQuery(edited)
break
}
case 'edit':
logic.actions.setQuery(query)
break
case 'restore':
tabUiStateLogic.actions.setSavedQueryForTab(undefined, 'events', query)
router.actions.push(urls.activity(ActivityTab.ExploreEvents))
break
}
await expectLogic(logic).toFinishAllListeners()
expect(((logic.values.query as DataTableNode).source as EventsQuery).event).toBe(expectedEvent)
}
)
it('keeps a cleared event when a later edit writes an undefined key', async () => {
let flagCallQueries = 0
useMocks({
post: {
'/api/environments/:team_id/query/:kind': async ({ request }) => {
const { query } = (await request.json()) as Record<string, any>
if (query.event !== '$feature_flag_called') {
return [200, { results: [] }]
}
flagCallQueries++
return [200, { results: [[LOOKUP_UUID]] }]
},
},
})
teamLogic.actions.loadCurrentTeamSuccess({
...MOCK_DEFAULT_TEAM,
flag_evaluations_mode: FlagEvaluationsModeEnumApi.Number2,
})
router.actions.push(
combineUrl(urls.activity(ActivityTab.ExploreEvents), {}, { q: getEventLookupQuery(LOOKUP_UUID) }).url
)
await expectLogic(logic).toFinishAllListeners()
const named = logic.values.query as DataTableNode
const cleared: DataTableNode = { ...named, source: { ...(named.source as EventsQuery), event: '' } }
const redated: DataTableNode = {
...cleared,
source: { ...(cleared.source as EventsQuery), after: '-24h', before: undefined },
}
logic.actions.setQuery(cleared)
await expectLogic(logic).toFinishAllListeners()
logic.actions.setQuery(redated)
await expectLogic(logic).toFinishAllListeners()
expect(((logic.values.query as DataTableNode).source as EventsQuery).event).toBe('')
expect(flagCallQueries).toBe(1)
})
})