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.

18.8 KB
Raw Blame
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] }],
        })
    })
})