: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 '@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()
}
)
})