@actuate-media/cms-admin 0.66.0 → 0.67.0

package/src/__tests__/components/inspector-pane.test.tsx

@@ -0,0 +1,64 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import {
+  InspectorPane,
+  InspectorPaneBody,
+  InspectorPaneFooter,
+  InspectorPaneHeader,
+  InspectorPaneSection,
+  SplitPaneLayout,
+  SplitPaneList,
+} from '../../components/ui/InspectorPane.js'
+
+function Pane({ open }: { open: boolean }) {
+  return (
+    <SplitPaneLayout>
+      <SplitPaneList>
+        <table aria-label="Rows" />
+      </SplitPaneList>
+      <InspectorPane open={open} width={420} aria-label="Row editor">
+        <InspectorPaneHeader onClose={() => {}}>
+          <span>Editing</span>
+        </InspectorPaneHeader>
+        <InspectorPaneBody>
+          <InspectorPaneSection title="Details">content</InspectorPaneSection>
+        </InspectorPaneBody>
+        <InspectorPaneFooter>
+          <button type="button">Save</button>
+        </InspectorPaneFooter>
+      </InspectorPane>
+    </SplitPaneLayout>
+  )
+}
+
+describe('InspectorPane', () => {
+  it('renders pane content with a labelled region when open', () => {
+    render(<Pane open />)
+    expect(screen.getByRole('region', { name: 'Row editor' })).toBeTruthy()
+    expect(screen.getByText('Editing')).toBeTruthy()
+    expect(screen.getByText('Details')).toBeTruthy()
+    expect(screen.getByRole('button', { name: 'Save' })).toBeTruthy()
+  })
+
+  it('collapses to zero width and hides content when closed', () => {
+    const { container } = render(<Pane open={false} />)
+    const shell = container.querySelector('[aria-hidden="true"]') as HTMLElement
+    expect(shell).toBeTruthy()
+    expect(shell.style.width).toBe('0px')
+    expect(screen.queryByText('Editing')).toBeNull()
+  })
+
+  it('close button in the header fires onClose with an accessible label', () => {
+    const onClose = vi.fn()
+    render(
+      <InspectorPane open width={400} aria-label="Detail">
+        <InspectorPaneHeader onClose={onClose} closeLabel="Close detail">
+          <span>Title</span>
+        </InspectorPaneHeader>
+      </InspectorPane>,
+    )
+    screen.getByRole('button', { name: 'Close detail' }).click()
+    expect(onClose).toHaveBeenCalledTimes(1)
+  })
+})

