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.

16.0 KB
Raw Blame
import '@testing-library/jest-dom'

import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
import { BindLogic } from 'kea'

import { shortcutLogic } from 'lib/components/Shortcuts/shortcutLogic'
import { LemonModal } from 'lib/lemon-ui/LemonModal'
import { DashboardEventSource } from 'lib/utils/eventUsageLogic'

import { useMocks } from '~/mocks/jest'
import { initKeaTests } from '~/test/init'
import { AccessControlLevel, DashboardMode, DashboardPlacement, DashboardType, InsightModel } from '~/types'

import { DashboardEmbeddedShareButton } from 'products/dashboards/frontend/DashboardHeaderActions'
import { useMcpToolApplyBack } from 'products/posthog_ai/frontend/api/logics'
import type { ToolStreamEvent } from 'products/posthog_ai/frontend/types/streamTypes'

import { DashboardHeader, insightIsAddedToDashboard } from './DashboardHeader'
import { DashboardLoadAction, dashboardLogic } from './dashboardLogic'

jest.mock('lib/components/FullScreen', () => ({
    FullScreen: () => null,
}))
jest.mock('scenes/max/MaxTool', () => ({
    MaxTool: ({ children }: any) => <>{children}</>,
}))

jest.mock('products/posthog_ai/frontend/api/logics', () => ({
    ...jest.requireActual('products/posthog_ai/frontend/api/logics'),
    useMcpToolApplyBack: jest.fn(),
}))

const MOCK_DASHBOARD: DashboardType = {
    id: 5,
    name: 'Test Dashboard',
    description: 'A test dashboard',
    pinned: false,
    tiles: [],
    tags: [],
    created_at: '2020-01-01T00:00:00Z',
    created_by: {
        id: 1,
        first_name: 'Test',
        last_name: 'User',
        email: '[email protected]',
        uuid: 'abc',
        distinct_id: 'test-distinct-id',
    },
    last_accessed_at: '2020-01-01T00:00:00Z',
    is_shared: false,
    deleted: false,
    creation_mode: 'default',
    user_access_level: AccessControlLevel.Editor,
    filters: {},
    variables: {},
}

function makeDashboard(overrides: Record<string, any> = {}): DashboardType {
    return { ...MOCK_DASHBOARD, ...overrides }
}

beforeAll(() => {
    const root = document.createElement('div')
    root.id = 'root'
    document.body.appendChild(root)
})

