Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

test(web): exercise overview owners and activity in browser (#45522)

Stephen Zhouc0b99c14a24c
diff --git a/web/features/new-rag/overview/__tests__/activity-drawer.browser.spec.tsx b/web/features/new-rag/overview/__tests__/activity-drawer.browser.spec.tsx
new file mode 100644
index 00000000000..a5a2682c286
--- /dev/null
+++ b/web/features/new-rag/overview/__tests__/activity-drawer.browser.spec.tsx
@@ -0,0 +1,126 @@
+import { page, userEvent } from 'vite-plus/test/browser'
+import { render } from 'vitest-browser-react'
+import { createConsoleQueryClient, createConsoleQueryWrapper } from '@/test/console/query-data'
+import {
+ createOverviewActivity as activity,
+ createOverviewTask as task,
+} from '@/test/new-rag-overview'
+import { QueryTestingAdapter } from '@/test/query-state-testing-adapter'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { OverviewActivity } from '../overview-activity'
+import { OverviewTaskSync } from '../overview-task-sync'
+import { OverviewStateBoundary } from '../state-boundary'
+
+const service = vi.hoisted(() => ({
+ drawerActivity: vi.fn(),
+ tasks: vi.fn(),
+}))
+
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleResponses } = await import('@/test/console/service-responses')
+ const { createOverviewData } = await import('@/test/new-rag-overview')
+ const data = createOverviewData()
+ const overview = 'knowledgeFs.spaces.byControlSpaceId.overview'
+ return {
+ ...actual,
+ consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ // Only the drawer bounds activity by date outside the cloud edition.
+ [`${overview}.activity.get`]: (input: { query: { from_at?: string } }) =>
+ input.query.from_at ? service.drawerActivity() : { data: [], next_cursor: null },
+ 'knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get': service.tasks,
+ [`${overview}.stats.get`]: () => data.stats,
+ [`${overview}.inventory.get`]: () => data.inventory,
+ [`${overview}.attention.get`]: () => data.attention,
+ 'knowledgeFs.spaces.byControlSpaceId.overview.queryOutcomes.get': async () => data.outcomes,
+ 'workspaces.current.members.get': () => ({ accounts: [] }),
+ }),
+ }
+})
+
+describe('overview activity drawer', () => {
+ let client: ReturnType<typeof createConsoleQueryClient>
+ beforeEach(async () => {
+ await page.viewport(640, 600)
+ onTestFinished(guardUnexpectedFetch())
+ vi.useFakeTimers({ toFake: ['setInterval', 'clearInterval'] })
+ service.tasks.mockReset().mockResolvedValue({ data: [task('running')], next_cursor: null })
+ service.drawerActivity.mockReset().mockResolvedValue({
+ data: [activity('activity-1', 1)],
+ next_cursor: null,
+ })
+ client = createConsoleQueryClient()
+ onTestFinished(() => {
+ client.clear()
+ vi.useRealTimers()
+ })
+ })
+
+ async function openDrawer() {
+ const { wrapper: Wrapper } = createConsoleQueryWrapper({
+ queryClient: client,
+ systemFeatures: { deployment_edition: 'ENTERPRISE' },
+ })
+ await render(
+ <Wrapper>
+ <QueryTestingAdapter>
+ <OverviewStateBoundary knowledgeSpaceId="space-a">
+ <OverviewTaskSync />
+ <OverviewActivity />
+ </OverviewStateBoundary>
+ </QueryTestingAdapter>
+ </Wrapper>,
+ )
+ await page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }).click()
+ const drawer = page.getByRole('dialog', { name: 'knowledgeOverview.overview.allActivity' })
+ await expect.element(drawer).toBeVisible()
+ return drawer
+ }
+
+ it('shows newly completed activity in the open drawer and retains earlier rows', async () => {
+ const drawer = await openDrawer()
+ await expect.element(drawer.getByText(/Synced 1 documents/)).toBeVisible()
+ service.drawerActivity.mockResolvedValue({
+ data: [activity('activity-2', 2), activity('activity-1', 1)],
+ next_cursor: null,
+ })
+ service.tasks.mockResolvedValue({ data: [task('completed')], next_cursor: null })
+ await vi.advanceTimersByTimeAsync(2000)
+
+ await expect.element(drawer.getByText(/Synced 2 documents/)).toBeVisible()
+ await expect.element(drawer.getByText(/Synced 1 documents/)).toBeVisible()
+ await expect.poll(() => drawer.getByRole('listitem').all()).toHaveLength(2)
+ })
+
+ it('retries a failed first request with a real control at a narrow viewport', async () => {
+ service.drawerActivity.mockRejectedValueOnce(new Error('network error'))
+ const drawer = await openDrawer()
+ const alert = drawer.getByRole('alert')
+ await expect.element(alert).toMatchTextContent('knowledgeSpace.tasksErrorDescription')
+ await expect
+ .element(drawer.getByText('knowledgeOverview.overview.noMatchingActivity'))
+ .not.toBeInTheDocument()
+ const retry = alert.getByRole('button', { name: 'common.operation.retry' })
+ await retry.click()
+
+ await expect.element(drawer.getByText(/Synced 1 documents/)).toBeVisible()
+ await expect.element(alert).not.toBeInTheDocument()
+ await userEvent.keyboard('{Escape}')
+ await expect
+ .element(page.getByLabelText('knowledgeOverview.overview.allActivity'))
+ .not.toBeInTheDocument()
+ })
+
+ it('keeps the loaded activity readable when a task-completion refresh fails', async () => {
+ const drawer = await openDrawer()
+ await expect.element(drawer.getByText(/Synced 1 documents/)).toBeVisible()
+ service.drawerActivity.mockRejectedValueOnce(new Error('network error'))
+ service.tasks.mockResolvedValue({ data: [task('completed')], next_cursor: null })
+ await vi.advanceTimersByTimeAsync(2000)
+
+ await expect
+ .element(drawer.getByRole('alert'))
+ .toMatchTextContent('knowledgeSpace.tasksErrorDescription')
+ await expect.element(drawer.getByText(/Synced 1 documents/)).toBeVisible()
+ })
+})
diff --git a/web/features/new-rag/overview/__tests__/activity-drawer.spec.tsx b/web/features/new-rag/overview/__tests__/activity-drawer.spec.tsx
deleted file mode 100644
index 52dc8224a8b..00000000000
--- a/web/features/new-rag/overview/__tests__/activity-drawer.spec.tsx
+++ /dev/null
@@ -1,168 +0,0 @@
-import type {
- KnowledgeFsBackgroundTaskResponse,
- KnowledgeFsOverviewActivityResponse,
-} from '@dify/contracts/api/console/knowledge-fs/types.gen'
-import type { ClientLink } from '@orpc/client'
-import type { ConsoleClientContext } from '@/service/console'
-import { act, render, screen, waitFor, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { consoleQuery } from '@/service/console'
-import { createConsoleQueryClient, createConsoleQueryWrapper } from '@/test/console/query-data'
-import { QueryTestingAdapter } from '@/test/query-state-testing-adapter'
-import { OverviewActivity } from '../overview-activity'
-import { OverviewTaskSync } from '../overview-task-sync'
-import { OverviewStateBoundary } from '../state-boundary'
-
-type ActivityInput = { query: { from_at?: string } }
-
-const service = vi.hoisted(() => ({
- drawerActivity: vi.fn(),
- tasks: vi.fn(),
-}))
-
-// Real generated query keys: the drawer must stay inside the task-sync invalidation boundary.
-vi.mock('@/service/console', async () => {
- const { createORPCClient } = await import('@orpc/client')
- const { createConsoleQuery } = await import('@/service/console/query-policies')
- const link: ClientLink<ConsoleClientContext> = {
- call: async (path, input) => {
- switch (path.join('.')) {
- case 'knowledgeFs.spaces.byControlSpaceId.overview.activity.get':
- // Only the drawer bounds activity by date in a non-cloud edition.
- return (input as ActivityInput).query.from_at
- ? service.drawerActivity()
- : { data: [], next_cursor: null }
- case 'knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get':
- return service.tasks()
- case 'knowledgeFs.spaces.byControlSpaceId.overview.stats.get':
- return { documents: 1, source_count: 1 }
- case 'knowledgeFs.spaces.byControlSpaceId.overview.inventory.get':
- return { index_coverage: { indexed: 1 } }
- case 'knowledgeFs.spaces.byControlSpaceId.overview.attention.get':
- return { data: [] }
- case 'workspaces.current.members.get':
- return { accounts: [] }
- default:
- return {}
- }
- },
- }
- return { consoleQuery: createConsoleQuery(createORPCClient(link)) }
-})
-
-function activity(id: string, count: number): KnowledgeFsOverviewActivityResponse {
- return {
- action: 'source.synced',
- actor: { id: 'system', type: 'system' },
- details: { count },
- id,
- occurred_at: new Date().toISOString(),
- resource: { id: 'source-1', type: 'source' },
- result: 'success',
- }
-}
-
-function task(
- state: KnowledgeFsBackgroundTaskResponse['state'],
-): KnowledgeFsBackgroundTaskResponse {
- return {
- can_cancel: state === 'running',
- can_retry: false,
- created_at: '2026-09-08T00:00:00Z',
- updated_at: state === 'running' ? '2026-09-08T00:00:00Z' : '2026-09-08T00:00:01Z',
- id: 'task-1',
- document_id: 'document-1',
- knowledge_space_id: 'space-a',
- operation: 'source_sync',
- progress_completed: 0,
- progress_failed: 0,
- progress_percent: 20,
- progress_total: 1,
- state,
- task_kind: 'source',
- }
-}
-
-const tasksKey = consoleQuery.knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get.key()
-
-describe('overview activity drawer', () => {
- let client: ReturnType<typeof createConsoleQueryClient>
- beforeEach(() => {
- vi.resetAllMocks()
- client = createConsoleQueryClient()
- service.tasks.mockResolvedValue({ data: [task('running')], next_cursor: null })
- service.drawerActivity.mockResolvedValue({
- data: [activity('activity-1', 1)],
- next_cursor: null,
- })
- })
- async function openDrawer() {
- const user = userEvent.setup()
- // Only the drawer bounds activity by date outside the cloud edition.
- const { wrapper } = createConsoleQueryWrapper({
- queryClient: client,
- systemFeatures: { deployment_edition: 'ENTERPRISE' },
- })
- render(
- <QueryTestingAdapter>
- <OverviewStateBoundary knowledgeSpaceId="space-a">
- <OverviewTaskSync />
- <OverviewActivity />
- </OverviewStateBoundary>
- </QueryTestingAdapter>,
- { wrapper },
- )
- await user.click(
- await screen.findByRole('button', { name: 'knowledgeOverview.overview.allActivity' }),
- )
- return {
- user,
- drawer: await screen.findByRole('dialog', { name: 'knowledgeOverview.overview.allActivity' }),
- }
- }
-
- it('refreshes the open drawer when a background task completes', async () => {
- const { drawer } = await openDrawer()
- await waitFor(() => expect(service.drawerActivity).toHaveBeenCalledOnce())
- expect(await within(drawer).findAllByRole('listitem')).toHaveLength(1)
-
- service.drawerActivity.mockResolvedValue({
- data: [activity('activity-2', 2), activity('activity-1', 1)],
- next_cursor: null,
- })
- service.tasks.mockResolvedValue({ data: [task('completed')], next_cursor: null })
- await act(() => client.invalidateQueries({ queryKey: tasksKey }))
-
- await waitFor(() => expect(within(drawer).getAllByRole('listitem')).toHaveLength(2))
- expect(service.drawerActivity).toHaveBeenCalledTimes(2)
- })
-
- it('shows a retryable error instead of an empty result when the first request fails', async () => {
- service.drawerActivity.mockRejectedValueOnce(new Error('network error'))
- const { drawer, user } = await openDrawer()
-
- const alert = await within(drawer).findByRole('alert')
- expect(alert).toHaveTextContent('knowledgeSpace.tasksErrorDescription')
- expect(
- within(drawer).queryByText('knowledgeOverview.overview.noMatchingActivity'),
- ).not.toBeInTheDocument()
-
- await user.click(within(alert).getByRole('button', { name: 'common.operation.retry' }))
- await waitFor(() => expect(within(drawer).getAllByRole('listitem')).toHaveLength(1))
- expect(within(drawer).queryByRole('alert')).not.toBeInTheDocument()
- })
-
- it('keeps loaded rows visible when a refresh fails', async () => {
- const { drawer } = await openDrawer()
- expect(await within(drawer).findAllByRole('listitem')).toHaveLength(1)
-
- service.drawerActivity.mockRejectedValueOnce(new Error('network error'))
- service.tasks.mockResolvedValue({ data: [task('completed')], next_cursor: null })
- await act(() => client.invalidateQueries({ queryKey: tasksKey }))
-
- expect(await within(drawer).findByRole('alert')).toHaveTextContent(
- 'knowledgeSpace.tasksErrorDescription',
- )
- expect(within(drawer).getAllByRole('listitem')).toHaveLength(1)
- })
-})
diff --git a/web/features/new-rag/overview/__tests__/page.browser.spec.tsx b/web/features/new-rag/overview/__tests__/page.browser.spec.tsx
new file mode 100644
index 00000000000..746a3f1d87c
--- /dev/null
+++ b/web/features/new-rag/overview/__tests__/page.browser.spec.tsx
@@ -0,0 +1,861 @@
+import type { KnowledgeFsProductPermission } from '@dify/contracts/api/console/knowledge-fs/types.gen'
+import dayjs from 'dayjs'
+import { page, userEvent } from 'vite-plus/test/browser'
+import { render } from 'vitest-browser-react'
+import { consoleQuery } from '@/service/console'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { createDeferred } from '@/test/deferred'
+import { createKnowledgeSpaceFixture, KnowledgeSpaceTestProvider } from '@/test/knowledge-space'
+import { createOverviewData } from '@/test/new-rag-overview'
+import { QueryTestingAdapter } from '@/test/query-state-testing-adapter'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { KnowledgeOverviewPage } from '../page'
+
+vi.mock('@/next/link', () => ({
+ default: ({ onClick, href, children, ...props }: import('react').ComponentProps<'a'>) => (
+ <a
+ {...props}
+ href={href}
+ onClick={(event) => {
+ onClick?.(event)
+ event.preventDefault()
+ }}
+ >
+ {children}
+ </a>
+ ),
+}))
+
+vi.mock('@/next/navigation', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/next/navigation')>()),
+ useSearchParams: () => new URLSearchParams(),
+ usePathname: () => '/datasets/new/space-1/overview',
+ useRouter: () => ({ push: vi.fn() }),
+}))
+
+// Isolate the external chart renderer; retain the real page, Query/Jotai owners and chart surface.
+
+vi.mock('echarts-for-react', () => ({
+ default: () => <div aria-label="query outcomes chart" />,
+}))
+type OverviewResource =
+ | 'activity'
+ | 'attention'
+ | 'inventory'
+ | 'members'
+ | 'outcomes'
+ | 'source'
+ | 'stats'
+ | 'tasks'
+let queryData = createOverviewData()
+
+const server = vi.hoisted(() => ({
+ calls: {
+ activity: vi.fn(),
+ attention: vi.fn(),
+ inventory: vi.fn(),
+ members: vi.fn(),
+ outcomes: vi.fn(),
+ source: vi.fn(),
+ stats: vi.fn(),
+ tasks: vi.fn(),
+ },
+ failing: new Set<string>(),
+ held: new Map<string, Promise<void>>(),
+}))
+
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleResponses } = await import('@/test/console/service-responses')
+ const respond =
+ (resource: OverviewResource, data: () => unknown) =>
+ async (input: unknown): Promise<unknown> => {
+ server.calls[resource](input)
+ await server.held.get(resource)
+ if (server.failing.has(resource)) throw new Error(`${resource} unavailable`)
+ return structuredClone(data())
+ }
+ const overview = 'knowledgeFs.spaces.byControlSpaceId.overview'
+ return {
+ ...actual,
+ consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ 'knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get': respond('tasks', () => ({
+ data: queryData.tasks,
+ next_cursor: null,
+ })),
+ 'knowledgeFs.spaces.byControlSpaceId.sources.bySourceId.get': respond(
+ 'source',
+ () => queryData.source,
+ ),
+ [`${overview}.activity.get`]: respond('activity', () => queryData.activity),
+ [`${overview}.attention.get`]: respond('attention', () => queryData.attention),
+ [`${overview}.inventory.get`]: respond('inventory', () => queryData.inventory),
+ [`${overview}.queryOutcomes.get`]: respond('outcomes', () => queryData.outcomes),
+ [`${overview}.stats.get`]: respond('stats', () => queryData.stats),
+ 'knowledgeFs.spaces.byControlSpaceId.settings.get': () => ({ configuration_state: 'active' }),
+ 'workspaces.current.members.get': respond('members', () => ({
+ accounts: [
+ {
+ avatar_url: null,
+ email: '[email protected]',
+ id: 'member-1',
+ name: 'Ada',
+ },
+ ],
+ })),
+ }),
+ }
+})
+type ActivityQuery = Record<string, unknown>
+const lastActivityQuery = () =>
+ (
+ server.calls.activity.mock.lastCall?.[0] as
+ | {
+ query: ActivityQuery
+ }
+ | undefined
+ )?.query
+const drawerActivityQueries = () =>
+ server.calls.activity.mock.calls
+ .map(
+ ([input]) =>
+ (
+ input as {
+ query: ActivityQuery
+ }
+ ).query,
+ )
+ .filter((query) => 'from_at' in query)
+/** Holds a resource's responses open until the returned release function is called. */
+function hold(resource: OverviewResource) {
+ const gate = createDeferred<void>()
+ server.held.set(resource, gate.promise)
+ return async () => {
+ server.held.delete(resource)
+ gate.resolve()
+ }
+}
+async function renderOverview({
+ deploymentEdition = 'COMMUNITY',
+ searchParams = '',
+ settle = true,
+ spacePermissions = ['knowledge_space_document_write'],
+}: {
+ deploymentEdition?: 'CLOUD' | 'COMMUNITY' | 'ENTERPRISE'
+ searchParams?: string
+ settle?: boolean
+ spacePermissions?: KnowledgeFsProductPermission[]
+} = {}) {
+ const onUrlUpdate = vi.fn()
+ const { wrapper: Wrapper, queryClient } = createConsoleQueryWrapper({
+ knowledgeFsFeatures: { upload_enabled: true },
+ systemFeatures: { deployment_edition: deploymentEdition },
+ })
+ onTestFinished(() => queryClient.clear())
+ const view = await render(
+ <Wrapper>
+ <QueryTestingAdapter searchParams={searchParams} onUrlUpdate={onUrlUpdate}>
+ <KnowledgeSpaceTestProvider
+ space={createKnowledgeSpaceFixture({ permission_keys: spacePermissions })}
+ >
+ <KnowledgeOverviewPage knowledgeSpaceId="space-1" />
+ </KnowledgeSpaceTestProvider>
+ </QueryTestingAdapter>
+ </Wrapper>,
+ )
+ if (settle) await expect.poll(() => queryClient.isFetching()).toBe(0)
+ const refetch = async (path: () => readonly unknown[]) => {
+ await queryClient.invalidateQueries({ queryKey: path() })
+ }
+ return { ...view, queryClient, onUrlUpdate, refetch }
+}
+const overviewKeys = {
+ attention: () => consoleQuery.knowledgeFs.spaces.byControlSpaceId.overview.attention.get.key(),
+ stats: () => consoleQuery.knowledgeFs.spaces.byControlSpaceId.overview.stats.get.key(),
+ tasks: () => consoleQuery.knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get.key(),
+}
+const emptyKnowledgeBase = () => {
+ queryData.stats.source_count = 0
+ queryData.stats.documents = 0
+}
+
+describe('KnowledgeOverviewPage', () => {
+ beforeEach(async () => {
+ await page.viewport(1280, 900)
+ onTestFinished(guardUnexpectedFetch())
+ server.failing.clear()
+ server.held.clear()
+ queryData = createOverviewData()
+ })
+
+ afterEach(() => {
+ vi.useRealTimers()
+ vi.restoreAllMocks()
+ })
+
+ it('refreshes the metrics queries when a user switches the overview range', async () => {
+ const { onUrlUpdate } = await renderOverview()
+ const sevenDayRadio = page.getByRole('radio', {
+ name: 'knowledgeOverview.overview.sevenDays',
+ })
+ await page.getByRole('radio', { name: 'knowledgeOverview.overview.twentyFourHours' }).click()
+ await userEvent.keyboard('{ArrowRight}')
+ await expect.element(sevenDayRadio).toHaveFocus()
+ await expect.element(sevenDayRadio).toHaveAttribute('aria-checked', 'true')
+ const sevenDays = { params: { control_space_id: 'space-1' }, query: { window: '7d' } }
+ await expect.poll(() => server.calls.stats).toHaveBeenLastCalledWith(sevenDays)
+ expect(server.calls.outcomes).toHaveBeenLastCalledWith(sevenDays)
+ await expect
+ .poll(() => onUrlUpdate.mock.calls.at(-1)?.[0].searchParams.get('window'))
+ .toBe('7d')
+ expect(onUrlUpdate.mock.calls.at(-1)?.[0].options.history).toBe('push')
+ })
+
+ it('restores the selected overview range from the URL', async () => {
+ await renderOverview({ searchParams: '?window=30d' })
+ await expect
+ .element(page.getByRole('radio', { name: 'knowledgeOverview.overview.thirtyDays' }))
+ .toHaveAttribute('aria-checked', 'true')
+ const thirtyDays = { params: { control_space_id: 'space-1' }, query: { window: '30d' } }
+ expect(server.calls.stats).toHaveBeenLastCalledWith(thirtyDays)
+ expect(server.calls.outcomes).toHaveBeenLastCalledWith(thirtyDays)
+ })
+
+ it('renders ratio fields from the API contract as percentages', async () => {
+ await renderOverview()
+ await expect.element(page.getByText('84%')).toBeInTheDocument()
+ await expect.element(page.getByText('+100%')).toBeInTheDocument()
+ await expect.element(page.getByText('+4 pp')).toBeInTheDocument()
+ })
+
+ it('keeps existing overview data visible during a background refresh', async () => {
+ queryData.outcomes.buckets = [
+ {
+ answered: 8,
+ low_confidence: 1,
+ no_evidence: 1,
+ query_count: 10,
+ start_at: '2026-07-29T09:00:00Z',
+ end_at: '2026-07-29T10:00:00Z',
+ },
+ ]
+ const { queryClient } = await renderOverview()
+ const release = hold('stats')
+ queryData.stats.answer_rate.value = 0.86
+ void queryClient.invalidateQueries({ queryKey: overviewKeys.stats() })
+ await expect.poll(() => queryClient.isFetching()).toBeGreaterThan(0)
+ await expect.element(page.getByText('84%')).toBeInTheDocument()
+ await expect.element(page.getByLabelText('query outcomes chart')).toBeInTheDocument()
+ await release()
+ await expect.element(page.getByText('86%')).toBeVisible()
+ })
+
+ it('shows the member who performed an activity instead of a system placeholder', async () => {
+ await renderOverview()
+ await expect.element(page.getByText('Ada')).toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.system'))
+ .not.toBeInTheDocument()
+ })
+
+ it('keeps activities beyond the seventh row available in the recent activity list', async () => {
+ const activity = queryData.activity.data[0]!
+ queryData.activity.data.push(
+ ...Array.from({ length: 7 }, (_, index) => ({
+ ...activity,
+ id: `activity-${index + 2}`,
+ details: { reasonCode: `Activity ${index + 2}` },
+ })),
+ )
+ await renderOverview()
+ const recentActivity = page.getByRole('table', {
+ name: 'knowledgeOverview.overview.recentActivity',
+ })
+ await expect.poll(() => recentActivity.getByRole('row').all()).toHaveLength(9)
+ await expect.element(recentActivity).toBeVisible()
+ const table = recentActivity.element()
+ const lastRow = recentActivity.getByRole('row').filter({ hasText: 'Activity 8' })
+ await expect.element(lastRow).toBeInTheDocument()
+ expect(table.scrollHeight).toBeGreaterThan(table.clientHeight)
+ await recentActivity.wheel({ delta: { y: 1000 } })
+ await expect
+ .poll(() => {
+ const row = lastRow.element().getBoundingClientRect()
+ const viewport = table.getBoundingClientRect()
+ return table.scrollTop > 0 && row.top >= viewport.top && row.bottom <= viewport.bottom
+ })
+ .toBe(true)
+ })
+
+ it('reveals resolved modules while waiting to decide the page empty state', async () => {
+ emptyKnowledgeBase()
+ const releases = (
+ ['activity', 'attention', 'inventory', 'outcomes', 'stats', 'tasks'] as const
+ ).map((resource) => [resource, hold(resource)] as const)
+ const release = Object.fromEntries(releases)
+ await renderOverview({ settle: false })
+ await expect
+ .element(page.getByRole('radiogroup', { name: 'knowledgeOverview.overview.timeRange' }))
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.noSources' }))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.needsAttention' }))
+ .toBeInTheDocument()
+ await expect.element(page.getByText('84%')).not.toBeInTheDocument()
+ await release.stats!()
+ await expect.element(page.getByText('84%')).toBeInTheDocument()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.noSources' }))
+ .not.toBeInTheDocument()
+ for (const [, releaseResource] of releases) await releaseResource()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.noSources' }))
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByRole('radiogroup', { name: 'knowledgeOverview.overview.timeRange' }))
+ .not.toBeInTheDocument()
+ })
+
+ it('shows an activity error with a retry action instead of an empty state', async () => {
+ server.failing.add('activity')
+ await renderOverview()
+ await expect.element(page.getByText('knowledgeSpace.tasksErrorDescription')).toBeInTheDocument()
+ server.failing.delete('activity')
+ await page.getByRole('button', { name: 'common.operation.retry' }).click()
+ await expect.element(page.getByText('Ada')).toBeInTheDocument()
+ await expect
+ .element(page.getByRole('table', { name: 'knowledgeOverview.overview.recentActivity' }))
+ .toBeVisible()
+ await expect
+ .element(page.getByText('knowledgeSpace.tasksErrorDescription'))
+ .not.toBeInTheDocument()
+ })
+
+ it('renders specific attention findings and clamps the page when polling removes issues', async () => {
+ queryData.attention.data = Array.from({ length: 6 }, (_, index) => ({
+ action: {
+ kind: 'open-resource' as const,
+ resource_id: `source-${index}`,
+ resource_type: 'source' as const,
+ },
+ evidence: [{ code: 'SOURCE_STALE', observed_at: '2026-07-29T08:00:00Z' }],
+ issue_key: `issue-${index}`,
+ knowledge_space_id: 'knowledge-1',
+ resource: { id: `source-${index}`, type: 'source' as const },
+ revision: 1,
+ rule_id: 'stale-source' as const,
+ severity: index === 0 ? ('critical' as const) : ('warning' as const),
+ status: 'active' as const,
+ title: `Source ${index} has not synced in 7 days`,
+ updated_at: '2026-07-29T08:00:00Z',
+ }))
+ const { refetch } = await renderOverview()
+ await expect
+ .poll(() => page.getByText('knowledgeOverview.overview.attention.staleSource.title').all())
+ .toHaveLength(4)
+ await expect
+ .element(page.getByText('Source 0 has not synced in 7 days'))
+ .not.toBeInTheDocument()
+ await expect.element(page.getByText('knowledgeOverview.overview.blocker')).toBeInTheDocument()
+ await page.getByRole('button', { name: 'common.pagination.next' }).click()
+ await expect.element(page.getByText('2 / 2')).toBeInTheDocument()
+ queryData.attention.data = queryData.attention.data.slice(0, 1)
+ await refetch(overviewKeys.attention)
+ await expect.element(page.getByText('1 / 1')).toBeInTheDocument()
+ await expect
+ .element(page.getByRole('button', { name: 'common.pagination.previous' }))
+ .toBeDisabled()
+ })
+
+ it('explains model blockers and ignores retired permission-readiness responses', async () => {
+ queryData.attention.data = [
+ {
+ action: { kind: 'review-models', resource_type: 'knowledge-space' },
+ evidence: [
+ { code: 'MODEL_PROFILE_NOT_READY', observed_at: '2026-07-29T08:00:00Z' },
+ { code: 'MODEL_RETRIEVAL_PROFILE_MISSING', observed_at: '2026-07-29T08:00:00Z' },
+ { code: 'MODEL_PUBLICATION_BINDING_MISSING', observed_at: '2026-07-29T08:00:00Z' },
+ ],
+ issue_key: 'model-readiness:knowledge-space:knowledge-1',
+ knowledge_space_id: 'knowledge-1',
+ resource: { id: 'knowledge-1', type: 'knowledge-space' },
+ revision: 1,
+ rule_id: 'model-readiness',
+ severity: 'critical',
+ status: 'active',
+ title: 'Retrieval model profile is not published',
+ updated_at: '2026-07-29T08:00:00Z',
+ },
+ {
+ action: { kind: 'review-permissions', resource_type: 'knowledge-space' },
+ evidence: [
+ { code: 'PERMISSION_AGGREGATE_NOT_READY', observed_at: '2026-07-29T08:00:00Z' },
+ { code: 'PERMISSION_POLICY_MISSING', observed_at: '2026-07-29T08:00:00Z' },
+ { code: 'PERMISSION_OWNER_MISSING', observed_at: '2026-07-29T08:00:00Z' },
+ ],
+ issue_key: 'permission-readiness:knowledge-space:knowledge-1',
+ knowledge_space_id: 'knowledge-1',
+ resource: { id: 'knowledge-1', type: 'knowledge-space' },
+ revision: 1,
+ rule_id: 'permission-readiness',
+ severity: 'critical',
+ status: 'active',
+ title: 'Knowledge-space permissions are not ready',
+ updated_at: '2026-07-29T08:00:00Z',
+ },
+ ]
+ await renderOverview()
+ await expect
+ .element(page.getByText('knowledgeSpace.overview.attention.modelReadiness.title'))
+ .toBeInTheDocument()
+ await expect
+ .element(
+ page.getByText(
+ 'knowledgeSpace.overview.attention.modelReadiness.profilesMissing knowledgeSpace.overview.attention.modelReadiness.bindingMissing',
+ ),
+ )
+ .toBeInTheDocument()
+ await expect
+ .element(
+ page.getByRole('button', {
+ name: 'knowledgeSpace.overview.attention.action.configureModels',
+ }),
+ )
+ .toHaveAttribute('href', '/datasets/new/space-1/settings')
+ await expect
+ .element(page.getByText('Retrieval model profile is not published'))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByText('Knowledge-space permissions are not ready'))
+ .not.toBeInTheDocument()
+ })
+
+ it('fetches complete activity on opening and removes the drawer before reopening', async () => {
+ await renderOverview()
+ const trigger = page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' })
+ expect(drawerActivityQueries()).toEqual([])
+ await trigger.click()
+ const dialog = page.getByRole('dialog', { name: 'knowledgeOverview.overview.allActivity' })
+ await expect.element(dialog).toBeVisible()
+ await expect
+ .element(dialog.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }))
+ .toMatchTextContent('knowledgeOverview.overview.today')
+ await expect
+ .element(dialog.getByRole('combobox', { name: 'knowledgeOverview.overview.operator' }))
+ .toBeVisible()
+ await expect.poll(() => drawerActivityQueries().length).toBe(1)
+ await userEvent.keyboard('{Escape}')
+ await expect
+ .element(page.getByLabelText('knowledgeOverview.overview.allActivity'))
+ .not.toBeInTheDocument()
+ await expect.element(trigger).toHaveFocus()
+ await trigger.click()
+ await expect.element(dialog).toBeVisible()
+ await expect.element(dialog.getByRole('listitem')).toBeVisible()
+ })
+
+ it('applies member and date filters to activity requests', async () => {
+ await renderOverview()
+ await page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }).click()
+ await page.getByRole('combobox', { name: 'knowledgeOverview.overview.operator' }).click()
+ await page.getByRole('option', { name: 'Ada' }).click()
+ await expect
+ .poll(() => lastActivityQuery())
+ .toMatchObject({
+ actor_id: 'dify-account:member-1',
+ actor_type: 'member',
+ limit: 20,
+ })
+ expect(lastActivityQuery()).not.toHaveProperty('cursor')
+ await page.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }).click()
+ await page.getByRole('option', { name: 'knowledgeOverview.overview.last90Days' }).click()
+ await expect
+ .poll(() => lastActivityQuery())
+ .toMatchObject({
+ actor_id: 'dify-account:member-1',
+ from_at: dayjs().subtract(89, 'day').startOf('day').toISOString(),
+ })
+ })
+
+ it('limits cloud activity filters to the most recent 90 calendar days', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] })
+ vi.setSystemTime(new Date(2026, 8, 8, 12))
+ const earliest = dayjs().subtract(89, 'day').startOf('day')
+ await renderOverview({ deploymentEdition: 'CLOUD' })
+ expect(lastActivityQuery()).toMatchObject({ from_at: earliest.toISOString() })
+ await page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }).click()
+ await page.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }).click()
+ await expect
+ .element(page.getByRole('option', { name: 'knowledgeOverview.overview.allTime' }))
+ .not.toBeInTheDocument()
+ await page.getByRole('option', { name: 'knowledgeOverview.overview.last90Days' }).click()
+ await expect
+ .poll(() => lastActivityQuery())
+ .toMatchObject({
+ from_at: earliest.toISOString(),
+ to_at: dayjs().endOf('day').toISOString(),
+ })
+ const ordinal = (day: number) => {
+ const suffix =
+ ['th', 'st', 'nd', 'rd'][day % 100 > 10 && day % 100 < 14 ? 0 : day % 10] ?? 'th'
+ return `${day}${suffix}`
+ }
+ const calendarLabel = (date: dayjs.Dayjs) =>
+ new RegExp(`${date.format('MMMM')} ${ordinal(date.date())}, ${date.year()}`)
+ await page.getByRole('button', { name: /knowledgeOverview\.overview\.timeRange start/ }).click()
+ await expect
+ .element(page.getByRole('button', { name: calendarLabel(earliest.subtract(1, 'day')) }))
+ .toBeDisabled()
+ await expect.element(page.getByRole('button', { name: calendarLabel(earliest) })).toBeEnabled()
+ await page.getByRole('button', { name: calendarLabel(earliest.add(1, 'day')) }).click()
+ await expect
+ .element(page.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }))
+ .toMatchTextContent('filter.period.custom')
+ await expect.poll(() => lastActivityQuery()?.from_at).toBe(earliest.add(1, 'day').toISOString())
+ })
+
+ it('preserves all-time activity queries outside cloud', async () => {
+ const deploymentEdition = 'ENTERPRISE'
+ await renderOverview({ deploymentEdition })
+ expect(lastActivityQuery()).not.toHaveProperty('from_at')
+ await page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }).click()
+ await expect.poll(() => drawerActivityQueries()).toHaveLength(1)
+ await page.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }).click()
+ await page.getByRole('option', { name: 'knowledgeOverview.overview.allTime' }).click()
+ await expect
+ .element(page.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }))
+ .toMatchTextContent('knowledgeOverview.overview.allTime')
+ await expect.poll(() => lastActivityQuery()).not.toHaveProperty('from_at')
+ expect(lastActivityQuery()).not.toHaveProperty('from_at')
+ expect(lastActivityQuery()).not.toHaveProperty('to_at')
+ })
+
+ it('keeps refreshing visible metrics until the snapshot catches up with the completed task', async () => {
+ vi.useFakeTimers({ toFake: ['setInterval', 'clearInterval'] })
+ queryData.tasks[0]!.state = 'running'
+ queryData.tasks[0]!.updated_at = '2026-07-29T10:00:00Z'
+ const { queryClient } = await renderOverview()
+ await expect.element(page.getByText('10', { exact: true })).toBeVisible()
+ queryData.stats.queries.value = 11
+ await vi.advanceTimersByTimeAsync(2000)
+ await expect.element(page.getByText('11', { exact: true })).toBeVisible()
+ queryData.tasks[0]!.state = 'completed'
+ queryData.stats.queries.value = 12
+ await queryClient.invalidateQueries({ queryKey: overviewKeys.tasks() })
+ await vi.advanceTimersByTimeAsync(2000)
+ await expect.element(page.getByText('12', { exact: true })).toBeVisible()
+ queryData.stats.generated_at = '2026-07-29T10:01:00Z'
+ queryData.stats.queries.value = 13
+ await vi.advanceTimersByTimeAsync(2000)
+ await expect.element(page.getByText('13', { exact: true })).toBeVisible()
+ await expect.poll(() => queryClient.isFetching()).toBe(0)
+ const caughtUp = server.calls.stats.mock.calls.length
+ await vi.advanceTimersByTimeAsync(6000)
+ expect(server.calls.stats).toHaveBeenCalledTimes(caughtUp)
+ await expect.element(page.getByText('13', { exact: true })).toBeVisible()
+ })
+
+ it('hides onboarding actions from a read-only member', async () => {
+ emptyKnowledgeBase()
+ await renderOverview({ spacePermissions: ['knowledge_space_read'] })
+ await expect
+ .element(page.getByRole('link', { name: 'knowledgeOverview.overview.connectSource' }))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('link', { name: 'knowledgeOverview.overview.uploadFiles' }))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.readOnlyDescription'))
+ .toBeVisible()
+ })
+
+ it.each([
+ ['document.failed', 'failure', 'text/plain', 'knowledgeOverview.overview.activityFailed'],
+ [
+ 'document.published',
+ 'success',
+ 'application/pdf',
+ 'knowledgeOverview.overview.activityCompleted',
+ ],
+ ] as const)(
+ 'omits the file MIME type from %s in recent and all activity',
+ async (action, result, documentType, label) => {
+ queryData.activity.data[0]!.action = action
+ queryData.activity.data[0]!.details = { documentType }
+ queryData.activity.data[0]!.result = result
+ await renderOverview()
+ const recentActivity = page.getByRole('table', {
+ name: 'knowledgeOverview.overview.recentActivity',
+ })
+ await expect.element(recentActivity.getByText(label, { exact: false })).toBeInTheDocument()
+ await expect.element(recentActivity).not.toMatchTextContent(documentType)
+ await page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }).click()
+ const dialog = page.getByRole('dialog', {
+ name: 'knowledgeOverview.overview.allActivity',
+ })
+ await expect.element(dialog.getByText(label, { exact: false })).toBeInTheDocument()
+ await expect.element(dialog).not.toMatchTextContent(documentType)
+ },
+ )
+
+ it('shows safe activity details and relative times for today in the drawer', async () => {
+ // At midnight, "two hours ago" is yesterday and deliberately uses an absolute date.
+ vi.useFakeTimers({ toFake: ['Date'] })
+ vi.setSystemTime(new Date(2026, 8, 8, 12, 0, 0))
+ queryData.activity.data[0]!.action = 'source.failed'
+ queryData.activity.data[0]!.details = { reasonCode: 'CREDENTIALS_EXPIRED' }
+ queryData.activity.data[0]!.occurred_at = new Date(Date.now() - 2 * 60 * 60000).toISOString()
+ queryData.activity.data[0]!.result = 'failure'
+ await renderOverview()
+ await page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }).click()
+ const dialog = page.getByRole('dialog', {
+ name: 'knowledgeOverview.overview.allActivity',
+ })
+ await expect.element(dialog).toMatchTextContent('Credentials expired')
+ await expect.element(dialog).toMatchTextContent('knowledgeOverview.overview.activityFailed')
+ await expect.element(dialog.getByText(/2h ago|2 hr\. ago|2 hours ago/)).toBeInTheDocument()
+ vi.useRealTimers()
+ })
+
+ it('shows one initiated query activity with its question and retrieval mode', async () => {
+ queryData.activity.data[0]!.action = 'query.requested'
+ queryData.activity.data[0]!.details = {
+ mode: 'research',
+ question: 'How do permissions work?',
+ }
+ queryData.activity.data[0]!.result = 'success'
+ await renderOverview()
+ const label = 'knowledgeSpace.qualityPage.question: How do permissions work? — research'
+ await expect.element(page.getByRole('table').getByText(label)).toBeInTheDocument()
+ await page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }).click()
+ await expect.element(page.getByRole('dialog').getByText(label)).toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeSpace.overview.activityQueued'))
+ .not.toBeInTheDocument()
+ })
+
+ it('offers source connection and direct upload when the knowledge base is empty', async () => {
+ emptyKnowledgeBase()
+ await renderOverview()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.noSources' }))
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByRole('link', { name: 'knowledgeOverview.overview.connectSource' }))
+ .toHaveAttribute('href', '/datasets/new/space-1/sources/new')
+ await expect
+ .element(page.getByRole('link', { name: 'knowledgeOverview.overview.uploadFiles' }))
+ .toHaveAttribute('href', '/datasets/new/space-1/documents?upload=1')
+ await expect.poll(() => page.getByText('—').all()).toHaveLength(5)
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.needsAttention' }))
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.noQueryData'))
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.recentActivity' }))
+ .toBeInTheDocument()
+ await expect.element(page.getByText('knowledgeSpace.documentsEmptyTitle')).toBeInTheDocument()
+ await expect
+ .element(page.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }))
+ .not.toBeInTheDocument()
+ await expect.element(page.getByRole('table')).not.toBeInTheDocument()
+ await expect.element(page.getByRole('tablist')).not.toBeInTheDocument()
+ })
+
+ it('disables both onboarding entries after starting navigation', async () => {
+ emptyKnowledgeBase()
+ await renderOverview()
+ const connectSource = page.getByRole('link', {
+ name: 'knowledgeOverview.overview.connectSource',
+ })
+ const uploadFiles = page.getByRole('link', {
+ name: 'knowledgeOverview.overview.uploadFiles',
+ })
+ await connectSource.click()
+ await expect.element(connectSource).toHaveAttribute('aria-busy', 'true')
+ await expect.element(connectSource).toHaveAttribute('aria-disabled', 'true')
+ await expect.element(uploadFiles).toHaveAttribute('aria-disabled', 'true')
+ })
+
+ it('keeps failed first-source tasks in Needs attention without a duplicate banner', async () => {
+ emptyKnowledgeBase()
+ queryData.tasks[0]!.can_retry = true
+ queryData.tasks[0]!.operation = 'document_processing'
+ queryData.tasks[0]!.state = 'failed'
+ await renderOverview()
+ await expect.element(page.getByRole('alert')).not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('button', { name: 'knowledgeSpace.retryTask' }))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.attention.failedDocument.title'))
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.noIssues'))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('button', { name: 'knowledgeOverview.overview.viewDocuments' }))
+ .toBeInTheDocument()
+ })
+
+ it('shows explicit section errors instead of healthy or zero-value fallbacks', async () => {
+ server.failing.add('attention')
+ server.failing.add('inventory')
+ await renderOverview()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.needsAttention' }))
+ .toBeVisible()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.inventory' }))
+ .toBeVisible()
+ await expect
+ .poll(() => page.getByText('knowledgeSpace.detailErrorDescription').all())
+ .toHaveLength(3)
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.noIssues'))
+ .not.toBeInTheDocument()
+ })
+
+ it('shows overview data when uploaded documents exist without a connected source', async () => {
+ queryData.stats.source_count = 0
+ queryData.stats.documents = 1
+ await renderOverview()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.recentActivity' }))
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByRole('link', { name: 'knowledgeOverview.overview.connectSource' }))
+ .not.toBeInTheDocument()
+ })
+
+ it('omits graph metrics from the knowledge inventory', async () => {
+ await renderOverview()
+ await expect
+ .element(
+ page.getByRole('listitem').filter({ hasText: 'knowledgeOverview.overview.webCrawl' }),
+ )
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeSpace.overview.graphEntities'))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeSpace.overview.graphRelations'))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeSpace.overview.indexCoverage'))
+ .not.toBeInTheDocument()
+ })
+
+ it('shows first-indexing progress while the initial document task is running', async () => {
+ emptyKnowledgeBase()
+ queryData.inventory.index_coverage.indexed = 0
+ queryData.tasks[0]!.operation = 'document_processing'
+ queryData.tasks[0]!.progress_completed = 1
+ queryData.tasks[0]!.progress_percent = 50
+ queryData.tasks[0]!.progress_total = 2
+ queryData.tasks[0]!.source_id = 'source-1'
+ queryData.tasks[0]!.state = 'running'
+ await renderOverview()
+ await // The source name is a dependent request that starts once the indexing task is known.
+ await expect
+ .element(
+ await page.getByRole('heading', {
+ name: 'knowledgeOverview.overview.indexingSource:{"source":"Notion — Support SOP"}',
+ }),
+ )
+ .toBeInTheDocument()
+ await expect
+ .element(
+ page.getByText('knowledgeOverview.overview.indexedDocuments:{"indexed":1,"total":2}'),
+ )
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByRole('progressbar', { name: 'knowledgeOverview.overview.indexing' }))
+ .toHaveAttribute('aria-valuenow', '1')
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.noSources' }))
+ .not.toBeInTheDocument()
+ })
+
+ it('exposes first-indexing progress as indeterminate until the total is known', async () => {
+ emptyKnowledgeBase()
+ queryData.inventory.index_coverage.indexed = 0
+ queryData.tasks[0]!.operation = 'document_processing'
+ queryData.tasks[0]!.progress_completed = 0
+ queryData.tasks[0]!.progress_percent = 0
+ queryData.tasks[0]!.progress_total = 0
+ queryData.tasks[0]!.state = 'queued'
+ await renderOverview()
+ const progressbar = page.getByRole('progressbar', {
+ name: 'knowledgeOverview.overview.indexing',
+ })
+ await expect.element(progressbar).not.toHaveAttribute('aria-valuemax')
+ await expect.element(progressbar).not.toHaveAttribute('aria-valuenow')
+ })
+
+ it('keeps the generic first-indexing title when the task has no source', async () => {
+ queryData.stats.source_count = 0
+ queryData.stats.documents = 1
+ queryData.inventory.index_coverage.indexed = 0
+ queryData.tasks[0]!.operation = 'document_processing'
+ queryData.tasks[0]!.source_id = null
+ queryData.tasks[0]!.state = 'running'
+ await renderOverview()
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeOverview.overview.indexing' }))
+ .toBeInTheDocument()
+ })
+
+ it('shows the actual elapsed minutes for recent activity', async () => {
+ const now = Date.parse('2026-07-29T09:04:30Z')
+ vi.spyOn(Date, 'now').mockReturnValue(now)
+ queryData.activity.data[0]!.occurred_at = '2026-07-29T08:05:00Z'
+ await renderOverview()
+ await expect.element(page.getByText('59 minutes ago')).toBeInTheDocument()
+ })
+
+ it.each([0, 1])(
+ 'shows document failures in Needs attention with %i visible documents',
+ async (documents) => {
+ queryData.stats.source_count = 0
+ queryData.stats.documents = documents
+ queryData.tasks[0]!.can_retry = true
+ queryData.tasks[0]!.operation = 'document_upload'
+ queryData.tasks[0]!.state = 'failed'
+ queryData.attention.data = [
+ {
+ action: {
+ kind: 'open-resource',
+ resource_id: 'document-1',
+ resource_type: 'document',
+ },
+ evidence: [{ code: 'DOCUMENT_PROCESSING_FAILED', observed_at: '2026-07-29T08:00:00Z' }],
+ issue_key: 'failed-document:document-1',
+ knowledge_space_id: 'knowledge-1',
+ resource: { id: 'document-1', type: 'document' },
+ revision: 1,
+ rule_id: 'failed-document',
+ severity: 'critical',
+ status: 'active',
+ title: 'Document processing failed',
+ updated_at: '2026-07-29T08:00:00Z',
+ },
+ ]
+ await renderOverview()
+ await expect.element(page.getByRole('alert')).not.toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.noIssues'))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.attention.failedDocument.title'))
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByRole('button', { name: 'knowledgeOverview.overview.viewDocuments' }))
+ .toBeInTheDocument()
+ },
+ )
+})
diff --git a/web/features/new-rag/overview/__tests__/page.spec.tsx b/web/features/new-rag/overview/__tests__/page.spec.tsx
deleted file mode 100644
index 7d878ee0a80..00000000000
--- a/web/features/new-rag/overview/__tests__/page.spec.tsx
+++ /dev/null
@@ -1,1024 +0,0 @@
-import type { KnowledgeFsProductPermission } from '@dify/contracts/api/console/knowledge-fs/types.gen'
-import { act, screen, waitFor, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import dayjs from 'dayjs'
-import { consoleQuery } from '@/service/console'
-import { renderWithConsoleQuery } from '@/test/console/query-data'
-import { createDeferred } from '@/test/deferred'
-import { createKnowledgeSpaceFixture, KnowledgeSpaceTestProvider } from '@/test/knowledge-space'
-import { QueryTestingAdapter } from '@/test/query-state-testing-adapter'
-import { KnowledgeOverviewPage } from '../page'
-
-vi.mock('../../components/knowledge-model-readiness-banner', () => ({
- KnowledgeModelReadinessBanner: () => null,
-}))
-
-// Query-cache synchronization is exercised with real Query/Jotai in task-sync.spec.tsx.
-vi.mock('../overview-task-sync', () => ({ OverviewTaskSync: () => null }))
-
-// ECharts needs a canvas; the overview only owns the data it hands to the chart.
-vi.mock('echarts-for-react', () => ({
- default: () => <div aria-label="query outcomes chart" />,
-}))
-
-type OverviewResource =
- | 'activity'
- | 'attention'
- | 'inventory'
- | 'members'
- | 'outcomes'
- | 'source'
- | 'stats'
- | 'tasks'
-
-const queryData = vi.hoisted(() => ({
- activity: {
- data: [
- {
- action: 'source.synced',
- actor: { id: 'dify-account:member-1', type: 'member' },
- details: { count: 1 } as Record<string, boolean | number | string>,
- id: 'activity-1',
- occurred_at: '2026-07-29T08:05:00Z',
- resource: { id: 'source-1', type: 'source' },
- result: 'success',
- },
- ],
- next_cursor: null,
- },
- attention: {
- data: [] as Array<{
- action: {
- kind: 'open-resource' | 'review-models' | 'review-permissions'
- resource_id?: string
- resource_type: 'document' | 'failed-query' | 'knowledge-space' | 'source'
- }
- evidence: Array<{ code: string; observed_at: string }>
- issue_key: string
- knowledge_space_id: string
- resource: {
- id: string
- type: 'document' | 'failed-query' | 'knowledge-space' | 'source'
- }
- revision: number
- rule_id:
- | 'failed-document'
- | 'low-quality-query'
- | 'model-readiness'
- | 'permission-readiness'
- | 'stale-source'
- severity: 'critical' | 'info' | 'warning'
- status: 'active' | 'dismissed' | 'resolved'
- title: string
- updated_at: string
- }>,
- },
- inventory: {
- generated_at: '2026-07-29T09:00:00Z',
- graph_entities: { added_last_7d: 1, total: 12 },
- graph_relations: { added_last_7d: 2, total: 18 },
- index_coverage: { indexed: 4, percentage: 80, total: 5 },
- knowledge_space_id: 'knowledge-1',
- source_categories: { crawl: 1, online_documents: 1, online_drives: 0, uploads: 1 },
- },
- outcomes: {
- buckets: [] as Array<{
- answered: number
- low_confidence: number
- no_evidence: number
- start_at: string
- }>,
- current: {
- answer_rate: 0.84,
- answered: 8,
- low_confidence: 1,
- no_evidence: 1,
- query_count: 10,
- },
- generated_at: '2026-07-29T09:00:00Z',
- knowledge_space_id: 'knowledge-1',
- previous: {
- answer_rate: 0.8,
- answered: 4,
- low_confidence: 1,
- no_evidence: 0,
- query_count: 5,
- },
- previous_since: '2026-07-27T09:00:00Z',
- since: '2026-07-28T09:00:00Z',
- window: '24h',
- },
- source: {
- name: 'Notion — Support SOP',
- },
- stats: {
- answer_rate: { change_percentage_points: 4, previous_value: 0.8, value: 0.84 },
- documents: 5,
- fresh_source_count: 3,
- freshness_seconds: 18000,
- generated_at: '2026-07-29T09:00:00Z',
- knowledge_space_id: 'knowledge-1',
- linked_apps: 2,
- queries: { change_rate: 1, previous_value: 5, value: 10 },
- source_count: 3,
- stale_source_count: 0,
- window: '24h',
- },
- tasks: [
- {
- can_cancel: false,
- can_retry: false,
- completed_at: '2026-07-29T08:05:00Z',
- created_at: '2026-07-29T08:00:00Z',
- id: 'task-1',
- knowledge_space_id: 'knowledge-1',
- operation: 'source_sync',
- progress_completed: 1,
- progress_failed: 0,
- progress_percent: 100,
- progress_total: 1,
- source_id: undefined as null | string | undefined,
- state: 'completed',
- task_kind: 'source',
- updated_at: '2026-07-29T08:05:00Z',
- },
- ],
-}))
-
-const server = vi.hoisted(() => ({
- calls: {
- activity: vi.fn(),
- attention: vi.fn(),
- inventory: vi.fn(),
- members: vi.fn(),
- outcomes: vi.fn(),
- source: vi.fn(),
- stats: vi.fn(),
- tasks: vi.fn(),
- },
- failing: new Set<string>(),
- held: new Map<string, Promise<void>>(),
-}))
-
-vi.mock('@/service/console', async (importOriginal) => {
- const actual = await importOriginal<typeof import('@/service/console')>()
- const { withConsoleResponses } = await import('@/test/console/service-responses')
- const respond =
- (resource: OverviewResource, data: () => unknown) =>
- async (input: unknown): Promise<unknown> => {
- server.calls[resource](input)
- await server.held.get(resource)
- if (server.failing.has(resource)) throw new Error(`${resource} unavailable`)
- return structuredClone(data())
- }
- const overview = 'knowledgeFs.spaces.byControlSpaceId.overview'
- return {
- ...actual,
- consoleQuery: withConsoleResponses(actual.consoleQuery, {
- 'knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get': respond('tasks', () => ({
- data: queryData.tasks,
- next_cursor: null,
- })),
- 'knowledgeFs.spaces.byControlSpaceId.sources.bySourceId.get': respond(
- 'source',
- () => queryData.source,
- ),
- [`${overview}.activity.get`]: respond('activity', () => queryData.activity),
- [`${overview}.attention.get`]: respond('attention', () => queryData.attention),
- [`${overview}.inventory.get`]: respond('inventory', () => queryData.inventory),
- [`${overview}.queryOutcomes.get`]: respond('outcomes', () => queryData.outcomes),
- [`${overview}.stats.get`]: respond('stats', () => queryData.stats),
- 'workspaces.current.members.get': respond('members', () => ({
- accounts: [
- {
- avatar_url: 'https://example.com/avatar.png',
- email: '[email protected]',
- id: 'member-1',
- name: 'Ada',
- },
- ],
- })),
- }),
- }
-})
-
-type ActivityQuery = Record<string, unknown>
-const lastActivityQuery = () =>
- (server.calls.activity.mock.lastCall?.[0] as { query: ActivityQuery } | undefined)?.query
-const drawerActivityQueries = () =>
- server.calls.activity.mock.calls
- .map(([input]) => (input as { query: ActivityQuery }).query)
- .filter((query) => 'from_at' in query)
-
-/** Holds a resource's responses open until the returned release function is called. */
-function hold(resource: OverviewResource) {
- const gate = createDeferred<void>()
- server.held.set(resource, gate.promise)
- return async () => {
- server.held.delete(resource)
- await act(async () => gate.resolve())
- }
-}
-
-async function renderOverview({
- deploymentEdition = 'COMMUNITY',
- searchParams = '',
- settle = true,
- spacePermissions = ['knowledge_space_document_write'],
-}: {
- deploymentEdition?: 'CLOUD' | 'COMMUNITY' | 'ENTERPRISE'
- searchParams?: string
- settle?: boolean
- spacePermissions?: KnowledgeFsProductPermission[]
-} = {}) {
- const onUrlUpdate = vi.fn()
- const view = renderWithConsoleQuery(
- <QueryTestingAdapter searchParams={searchParams} onUrlUpdate={onUrlUpdate}>
- <KnowledgeSpaceTestProvider
- space={createKnowledgeSpaceFixture({ permission_keys: spacePermissions })}
- >
- <KnowledgeOverviewPage knowledgeSpaceId="space-1" />
- </KnowledgeSpaceTestProvider>
- </QueryTestingAdapter>,
- {
- knowledgeFsFeatures: { upload_enabled: true },
- systemFeatures: { deployment_edition: deploymentEdition },
- },
- )
- if (settle) await waitFor(() => expect(view.queryClient.isFetching()).toBe(0))
- const refetch = async (path: () => readonly unknown[]) => {
- await act(() => view.queryClient.invalidateQueries({ queryKey: path() }))
- }
- return { ...view, onUrlUpdate, refetch }
-}
-
-const overviewKeys = {
- attention: () => consoleQuery.knowledgeFs.spaces.byControlSpaceId.overview.attention.get.key(),
- stats: () => consoleQuery.knowledgeFs.spaces.byControlSpaceId.overview.stats.get.key(),
- tasks: () => consoleQuery.knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get.key(),
-}
-
-const emptyKnowledgeBase = () => {
- queryData.stats.source_count = 0
- queryData.stats.documents = 0
-}
-
-describe('KnowledgeOverviewPage', () => {
- beforeEach(() => {
- server.failing.clear()
- server.held.clear()
- queryData.attention.data = []
- queryData.activity.data.splice(1)
- queryData.activity.data[0]!.action = 'source.synced'
- queryData.activity.data[0]!.actor = { id: 'dify-account:member-1', type: 'member' }
- queryData.activity.data[0]!.details = { count: 1 }
- queryData.activity.data[0]!.occurred_at = '2026-07-29T08:05:00Z'
- queryData.activity.data[0]!.result = 'success'
- queryData.stats.source_count = 3
- queryData.stats.documents = 5
- queryData.outcomes.buckets = []
- queryData.inventory.source_categories = {
- crawl: 1,
- online_documents: 1,
- online_drives: 0,
- uploads: 1,
- }
- queryData.inventory.index_coverage.indexed = 4
- queryData.tasks[0]!.operation = 'source_sync'
- queryData.tasks[0]!.can_retry = false
- queryData.tasks[0]!.progress_completed = 1
- queryData.tasks[0]!.progress_percent = 100
- queryData.tasks[0]!.progress_total = 1
- queryData.tasks[0]!.source_id = undefined
- queryData.tasks[0]!.state = 'completed'
- queryData.tasks[0]!.updated_at = '2026-07-29T08:05:00Z'
- queryData.stats.generated_at = '2026-07-29T09:00:00Z'
- })
-
- afterEach(() => {
- vi.useRealTimers()
- vi.restoreAllMocks()
- })
-
- it('refreshes the metrics queries when a user switches the overview range', async () => {
- const user = userEvent.setup()
- const { onUrlUpdate } = await renderOverview()
-
- const sevenDayRadio = screen.getByRole('radio', {
- name: 'knowledgeOverview.overview.sevenDays',
- })
- await user.click(sevenDayRadio)
-
- expect(sevenDayRadio).toHaveAttribute('aria-checked', 'true')
- const sevenDays = { params: { control_space_id: 'space-1' }, query: { window: '7d' } }
- await waitFor(() => expect(server.calls.stats).toHaveBeenLastCalledWith(sevenDays))
- expect(server.calls.outcomes).toHaveBeenLastCalledWith(sevenDays)
- await waitFor(() => {
- const urlUpdate = onUrlUpdate.mock.calls.at(-1)?.[0]
- expect(urlUpdate?.searchParams.get('window')).toBe('7d')
- expect(urlUpdate?.options.history).toBe('push')
- })
- })
-
- it('restores the selected overview range from the URL', async () => {
- await renderOverview({ searchParams: '?window=30d' })
-
- expect(
- screen.getByRole('radio', { name: 'knowledgeOverview.overview.thirtyDays' }),
- ).toHaveAttribute('aria-checked', 'true')
- const thirtyDays = { params: { control_space_id: 'space-1' }, query: { window: '30d' } }
- expect(server.calls.stats).toHaveBeenLastCalledWith(thirtyDays)
- expect(server.calls.outcomes).toHaveBeenLastCalledWith(thirtyDays)
- })
-
- it('renders ratio fields from the API contract as percentages', async () => {
- await renderOverview()
-
- expect(screen.getByText('84%')).toBeInTheDocument()
- expect(screen.getByText('+100%')).toBeInTheDocument()
- expect(screen.getByText('+4 pp')).toBeInTheDocument()
- })
-
- it('keeps existing overview data visible during a background refresh', async () => {
- queryData.outcomes.buckets = [
- { answered: 8, low_confidence: 1, no_evidence: 1, start_at: '2026-07-29T09:00:00Z' },
- ]
- const { queryClient } = await renderOverview()
- hold('stats')
- hold('outcomes')
-
- act(() => {
- void queryClient.invalidateQueries({ queryKey: overviewKeys.stats() })
- })
-
- await waitFor(() => expect(queryClient.isFetching()).toBeGreaterThan(0))
- expect(screen.getByText('84%')).toBeInTheDocument()
- expect(screen.getByLabelText('query outcomes chart')).toBeInTheDocument()
- })
-
- it('shows the member who performed an activity instead of a system placeholder', async () => {
- await renderOverview()
-
- expect(screen.getByText('Ada')).toBeInTheDocument()
- expect(screen.queryByText('knowledgeOverview.overview.system')).not.toBeInTheDocument()
- })
-
- it('keeps activities beyond the seventh row available in the recent activity list', async () => {
- const activity = queryData.activity.data[0]!
- queryData.activity.data.push(
- ...Array.from({ length: 7 }, (_, index) => ({ ...activity, id: `activity-${index + 2}` })),
- )
-
- await renderOverview()
-
- const recentActivity = screen.getByRole('table', {
- name: 'knowledgeOverview.overview.recentActivity',
- })
- expect(within(recentActivity).getAllByRole('row')).toHaveLength(9)
- })
-
- it('reveals resolved modules while waiting to decide the page empty state', async () => {
- emptyKnowledgeBase()
- const releases = (
- ['activity', 'attention', 'inventory', 'outcomes', 'stats', 'tasks'] as const
- ).map((resource) => [resource, hold(resource)] as const)
- const release = Object.fromEntries(releases)
-
- await renderOverview({ settle: false })
-
- expect(
- await screen.findByRole('radiogroup', { name: 'knowledgeOverview.overview.timeRange' }),
- ).toBeInTheDocument()
- expect(
- screen.queryByRole('heading', { name: 'knowledgeOverview.overview.noSources' }),
- ).not.toBeInTheDocument()
- expect(
- screen.getByRole('heading', { name: 'knowledgeOverview.overview.needsAttention' }),
- ).toBeInTheDocument()
- expect(screen.queryByText('84%')).not.toBeInTheDocument()
-
- await release.stats!()
-
- expect(await screen.findByText('84%')).toBeInTheDocument()
- expect(
- screen.queryByRole('heading', { name: 'knowledgeOverview.overview.noSources' }),
- ).not.toBeInTheDocument()
-
- for (const [, releaseResource] of releases) await releaseResource()
-
- expect(
- await screen.findByRole('heading', { name: 'knowledgeOverview.overview.noSources' }),
- ).toBeInTheDocument()
- expect(
- screen.queryByRole('radiogroup', { name: 'knowledgeOverview.overview.timeRange' }),
- ).not.toBeInTheDocument()
- })
-
- it('shows an activity error with a retry action instead of an empty state', async () => {
- const user = userEvent.setup()
- server.failing.add('activity')
-
- await renderOverview()
-
- expect(screen.getByText('knowledgeSpace.tasksErrorDescription')).toBeInTheDocument()
- const activitySection = screen
- .getByRole('heading', { name: 'knowledgeOverview.overview.recentActivity' })
- .closest('section')!
- server.failing.delete('activity')
- await user.click(
- within(activitySection).getByRole('button', { name: 'common.operation.retry' }),
- )
-
- expect(await within(activitySection).findByText('Ada')).toBeInTheDocument()
- expect(
- within(activitySection).queryByText('knowledgeOverview.overview.noActivity'),
- ).not.toBeInTheDocument()
- })
-
- it('renders specific attention findings and clamps the page when polling removes issues', async () => {
- const user = userEvent.setup()
- queryData.attention.data = Array.from({ length: 6 }, (_, index) => ({
- action: {
- kind: 'open-resource' as const,
- resource_id: `source-${index}`,
- resource_type: 'source' as const,
- },
- evidence: [{ code: 'SOURCE_STALE', observed_at: '2026-07-29T08:00:00Z' }],
- issue_key: `issue-${index}`,
- knowledge_space_id: 'knowledge-1',
- resource: { id: `source-${index}`, type: 'source' as const },
- revision: 1,
- rule_id: 'stale-source' as const,
- severity: index === 0 ? ('critical' as const) : ('warning' as const),
- status: 'active' as const,
- title: `Source ${index} has not synced in 7 days`,
- updated_at: '2026-07-29T08:00:00Z',
- }))
- const { refetch } = await renderOverview()
-
- expect(
- screen.getAllByText('knowledgeOverview.overview.attention.staleSource.title'),
- ).toHaveLength(4)
- expect(screen.queryByText('Source 0 has not synced in 7 days')).not.toBeInTheDocument()
- expect(screen.getByText('knowledgeOverview.overview.blocker')).toBeInTheDocument()
- await user.click(screen.getByRole('button', { name: 'common.pagination.next' }))
- expect(screen.getByText('2 / 2')).toBeInTheDocument()
-
- queryData.attention.data = queryData.attention.data.slice(0, 1)
- await refetch(overviewKeys.attention)
-
- expect(await screen.findByText('1 / 1')).toBeInTheDocument()
- expect(screen.getByRole('button', { name: 'common.pagination.previous' })).toBeDisabled()
- })
-
- it('explains model blockers and ignores retired permission-readiness responses', async () => {
- queryData.attention.data = [
- {
- action: { kind: 'review-models', resource_type: 'knowledge-space' },
- evidence: [
- { code: 'MODEL_PROFILE_NOT_READY', observed_at: '2026-07-29T08:00:00Z' },
- { code: 'MODEL_RETRIEVAL_PROFILE_MISSING', observed_at: '2026-07-29T08:00:00Z' },
- { code: 'MODEL_PUBLICATION_BINDING_MISSING', observed_at: '2026-07-29T08:00:00Z' },
- ],
- issue_key: 'model-readiness:knowledge-space:knowledge-1',
- knowledge_space_id: 'knowledge-1',
- resource: { id: 'knowledge-1', type: 'knowledge-space' },
- revision: 1,
- rule_id: 'model-readiness',
- severity: 'critical',
- status: 'active',
- title: 'Retrieval model profile is not published',
- updated_at: '2026-07-29T08:00:00Z',
- },
- {
- action: { kind: 'review-permissions', resource_type: 'knowledge-space' },
- evidence: [
- { code: 'PERMISSION_AGGREGATE_NOT_READY', observed_at: '2026-07-29T08:00:00Z' },
- { code: 'PERMISSION_POLICY_MISSING', observed_at: '2026-07-29T08:00:00Z' },
- { code: 'PERMISSION_OWNER_MISSING', observed_at: '2026-07-29T08:00:00Z' },
- ],
- issue_key: 'permission-readiness:knowledge-space:knowledge-1',
- knowledge_space_id: 'knowledge-1',
- resource: { id: 'knowledge-1', type: 'knowledge-space' },
- revision: 1,
- rule_id: 'permission-readiness',
- severity: 'critical',
- status: 'active',
- title: 'Knowledge-space permissions are not ready',
- updated_at: '2026-07-29T08:00:00Z',
- },
- ]
-
- await renderOverview()
-
- expect(
- screen.getByText('knowledgeSpace.overview.attention.modelReadiness.title'),
- ).toBeInTheDocument()
- expect(
- screen.getByText(
- 'knowledgeSpace.overview.attention.modelReadiness.profilesMissing knowledgeSpace.overview.attention.modelReadiness.bindingMissing',
- ),
- ).toBeInTheDocument()
- expect(
- screen.getByRole('button', {
- name: 'knowledgeSpace.overview.attention.action.configureModels',
- }),
- ).toHaveAttribute('href', '/datasets/new/space-1/settings')
- expect(screen.queryByText('Retrieval model profile is not published')).not.toBeInTheDocument()
- expect(screen.queryByText('Knowledge-space permissions are not ready')).not.toBeInTheDocument()
- })
-
- it('opens the complete activity view from recent activity', async () => {
- const user = userEvent.setup()
- await renderOverview()
-
- await user.click(screen.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }))
-
- expect(
- await screen.findByRole('dialog', { name: 'knowledgeOverview.overview.allActivity' }),
- ).toBeInTheDocument()
- expect(
- screen.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }),
- ).toHaveTextContent('knowledgeOverview.overview.today')
- expect(
- screen.getByRole('combobox', { name: 'knowledgeOverview.overview.operator' }),
- ).toBeInTheDocument()
- expect(
- screen.getByRole('group', { name: 'knowledgeOverview.overview.timeRange' }),
- ).toBeInTheDocument()
- })
-
- it('requests the complete activity list only while its drawer is open', async () => {
- const user = userEvent.setup()
- await renderOverview()
-
- expect(drawerActivityQueries()).toEqual([])
-
- await user.click(screen.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }))
-
- await waitFor(() => expect(drawerActivityQueries()).toHaveLength(1))
- })
-
- it('restarts activity pagination when the date or operator filter changes', async () => {
- const user = userEvent.setup()
- await renderOverview()
- await user.click(screen.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }))
-
- await user.click(screen.getByRole('combobox', { name: 'knowledgeOverview.overview.operator' }))
- await user.click(await screen.findByRole('option', { name: 'Ada' }))
-
- await waitFor(() =>
- expect(lastActivityQuery()).toMatchObject({
- actor_id: 'dify-account:member-1',
- actor_type: 'member',
- limit: 20,
- }),
- )
- expect(lastActivityQuery()).not.toHaveProperty('cursor')
-
- await user.click(screen.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }))
- await user.click(
- await screen.findByRole('option', { name: 'knowledgeOverview.overview.last90Days' }),
- )
-
- await waitFor(() =>
- expect(lastActivityQuery()).toMatchObject({
- actor_id: 'dify-account:member-1',
- from_at: dayjs().subtract(89, 'day').startOf('day').toISOString(),
- }),
- )
- })
-
- it('limits cloud activity filters to the most recent 90 calendar days', async () => {
- vi.useFakeTimers({ toFake: ['Date'] })
- vi.setSystemTime(new Date(2026, 8, 8, 12))
- const user = userEvent.setup()
- const earliest = dayjs().subtract(89, 'day').startOf('day')
-
- await renderOverview({ deploymentEdition: 'CLOUD' })
- expect(lastActivityQuery()).toMatchObject({ from_at: earliest.toISOString() })
- await user.click(screen.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }))
- await user.click(screen.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }))
- expect(
- screen.queryByRole('option', { name: 'knowledgeOverview.overview.allTime' }),
- ).not.toBeInTheDocument()
- await user.click(
- await screen.findByRole('option', { name: 'knowledgeOverview.overview.last90Days' }),
- )
- await waitFor(() =>
- expect(lastActivityQuery()).toMatchObject({
- from_at: earliest.toISOString(),
- to_at: dayjs().endOf('day').toISOString(),
- }),
- )
-
- const ordinal = (day: number) => {
- const suffix =
- ['th', 'st', 'nd', 'rd'][day % 100 > 10 && day % 100 < 14 ? 0 : day % 10] ?? 'th'
- return `${day}${suffix}`
- }
- const calendarLabel = (date: dayjs.Dayjs) =>
- new RegExp(`${date.format('MMMM')} ${ordinal(date.date())}, ${date.year()}`)
- await user.click(
- screen.getByRole('button', { name: /knowledgeOverview\.overview\.timeRange start/ }),
- )
- expect(
- screen.getByRole('button', { name: calendarLabel(earliest.subtract(1, 'day')) }),
- ).toBeDisabled()
- expect(screen.getByRole('button', { name: calendarLabel(earliest) })).toBeEnabled()
- await user.click(screen.getByRole('button', { name: calendarLabel(earliest.add(1, 'day')) }))
- expect(
- screen.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }),
- ).toHaveTextContent('filter.period.custom')
- await waitFor(() =>
- expect(lastActivityQuery()?.from_at).toBe(earliest.add(1, 'day').toISOString()),
- )
- })
-
- it.each(['COMMUNITY', 'ENTERPRISE'] as const)(
- 'preserves all-time activity queries for %s',
- async (deploymentEdition) => {
- const user = userEvent.setup()
- await renderOverview({ deploymentEdition })
- expect(lastActivityQuery()).not.toHaveProperty('from_at')
- await user.click(
- screen.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }),
- )
- await waitFor(() => expect(drawerActivityQueries()).toHaveLength(1))
- await user.click(
- screen.getByRole('combobox', { name: 'knowledgeOverview.overview.timeRange' }),
- )
- await user.click(
- await screen.findByRole('option', { name: 'knowledgeOverview.overview.allTime' }),
- )
-
- await waitFor(() => expect(server.calls.activity).toHaveBeenCalledTimes(3))
- expect(lastActivityQuery()).not.toHaveProperty('from_at')
- expect(lastActivityQuery()).not.toHaveProperty('to_at')
- },
- )
-
- it('polls overview snapshots until they catch up with a completed background task', async () => {
- vi.useFakeTimers({ shouldAdvanceTime: true })
- queryData.tasks[0]!.state = 'running'
- queryData.tasks[0]!.updated_at = '2026-07-29T10:00:00Z'
- const { refetch } = await renderOverview()
- const statsRequests = () => server.calls.stats.mock.calls.length
- const afterLoad = statsRequests()
-
- await act(() => vi.advanceTimersByTimeAsync(2100))
- expect(statsRequests()).toBe(afterLoad + 1)
-
- queryData.tasks[0]!.state = 'completed'
- await refetch(overviewKeys.tasks)
- await act(() => vi.advanceTimersByTimeAsync(2100))
- expect(statsRequests()).toBe(afterLoad + 2)
-
- queryData.stats.generated_at = '2026-07-29T10:01:00Z'
- await act(() => vi.advanceTimersByTimeAsync(2100))
- const caughtUp = statsRequests()
- await act(() => vi.advanceTimersByTimeAsync(6000))
- expect(statsRequests()).toBe(caughtUp)
- })
-
- it.each([
- ['read-only member', ['knowledge_space_read'] satisfies KnowledgeFsProductPermission[], false],
- [
- 'member with document-write access',
- ['knowledge_space_document_write'] satisfies KnowledgeFsProductPermission[],
- true,
- ],
- ])(
- 'uses the space permission of a %s for onboarding actions',
- async (_, permissions, canWrite) => {
- emptyKnowledgeBase()
-
- await renderOverview({ spacePermissions: permissions })
-
- const connectSource = screen.queryByRole('link', {
- name: 'knowledgeOverview.overview.connectSource',
- })
- const uploadFiles = screen.queryByRole('link', {
- name: 'knowledgeOverview.overview.uploadFiles',
- })
- if (canWrite) {
- expect(connectSource).toBeInTheDocument()
- expect(uploadFiles).toBeInTheDocument()
- } else {
- expect(connectSource).not.toBeInTheDocument()
- expect(uploadFiles).not.toBeInTheDocument()
- expect(
- screen.getByText('knowledgeOverview.overview.readOnlyDescription'),
- ).toBeInTheDocument()
- }
- },
- )
-
- it.each([
- ['document.failed', 'failure', 'text/plain', 'knowledgeOverview.overview.activityFailed'],
- [
- 'document.published',
- 'success',
- 'application/pdf',
- 'knowledgeOverview.overview.activityCompleted',
- ],
- ])(
- 'omits the file MIME type from %s in recent and all activity',
- async (action, result, documentType, label) => {
- const user = userEvent.setup()
- queryData.activity.data[0]!.action = action
- queryData.activity.data[0]!.details = { documentType }
- queryData.activity.data[0]!.result = result
-
- await renderOverview()
-
- const recentActivity = screen.getByRole('table', {
- name: 'knowledgeOverview.overview.recentActivity',
- })
- expect(within(recentActivity).getByText(label, { exact: false })).toBeInTheDocument()
- expect(recentActivity).not.toHaveTextContent(documentType)
-
- await user.click(
- screen.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }),
- )
-
- const dialog = screen.getByRole('dialog', {
- name: 'knowledgeOverview.overview.allActivity',
- })
- expect(within(dialog).getByText(label, { exact: false })).toBeInTheDocument()
- expect(dialog).not.toHaveTextContent(documentType)
- },
- )
-
- it('shows safe activity details and relative times for today in the drawer', async () => {
- // At midnight, "two hours ago" is yesterday and deliberately uses an absolute date.
- vi.useFakeTimers({ toFake: ['Date'] })
- vi.setSystemTime(new Date(2026, 8, 8, 12, 0, 0))
- const user = userEvent.setup()
- queryData.activity.data[0]!.action = 'source.failed'
- queryData.activity.data[0]!.details = { reasonCode: 'CREDENTIALS_EXPIRED' }
- queryData.activity.data[0]!.occurred_at = new Date(Date.now() - 2 * 60 * 60_000).toISOString()
- queryData.activity.data[0]!.result = 'failure'
-
- await renderOverview()
- await user.click(screen.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }))
-
- const dialog = screen.getByRole('dialog', {
- name: 'knowledgeOverview.overview.allActivity',
- })
- expect(dialog).toHaveTextContent('Credentials expired')
- expect(dialog).toHaveTextContent('knowledgeOverview.overview.activityFailed')
- expect(within(dialog).getByText(/2h ago|2 hr\. ago|2 hours ago/)).toBeInTheDocument()
- vi.useRealTimers()
- })
-
- it('shows one initiated query activity with its question and retrieval mode', async () => {
- const user = userEvent.setup()
- queryData.activity.data[0]!.action = 'query.requested'
- queryData.activity.data[0]!.details = {
- mode: 'research',
- question: 'How do permissions work?',
- }
- queryData.activity.data[0]!.result = 'success'
-
- await renderOverview()
-
- const label = 'knowledgeSpace.qualityPage.question: How do permissions work? — research'
- expect(within(screen.getByRole('table')).getByText(label)).toBeInTheDocument()
-
- await user.click(screen.getByRole('button', { name: 'knowledgeOverview.overview.allActivity' }))
- expect(within(screen.getByRole('dialog')).getByText(label)).toBeInTheDocument()
- expect(screen.queryByText('knowledgeSpace.overview.activityQueued')).not.toBeInTheDocument()
- })
-
- it('offers source connection and direct upload when the knowledge base is empty', async () => {
- emptyKnowledgeBase()
-
- await renderOverview()
-
- expect(
- screen.getByRole('heading', { name: 'knowledgeOverview.overview.noSources' }),
- ).toBeInTheDocument()
- expect(
- screen.getByRole('link', { name: 'knowledgeOverview.overview.connectSource' }),
- ).toHaveAttribute('href', '/datasets/new/space-1/sources/new')
- expect(
- screen.getByRole('link', { name: 'knowledgeOverview.overview.uploadFiles' }),
- ).toHaveAttribute('href', '/datasets/new/space-1/documents?upload=1')
- expect(screen.getAllByText('—')).toHaveLength(5)
- expect(
- screen.getByRole('heading', { name: 'knowledgeOverview.overview.needsAttention' }),
- ).toBeInTheDocument()
- expect(screen.getByText('knowledgeOverview.overview.noQueryData')).toBeInTheDocument()
- expect(
- screen.getByRole('heading', { name: 'knowledgeOverview.overview.recentActivity' }),
- ).toBeInTheDocument()
- expect(screen.getByText('knowledgeSpace.documentsEmptyTitle')).toBeInTheDocument()
- expect(
- screen.queryByRole('button', { name: 'knowledgeOverview.overview.allActivity' }),
- ).not.toBeInTheDocument()
- expect(screen.queryByRole('table')).not.toBeInTheDocument()
- expect(screen.queryByRole('tablist')).not.toBeInTheDocument()
- })
-
- it('disables both onboarding entries after starting navigation', async () => {
- const user = userEvent.setup()
- emptyKnowledgeBase()
-
- await renderOverview()
-
- const connectSource = screen.getByRole('link', {
- name: 'knowledgeOverview.overview.connectSource',
- })
- const uploadFiles = screen.getByRole('link', {
- name: 'knowledgeOverview.overview.uploadFiles',
- })
- await user.click(connectSource)
-
- expect(connectSource).toHaveAttribute('aria-busy', 'true')
- expect(connectSource).toHaveAttribute('aria-disabled', 'true')
- expect(uploadFiles).toHaveAttribute('aria-disabled', 'true')
- })
-
- it('keeps failed first-source tasks in Needs attention without a duplicate banner', async () => {
- emptyKnowledgeBase()
- queryData.tasks[0]!.can_retry = true
- queryData.tasks[0]!.operation = 'document_processing'
- queryData.tasks[0]!.state = 'failed'
-
- await renderOverview()
-
- expect(screen.queryByRole('alert')).not.toBeInTheDocument()
- expect(
- screen.queryByRole('button', { name: 'knowledgeSpace.retryTask' }),
- ).not.toBeInTheDocument()
- expect(
- screen.getByText('knowledgeOverview.overview.attention.failedDocument.title'),
- ).toBeInTheDocument()
- expect(screen.queryByText('knowledgeOverview.overview.noIssues')).not.toBeInTheDocument()
- expect(
- screen.getByRole('button', { name: 'knowledgeOverview.overview.viewDocuments' }),
- ).toBeInTheDocument()
- })
-
- it('shows explicit section errors instead of healthy or zero-value fallbacks', async () => {
- server.failing.add('attention')
- server.failing.add('inventory')
-
- await renderOverview()
-
- const healthSection = screen
- .getByRole('heading', { name: 'knowledgeOverview.overview.needsAttention' })
- .closest('section')
- const inventorySection = screen
- .getByRole('heading', { name: 'knowledgeOverview.overview.inventory' })
- .closest('section')
- expect(healthSection).not.toBeNull()
- expect(inventorySection).not.toBeNull()
- expect(
- within(healthSection!).getByText('knowledgeSpace.detailErrorDescription'),
- ).toBeInTheDocument()
- expect(
- within(healthSection!).queryByText('knowledgeOverview.overview.noIssues'),
- ).not.toBeInTheDocument()
- expect(
- within(inventorySection!).getByText('knowledgeSpace.detailErrorDescription'),
- ).toBeInTheDocument()
- })
-
- it('shows overview data when uploaded documents exist without a connected source', async () => {
- queryData.stats.source_count = 0
- queryData.stats.documents = 1
-
- await renderOverview()
-
- expect(
- screen.getByRole('heading', { name: 'knowledgeOverview.overview.recentActivity' }),
- ).toBeInTheDocument()
- expect(
- screen.queryByRole('link', { name: 'knowledgeOverview.overview.connectSource' }),
- ).not.toBeInTheDocument()
- })
-
- it('omits graph metrics from the knowledge inventory', async () => {
- await renderOverview()
-
- expect(screen.getByText('knowledgeOverview.overview.webCrawl')).toBeInTheDocument()
- expect(screen.queryByText('knowledgeSpace.overview.graphEntities')).not.toBeInTheDocument()
- expect(screen.queryByText('knowledgeSpace.overview.graphRelations')).not.toBeInTheDocument()
- expect(screen.queryByText('knowledgeSpace.overview.indexCoverage')).not.toBeInTheDocument()
- })
-
- it('shows first-indexing progress while the initial document task is running', async () => {
- emptyKnowledgeBase()
- queryData.inventory.index_coverage.indexed = 0
- queryData.tasks[0]!.operation = 'document_processing'
- queryData.tasks[0]!.progress_completed = 1
- queryData.tasks[0]!.progress_percent = 50
- queryData.tasks[0]!.progress_total = 2
- queryData.tasks[0]!.source_id = 'source-1'
- queryData.tasks[0]!.state = 'running'
-
- await renderOverview()
-
- // The source name is a dependent request that starts once the indexing task is known.
- expect(
- await screen.findByRole('heading', {
- name: 'knowledgeOverview.overview.indexingSource:{"source":"Notion — Support SOP"}',
- }),
- ).toBeInTheDocument()
- expect(
- screen.getByText('knowledgeOverview.overview.indexedDocuments:{"indexed":1,"total":2}'),
- ).toBeInTheDocument()
- expect(
- screen.getByRole('progressbar', { name: 'knowledgeOverview.overview.indexing' }),
- ).toHaveAttribute('aria-valuenow', '1')
- expect(
- screen.queryByRole('heading', { name: 'knowledgeOverview.overview.noSources' }),
- ).not.toBeInTheDocument()
- })
-
- it('exposes first-indexing progress as indeterminate until the total is known', async () => {
- emptyKnowledgeBase()
- queryData.inventory.index_coverage.indexed = 0
- queryData.tasks[0]!.operation = 'document_processing'
- queryData.tasks[0]!.progress_completed = 0
- queryData.tasks[0]!.progress_percent = 0
- queryData.tasks[0]!.progress_total = 0
- queryData.tasks[0]!.state = 'queued'
-
- await renderOverview()
-
- const progressbar = screen.getByRole('progressbar', {
- name: 'knowledgeOverview.overview.indexing',
- })
- expect(progressbar).not.toHaveAttribute('aria-valuemax')
- expect(progressbar).not.toHaveAttribute('aria-valuenow')
- })
-
- it('keeps the generic first-indexing title when the task has no source', async () => {
- queryData.stats.source_count = 0
- queryData.stats.documents = 1
- queryData.inventory.index_coverage.indexed = 0
- queryData.tasks[0]!.operation = 'document_processing'
- queryData.tasks[0]!.source_id = null
- queryData.tasks[0]!.state = 'running'
-
- await renderOverview()
-
- expect(
- screen.getByRole('heading', { name: 'knowledgeOverview.overview.indexing' }),
- ).toBeInTheDocument()
- })
-
- it('shows the actual elapsed minutes for recent activity', async () => {
- const now = Date.parse('2026-07-29T09:04:30Z')
- vi.spyOn(Date, 'now').mockReturnValue(now)
- queryData.activity.data[0]!.occurred_at = '2026-07-29T08:05:00Z'
-
- await renderOverview()
-
- expect(screen.getByText('59 minutes ago')).toBeInTheDocument()
- })
-
- it.each([0, 1])(
- 'shows document failures in Needs attention with %i visible documents',
- async (documents) => {
- queryData.stats.source_count = 0
- queryData.stats.documents = documents
- queryData.tasks[0]!.can_retry = true
- queryData.tasks[0]!.operation = 'document_upload'
- queryData.tasks[0]!.state = 'failed'
- queryData.attention.data = [
- {
- action: {
- kind: 'open-resource',
- resource_id: 'document-1',
- resource_type: 'document',
- },
- evidence: [{ code: 'DOCUMENT_PROCESSING_FAILED', observed_at: '2026-07-29T08:00:00Z' }],
- issue_key: 'failed-document:document-1',
- knowledge_space_id: 'knowledge-1',
- resource: { id: 'document-1', type: 'document' },
- revision: 1,
- rule_id: 'failed-document',
- severity: 'critical',
- status: 'active',
- title: 'Document processing failed',
- updated_at: '2026-07-29T08:00:00Z',
- },
- ]
-
- await renderOverview()
-
- expect(screen.queryByRole('alert')).not.toBeInTheDocument()
- expect(screen.queryByText('knowledgeOverview.overview.noIssues')).not.toBeInTheDocument()
- expect(
- screen.getByText('knowledgeOverview.overview.attention.failedDocument.title'),
- ).toBeInTheDocument()
- expect(
- screen.getByRole('button', { name: 'knowledgeOverview.overview.viewDocuments' }),
- ).toBeInTheDocument()
- },
- )
-})
diff --git a/web/features/new-rag/overview/__tests__/task-sync.spec.tsx b/web/features/new-rag/overview/__tests__/task-sync.browser.spec.tsx
similarity index 54%
rename from web/features/new-rag/overview/__tests__/task-sync.spec.tsx
rename to web/features/new-rag/overview/__tests__/task-sync.browser.spec.tsx
index 018c524e925..8b9eb723cfd 100644
--- a/web/features/new-rag/overview/__tests__/task-sync.spec.tsx
+++ b/web/features/new-rag/overview/__tests__/task-sync.browser.spec.tsx
@@ -1,22 +1,27 @@
-import type {
- KnowledgeFsBackgroundTaskResponse,
- KnowledgeFsOverviewAttentionResponse,
-} from '@dify/contracts/api/console/knowledge-fs/types.gen'
+import type { KnowledgeFsOverviewAttentionResponse } from '@dify/contracts/api/console/knowledge-fs/types.gen'
import { zGetFeaturesVectorSpaceResponse } from '@dify/contracts/api/console/features/zod.gen'
import { QueryObserver } from '@tanstack/react-query'
-import { act, render, screen, waitFor } from '@testing-library/react'
-import { useAtomValueRawSync } from 'jotai'
+import { page } from 'vite-plus/test/browser'
+import { render } from 'vitest-browser-react'
import { consoleQuery } from '@/service/console'
import {
createConsoleQueryClient,
createConsoleQueryWrapper,
seedFeatures,
} from '@/test/console/query-data'
+import { createOverviewTask as task } from '@/test/new-rag-overview'
+import { QueryTestingAdapter } from '@/test/query-state-testing-adapter'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { OverviewActivity } from '../overview-activity'
+import { AttentionPanel } from '../overview-attention'
import { OverviewTaskSync } from '../overview-task-sync'
-import { overviewActivityPreviewDataAtom, overviewAttentionDataAtom } from '../state'
import { OverviewStateBoundary } from '../state-boundary'
-type SpaceInput = { params: { control_space_id: string } }
+type SpaceInput = {
+ params: {
+ control_space_id: string
+ }
+}
const service = vi.hoisted(() => ({
attention: vi.fn(),
@@ -26,7 +31,10 @@ const service = vi.hoisted(() => ({
vi.mock('@/service/console', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/service/console')>()
- const { withConsoleQueryOverrides } = await import('@/test/console/service-responses')
+ const { withConsoleResponses, withConsoleQueryOverrides } =
+ await import('@/test/console/service-responses')
+ const { createOverviewData } = await import('@/test/new-rag-overview')
+ const data = createOverviewData()
const spaceQuery = (handler: (spaceId: string, signal: AbortSignal) => unknown) => ({
queryOptions: ({ input }: { input: SpaceInput }) => ({
queryFn: ({ signal }: { signal: AbortSignal }) =>
@@ -35,16 +43,24 @@ vi.mock('@/service/console', async (importOriginal) => {
})
return {
...actual,
- consoleQuery: withConsoleQueryOverrides(actual.consoleQuery, {
- 'knowledgeFs.spaces.byControlSpaceId.overview.attention.get': spaceQuery(service.attention),
- 'knowledgeFs.spaces.byControlSpaceId.overview.activity.get': spaceQuery(service.activity),
- 'knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get': {
- infiniteOptions: ({ input }: { input: (page: null) => SpaceInput }) => ({
- queryFn: ({ signal }: { signal: AbortSignal }) =>
- service.tasks(input(null).params.control_space_id, signal),
- }),
+ consoleQuery: withConsoleQueryOverrides(
+ withConsoleResponses(actual.consoleQuery, {
+ 'knowledgeFs.spaces.byControlSpaceId.overview.stats.get': () => data.stats,
+ 'knowledgeFs.spaces.byControlSpaceId.overview.inventory.get': () => data.inventory,
+ 'knowledgeFs.spaces.byControlSpaceId.overview.queryOutcomes.get': async () => data.outcomes,
+ 'workspaces.current.members.get': () => ({ accounts: [] }),
+ }),
+ {
+ 'knowledgeFs.spaces.byControlSpaceId.overview.attention.get': spaceQuery(service.attention),
+ 'knowledgeFs.spaces.byControlSpaceId.overview.activity.get': spaceQuery(service.activity),
+ 'knowledgeFs.spaces.byControlSpaceId.backgroundTasks.get': {
+ infiniteOptions: ({ input }: { input: (page: null) => SpaceInput }) => ({
+ queryFn: ({ signal }: { signal: AbortSignal }) =>
+ service.tasks(input(null).params.control_space_id, signal),
+ }),
+ },
},
- }),
+ ),
}
})
@@ -67,43 +83,20 @@ const failedIssue: KnowledgeFsOverviewAttentionResponse = {
title: 'Document processing failed',
updated_at: '2026-09-08T00:00:01Z',
}
-function task(
- state: KnowledgeFsBackgroundTaskResponse['state'],
-): KnowledgeFsBackgroundTaskResponse {
- return {
- can_cancel: state === 'running',
- can_retry: state === 'failed',
- created_at: '2026-09-08T00:00:00Z',
- updated_at: state === 'running' ? '2026-09-08T00:00:00Z' : '2026-09-08T00:00:01Z',
- id: 'task-1',
- document_id: 'document-1',
- knowledge_space_id: 'space-a',
- operation: 'document_processing',
- progress_completed: 0,
- progress_failed: state === 'failed' ? 1 : 0,
- progress_percent: 20,
- progress_total: 1,
- state,
- task_kind: 'document',
- }
-}
-function Snapshot() {
- const attention = useAtomValueRawSync(overviewAttentionDataAtom)
- const activity = useAtomValueRawSync(overviewActivityPreviewDataAtom)
- return (
- <div>
- {attention.map((issue) => (
- <p key={issue.issue_key}>{issue.title}</p>
- ))}
- <output>{activity.length}</output>
- </div>
- )
-}
describe('overview task completion synchronization', () => {
let client: ReturnType<typeof createConsoleQueryClient>
- beforeEach(() => {
- vi.resetAllMocks()
+ beforeEach(async () => {
+ await page.viewport(1280, 900)
+ onTestFinished(guardUnexpectedFetch())
+ vi.useFakeTimers({ toFake: ['setInterval', 'clearInterval'] })
+ onTestFinished(() => {
+ client.clear()
+ vi.useRealTimers()
+ })
+ service.attention.mockReset()
+ service.activity.mockReset()
+ service.tasks.mockReset()
client = createConsoleQueryClient()
service.activity.mockResolvedValue({ data: [], next_cursor: null })
service.attention.mockResolvedValue({ data: [] })
@@ -115,51 +108,59 @@ describe('overview task completion synchronization', () => {
)
})
- function mount(deploymentEdition: 'CLOUD' | 'ENTERPRISE' = 'ENTERPRISE') {
- const { wrapper } = createConsoleQueryWrapper({
+ async function mount(deploymentEdition: 'CLOUD' | 'ENTERPRISE' = 'ENTERPRISE') {
+ const { wrapper: Wrapper } = createConsoleQueryWrapper({
queryClient: client,
systemFeatures: { deployment_edition: deploymentEdition },
})
- return render(
- <OverviewStateBoundary knowledgeSpaceId="space-a">
- <OverviewTaskSync />
- <Snapshot />
- </OverviewStateBoundary>,
- { wrapper },
+ await render(
+ <Wrapper>
+ <QueryTestingAdapter>
+ <OverviewStateBoundary knowledgeSpaceId="space-a">
+ <OverviewTaskSync />
+ <AttentionPanel />
+ <OverviewActivity />
+ </OverviewStateBoundary>
+ </QueryTestingAdapter>
+ </Wrapper>,
)
+ await expect.poll(() => client.isFetching({ queryKey: tasksKey() })).toBe(0)
}
it('cancels a pre-terminal snapshot and fetches failures after the last active task stops', async () => {
let resolveStale!: (value: { data: KnowledgeFsOverviewAttentionResponse[] }) => void
- service.attention.mockImplementationOnce(
+ service.attention.mockImplementation(
() =>
new Promise((resolve) => {
resolveStale = resolve
}),
)
- mount('CLOUD')
- await waitFor(() => expect(service.attention).toHaveBeenCalledOnce())
- await waitFor(() => expect(service.tasks).toHaveBeenCalledOnce())
+ await mount('CLOUD')
+ await expect
+ .poll(() => service.attention.mock.calls.some(([, signal]) => !signal.aborted))
+ .toBe(true)
+ await expect.poll(() => service.tasks).toHaveBeenCalledOnce()
expect(client.getQueryState(billingKeys.features())?.isInvalidated).toBe(false)
expect(client.getQueryState(billingKeys['vector-space']())?.isInvalidated).toBe(false)
- const staleSignal = service.attention.mock.calls[0]![1] as AbortSignal
+ const staleSignal = service.attention.mock.calls.at(-1)![1] as AbortSignal
+ expect(staleSignal.aborted).toBe(false)
service.tasks.mockResolvedValue({ data: [task('failed')], next_cursor: null })
service.attention.mockResolvedValue({ data: [failedIssue] })
-
- await act(() => client.invalidateQueries({ queryKey: tasksKey() }))
- expect(await screen.findByText('Document processing failed')).toBeInTheDocument()
+ // Complete via a public refetch before any interval can cancel the pending snapshot.
+ await client.invalidateQueries({ queryKey: tasksKey() })
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.attention.failedDocument.title'))
+ .toBeVisible()
expect(staleSignal.aborted).toBe(true)
expect(client.getQueryState(billingKeys.features())?.isInvalidated).toBe(true)
expect(client.getQueryState(billingKeys['vector-space']())?.isInvalidated).toBe(true)
- await act(async () => {
- resolveStale({ data: [] })
- })
- expect(screen.getByText('Document processing failed')).toBeInTheDocument()
- expect(service.activity.mock.calls.length).toBeGreaterThanOrEqual(2)
+ resolveStale({ data: [] })
+ await expect.poll(() => client.isFetching()).toBe(0)
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.attention.failedDocument.title'))
+ .toBeVisible()
const calls = service.attention.mock.calls.length
- await act(async () => {
- await new Promise((resolve) => setTimeout(resolve, 2100))
- })
+ await vi.advanceTimersByTimeAsync(4000)
expect(service.attention).toHaveBeenCalledTimes(calls)
})
@@ -170,8 +171,11 @@ describe('overview task completion synchronization', () => {
let resolveUsage!: (value: { size: number; limit: number }) => void
let precheckSignal!: AbortSignal
const queryFn = vi.fn(({ signal }: { signal: AbortSignal }) => {
- precheckSignal = signal
- return new Promise<{ size: number; limit: number }>((resolve) => {
+ precheckSignal ??= signal
+ return new Promise<{
+ size: number
+ limit: number
+ }>((resolve) => {
resolveUsage = resolve
})
})
@@ -180,18 +184,17 @@ describe('overview task completion synchronization', () => {
const precheck = client
.query({ queryKey, queryFn, staleTime: 0, retry: false })
.catch((error: unknown) => error)
-
try {
- mount('CLOUD')
- await waitFor(() => expect(service.tasks).toHaveBeenCalledOnce())
+ await mount('CLOUD')
+ await expect.poll(() => service.tasks).toHaveBeenCalledOnce()
service.tasks.mockResolvedValue({ data: [task('failed')], next_cursor: null })
service.attention.mockResolvedValue({ data: [failedIssue] })
-
- await act(() => client.invalidateQueries({ queryKey: tasksKey() }))
- expect(await screen.findByText('Document processing failed')).toBeInTheDocument()
+ await client.invalidateQueries({ queryKey: tasksKey() })
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.attention.failedDocument.title'))
+ .toBeVisible()
expect(precheckSignal.aborted).toBe(false)
expect(queryFn).toHaveBeenCalledOnce()
-
resolveUsage({ size: 2, limit: 10 })
await expect(precheck).resolves.toEqual({ size: 2, limit: 10 })
} finally {
@@ -208,27 +211,35 @@ describe('overview task completion synchronization', () => {
query: { include_dismissed: false, limit: 100 },
},
})
- client.setQueryData(otherSpaceAttentionKey, { data: [failedIssue] })
- mount()
- await waitFor(() => expect(service.tasks).toHaveBeenCalledOnce())
+ const otherIssue = {
+ ...failedIssue,
+ knowledge_space_id: 'space-b',
+ issue_key: 'space-b-failed-document',
+ }
+ client.setQueryData(otherSpaceAttentionKey, { data: [otherIssue] })
+ await mount()
+ await expect.poll(() => service.tasks).toHaveBeenCalledOnce()
service.tasks.mockResolvedValue({ data: [task('failed')], next_cursor: null })
service.attention.mockResolvedValue({ data: [failedIssue] })
- await act(() => client.invalidateQueries({ queryKey: tasksKey() }))
- expect(await screen.findByText('Document processing failed')).toBeInTheDocument()
+ await client.invalidateQueries({ queryKey: tasksKey() })
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.attention.failedDocument.title'))
+ .toBeVisible()
service.tasks.mockResolvedValue({ data: [task('running')], next_cursor: null })
- await act(() => client.invalidateQueries({ queryKey: tasksKey() }))
+ await client.invalidateQueries({ queryKey: tasksKey() })
service.tasks.mockResolvedValue({
data: [{ ...task('completed'), updated_at: '2026-09-08T00:00:03Z' }],
next_cursor: null,
})
service.attention.mockResolvedValue({ data: [] })
- await act(() => client.invalidateQueries({ queryKey: tasksKey() }))
- await waitFor(() =>
- expect(screen.queryByText('Document processing failed')).not.toBeInTheDocument(),
- )
+ await client.invalidateQueries({ queryKey: tasksKey() })
+ await expect.element(page.getByText('knowledgeOverview.overview.noIssues')).toBeVisible()
+ await expect
+ .element(page.getByText('knowledgeOverview.overview.attention.failedDocument.title'))
+ .not.toBeInTheDocument()
expect(client.getQueryState(otherSpaceAttentionKey)?.isInvalidated).toBe(false)
expect(client.getQueryData(otherSpaceAttentionKey)).toEqual({
- data: [failedIssue],
+ data: [otherIssue],
})
expect(client.getQueryState(billingKeys.features())?.isInvalidated).toBe(false)
expect(client.getQueryState(billingKeys['vector-space']())?.isInvalidated).toBe(false)
diff --git a/web/test/new-rag-overview.ts b/web/test/new-rag-overview.ts
new file mode 100644
index 00000000000..d0d86906fa7
--- /dev/null
+++ b/web/test/new-rag-overview.ts
@@ -0,0 +1,135 @@
+import type {
+ KnowledgeFsBackgroundTaskResponse,
+ KnowledgeFsOverviewActivityResponse,
+ KnowledgeFsOverviewAttentionListResponse,
+ KnowledgeFsOverviewInventoryResponse,
+ KnowledgeFsOverviewQueryOutcomesResponse,
+ KnowledgeFsOverviewStatsResponse,
+} from '@dify/contracts/api/console/knowledge-fs/types.gen'
+
+type OverviewResponses = {
+ activity: { data: KnowledgeFsOverviewActivityResponse[]; next_cursor: null }
+ attention: KnowledgeFsOverviewAttentionListResponse
+ inventory: KnowledgeFsOverviewInventoryResponse
+ outcomes: KnowledgeFsOverviewQueryOutcomesResponse
+ stats: KnowledgeFsOverviewStatsResponse
+ tasks: KnowledgeFsBackgroundTaskResponse[]
+ source: { name: string }
+}
+
+/** Fresh response presets; no providers, hooks or shared mutation on import. */
+export const createOverviewData = (): OverviewResponses => ({
+ activity: {
+ data: [
+ {
+ action: 'source.synced',
+ actor: { id: 'dify-account:member-1', type: 'member' },
+ details: { count: 1 },
+ id: 'activity-1',
+ occurred_at: '2026-07-29T08:05:00Z',
+ resource: { id: 'source-1', type: 'source' },
+ result: 'success',
+ },
+ ],
+ next_cursor: null,
+ },
+ attention: { data: [] },
+ inventory: {
+ generated_at: '2026-07-29T09:00:00Z',
+ graph_entities: { added_last_7d: 1, total: 12 },
+ graph_relations: { added_last_7d: 2, total: 18 },
+ index_coverage: { indexed: 4, percentage: 80, total: 5 },
+ knowledge_space_id: 'knowledge-1',
+ source_categories: { crawl: 1, online_documents: 1, online_drives: 0, uploads: 1 },
+ },
+ outcomes: {
+ buckets: [],
+ current: {
+ answer_rate: 0.84,
+ answered: 8,
+ low_confidence: 1,
+ no_evidence: 1,
+ query_count: 10,
+ },
+ generated_at: '2026-07-29T09:00:00Z',
+ knowledge_space_id: 'knowledge-1',
+ previous: {
+ answer_rate: 0.8,
+ answered: 4,
+ low_confidence: 1,
+ no_evidence: 0,
+ query_count: 5,
+ },
+ previous_since: '2026-07-27T09:00:00Z',
+ since: '2026-07-28T09:00:00Z',
+ window: '24h',
+ },
+ source: {
+ name: 'Notion — Support SOP',
+ },
+ stats: {
+ answer_rate: { change_percentage_points: 4, previous_value: 0.8, value: 0.84 },
+ documents: 5,
+ fresh_source_count: 3,
+ freshness_seconds: 18000,
+ generated_at: '2026-07-29T09:00:00Z',
+ knowledge_space_id: 'knowledge-1',
+ linked_apps: 2,
+ queries: { change_rate: 1, previous_value: 5, value: 10 },
+ source_count: 3,
+ stale_source_count: 0,
+ window: '24h',
+ },
+ tasks: [
+ {
+ can_cancel: false,
+ can_retry: false,
+ completed_at: '2026-07-29T08:05:00Z',
+ created_at: '2026-07-29T08:00:00Z',
+ id: 'task-1',
+ knowledge_space_id: 'knowledge-1',
+ operation: 'source_sync',
+ progress_completed: 1,
+ progress_failed: 0,
+ progress_percent: 100,
+ progress_total: 1,
+ source_id: undefined,
+ state: 'completed',
+ task_kind: 'source',
+ updated_at: '2026-07-29T08:05:00Z',
+ },
+ ],
+})
+
+export function createOverviewTask(state: KnowledgeFsBackgroundTaskResponse['state']) {
+ return {
+ ...createOverviewData().tasks[0]!,
+ task_kind: 'document',
+ id: 'task-1',
+ knowledge_space_id: 'space-a',
+ document_id: 'document-1',
+ can_cancel: state === 'running',
+ can_retry: state === 'failed',
+ completed_at: state === 'completed' ? '2026-09-08T00:00:01Z' : undefined,
+ progress_completed: state === 'completed' ? 1 : 0,
+ progress_percent: state === 'completed' ? 100 : 20,
+ operation: 'document_processing',
+ progress_failed: state === 'failed' ? 1 : 0,
+ state,
+ created_at: '2026-09-08T00:00:00Z',
+ updated_at: state === 'running' ? '2026-09-08T00:00:00Z' : '2026-09-08T00:00:01Z',
+ } satisfies KnowledgeFsBackgroundTaskResponse
+}
+
+export function createOverviewActivity(id: string, count: number) {
+ return {
+ ...createOverviewData().activity.data[0]!,
+ action: 'source.synced',
+ result: 'success',
+ resource: { id: 'source-1', type: 'source' },
+ id,
+ actor: { id: 'system', type: 'system' },
+ details: { count, reasonCode: `Synced ${count} documents` },
+ occurred_at: '2026-09-08T00:00:00Z',
+ } satisfies KnowledgeFsOverviewActivityResponse
+}