package/src/__tests__/lib/pages-tree.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, it } from 'vitest'
+import {
+  buildPageTree,
+  defaultExpandedIds,
+  flattenPageTree,
+  type PageTreeNode,
+} from '../../lib/pages-tree.js'
+import type { Page } from '../../lib/pages-service.js'
+
+/**
+ * Unit coverage for the Pages tree hierarchy resolution. Pure functions —
+ * locked independent of the REST layer and the view. The contract:
+ * explicit `parentPageId` wins, path-prefix derivation fills the gaps,
+ * and no input (orphans, cycles, duplicates) can lose or duplicate a page.
+ */
+
+function page(partial: Partial<Page> & Pick<Page, 'id' | 'title' | 'path'>): Page {
+  return {
+    id: partial.id,
+    title: partial.title,
+    path: partial.path,
+    slug: partial.slug ?? partial.path.split('/').filter(Boolean).pop() ?? '',
+    parentPageId: partial.parentPageId ?? null,
+    tags: [],
+    primaryTagId: null,
+    authorId: 'u1',
+    authorName: 'Maria K.',
+    authorInitials: 'MK',
+    status: partial.status ?? 'PUBLISHED',
+    publishDate: null,
+    scheduledDate: null,
+    lastModified: '2026-05-01',
+    seoScore: null,
+    seoTitle: null,
+    seoDescription: null,
+    templateId: partial.templateId ?? null,
+    isHomepage: partial.path === '/',
+    isSystemPage: false,
+    createdAt: '2026-01-01',
+    updatedAt: '2026-05-01',
+  }
+}
+
+function titles(nodes: PageTreeNode[]): string[] {
+  return nodes.map((n) => n.page.title)
+}
+
+function countNodes(nodes: PageTreeNode[]): number {
+  return nodes.reduce((n, node) => n + 1 + countNodes(node.children), 0)
+}
+
+describe('buildPageTree', () => {
+  it('nests children under explicit parentPageId parents', () => {
+    const roots = buildPageTree([
+      page({ id: 'about', title: 'About Us', path: '/about' }),
+      page({ id: 'team', title: 'Our Team', path: '/team-page', parentPageId: 'about' }),
+    ])
+    expect(titles(roots)).toEqual(['About Us'])
+    expect(titles(roots[0]!.children)).toEqual(['Our Team'])
+  })
+
+  it('derives parents from path prefixes when parentPageId is null', () => {
+    const roots = buildPageTree([
+      page({ id: 'home', title: 'Home', path: '/' }),
+      page({ id: 'about', title: 'About Us', path: '/about' }),
+      page({ id: 'team', title: 'Our Team', path: '/about/team' }),
+      page({ id: 'story', title: 'Our Story', path: '/about/story' }),
+      page({ id: 'contact', title: 'Contact', path: '/contact' }),
+    ])
+    expect(titles(roots)).toEqual(['About Us', 'Contact', 'Home'])
+    const about = roots[0]!
+    expect(titles(about.children)).toEqual(['Our Story', 'Our Team'])
+  })
+
+  it('skips missing intermediate path levels to the longest existing prefix', () => {
+    const roots = buildPageTree([
+      page({ id: 'svc', title: 'Services', path: '/services' }),
+      // No "/services/web" page exists — attaches to "/services".
+      page({ id: 'design', title: 'Web Design', path: '/services/web/design' }),
+    ])
+    expect(titles(roots)).toEqual(['Services'])
+    expect(titles(roots[0]!.children)).toEqual(['Web Design'])
+  })
+
+  it('never derives the homepage ("/") as a path parent', () => {
+    const roots = buildPageTree([
+      page({ id: 'home', title: 'Home', path: '/' }),
+      page({ id: 'blog', title: 'Blog', path: '/blog' }),
+    ])
+    expect(titles(roots)).toEqual(['Blog', 'Home'])
+  })
+
+  it('prefers explicit parentPageId over the path prefix', () => {
+    const roots = buildPageTree([
+      page({ id: 'about', title: 'About', path: '/about' }),
+      page({ id: 'lp', title: 'Landing', path: '/lp' }),
+      // Path says "/about/…" but the explicit link says "lp" — link wins.
+      page({ id: 'x', title: 'Campaign', path: '/about/campaign', parentPageId: 'lp' }),
+    ])
+    const lp = roots.find((n) => n.page.id === 'lp')!
+    expect(titles(lp.children)).toEqual(['Campaign'])
+    expect(roots.find((n) => n.page.id === 'about')!.children).toHaveLength(0)
+  })
+
+  it('treats orphans (parent not in the set) as roots', () => {
+    const roots = buildPageTree([
+      page({ id: 'a', title: 'A', path: '/a', parentPageId: 'missing' }),
+      page({ id: 'b', title: 'B', path: '/b' }),
+    ])
+    expect(titles(roots)).toEqual(['A', 'B'])
+  })
+
+  it('breaks parentPageId cycles to the root without losing pages', () => {
+    const roots = buildPageTree([
+      page({ id: 'a', title: 'A', path: '/x-a', parentPageId: 'b' }),
+      page({ id: 'b', title: 'B', path: '/x-b', parentPageId: 'a' }),
+      page({ id: 'c', title: 'C', path: '/x-c' }),
+    ])
+    expect(countNodes(roots)).toBe(3)
+    // One of the cycle members must have been rooted.
+    const rootIds = roots.map((n) => n.page.id)
+    expect(rootIds).toContain('c')
+    expect(rootIds.some((id) => id === 'a' || id === 'b')).toBe(true)
+  })
+
+  it('ignores a self-referencing parentPageId', () => {
+    const roots = buildPageTree([page({ id: 'a', title: 'A', path: '/a', parentPageId: 'a' })])
+    expect(titles(roots)).toEqual(['A'])
+  })
+
+  it('orders siblings by title then path, at every depth', () => {
+    const roots = buildPageTree([
+      page({ id: 'svc', title: 'Services', path: '/services' }),
+      page({ id: 's2', title: 'Web Design', path: '/services/web-design' }),
+      page({ id: 's1', title: 'CMS Solutions', path: '/services/cms' }),
+      page({ id: 's3', title: 'SEO Services', path: '/services/seo' }),
+      page({ id: 'blog', title: 'Blog', path: '/blog' }),
+    ])
+    expect(titles(roots)).toEqual(['Blog', 'Services'])
+    expect(titles(roots.find((n) => n.page.id === 'svc')!.children)).toEqual([
+      'CMS Solutions',
+      'SEO Services',
+      'Web Design',
+    ])
+  })
+
+  it('keeps every page exactly once on messy input', () => {
+    const pages = [
+      page({ id: 'home', title: 'Home', path: '/' }),
+      page({ id: 'dup1', title: 'Dup A', path: '/dup' }),
+      page({ id: 'dup2', title: 'Dup B', path: '/dup' }),
+      page({ id: 'kid', title: 'Kid', path: '/dup/kid' }),
+      page({ id: 'cyc1', title: 'Cyc 1', path: '/c1', parentPageId: 'cyc2' }),
+      page({ id: 'cyc2', title: 'Cyc 2', path: '/c2', parentPageId: 'cyc1' }),
+      page({ id: 'orph', title: 'Orphan', path: '/orphan', parentPageId: 'gone' }),
+    ]
+    const roots = buildPageTree(pages)
+    expect(countNodes(roots)).toBe(pages.length)
+    // "/dup/kid" attaches to the first page seen with path "/dup".
+    expect(roots.some((n) => n.page.id === 'dup1' && n.children.length === 1)).toBe(true)
+  })
+})
+
+describe('flattenPageTree', () => {
+  const roots = buildPageTree([
+    page({ id: 'about', title: 'About Us', path: '/about' }),
+    page({ id: 'team', title: 'Our Team', path: '/about/team' }),
+    page({ id: 'blog', title: 'Blog', path: '/blog' }),
+  ])
+
+  it('renders children only when the parent is expanded', () => {
+    const collapsed = flattenPageTree(roots, new Set())
+    expect(collapsed.map((r) => r.page.id)).toEqual(['about', 'blog'])
+
+    const open = flattenPageTree(roots, new Set(['about']))
+    expect(open.map((r) => r.page.id)).toEqual(['about', 'team', 'blog'])
+  })
+
+  it('reports depth and hasChildren per row', () => {
+    const rows = flattenPageTree(roots, new Set(['about']))
+    expect(rows[0]).toMatchObject({ depth: 0, hasChildren: true })
+    expect(rows[1]).toMatchObject({ depth: 1, hasChildren: false })
+    expect(rows[2]).toMatchObject({ depth: 0, hasChildren: false })
+  })
+})
+
+describe('defaultExpandedIds', () => {
+  it('expands only root nodes that have children', () => {
+    const roots = buildPageTree([
+      page({ id: 'about', title: 'About Us', path: '/about' }),
+      page({ id: 'team', title: 'Our Team', path: '/about/team' }),
+      page({ id: 'deep', title: 'Deep', path: '/about/team/deep' }),
+      page({ id: 'blog', title: 'Blog', path: '/blog' }),
+    ])
+    expect([...defaultExpandedIds(roots)]).toEqual(['about'])
+  })
+})