describe('DashboardHeader', () => {
    beforeEach(() => {
        localStorage.clear()
        sessionStorage.clear()
        useMocks({
            post: {
                '/api/environments/:team_id/query/': () => [200, { results: [] }],
            },
        })
        initKeaTests()
    })

    afterEach(() => {
        cleanup()
    })

    function renderHeader(opts: {
        dashboard?: DashboardType | null
        dashboardMode?: DashboardMode | null
        dashboardEditing?: { filters: boolean; layout: boolean } | null
        dashboardModeSource?: DashboardEventSource
        loading?: boolean
        spyOnLoadDashboard?: boolean
    }): { logic: ReturnType<typeof dashboardLogic.build>; loadDashboard?: jest.SpyInstance } {
        const {
            dashboard = MOCK_DASHBOARD,
            dashboardMode = null,
            dashboardEditing = null,
            dashboardModeSource = DashboardEventSource.Browser,
            loading = false,
        } = opts

        const logic = dashboardLogic({ id: dashboard?.id ?? MOCK_DASHBOARD.id, dashboard: dashboard ?? undefined })
        logic.mount()
        const loadDashboard = opts.spyOnLoadDashboard
            ? jest.spyOn(logic.actions, 'loadDashboard').mockImplementation()
            : undefined

        if (dashboardEditing) {
            logic.actions.setDashboardEditing(dashboardEditing, dashboardModeSource)
        } else if (dashboardMode) {
            logic.actions.setDashboardMode(dashboardMode, dashboardModeSource)
        }

        render(
            <BindLogic
                logic={dashboardLogic}
                props={{ id: dashboard?.id ?? MOCK_DASHBOARD.id, dashboard: dashboard ?? undefined }}
            >
                <DashboardHeader loading={loading} />
            </BindLogic>
        )

        return { logic, loadDashboard }
    }

    it('closes an open tile dialog on Escape without discarding the layout draft', () => {
        const dashboard = makeDashboard({
            tiles: [{ id: 1, color: null, layouts: {}, text: { body: 'Dashboard note' } }],
        })
        const { logic } = renderHeader({ dashboard, dashboardEditing: { filters: true, layout: true } })
        logic.actions.updateLayouts({
            ...logic.values.layouts,
            sm: logic.values.layouts.sm?.map((layout) => ({ ...layout, x: layout.x + 1 })),
        })
        expect(shortcutLogic.values.registeredShortcuts.some(({ name }) => name === 'CancelDashboardEdit')).toBe(true)
        act(() => logic.actions.openImageTileModal())
        expect(shortcutLogic.values.registeredShortcuts.some(({ name }) => name === 'CancelDashboardEdit')).toBe(false)

        const { unmount } = render(
            <LemonModal isOpen onClose={() => logic.actions.closeTileModal()}>
                <button type="button">Dialog action</button>
            </LemonModal>
        )
        const dialogButton = screen.getByText('Dialog action')
        dialogButton.focus()
        fireEvent.keyDown(dialogButton, { key: 'Escape', code: 'Escape' })

        expect(logic.values.showImageTileModal).toBe(false)
        expect(logic.values.dashboardEditing?.layout).toBe(true)
        expect(logic.values.hasUnsavedLayoutChanges).toBe(true)

        unmount()
        logic.unmount()
    })

    it('keeps the scene header visible while the dashboard is loading', () => {
        const { logic } = renderHeader({ dashboard: null, loading: true })

        expect(document.querySelector('.scene-title-section')).toBeInTheDocument()

        logic.unmount()
    })

    test.each([
        { mode: 'view', dashboardEditing: null, access: AccessControlLevel.Editor, canEdit: true },
        {
            mode: 'filter edit',
            dashboardEditing: { filters: true, layout: false },
            access: AccessControlLevel.Editor,
            canEdit: true,
        },
        { mode: 'view', dashboardEditing: null, access: AccessControlLevel.Viewer, canEdit: false },
    ])(
        'pressing E in $mode mode with $access access enters layout editing=$canEdit',
        ({ dashboardEditing, access, canEdit }) => {
            const dashboard = makeDashboard({
                user_access_level: access,
                tiles: [{ id: 1, color: null, layouts: {}, text: { body: 'Dashboard note' } }],
            })
            const { logic } = renderHeader({ dashboard, dashboardEditing })
            act(() => logic.actions.updateContainerWidth(1200, 12))

            fireEvent.keyDown(document.body, { key: 'e', code: 'KeyE' })

            expect(logic.values.layoutEditMode).toBe(canEdit)
            if (canEdit) {
                expect(document.querySelector('[data-attr="dashboard-edit-mode-save"]')).toBeInTheDocument()
            }

            logic.unmount()
        }
    )

    it.each([600, 768])('shows customization without layout editing at %ipx', async (width) => {
        const originalWidth = window.innerWidth
        Object.defineProperty(window, 'innerWidth', { configurable: true, value: width })
        window.dispatchEvent(new Event('resize'))

        try {
            const dashboard = makeDashboard({
                tiles: [{ id: 1, color: null, layouts: {}, text: { body: 'Dashboard note' } }],
            })
            const { logic } = renderHeader({ dashboard })

            expect(document.querySelector('[data-attr="dashboard-edit-mode-button"]')).not.toBeInTheDocument()
            expect(document.querySelector('[data-attr="dashboard-edit-layout-customize-dropdown"]')).toBeInTheDocument()
            fireEvent.click(
                document.querySelector('[data-attr="dashboard-edit-layout-customize-dropdown"]') as HTMLElement
            )
            expect(await screen.findByText('Tile density')).toBeInTheDocument()
            expect(screen.queryByText('When you move a tile')).not.toBeInTheDocument()
            expect(logic.values.layoutEditMode).toBe(false)

            logic.unmount()
        } finally {
            Object.defineProperty(window, 'innerWidth', { configurable: true, value: originalWidth })
            window.dispatchEvent(new Event('resize'))
        }
    })

    it('recognizes sandbox insight calls that add to the open dashboard', () => {
        expect(insightIsAddedToDashboard({ dashboards: ['5', 8] }, 5)).toBe(true)
        expect(insightIsAddedToDashboard({ dashboards: [8] }, 5)).toBe(false)
        expect(insightIsAddedToDashboard({ dashboards: '5' }, 5)).toBe(false)
    })

    it('reloads the open dashboard when sandbox AI adds an insight to it', () => {
        const { logic, loadDashboard } = renderHeader({ dashboard: MOCK_DASHBOARD, spyOnLoadDashboard: true })
        const applyBackOptions = jest
            .mocked(useMcpToolApplyBack)
            .mock.calls.map(([options]) => options)
            .find((options) => options.targetKey === `dashboard:${MOCK_DASHBOARD.id}`)

        applyBackOptions?.onApply({} as ToolStreamEvent, { innerInput: { dashboards: [MOCK_DASHBOARD.id] } })

        expect(loadDashboard).toHaveBeenCalledWith({ action: DashboardLoadAction.Update })
        logic.unmount()
    })

    it('keeps the dashboard name and description visible during a background load', () => {
        const { logic } = renderHeader({ dashboard: MOCK_DASHBOARD, loading: true })

        expect(screen.getByText('Test Dashboard')).toBeInTheDocument()
        expect(screen.getByText('A test dashboard')).toBeInTheDocument()

        logic.unmount()
    })

    it.each([
        { isShared: false, active: false, empty: false },
        { isShared: true, active: true, empty: false },
        { isShared: true, active: true, empty: true },
    ])(
        'shows the share button as active when sharing is $isShared and empty is $empty',
        ({ isShared, active, empty }) => {
            const dashboard = makeDashboard({
                is_shared: isShared,
                tiles: empty ? [] : [{ id: 1, color: null, layouts: {}, text: { body: 'Dashboard note' } }],
            })
            const { logic } = renderHeader({ dashboard })

            const shareButton = document.querySelector('[data-attr="dashboard-share-button"]')

            if (active) {
                expect(shareButton).toHaveClass('LemonButton--active')
                expect(shareButton).toHaveTextContent('OnSharing')
                expect(shareButton?.querySelector('.LemonBadge--primary')).toBeVisible()
                expect(shareButton?.querySelector('.LemonButton__icon svg')).not.toBeInTheDocument()
            } else {
                expect(shareButton).not.toHaveClass('LemonButton--active')
                expect(shareButton).toHaveTextContent('Share')
                expect(shareButton?.querySelector('.LemonBadge')).not.toBeInTheDocument()
                expect(shareButton?.querySelector('.LemonButton__icon svg')).toBeInTheDocument()
            }

            logic.unmount()
        }
    )

    it.each([
        { placement: DashboardPlacement.Builtin, isShared: true, visible: true },
        { placement: DashboardPlacement.ProjectHomepage, isShared: true, visible: true },
        { placement: DashboardPlacement.Builtin, isShared: false, visible: false },
        { placement: DashboardPlacement.Public, isShared: true, visible: false },
        { placement: DashboardPlacement.Export, isShared: true, visible: false },
    ])(
        'shows the embedded sharing state for $placement when sharing is $isShared',
        ({ placement, isShared, visible }) => {
            const dashboard = makeDashboard({ is_shared: isShared })

            render(<DashboardEmbeddedShareButton dashboard={dashboard} placement={placement} />)

            const shareButton = document.querySelector('[data-attr="dashboard-share-button"]')
            if (visible) {
                expect(shareButton).toHaveTextContent('OnSharing')
                expect(shareButton).toHaveClass('LemonButton--active')
            } else {
                expect(shareButton).not.toBeInTheDocument()
            }
        }
    )

    it.each([
        {
            scenario: 'View mode, can edit',
            dashboardMode: null as DashboardMode | null,
            canEdit: true,
            hasTiles: false,
            visible: [],
            notVisible: [
                'dashboard-add-tile',
                'dashboard-share-button',
                'dashboard-edit-mode-button',
                'dashboard-edit-mode-discard',
                'dashboard-edit-mode-save',
            ],
        },
        {
            scenario: 'View mode, cannot edit',
            dashboardMode: null as DashboardMode | null,
            canEdit: false,
            hasTiles: false,
            visible: [],
            notVisible: [
                'dashboard-add-tile',
                'dashboard-share-button',
                'dashboard-edit-mode-discard',
                'dashboard-edit-mode-save',
                'dashboard-edit-mode-button',
            ],
        },
        {
            scenario: 'Filter edit mode',
            dashboardEditing: { filters: true, layout: false },
            dashboardModeSource: DashboardEventSource.DashboardFilters,
            canEdit: true,
            hasTiles: false,
            visible: [],
            notVisible: [
                'dashboard-add-tile',
                'dashboard-edit-mode-discard',
                'dashboard-edit-mode-save',
                'dashboard-share-button',
                'dashboard-edit-layout-customize-dropdown',
                'add-text-tile-to-dashboard',
                'dashboard-add-graph-header',
            ],
        },
        {
            scenario: 'Filter edit mode, cannot edit',
            dashboardEditing: { filters: true, layout: false },
            dashboardModeSource: DashboardEventSource.DashboardFilters,
            canEdit: false,
            hasTiles: true,
            visible: [],
            notVisible: [
                'dashboard-edit-mode-button',
                'dashboard-edit-mode-discard',
                'dashboard-edit-mode-save',
                'dashboard-share-button',
            ],
        },
        {
            scenario: 'Layout edit mode',
            dashboardEditing: { filters: true, layout: true },
            dashboardModeSource: DashboardEventSource.SceneCommonButtons,
            canEdit: true,
            hasTiles: false,
            visible: ['dashboard-edit-mode-discard', 'dashboard-edit-mode-save'],
            notVisible: [
                'dashboard-add-tile',
                'dashboard-share-button',
                'dashboard-edit-layout-customize-dropdown',
                'add-text-tile-to-dashboard',
                'dashboard-add-graph-header',
            ],
        },
        {
            scenario: 'Fullscreen mode',
            dashboardMode: DashboardMode.Fullscreen,
            canEdit: true,
            hasTiles: false,
            visible: ['dashboard-exit-presentation-mode'],
            notVisible: ['dashboard-share-button', 'dashboard-edit-mode-save'],
        },
    ])(
        '$scenario shows correct action buttons',
        ({ dashboardMode, dashboardEditing, dashboardModeSource, canEdit, hasTiles, visible, notVisible }) => {
            const dashboard = makeDashboard({
                user_access_level: canEdit ? AccessControlLevel.Editor : AccessControlLevel.Viewer,
                tiles: hasTiles
                    ? [
                          {
                              id: 1,
                              color: null,
                              layouts: {},
                              insight: { id: 1, short_id: 'test', name: 'Test' } as InsightModel,
                          },
                      ]
                    : [],
            })
            const { logic } = renderHeader({ dashboard, dashboardMode, dashboardEditing, dashboardModeSource })

            for (const attr of visible) {
                expect(document.querySelector(`[data-attr="${attr}"]`)).toBeInTheDocument()
            }
            for (const attr of notVisible) {
                expect(document.querySelector(`[data-attr="${attr}"]`)).not.toBeInTheDocument()
            }

            logic.unmount()
        }
    )
})