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 { expectLogic } from 'kea-test-utils'
import posthog from 'posthog-js'

import { urls } from 'scenes/urls'

import { performQuery } from '~/queries/query'
import { initKeaTests } from '~/test/init'

import { MANAGED_TRINO_SCHEMA_SCOPE, databaseTableListLogic } from './databaseTableListLogic'

jest.mock('~/queries/query')

describe('databaseTableListLogic', () => {
    let logic: ReturnType<typeof databaseTableListLogic.build>

    beforeEach(() => {
        initKeaTests()
        ;(performQuery as jest.Mock).mockResolvedValue({
            tables: {},
            joins: [],
        })
    })

    afterEach(() => {
        logic?.unmount()
        window.history.replaceState({}, '', urls.sqlEditor())
        jest.clearAllMocks()
    })

    it('does not read sql editor connection hashes or auto-load on mount', () => {
        window.history.replaceState({}, '', `${urls.sqlEditor()}#c=conn-123`)

        logic = databaseTableListLogic()
        logic.mount()

        expect(logic.values.connectionId).toBeNull()
        expect(performQuery).not.toHaveBeenCalled()
    })

    it('does not auto-load on mount without a connection hash', () => {
        window.history.replaceState({}, '', urls.sqlEditor())

        logic = databaseTableListLogic()
        logic.mount()

        expect(performQuery).not.toHaveBeenCalled()
    })

    it('deduplicates in-flight schema loads for the same connection', async () => {
        let resolveQuery: ((value: { tables: Record<string, never>; joins: never[] }) => void) | undefined
        ;(performQuery as jest.Mock).mockImplementation(
            () =>
                new Promise((resolve) => {
                    resolveQuery = resolve
                })
        )

        logic = databaseTableListLogic()
        logic.mount()
        logic.actions.setConnection('conn-123')

        const firstRequest = logic.asyncActions.loadDatabase()
        const secondRequest = logic.asyncActions.loadDatabase()

        expect(performQuery).toHaveBeenCalledTimes(1)

        resolveQuery?.({ tables: {}, joins: [] })

        await Promise.all([firstRequest, secondRequest])
        expect(performQuery).toHaveBeenCalledTimes(1)
    })

    it.each([
        { name: 'main path', concurrentLoads: 1 },
        { name: 'dedup branch', concurrentLoads: 2 },
    ])('does not crash when unmounted mid-load ($name)', async ({ concurrentLoads }) => {
        let resolveQuery: ((value: { tables: Record<string, never>; joins: never[] }) => void) | undefined
        ;(performQuery as jest.Mock).mockImplementation(
            () =>
                new Promise((resolve) => {
                    resolveQuery = resolve
                })
        )

        const localLogic = databaseTableListLogic()
        localLogic.mount()

        const requests = Array.from({ length: concurrentLoads }, () => localLogic.asyncActions.loadDatabase())
        expect(performQuery).toHaveBeenCalledTimes(1)

        localLogic.unmount()
        resolveQuery?.({ tables: {}, joins: [] })
        await Promise.all(requests)

        expect(posthog.captureException).not.toHaveBeenCalled()
    })

    it('refreshDatabaseSchema issues a fresh request instead of piggybacking on an in-flight load', () => {
        ;(performQuery as jest.Mock).mockImplementation(() => new Promise(() => {}))

        logic = databaseTableListLogic()
        logic.mount()
        logic.actions.setConnection('conn-123')

        logic.actions.loadDatabase()
        expect(performQuery).toHaveBeenCalledTimes(1)

        // A plain reload would dedupe onto the in-flight request and return its (pre-mutation)
        // result; the forced refresh must issue its own request.
        logic.actions.refreshDatabaseSchema()
        expect(performQuery).toHaveBeenCalledTimes(2)
    })

    it('discards a superseded in-flight response so a refreshed post-deletion schema is not overwritten', async () => {
        let resolveStale: ((value: { tables: Record<string, unknown>; joins: never[] }) => void) | undefined
        let resolveFresh: ((value: { tables: Record<string, unknown>; joins: never[] }) => void) | undefined
        ;(performQuery as jest.Mock)
            .mockImplementationOnce(() => new Promise((resolve) => (resolveStale = resolve)))
            .mockImplementationOnce(() => new Promise((resolve) => (resolveFresh = resolve)))

        logic = databaseTableListLogic()
        logic.mount()

        const stalePreDeletion = logic.asyncActions.loadDatabase()
        const freshPostDeletion = logic.asyncActions.loadDatabase({ force: true })
        expect(performQuery).toHaveBeenCalledTimes(2)

        // The forced (post-deletion) refresh resolves first: the deleted view is gone.
        resolveFresh?.({ tables: {}, joins: [] })
        await freshPostDeletion
        expect(logic.values.views).toEqual([])

        // The older in-flight request resolves later, still carrying the deleted view. It is
        // superseded and must not clobber the refreshed schema.
        resolveStale?.({ tables: { my_view: { name: 'my_view', type: 'view' } }, joins: [] })
        await stalePreDeletion
        expect(logic.values.views).toEqual([])
    })

    it('resetConnectionScope drops the connection and reloads the project catalog', async () => {
        logic = databaseTableListLogic()
        logic.mount()
        logic.actions.setConnection('conn-123')
        await logic.asyncActions.loadDatabase()
        ;(performQuery as jest.Mock).mockClear()
        ;(performQuery as jest.Mock).mockResolvedValue({
            tables: { events: { name: 'events', type: 'posthog' } },
            joins: [],
        })

        // Without the reload, consumers that only fetch when `database` is empty would keep
        // rendering the connection's tables long after the SQL editor closed.
        logic.actions.resetConnectionScope()
        await expectLogic(logic).toFinishAllListeners()

        expect(logic.values.connectionId).toBeNull()
        expect(performQuery).toHaveBeenCalledTimes(1)
        expect((performQuery as jest.Mock).mock.calls[0][0]).toMatchObject({ connectionId: undefined })
        expect(logic.values.allTables.map((table) => table.name)).toEqual(['events'])
    })

    it.each(['conn-123', MANAGED_TRINO_SCHEMA_SCOPE])(
        'discards stale default schema responses after selecting %s',
        async (scope) => {
            let resolvePosthogQuery:
                | ((value: { tables: Record<string, { name: string; type: 'posthog' }>; joins: never[] }) => void)
                | undefined
            let resolveDirectQuery:
                | ((value: {
                      tables: Record<string, { name: string; type: 'data_warehouse' }>
                      joins: never[]
                  }) => void)
                | undefined

            ;(performQuery as jest.Mock)
                .mockImplementationOnce(
                    () =>
                        new Promise((resolve) => {
                            resolvePosthogQuery = resolve
                        })
                )
                .mockImplementationOnce(
                    () =>
                        new Promise((resolve) => {
                            resolveDirectQuery = resolve
                        })
                )

            logic = databaseTableListLogic()
            logic.mount()

            const posthogRequest = logic.asyncActions.loadDatabase()

            logic.actions.setConnection(scope)
            const directRequest = logic.asyncActions.loadDatabase()

            resolveDirectQuery?.({
                tables: {
                    ducklake_accounts: { name: 'ducklake_accounts', type: 'data_warehouse' },
                },
                joins: [],
            })
            await directRequest

            expect(logic.values.allTables.map((table) => table.name)).toEqual(['ducklake_accounts'])

            resolvePosthogQuery?.({
                tables: {
                    events: { name: 'events', type: 'posthog' },
                },
                joins: [],
            })
            await posthogRequest

            expect(logic.values.connectionId).toEqual(scope)
            expect(logic.values.allTables.map((table) => table.name)).toEqual(['ducklake_accounts'])
        }
    )

    describe('lazy schema loading', () => {
        const shallowTables = {
            events: { name: 'events', type: 'posthog', fields: {} },
            persons: { name: 'persons', type: 'posthog', fields: {} },
        }
        const eventsFields = {
            uuid: { name: 'uuid', hogql_value: 'uuid', type: 'string', schema_valid: true },
        }

        const loadShallow = async (): Promise<void> => {
            ;(performQuery as jest.Mock).mockResolvedValueOnce({ tables: shallowTables, joins: [] })
            await logic.asyncActions.loadDatabase({ shallow: true })
        }

        beforeEach(() => {
            logic = databaseTableListLogic()
            logic.mount()
        })

        it('a shallow load requests no fields and marks the schema incomplete', async () => {
            jest.useFakeTimers()
            await loadShallow()
            await jest.advanceTimersByTimeAsync(5000)
            expect(performQuery).toHaveBeenCalledTimes(1)
            jest.useRealTimers()

            expect((performQuery as jest.Mock).mock.calls[0][0]).toMatchObject({ includeFields: false })
            expect(logic.values.databaseFieldsComplete).toBe(false)
            expect(logic.values.allTables.map((table) => table.name)).toEqual(['events', 'persons'])

            ;(performQuery as jest.Mock).mockResolvedValueOnce({ tables: shallowTables, joins: [] })
            await logic.asyncActions.loadDatabase({ force: true })
            expect(logic.values.databaseFieldsComplete).toBe(true)
        })

        it('refreshes fields already requested without hydrating untouched tables', async () => {
            await loadShallow()
            const hydratedEvents = { ...shallowTables.events, fields: eventsFields }
            ;(performQuery as jest.Mock).mockResolvedValueOnce({ tables: { events: hydratedEvents }, joins: [] })
            await logic.asyncActions.hydrateTableFields(['events'])

            const refreshedFields = { ...eventsFields, event: { ...eventsFields.uuid, name: 'event' } }
            ;(performQuery as jest.Mock)
                .mockResolvedValueOnce({ tables: shallowTables, joins: [] })
                .mockResolvedValueOnce({
                    tables: { events: { ...hydratedEvents, fields: refreshedFields } },
                    joins: [],
                })
            await expectLogic(logic, () => logic.actions.refreshDatabaseSchema()).toFinishAllListeners()

            expect((performQuery as jest.Mock).mock.calls[2][0]).toMatchObject({ includeFields: false })
            expect((performQuery as jest.Mock).mock.calls[3][0]).toMatchObject({ tables: ['events'] })
            expect(logic.values.database?.tables.events.fields).toEqual(refreshedFields)
            expect(logic.values.database?.tables.persons.fields).toEqual({})
        })

        it('hydrateTableFields merges the requested tables and flags missing ones as errors', async () => {
            await loadShallow()
            ;(performQuery as jest.Mock).mockResolvedValueOnce({
                tables: { events: { ...shallowTables.events, fields: eventsFields } },
                joins: [],
            })

            await logic.asyncActions.hydrateTableFields(['events', 'gone_table'])

            expect((performQuery as jest.Mock).mock.calls[1][0]).toMatchObject({
                tables: ['events'],
            })
            expect(logic.values.database?.tables['events'].fields).toEqual(eventsFields)
            expect(logic.values.database?.tables['persons'].fields).toEqual({})
            expect(logic.values.tableFieldsStatus).toMatchObject({ events: 'loaded' })
            // 'gone_table' isn't in the schema at all, so it's filtered before the request.
            expect(logic.values.tableFieldsStatus['gone_table']).toBeUndefined()
        })

        it('hydrateTableFields skips tables that are already loaded or loading', async () => {
            await loadShallow()
            ;(performQuery as jest.Mock).mockResolvedValueOnce({
                tables: { events: { ...shallowTables.events, fields: eventsFields } },
                joins: [],
            })
            await logic.asyncActions.hydrateTableFields(['events'])
            expect(performQuery).toHaveBeenCalledTimes(2)

            await logic.asyncActions.hydrateTableFields(['events'])
            expect(performQuery).toHaveBeenCalledTimes(2)
        })

        it('does not let a stale hydration failure overwrite fields loaded for another connection', async () => {
            logic.actions.setConnection('conn-old')
            await loadShallow()

            let rejectStaleHydration: ((reason?: unknown) => void) | undefined
            ;(performQuery as jest.Mock).mockImplementationOnce(
                () =>
                    new Promise<never>((_, reject) => {
                        rejectStaleHydration = reject
                    })
            )
            const staleHydration = logic.asyncActions.hydrateTableFields(['events'])

            logic.actions.setConnection('conn-new')
            await loadShallow()
            ;(performQuery as jest.Mock).mockResolvedValueOnce({
                tables: { events: { ...shallowTables.events, fields: eventsFields } },
                joins: [],
            })
            await logic.asyncActions.hydrateTableFields(['events'])

            expect(logic.values.database?.tables['events'].fields).toEqual(eventsFields)
            expect(logic.values.tableFieldsStatus).toMatchObject({ events: 'loaded' })

            rejectStaleHydration?.(new Error('Stale connection failed'))
            await staleHydration

            expect(logic.values.database?.tables['events'].fields).toEqual(eventsFields)
            expect(logic.values.tableFieldsStatus).toMatchObject({ events: 'loaded' })
        })

        it('treats a requested table missing from the response as terminal', async () => {
            await loadShallow()
            ;(performQuery as jest.Mock).mockResolvedValueOnce({ tables: {}, joins: [] })

            await logic.asyncActions.hydrateTableFields(['events'])

            expect(logic.values.tableFieldsStatus).toMatchObject({ events: 'missing' })
            expect(logic.values.database?.tables['events']).toBeUndefined()
            expect(logic.values.databaseFieldsComplete).toBe(false)

            ;(performQuery as jest.Mock).mockResolvedValueOnce({
                tables: { persons: { ...shallowTables.persons, fields: eventsFields } },
                joins: [],
            })
            await logic.asyncActions.hydrateTableFields(['events', 'persons'])

            expect(logic.values.databaseFieldsComplete).toBe(true)
            expect((performQuery as jest.Mock).mock.calls[2][0]).toMatchObject({ tables: ['persons'] })

            await logic.asyncActions.hydrateTableFields(['events'])
            expect(performQuery).toHaveBeenCalledTimes(3)
        })

        it('ensureAllTableFields hydrates every table in place and marks the schema complete', async () => {
            await loadShallow()
            ;(performQuery as jest.Mock).mockResolvedValueOnce({
                tables: {
                    events: { ...shallowTables.events, fields: eventsFields },
                    persons: { ...shallowTables.persons, fields: eventsFields },
                },
                joins: [],
            })

            logic.actions.ensureAllTableFields()
            await expectLogic(logic).toFinishAllListeners()

            // Upgrades through the merge path, so `databaseLoading` never blanks consumers.
            expect((performQuery as jest.Mock).mock.calls[1][0]).toMatchObject({
                tables: ['events', 'persons'],
            })
            expect(logic.values.databaseFieldsComplete).toBe(true)
            expect(logic.values.database?.tables['persons'].fields).toEqual(eventsFields)

            ;(performQuery as jest.Mock)
                .mockResolvedValueOnce({ tables: shallowTables, joins: [] })
                .mockResolvedValueOnce({
                    tables: {
                        events: { ...shallowTables.events, fields: eventsFields },
                        persons: { ...shallowTables.persons, fields: eventsFields },
                    },
                    joins: [],
                })
            await expectLogic(logic, () => logic.actions.loadDatabase({ shallow: true })).toFinishAllListeners()
            expect(logic.values.databaseFieldsComplete).toBe(true)
            expect(logic.values.database?.tables['persons'].fields).toEqual(eventsFields)
        })

        it('a full load does not piggyback on an in-flight shallow request', () => {
            ;(performQuery as jest.Mock).mockImplementation(() => new Promise(() => {}))

            logic.actions.loadDatabase({ shallow: true })
            expect(performQuery).toHaveBeenCalledTimes(1)

            logic.actions.loadDatabase()
            expect(performQuery).toHaveBeenCalledTimes(2)
            expect((performQuery as jest.Mock).mock.calls[1][0].includeFields).toBeUndefined()
        })
    })
    it('keeps native Trino scope when loading, hydrating, and refreshing its catalog', async () => {
        logic = databaseTableListLogic()
        logic.mount()
        logic.actions.setConnection(MANAGED_TRINO_SCHEMA_SCOPE)
        ;(performQuery as jest.Mock).mockResolvedValueOnce({
            tables: {
                'analytics.orders': {
                    id: 'analytics.orders',
                    name: 'analytics.orders',
                    type: 'data_warehouse',
                    fields: {},
                },
            },
            joins: [],
        })
        await logic.asyncActions.loadDatabase({ shallow: true })
        expect(performQuery).toHaveBeenLastCalledWith(
            expect.objectContaining({
                executionTarget: 'managed_trino',
                includeFields: false,
            })
        )
        expect((performQuery as jest.Mock).mock.lastCall[0].connectionId).toBeUndefined()
        logic.actions.hydrateTableFields(['analytics.orders'])
        await expectLogic(logic).toFinishAllListeners()
        expect(performQuery).toHaveBeenLastCalledWith(
            expect.objectContaining({
                executionTarget: 'managed_trino',
                tables: ['analytics.orders'],
            })
        )
        logic.actions.refreshDatabaseSchema()
        await expectLogic(logic).toFinishAllListeners()
        expect(performQuery).toHaveBeenLastCalledWith(expect.objectContaining({ executionTarget: 'managed_trino' }))
        logic.actions.resetConnectionScope()
        await expectLogic(logic).toFinishAllListeners()
        expect(performQuery).toHaveBeenLastCalledWith(expect.objectContaining({ connectionId: undefined }))
        expect((performQuery as jest.Mock).mock.lastCall[0].executionTarget).toBeUndefined()
    })
})