package/src/__tests__/views/dashboard.test.tsx

@@ -59,13 +59,17 @@ describe('Dashboard', () => {
     expect(screen.queryByText('Recent Activity')).toBeNull()
   })
 
-  it('shows empty states when there is no content', () => {
+  it('shows the onboarding block instead of the activity grid when there is no content', () => {
     responses['/stats'] = statsResult()
 
     render(<Dashboard config={{ collections: [] }} session={{}} onNavigate={() => {}} />)
 
-    expect(screen.getByText('No activity yet')).toBeTruthy()
-    expect(screen.getByText('No scheduled content')).toBeTruthy()
+    // An effectively-empty site (zero posts+pages, zero media) swaps the
+    // Recent Activity / Publishing Queue / Content Health grid for the
+    // getting-started onboarding block.
+    expect(screen.getByText(/Welcome to ActuateCMS/)).toBeTruthy()
+    expect(screen.queryByText('No activity yet')).toBeNull()
+    expect(screen.queryByText('No scheduled content')).toBeNull()
   })
 
   it('surfaces a retryable banner when the stats request is exhausted', () => {

package/src/__tests__/views/media-seo-audit.render.test.tsx

@@ -0,0 +1,117 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from 'vitest'
+import { fireEvent, render, screen, within } from '@testing-library/react'
+
+import { MediaSeoAudit, type MediaSeoAuditItem } from '../../views/MediaSeoAudit.js'
+
+// Scores mirror what cms-core's `calculateMediaSeoScore()` would return for
+// each row — the component never re-scores, it renders `seoScore` as-is.
+const ITEMS: MediaSeoAuditItem[] = [
+  {
+    id: 'complete',
+    name: 'seattle-team.webp',
+    type: 'image/webp',
+    size: '120 KB',
+    url: 'https://cdn.example.com/seattle-team.webp',
+    format: 'webp',
+    altTag: 'Team collaborating in the Seattle office',
+    title: 'Seattle Team',
+    description: 'The team collaborating in the Seattle office.',
+    seoScore: 100,
+  },
+  {
+    id: 'no-alt',
+    name: 'hero-banner.jpg',
+    type: 'image/jpeg',
+    size: '342 KB',
+    url: 'https://cdn.example.com/hero-banner.jpg',
+    format: 'jpeg',
+    altTag: '',
+    title: 'Hero Banner',
+    description: 'Homepage hero banner.',
+    seoScore: 70,
+  },
+  {
+    id: 'bare',
+    name: 'IMG_4892.jpg',
+    type: 'image/jpeg',
+    size: '1.8 MB',
+    url: 'https://cdn.example.com/IMG_4892.jpg',
+    format: 'jpeg',
+    altTag: '',
+    title: '',
+    description: '',
+    seoScore: 0,
+  },
+]
+
+describe('MediaSeoAudit', () => {
+  it('renders the four summary stat cards from item metadata', () => {
+    render(<MediaSeoAudit items={ITEMS} onEdit={vi.fn()} />)
+
+    // Avg = round((100 + 70 + 0) / 3) = 57 → "Fair"
+    expect(screen.getByText('57/100')).toBeTruthy()
+    expect(screen.getByText('Avg SEO Score')).toBeTruthy()
+    expect(screen.getByText('Fair')).toBeTruthy()
+
+    expect(screen.getByText('Missing Alt Text')).toBeTruthy()
+    expect(screen.getByText('1 have alt text')).toBeTruthy()
+    expect(screen.getByText('Missing Titles')).toBeTruthy()
+    expect(screen.getByText('2 have titles')).toBeTruthy()
+    expect(screen.getByText('Missing Descriptions')).toBeTruthy()
+    expect(screen.getByText('2 have descriptions')).toBeTruthy()
+  })
+
+  it('shows all items by default with a right-aligned count', () => {
+    render(<MediaSeoAudit items={ITEMS} onEdit={vi.fn()} />)
+
+    const table = screen.getByRole('table', { name: 'Media SEO audit' })
+    expect(within(table).getAllByRole('row')).toHaveLength(4) // header + 3 items
+    expect(screen.getByText('3 items')).toBeTruthy()
+  })
+
+  it('filters to items missing alt text', () => {
+    render(<MediaSeoAudit items={ITEMS} onEdit={vi.fn()} />)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Missing Alt' }))
+
+    const table = screen.getByRole('table', { name: 'Media SEO audit' })
+    expect(within(table).getAllByRole('row')).toHaveLength(3) // header + 2 items
+    expect(within(table).queryByText('seattle-team.webp')).toBeNull()
+    expect(screen.getByText('2 items')).toBeTruthy()
+  })
+
+  it('filters to poor scores (score < 40)', () => {
+    render(<MediaSeoAudit items={ITEMS} onEdit={vi.fn()} />)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Poor score' }))
+
+    const table = screen.getByRole('table', { name: 'Media SEO audit' })
+    expect(within(table).getAllByRole('row')).toHaveLength(2) // header + 1 item
+    expect(within(table).getByText('IMG_4892.jpg')).toBeTruthy()
+    expect(screen.getByText('1 item')).toBeTruthy()
+  })
+
+  it('fires onEdit with the row item from the Edit button', () => {
+    const onEdit = vi.fn()
+    render(<MediaSeoAudit items={ITEMS} onEdit={onEdit} />)
+
+    const buttons = screen.getAllByRole('button', { name: 'Edit' })
+    expect(buttons).toHaveLength(3)
+    fireEvent.click(buttons[1]!)
+    expect(onEdit).toHaveBeenCalledTimes(1)
+    expect(onEdit.mock.calls[0]![0].id).toBe('no-alt')
+  })
+
+  it('shows an empty state when there is nothing to audit', () => {
+    render(<MediaSeoAudit items={[]} onEdit={vi.fn()} />)
+    expect(screen.getByText('No media to audit')).toBeTruthy()
+    expect(screen.queryByRole('table')).toBeNull()
+  })
+
+  it('shows a filter-specific empty state when a filter matches nothing', () => {
+    render(<MediaSeoAudit items={[ITEMS[0]!]} onEdit={vi.fn()} />)
+    fireEvent.click(screen.getByRole('button', { name: 'Missing Alt' }))
+    expect(screen.getByText('No items match this filter')).toBeTruthy()
+  })
+})

package/src/__tests__/views/onboarding-block.render.test.tsx

@@ -0,0 +1,193 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from 'vitest'
+import { fireEvent, render, screen } from '@testing-library/react'
+import {
+  OnboardingBlock,
+  deriveOnboardingSteps,
+  shouldShowOnboarding,
+  type OnboardingSignals,
+} from '../../views/dashboard/OnboardingBlock.js'
+
+function signals(over: Partial<OnboardingSignals> = {}): OnboardingSignals {
+  return {
+    postsAndPagesCount: 0,
+    mediaCount: 0,
+    seoScore: 0,
+    userCount: 1,
+    hasApiTraffic: false,
+    ...over,
+  }
+}
+
+describe('deriveOnboardingSteps', () => {
+  it('marks only the workspace step done on a brand-new site', () => {
+    const steps = deriveOnboardingSteps(signals())
+    expect(steps).toHaveLength(6)
+    expect(steps.filter((s) => s.done).map((s) => s.id)).toEqual(['workspace'])
+  })
+
+  it('derives each step from its dashboard signal', () => {
+    const steps = deriveOnboardingSteps(
+      signals({
+        postsAndPagesCount: 3,
+        mediaCount: 2,
+        seoScore: 71,
+        userCount: 4,
+        hasApiTraffic: true,
+      }),
+    )
+    expect(steps.every((s) => s.done)).toBe(true)
+  })
+
+  it('treats a lone user and zero SEO score as incomplete steps', () => {
+    const steps = deriveOnboardingSteps(signals({ userCount: 1, seoScore: 0 }))
+    const byId = Object.fromEntries(steps.map((s) => [s.id, s.done]))
+    expect(byId['invite']).toBe(false)
+    expect(byId['seo']).toBe(false)
+    expect(byId['api-key']).toBe(false)
+  })
+})
+
+describe('shouldShowOnboarding', () => {
+  it('shows only when both posts+pages and media are empty', () => {
+    expect(shouldShowOnboarding(signals())).toBe(true)
+    expect(shouldShowOnboarding(signals({ postsAndPagesCount: 1 }))).toBe(false)
+    expect(shouldShowOnboarding(signals({ mediaCount: 1 }))).toBe(false)
+  })
+})
+
+describe('OnboardingBlock', () => {
+  it('renders the welcome banner with the derived progress count', () => {
+    render(<OnboardingBlock signals={signals()} onNavigate={() => {}} />)
+
+    expect(screen.getByText(/Welcome to ActuateCMS/)).toBeTruthy()
+    // 1 of 6 done (workspace only) on a fresh site.
+    expect(screen.getByText(/1\/6 steps complete/)).toBeTruthy()
+
+    const bar = screen.getByRole('progressbar', { name: 'Onboarding progress' })
+    expect(bar.getAttribute('aria-valuenow')).toBe('1')
+    expect(bar.getAttribute('aria-valuemax')).toBe('6')
+  })
+
+  it('updates the progress count as steps derive complete', () => {
+    render(
+      <OnboardingBlock signals={signals({ userCount: 3, seoScore: 50 })} onNavigate={() => {}} />,
+    )
+
+    expect(screen.getByText(/3\/6 steps complete/)).toBeTruthy()
+    expect(
+      screen
+        .getByRole('progressbar', { name: 'Onboarding progress' })
+        .getAttribute('aria-valuenow'),
+    ).toBe('3')
+  })
+
+  it('renders all six checklist labels with accessible completion state', () => {
+    render(<OnboardingBlock signals={signals()} onNavigate={() => {}} />)
+
+    for (const label of [
+      'Create your workspace',
+      'Create your first Post or Page',
+      'Upload media assets',
+      'Configure SEO defaults',
+      'Get your API key',
+      'Invite team members',
+    ]) {
+      expect(screen.getByText(label)).toBeTruthy()
+    }
+
+    // Completion is announced via text, not color alone.
+    expect(screen.getAllByText('(completed)')).toHaveLength(1)
+    expect(screen.getAllByText('(not completed)')).toHaveLength(5)
+  })
+
+  it('navigates through quick links via onNavigate', () => {
+    const onNavigate = vi.fn()
+    render(<OnboardingBlock signals={signals()} onNavigate={onNavigate} />)
+
+    fireEvent.click(screen.getByRole('button', { name: /Invite team/ }))
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=users')
+
+    fireEvent.click(screen.getByRole('button', { name: /API Reference/ }))
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=api-keys')
+
+    fireEvent.click(screen.getByRole('button', { name: /SEO defaults/ }))
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=seo')
+  })
+})
+
+// ── Dashboard integration: visibility rule ─────────────────────────────────
+
+const responses: Record<string, unknown> = {}
+const emptyResult = { data: null, loading: false, error: null, exhausted: false, refetch: () => {} }
+
+vi.mock('../../lib/useApiData.js', () => ({
+  useApiData: (endpoint: string | null) => responses[endpoint ?? ''] ?? emptyResult,
+}))
+
+const { Dashboard } = await import('../../views/Dashboard.js')
+
+const baseStats = {
+  totalDocuments: 0,
+  totalMedia: 0,
+  totalUsers: 1,
+  formCount: 0,
+  avgSeoScore: 0,
+  webhookCount: 0,
+  webhookActiveCount: 0,
+  collectionCounts: {} as Record<string, number>,
+  statusCounts: {},
+  recentDocuments: [] as unknown[],
+}
+
+function statsResult(over: Partial<typeof baseStats> = {}) {
+  return {
+    data: { ...baseStats, ...over },
+    loading: false,
+    error: null,
+    exhausted: false,
+    refetch: () => {},
+  }
+}
+
+describe('Dashboard onboarding visibility', () => {
+  it('replaces the activity grid with onboarding when the site is empty', () => {
+    responses['/stats'] = statsResult()
+
+    render(<Dashboard config={{ collections: [] }} session={{}} onNavigate={() => {}} />)
+
+    expect(screen.getByText(/Welcome to ActuateCMS/)).toBeTruthy()
+    expect(screen.queryByText('Recent Activity')).toBeNull()
+    expect(screen.queryByText('Publishing Queue')).toBeNull()
+    expect(screen.queryByText('Content Health')).toBeNull()
+    // The Delivery API card below the block stays.
+    expect(screen.getByText('Delivery API')).toBeTruthy()
+    delete responses['/stats']
+  })
+
+  it('renders the normal dashboard when posts or pages exist', () => {
+    responses['/stats'] = statsResult({ collectionCounts: { posts: 2 } })
+
+    render(
+      <Dashboard
+        config={{ collections: [{ slug: 'posts', type: 'post' }] }}
+        session={{}}
+        onNavigate={() => {}}
+      />,
+    )
+
+    expect(screen.queryByText(/Welcome to ActuateCMS/)).toBeNull()
+    expect(screen.getByText('Recent Activity')).toBeTruthy()
+    delete responses['/stats']
+  })
+
+  it('renders the normal dashboard when only media exists', () => {
+    responses['/stats'] = statsResult({ totalMedia: 5 })
+
+    render(<Dashboard config={{ collections: [] }} session={{}} onNavigate={() => {}} />)
+
+    expect(screen.queryByText(/Welcome to ActuateCMS/)).toBeNull()
+    expect(screen.getByText('Recent Activity')).toBeTruthy()
+    delete responses['/stats']
+  })
+})