: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_TEAM_ID } from 'lib/api.mock'
import { expectLogic, partial } from 'kea-test-utils'
import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
import { teamLogic } from 'scenes/teamLogic'
import { dataNodeLogic } from '~/queries/nodes/DataNode/dataNodeLogic'
import { DataTableRow, dataTableLogic } from '~/queries/nodes/DataTable/dataTableLogic'
import { performQuery } from '~/queries/query'
import { setLatestVersionsOnQuery } from '~/queries/schema/query-versions'
import { DataTableNode, NodeKind } from '~/queries/schema/schema-general'
import { initKeaTests } from '~/test/init'
jest.mock('~/queries/query')
const testUniqueKey = 'testUniqueKey'
function getDataTableQuery(extras?: {
orderBy?: string[]
select?: string[]
allowSorting?: boolean
showOpenEditorButton?: boolean
}): DataTableNode {
return setLatestVersionsOnQuery({
kind: NodeKind.DataTableNode,
source: {
kind: NodeKind.EventsQuery,
select: extras?.select || ['*', 'event', 'timestamp'],
...(extras?.orderBy ? { orderBy: extras.orderBy } : {}),
},
...(extras?.allowSorting !== undefined ? { allowSorting: extras.allowSorting } : {}),
...(extras?.showOpenEditorButton !== undefined ? { showOpenEditorButton: extras.showOpenEditorButton } : {}),
})
}
describe('dataTableLogic', () => {
let logic: ReturnType<typeof dataTableLogic.build>
beforeEach(async () => {
initKeaTests()
featureFlagLogic.mount()
})
afterEach(() => logic?.unmount())
it('gets the response from dataNodeLogic', async () => {
const dataTableQuery: DataTableNode = getDataTableQuery()
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: dataTableQuery,
})
const randomResponse = null
;(performQuery as any).mockResolvedValueOnce(randomResponse)
logic.mount()
const builtDataNodeLogic = dataNodeLogic({ key: testUniqueKey, query: dataTableQuery.source })
await expectLogic(logic).toMount([builtDataNodeLogic])
await expectLogic(logic).delay(0).toMatchValues({
responseLoading: false,
response: randomResponse,
})
await expectLogic(builtDataNodeLogic).toMatchValues({
responseLoading: false,
response: randomResponse,
})
expect(performQuery).toHaveBeenCalledWith(
setLatestVersionsOnQuery({ kind: 'EventsQuery', select: ['*', 'event', 'timestamp'] }),
{ signal: expect.any(Object), onRequestTiming: expect.any(Function) },
'blocking',
expect.any(String),
expect.any(Function),
undefined,
undefined,
false,
undefined
)
expect(performQuery).toHaveBeenCalledTimes(1)
})
it('rejects if passed anything other than a DataTableNode', async () => {
expect(() => {
dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: {
kind: NodeKind.EventsQuery,
select: ['*', 'event', 'timestamp'],
} as any, // explicitly passing bad data
})
}).toThrow('dataTableLogic only accepts queries of type DataTableNode')
})
it('extracts sourceKind and orderBy', async () => {
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery(),
})
logic.mount()
await expectLogic(logic).toMatchValues({
sourceKind: NodeKind.EventsQuery,
orderBy: ['timestamp DESC'],
})
// change props
dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery({ orderBy: ['event'] }),
})
await expectLogic(logic)
.delay(0)
.toMatchValues({
sourceKind: NodeKind.EventsQuery,
orderBy: ['event'],
})
// change props
dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: {
kind: NodeKind.DataTableNode,
source: {
kind: NodeKind.PersonsNode,
},
},
})
await expectLogic(logic).toMatchValues({
sourceKind: NodeKind.PersonsNode,
orderBy: null,
})
})
it('updates local columns if query changed', async () => {
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery(),
})
logic.mount()
await expectLogic(logic).toMatchValues({
columnsInQuery: ['*', 'event', 'timestamp'],
})
// change props
dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery({ select: ['*', 'event', 'timestamp', 'properties.foobar'] }),
})
await expectLogic(logic).toMatchValues({
columnsInQuery: ['*', 'event', 'timestamp', 'properties.foobar'],
})
})
it('adds category rows for default live events table', async () => {
const commonResult = {
uuid: '01853a90-ba94-0000-8776-e8df5617c3ec',
event: 'update user properties',
properties: {},
team_id: 1,
distinct_id: '123',
}
const results = [
[
{ ...commonResult, timestamp: '2022-12-24T17:00:41.165000Z' },
'update user properties',
'2022-12-24T17:00:41.165000Z',
],
[
{ ...commonResult, timestamp: '2022-12-23T17:00:41.165000Z' },
'update user properties',
'2022-12-23T17:00:41.165000Z',
],
[
{ ...commonResult, timestamp: '2022-12-23T16:00:41.165000Z' },
'update user properties',
'2022-12-23T16:00:41.165000Z',
],
[
{ ...commonResult, timestamp: '2022-12-22T17:00:41.165000Z' },
'update user properties',
'2022-12-22T17:00:41.165000Z',
],
[
{ ...commonResult, timestamp: '2022-12-22T16:00:41.165000Z' },
'update user properties',
'2022-12-22T16:00:41.165000Z',
],
]
;(performQuery as any).mockResolvedValueOnce({
columns: ['*', 'event', 'timestamp'],
types: [
"Tuple(UUID, String, String, DateTime64(6, 'UTC'), Int64, String, String, DateTime64(6, 'UTC'), UUID, DateTime64(3), String)",
'String',
"DateTime64(6, 'UTC')",
],
results: results,
hasMore: true,
})
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: {
kind: NodeKind.DataTableNode,
source: {
kind: NodeKind.EventsQuery,
select: ['*', 'event', 'timestamp'],
},
},
})
logic.mount()
expect(performQuery).toHaveBeenCalledTimes(1)
await expectLogic(logic)
.toMatchValues({ responseLoading: true })
.delay(0)
.toMatchValues({ responseLoading: false, response: partial({ results }) })
await expectLogic(logic).toMatchValues({
dataTableRows: [
{ result: results[0] },
{ label: 'December 23, 2022' },
{ result: results[1] },
{ result: results[2] },
{ label: 'December 22, 2022' },
{ result: results[3] },
{ result: results[4] },
],
})
})
it('respects allowSorting', async () => {
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery({ allowSorting: false }),
})
logic.mount()
await expectLogic(logic).toMatchValues({
canSort: false,
})
// change props
dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery({ allowSorting: true }),
})
await expectLogic(logic).delay(0).toMatchValues({
canSort: true,
})
})
it('defaults to showing the open editor button', async () => {
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery(),
})
logic.mount()
await expectLogic(logic).toMatchValues({
queryWithDefaults: expect.objectContaining({
showOpenEditorButton: true,
}),
})
})
it('query can set whether showing the open editor button', async () => {
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery({ showOpenEditorButton: false }),
})
logic.mount()
await expectLogic(logic).toMatchValues({
queryWithDefaults: expect.objectContaining({
showOpenEditorButton: false,
}),
})
})
it('context can set whether showing the open editor button', async () => {
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: getDataTableQuery(),
context: {
showOpenEditorButton: false,
},
})
logic.mount()
await expectLogic(logic).toMatchValues({
queryWithDefaults: expect.objectContaining({
showOpenEditorButton: false,
}),
})
})
it.each([
{
timezone: 'US/Pacific',
// 2022-12-24T05:00Z = Dec 23 21:00 PST; 2022-12-24T10:00Z = Dec 24 02:00 PST
timestamps: ['2022-12-24T10:00:00.000000Z', '2022-12-24T05:00:00.000000Z'],
expectedLabel: 'December 23, 2022',
},
{
timezone: 'Asia/Tokyo',
// 2022-12-24T15:00Z = Dec 25 00:00 JST; 2022-12-24T14:00Z = Dec 24 23:00 JST
timestamps: ['2022-12-24T15:00:00.000000Z', '2022-12-24T14:00:00.000000Z'],
expectedLabel: 'December 24, 2022',
},
])('groups date headers by project timezone ($timezone)', async ({ timezone, timestamps, expectedLabel }) => {
teamLogic.mount()
teamLogic.actions.loadCurrentTeamSuccess({ id: MOCK_TEAM_ID, timezone } as any)
const commonResult = {
uuid: '01853a90-ba94-0000-8776-e8df5617c3ec',
event: 'test event',
properties: {},
team_id: 1,
distinct_id: '123',
}
const results = timestamps.map((ts) => [{ ...commonResult, timestamp: ts }, 'test event', ts])
;(performQuery as any).mockResolvedValueOnce({
columns: ['*', 'event', 'timestamp'],
types: [
"Tuple(UUID, String, String, DateTime64(6, 'UTC'), Int64, String, String, DateTime64(6, 'UTC'), UUID, DateTime64(3), String)",
'String',
"DateTime64(6, 'UTC')",
],
results,
hasMore: false,
})
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: {
kind: NodeKind.DataTableNode,
source: {
kind: NodeKind.EventsQuery,
select: ['*', 'event', 'timestamp'],
},
},
})
logic.mount()
await expectLogic(logic)
.toMatchValues({ responseLoading: true })
.delay(0)
.toMatchValues({ responseLoading: false })
await expectLogic(logic).toMatchValues({
dataTableRows: [{ result: results[0] }, { label: expectedLabel }, { result: results[1] }],
})
})
it('keeps the dataTableRows reference stable when a reload returns deep-equal results', async () => {
// A poll or reload reparses JSON, so a byte-identical response still arrives as all-new
// object identities. Without result equality on dataTableRows every row's memoized
// TableRow re-renders per cycle — the detached-DOM churn this selector exists to prevent.
const makeResults = (eventName: string = 'pageview'): any[][] => [
[
{
uuid: '01853a90-ba94-0000-8776-e8df5617c3ec',
event: eventName,
properties: {},
team_id: 1,
distinct_id: '123',
timestamp: '2022-12-24T17:00:41.165000Z',
},
eventName,
'2022-12-24T17:00:41.165000Z',
],
[
{
uuid: '01853a90-ba94-0000-8776-e8df5617c3ed',
event: eventName,
properties: {},
team_id: 1,
distinct_id: '123',
timestamp: '2022-12-24T16:00:41.165000Z',
},
eventName,
'2022-12-24T16:00:41.165000Z',
],
]
const responseFor = (results: any[][]): Record<string, any> => ({
columns: ['*', 'event', 'timestamp'],
types: [
"Tuple(UUID, String, String, DateTime64(6, 'UTC'), Int64, String, String, DateTime64(6, 'UTC'), UUID, DateTime64(3), String)",
'String',
"DateTime64(6, 'UTC')",
],
results,
hasMore: false,
})
;(performQuery as any).mockResolvedValueOnce(responseFor(makeResults()))
const dataTableQuery = getDataTableQuery()
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: dataTableQuery,
})
logic.mount()
await expectLogic(logic).delay(0).toMatchValues({ responseLoading: false })
const initialRows = logic.values.dataTableRows
expect(initialRows).toHaveLength(2)
const builtDataNodeLogic = dataNodeLogic({ key: testUniqueKey, query: dataTableQuery.source })
;(performQuery as any).mockResolvedValueOnce(responseFor(makeResults()))
builtDataNodeLogic.actions.loadData('force_blocking')
await expectLogic(builtDataNodeLogic).delay(0).toMatchValues({ responseLoading: false })
expect(logic.values.dataTableRows).toBe(initialRows)
// The counter-case: a genuinely changed response must produce fresh rows, or tables go stale.
;(performQuery as any).mockResolvedValueOnce(responseFor(makeResults('autocapture')))
builtDataNodeLogic.actions.loadData('force_blocking')
await expectLogic(builtDataNodeLogic).delay(0).toMatchValues({ responseLoading: false })
expect(logic.values.dataTableRows).not.toBe(initialRows)
expect((logic.values.dataTableRows?.[0]?.result as any[])[1]).toEqual('autocapture')
})
it('reapplies the rows transformer when the context passes a new one', async () => {
const hogQLQuery = setLatestVersionsOnQuery({
kind: NodeKind.DataTableNode,
source: { kind: NodeKind.HogQLQuery, query: 'select 1' },
}) as DataTableNode
const values = (rows: DataTableRow[]): number[] => rows.map((row) => (row.result as number[])[0])
const ascending = (rows: DataTableRow[]): DataTableRow[] =>
[...rows].sort((a, b) => (a.result as number[])[0] - (b.result as number[])[0])
const descending = (rows: DataTableRow[]): DataTableRow[] => ascending(rows).reverse()
const logicProps = { dataKey: testUniqueKey, vizKey: testUniqueKey, query: hogQLQuery }
;(performQuery as any).mockResolvedValueOnce({ results: [[1], [3], [2]] })
logic = dataTableLogic({ ...logicProps, context: { dataTableRowsTransformer: ascending } })
logic.mount()
await expectLogic(logic).delay(0).toMatchValues({ responseLoading: false })
expect(values(logic.values.dataTableRows ?? [])).toEqual([1, 2, 3])
dataTableLogic({ ...logicProps, context: { dataTableRowsTransformer: descending } })
expect(values(logic.values.dataTableRows ?? [])).toEqual([3, 2, 1])
})
it('shows results even when columns in query do not match columns in response', async () => {
const commonResult = {
uuid: '01853a90-ba94-0000-8776-e8df5617c3ec',
event: 'pageview',
properties: {},
team_id: 1,
distinct_id: '123',
}
const results = [
[{ ...commonResult, timestamp: '2022-12-24T17:00:41.165000Z' }, 'pageview', '2022-12-24T17:00:41.165000Z'],
[{ ...commonResult, timestamp: '2022-12-23T17:00:41.165000Z' }, 'pageview', '2022-12-23T17:00:41.165000Z'],
]
// Simulate the race condition: query has new column but API response still has old columns
// This happens when applying a table view or adding a column - the query updates immediately
// but the API response is asynchronous
;(performQuery as any).mockResolvedValueOnce({
columns: ['*', 'event', 'timestamp'], // Response has old columns (without properties.foo)
types: [
"Tuple(UUID, String, String, DateTime64(6, 'UTC'), Int64, String, String, DateTime64(6, 'UTC'), UUID, DateTime64(3), String)",
'String',
"DateTime64(6, 'UTC')",
],
results: results,
hasMore: false,
})
logic = dataTableLogic({
dataKey: testUniqueKey,
vizKey: testUniqueKey,
query: {
kind: NodeKind.DataTableNode,
source: {
kind: NodeKind.EventsQuery,
select: ['*', 'event', 'timestamp', 'properties.foo'], // Query has new column
},
},
})
logic.mount()
expect(performQuery).toHaveBeenCalledTimes(1)
await expectLogic(logic)
.toMatchValues({ responseLoading: true })
.delay(0)
.toMatchValues({ responseLoading: false, response: partial({ results }) })
// The key assertion: dataTableRows should contain results, not be empty
// Even though columnsInQuery !== columnsInResponse, we should still show the results
// Note: Date labels are inserted between results from different days (this is expected behavior)
await expectLogic(logic).toMatchValues({
dataTableRows: [{ result: results[0] }, { label: 'December 23, 2022' }, { result: results[1] }],
})
})
})