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 knowledge tags and upgrades in browser (#45517)

Stephen Zhou5ae6f0c0c0e7
diff --git a/web/features/new-rag/list/__tests__/knowledge-space-card-tags.browser.spec.tsx b/web/features/new-rag/list/__tests__/knowledge-space-card-tags.browser.spec.tsx
new file mode 100644
index 00000000000..2c30698f2ba
--- /dev/null
+++ b/web/features/new-rag/list/__tests__/knowledge-space-card-tags.browser.spec.tsx
@@ -0,0 +1,228 @@
+import type { TagResponse as Tag } from '@dify/contracts/api/console/tags/types.gen'
+import type { consoleClient } from '@/service/console'
+import { useQuery } from '@tanstack/react-query'
+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 { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { KnowledgeSpaceCardTags } from '../knowledge-space-card-tags'
+
+type KnowledgeFsSpaceListItemResponse = Awaited<
+ ReturnType<typeof consoleClient.knowledgeFs.spaces.get>
+>['data'][number]
+type KnowledgeTag = Tag & { type: 'knowledge' }
+
+const api = vi.hoisted(() => ({
+ putTags: vi.fn<typeof consoleClient.knowledgeFs.spaces.byControlSpaceId.tags.put>(),
+ spaces: vi.fn<typeof consoleClient.knowledgeFs.spaces.get>(),
+ tags: vi.fn<typeof consoleClient.tags.get>(),
+}))
+
+const knowledgeTags: KnowledgeTag[] = [
+ { binding_count: '1', id: 'tag-1', name: 'Frontend', type: 'knowledge' },
+ { binding_count: '1', id: 'tag-2', name: 'Backend', type: 'knowledge' },
+ { binding_count: '0', id: 'tag-3', name: 'Public docs', type: 'knowledge' },
+]
+
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleResponses } = await import('@/test/console/service-responses')
+ return {
+ ...actual,
+ consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ 'knowledgeFs.spaces.byControlSpaceId.tags.put': api.putTags,
+ 'tags.get': api.tags,
+ 'knowledgeFs.spaces.get': api.spaces,
+ }),
+ }
+})
+
+function createKnowledgeSpace(
+ permissionKeys: KnowledgeFsSpaceListItemResponse['permission_keys'],
+): KnowledgeFsSpaceListItemResponse {
+ return {
+ control_space_id: 'space-1',
+ created_at: '2026-08-13T00:00:00Z',
+ knowledge_space_id: 'knowledge-space-1',
+ linked_apps: 0,
+ owner_account_id: 'account-1',
+ permission_keys: permissionKeys,
+ resource_version: 1,
+ state: 'active',
+ tags: [
+ { id: 'tag-1', name: 'Frontend', type: 'knowledge' },
+ { id: 'tag-2', name: 'Backend', type: 'knowledge' },
+ ],
+ technical_status: 'available',
+ technical_summary: {
+ description: null,
+ document_count: 0,
+ icon: null,
+ knowledge_space_id: 'knowledge-space-1',
+ name: 'Public docs',
+ revision: 1,
+ slug: 'public-docs',
+ },
+ updated_at: '2026-08-13T00:00:00Z',
+ visibility: 'only_me',
+ }
+}
+
+const editable: KnowledgeFsSpaceListItemResponse['permission_keys'] = [
+ 'knowledge_space_edit',
+ 'knowledge_space_read',
+]
+let serverSpace: KnowledgeFsSpaceListItemResponse
+let serverTags: KnowledgeTag[]
+const trigger = (name = 'Frontend, Backend: Public docs') =>
+ page.getByRole('combobox', { name, exact: true })
+const option = (name: string) => page.getByRole('option', { name, exact: true })
+
+// Apply refreshed query data through the same public props as the knowledge list.
+function TagsOwner() {
+ const { data } = useQuery(
+ consoleQuery.knowledgeFs.spaces.get.queryOptions({
+ input: { query: { limit: 30, page: 1 } },
+ }),
+ )
+ return data?.data.map((space) => (
+ <KnowledgeSpaceCardTags
+ key={space.control_space_id}
+ knowledgeSpace={space}
+ onOpenTagManagement={() => {}}
+ />
+ ))
+}
+async function setup(permissionKeys = editable) {
+ serverSpace = createKnowledgeSpace(permissionKeys)
+ const { queryClient, wrapper: QueryProvider } = createConsoleQueryWrapper({
+ workspacePermissionKeys: ['dataset.tag.manage'],
+ })
+ await render(
+ <QueryProvider>
+ <div className="w-80">
+ <TagsOwner />
+ </div>
+ </QueryProvider>,
+ )
+ await expect.element(trigger()).toBeVisible()
+ return queryClient
+}
+beforeEach(async ({ onTestFinished }) => {
+ onTestFinished(guardUnexpectedFetch())
+ await page.viewport(640, 600)
+ serverTags = knowledgeTags.map((tag) => ({ ...tag }))
+ api.tags.mockImplementation(async () => serverTags)
+ api.spaces.mockImplementation(async () => ({
+ data: [serverSpace],
+ has_more: false,
+ limit: 30,
+ page: 1,
+ }))
+ api.putTags.mockImplementation(async ({ body }) => {
+ const tagIds = body.tag_ids ?? []
+ serverSpace = {
+ ...serverSpace,
+ tags: serverTags.filter((tag) => tagIds.includes(tag.id)),
+ }
+ serverTags = serverTags.map((tag) => ({
+ ...tag,
+ binding_count: tagIds.includes(tag.id) ? '1' : '0',
+ }))
+ return { data: serverSpace.tags ?? [] }
+ })
+})
+
+it('keeps provided tags read-only without space edit permission even for a tag manager', async () => {
+ await setup(['knowledge_space_read'])
+ await expect.element(trigger()).toBeDisabled()
+ await expect.element(trigger().getByText('Frontend', { exact: true })).toBeVisible()
+ await expect.element(trigger().getByText('Backend', { exact: true })).toBeVisible()
+})
+
+it('saves the final selection on close and refreshes server tags and binding counts', async () => {
+ const client = await setup()
+ await trigger().click()
+ await option('Frontend').click()
+ await option('Public docs').click()
+ await userEvent.keyboard('{Escape}')
+ await expect.element(page.getByRole('listbox')).not.toBeInTheDocument()
+ await expect.element(trigger('Backend, Public docs: Public docs')).toBeVisible()
+ await expect
+ .poll(() => api.putTags.mock.calls)
+ .toEqual([
+ [
+ {
+ body: { tag_ids: ['tag-2', 'tag-3'] },
+ params: { control_space_id: 'space-1' },
+ },
+ ],
+ ])
+ await expect
+ .poll(() =>
+ client.getQueryData(
+ consoleQuery.tags.get.queryKey({ input: { query: { type: 'knowledge' } } }),
+ ),
+ )
+ .toEqual([
+ { ...knowledgeTags[0], binding_count: '0' },
+ knowledgeTags[1],
+ { ...knowledgeTags[2], binding_count: '1' },
+ ])
+ await trigger('Backend, Public docs: Public docs').click()
+ await expect.element(option('Frontend')).toHaveAttribute('aria-selected', 'false')
+ await expect.element(option('Backend')).toHaveAttribute('aria-selected', 'true')
+ await expect.element(option('Public docs')).toHaveAttribute('aria-selected', 'true')
+})
+
+it('reopens with the submitted selection and serializes later edits while a replacement is pending', async () => {
+ const firstReplacement = createDeferred<{ data: [] }>()
+ api.putTags.mockImplementationOnce(async () => {
+ await firstReplacement.promise
+ serverSpace = { ...serverSpace, tags: [knowledgeTags[1]!] }
+ return { data: [] }
+ })
+ await setup()
+ await trigger().click()
+ await option('Frontend').click()
+ await userEvent.keyboard('{Escape}')
+ await expect.poll(() => api.putTags.mock.calls.length).toBe(1)
+ await trigger('Backend: Public docs').click()
+ await expect.element(option('Frontend')).toHaveAttribute('aria-selected', 'false')
+ await expect.element(option('Backend')).toHaveAttribute('aria-selected', 'true')
+ await option('Public docs').click()
+ await userEvent.keyboard('{Escape}')
+ await expect.element(trigger('Backend, Public docs: Public docs')).toBeVisible()
+ expect(api.putTags).toHaveBeenCalledOnce()
+ firstReplacement.resolve({ data: [] })
+ await expect
+ .poll(() => api.putTags.mock.calls.map(([input]) => input.body.tag_ids))
+ .toEqual([['tag-2'], ['tag-2', 'tag-3']])
+ await trigger('Backend, Public docs: Public docs').click()
+ await expect.element(option('Backend')).toHaveAttribute('aria-selected', 'true')
+ await expect.element(option('Public docs')).toHaveAttribute('aria-selected', 'true')
+})
+
+it('persists an empty selection after every tag is removed', async () => {
+ await setup()
+ await trigger().click()
+ await option('Frontend').click()
+ await option('Backend').click()
+ await userEvent.keyboard('{Escape}')
+ await expect.element(trigger('common.tag.addTag: Public docs')).toBeVisible()
+ await expect
+ .poll(() => api.putTags.mock.calls)
+ .toEqual([
+ [
+ {
+ body: { tag_ids: [] },
+ params: { control_space_id: 'space-1' },
+ },
+ ],
+ ])
+ await trigger('common.tag.addTag: Public docs').click()
+ await expect.element(option('Frontend')).toHaveAttribute('aria-selected', 'false')
+ await expect.element(option('Backend')).toHaveAttribute('aria-selected', 'false')
+})
diff --git a/web/features/new-rag/list/__tests__/knowledge-space-card-tags.spec.tsx b/web/features/new-rag/list/__tests__/knowledge-space-card-tags.spec.tsx
deleted file mode 100644
index 2eb56320d10..00000000000
--- a/web/features/new-rag/list/__tests__/knowledge-space-card-tags.spec.tsx
+++ /dev/null
@@ -1,163 +0,0 @@
-import type { KnowledgeFsSpaceListItemResponse } from '@dify/contracts/api/console/knowledge-fs/types.gen'
-import type { TagResponse as Tag } from '@dify/contracts/api/console/tags/types.gen'
-import type { consoleClient } from '@/service/console'
-import { act, screen, waitFor } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { consoleQuery } from '@/service/console'
-import { renderWithConsoleQuery } from '@/test/console/query-data'
-import { createDeferred } from '@/test/deferred'
-import { KnowledgeSpaceCardTags } from '../knowledge-space-card-tags'
-
-const api = vi.hoisted(() => ({
- putTags: vi.fn<typeof consoleClient.knowledgeFs.spaces.byControlSpaceId.tags.put>(),
- toast: { error: vi.fn(), success: vi.fn() },
-}))
-
-const knowledgeTags: Tag[] = [
- { binding_count: '1', id: 'tag-1', name: 'Frontend', type: 'knowledge' },
- { binding_count: '1', id: 'tag-2', name: 'Backend', type: 'knowledge' },
- { binding_count: '0', id: 'tag-3', name: 'Public docs', type: 'knowledge' },
-]
-
-vi.mock('@/app/notifications', () => ({ toast: api.toast }))
-vi.mock('@/service/console', async (importOriginal) => {
- const actual = await importOriginal<typeof import('@/service/console')>()
- const { withConsoleResponses } = await import('@/test/console/service-responses')
- return {
- ...actual,
- consoleQuery: withConsoleResponses(actual.consoleQuery, {
- 'knowledgeFs.spaces.byControlSpaceId.tags.put': api.putTags,
- 'tags.get': async () => knowledgeTags,
- }),
- }
-})
-
-function createKnowledgeSpace(
- permissionKeys: KnowledgeFsSpaceListItemResponse['permission_keys'],
-): KnowledgeFsSpaceListItemResponse {
- return {
- control_space_id: 'space-1',
- created_at: '2026-08-13T00:00:00Z',
- knowledge_space_id: 'knowledge-space-1',
- linked_apps: 0,
- owner_account_id: 'account-1',
- permission_keys: permissionKeys,
- resource_version: 1,
- state: 'active',
- tags: [
- { id: 'tag-1', name: 'Frontend', type: 'knowledge' },
- { id: 'tag-2', name: 'Backend', type: 'knowledge' },
- ],
- technical_status: 'available',
- technical_summary: {
- description: null,
- document_count: 0,
- icon: null,
- knowledge_space_id: 'knowledge-space-1',
- name: 'Public docs',
- revision: 1,
- slug: 'public-docs',
- },
- updated_at: '2026-08-13T00:00:00Z',
- visibility: 'only_me',
- }
-}
-
-const renderTags = (permissionKeys: KnowledgeFsSpaceListItemResponse['permission_keys']) =>
- renderWithConsoleQuery(
- <KnowledgeSpaceCardTags
- knowledgeSpace={createKnowledgeSpace(permissionKeys)}
- onOpenTagManagement={vi.fn()}
- />,
- { workspacePermissionKeys: ['dataset.tag.manage'] },
- )
-
-const editable: KnowledgeFsSpaceListItemResponse['permission_keys'] = [
- 'knowledge_space_edit',
- 'knowledge_space_read',
-]
-const trigger = (name = 'Frontend, Backend: Public docs') => screen.getByRole('combobox', { name })
-
-describe('KnowledgeSpaceCardTags', () => {
- beforeEach(() => {
- api.putTags.mockResolvedValue({ data: [] })
- })
-
- it('shows provided tag names read-only without space edit permission', () => {
- renderTags(['knowledge_space_read'])
-
- expect(trigger()).toBeDisabled()
- expect(screen.getByText('Frontend')).toBeInTheDocument()
- expect(screen.getByText('Backend')).toBeInTheDocument()
- })
-
- it('submits the final tag set and refreshes the list and binding counts', async () => {
- const user = userEvent.setup()
- const { queryClient } = renderTags(editable)
- const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries')
-
- await user.click(trigger())
- await user.click(await screen.findByRole('option', { name: 'Frontend' }))
- await user.click(screen.getByRole('option', { name: 'Public docs' }))
- await user.click(trigger())
-
- await waitFor(() => expect(api.putTags).toHaveBeenCalled())
- expect(api.toast.success).not.toHaveBeenCalled()
- expect(api.putTags).toHaveBeenCalledWith({
- body: { tag_ids: ['tag-2', 'tag-3'] },
- params: { control_space_id: 'space-1' },
- })
- expect(invalidateQueries).toHaveBeenCalledWith({
- queryKey: consoleQuery.knowledgeFs.spaces.get.key(),
- })
- expect(invalidateQueries).toHaveBeenCalledWith({
- queryKey: consoleQuery.tags.get.key({
- type: 'query',
- input: { query: { type: 'knowledge' } },
- }),
- })
- })
-
- it('serializes replacements against the latest submitted selection', async () => {
- const user = userEvent.setup()
- const firstReplacement = createDeferred<{ data: [] }>()
- api.putTags.mockReturnValueOnce(firstReplacement.promise)
- renderTags(editable)
-
- await user.click(trigger())
- await user.click(await screen.findByRole('option', { name: 'Frontend' }))
- await user.click(trigger())
- await waitFor(() => expect(api.putTags).toHaveBeenCalledOnce())
-
- const pendingTrigger = trigger('Backend: Public docs')
- await user.click(pendingTrigger)
- await user.click(await screen.findByRole('option', { name: 'Public docs' }))
- await user.click(pendingTrigger)
-
- expect(api.putTags).toHaveBeenCalledOnce()
- await act(async () => firstReplacement.resolve({ data: [] }))
-
- await waitFor(() => expect(api.putTags).toHaveBeenCalledTimes(2))
- expect(api.putTags.mock.calls.map(([input]) => input.body.tag_ids)).toEqual([
- ['tag-2'],
- ['tag-2', 'tag-3'],
- ])
- })
-
- it('can clear every tag from an editable knowledge space', async () => {
- const user = userEvent.setup()
- renderTags(editable)
-
- await user.click(trigger())
- await user.click(await screen.findByRole('option', { name: 'Frontend' }))
- await user.click(screen.getByRole('option', { name: 'Backend' }))
- await user.click(trigger())
-
- await waitFor(() =>
- expect(api.putTags).toHaveBeenCalledWith({
- body: { tag_ids: [] },
- params: { control_space_id: 'space-1' },
- }),
- )
- })
-})
diff --git a/web/features/new-rag/list/__tests__/knowledge-view-switcher.browser.spec.tsx b/web/features/new-rag/list/__tests__/knowledge-view-switcher.browser.spec.tsx
new file mode 100644
index 00000000000..1941cf4643a
--- /dev/null
+++ b/web/features/new-rag/list/__tests__/knowledge-view-switcher.browser.spec.tsx
@@ -0,0 +1,61 @@
+import { useState } from 'react'
+import { page, userEvent } from 'vite-plus/test/browser'
+import { render } from 'vitest-browser-react'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { KnowledgeViewSwitcher } from '../knowledge-view-switcher'
+
+function ViewOwner() {
+ const [view, setView] = useState<'classic' | 'agent'>('agent')
+ return <KnowledgeViewSwitcher value={view} onChange={setView} />
+}
+
+beforeEach(async ({ onTestFinished }) => {
+ onTestFinished(guardUnexpectedFetch())
+ localStorage.clear()
+ await page.viewport(640, 600)
+})
+
+it('persists guide dismissal without changing the selected knowledge view', async () => {
+ const { wrapper: QueryProvider } = createConsoleQueryWrapper()
+ await render(
+ <QueryProvider>
+ <ViewOwner />
+ </QueryProvider>,
+ )
+ const guide = page.getByRole('dialog', { name: 'knowledgeSpace.guideTitle' })
+ await guide.getByRole('button', { name: 'knowledgeSpace.gotIt' }).click()
+
+ await expect.element(guide).not.toBeInTheDocument()
+ await expect.element(page.getByRole('radio', { name: /knowledgeSpace.view.agent/ })).toBeChecked()
+ expect(localStorage.getItem('dify-new-knowledge-guide-dismissed')).toBe('true')
+
+ await page.getByRole('button', { name: 'knowledgeSpace.guideTitle' }).click()
+ await expect.element(guide).toBeVisible()
+ await guide.getByRole('button', { name: 'knowledgeSpace.gotIt' }).click()
+ await expect.element(guide).not.toBeInTheDocument()
+ await expect.element(page.getByRole('radio', { name: /knowledgeSpace.view.agent/ })).toBeChecked()
+})
+
+it('keeps existing focus for the automatic guide and focuses Got it when explicitly reopened', async () => {
+ const { wrapper: QueryProvider } = createConsoleQueryWrapper()
+ await render(
+ <QueryProvider>
+ {/* oxlint-disable-next-line jsx-a11y/no-autofocus -- Existing focus must survive the automatically opened guide. */}
+ <button type="button" autoFocus>
+ Before switcher
+ </button>
+ <ViewOwner />
+ </QueryProvider>,
+ )
+ const guide = page.getByRole('dialog', { name: 'knowledgeSpace.guideTitle' })
+ await expect.element(guide).toBeVisible()
+ await expect.element(page.getByRole('button', { name: 'Before switcher' })).toHaveFocus()
+ await guide.getByRole('button', { name: 'knowledgeSpace.gotIt' }).click()
+ await expect.element(guide).not.toBeInTheDocument()
+
+ await page.getByRole('button', { name: 'knowledgeSpace.guideTitle' }).click()
+ await expect.element(guide.getByRole('button', { name: 'knowledgeSpace.gotIt' })).toHaveFocus()
+ await userEvent.keyboard('{Enter}')
+ await expect.element(guide).not.toBeInTheDocument()
+})
diff --git a/web/features/new-rag/list/__tests__/knowledge-view-switcher.spec.tsx b/web/features/new-rag/list/__tests__/knowledge-view-switcher.spec.tsx
deleted file mode 100644
index 628c3fe933e..00000000000
--- a/web/features/new-rag/list/__tests__/knowledge-view-switcher.spec.tsx
+++ /dev/null
@@ -1,38 +0,0 @@
-import { screen, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { renderWithConsoleQuery as render } from '@/test/console/query-data'
-import { KnowledgeViewSwitcher } from '../knowledge-view-switcher'
-
-const guide = () => screen.getByRole('dialog', { name: 'knowledgeSpace.guideTitle' })
-
-describe('KnowledgeViewSwitcher', () => {
- beforeEach(() => {
- localStorage.clear()
- })
-
- it('remembers a dismissed guide without changing the selected view', async () => {
- const user = userEvent.setup()
- const onChange = vi.fn()
- const { unmount } = render(<KnowledgeViewSwitcher value="agent" onChange={onChange} />)
-
- await user.click(within(guide()).getByRole('button', { name: 'knowledgeSpace.gotIt' }))
- unmount()
- render(<KnowledgeViewSwitcher value="agent" onChange={onChange} />)
-
- expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
- expect(onChange).not.toHaveBeenCalled()
- })
-
- it('leaves focus alone when the guide opens itself and focuses Got it when reopened', async () => {
- const user = userEvent.setup()
- render(<KnowledgeViewSwitcher value="classic" onChange={vi.fn()} />)
-
- expect(guide()).not.toContainElement(document.activeElement as HTMLElement)
- await user.click(within(guide()).getByRole('button', { name: 'knowledgeSpace.gotIt' }))
- await user.click(screen.getByRole('button', { name: 'knowledgeSpace.guideTitle' }))
-
- expect(
- await within(guide()).findByRole('button', { name: 'knowledgeSpace.gotIt' }),
- ).toHaveFocus()
- })
-})
diff --git a/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-card.browser.spec.tsx b/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-card.browser.spec.tsx
new file mode 100644
index 00000000000..4cba6422be4
--- /dev/null
+++ b/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-card.browser.spec.tsx
@@ -0,0 +1,152 @@
+import type { KnowledgeFsUpgradeJobResponse } from '@dify/contracts/api/console/datasets/types.gen'
+import type { KnowledgeUpgrade } from '../knowledge-upgrade-context-value'
+import type { consoleClient } from '@/service/console'
+import { useState } from 'react'
+import { page, userEvent } from 'vite-plus/test/browser'
+import { render } from 'vitest-browser-react'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { createDeferred } from '@/test/deferred'
+import { upgradeDataset, upgradeJob } from '@/test/new-rag-upgrade'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { KnowledgeUpgradeCard } from '../knowledge-upgrade-card'
+import { KnowledgeUpgradeProvider } from '../knowledge-upgrade-context'
+import { useKnowledgeUpgrade } from '../knowledge-upgrade-context-value'
+
+const api = vi.hoisted(() => ({
+ status: vi.fn<typeof consoleClient.datasets.byDatasetId.knowledgeFsUpgrades.byJobId.get>(),
+}))
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleResponses } = await import('@/test/console/service-responses')
+ return {
+ ...actual,
+ consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ 'datasets.byDatasetId.knowledgeFsUpgrades.byJobId.get': api.status,
+ }),
+ }
+})
+
+const job: KnowledgeFsUpgradeJobResponse = {
+ ...upgradeJob,
+ completed_documents: 12,
+ completed_sources: 1,
+ new_control_space_id: 'space-1',
+ status: 'running',
+ stage: 'submitting_documents',
+ total_documents: 52,
+ total_sources: 1,
+}
+const upgrade: KnowledgeUpgrade = {
+ canRetry: false,
+ dataset: { ...upgradeDataset, app_count: 2, description: 'Support articles', document_count: 52 },
+ job,
+}
+async function renderCard(value = upgrade) {
+ const { wrapper: QueryProvider } = createConsoleQueryWrapper()
+ const ui = (next: KnowledgeUpgrade) => (
+ <QueryProvider>
+ <ul className="w-80">
+ <KnowledgeUpgradeCard upgrade={next} />
+ </ul>
+ </QueryProvider>
+ )
+ const screen = await render(ui(value))
+ return { rerender: (next: KnowledgeUpgrade) => screen.rerender(ui(next)) }
+}
+function PollingOwner() {
+ const { settleUpgrade, upgrades } = useKnowledgeUpgrade()
+ const [destination, setDestination] = useState<string>()
+ return (
+ <>
+ <ul className="w-80">
+ <KnowledgeUpgradeCard
+ upgrade={upgrades[0] ?? upgrade}
+ onSettled={settleUpgrade}
+ onSucceeded={setDestination}
+ />
+ </ul>
+ <output aria-label="Tracked upgrade">
+ {upgrades.map((entry) => `${entry.job.id}:${entry.job.status}`).join(',')}
+ </output>
+ {destination && <a href={`/datasets/new/${destination}`}>Continue to knowledge</a>}
+ </>
+ )
+}
+
+beforeEach(async ({ onTestFinished }) => {
+ onTestFinished(guardUnexpectedFetch())
+ await page.viewport(640, 600)
+ api.status.mockReset().mockImplementation(() => new Promise(() => {}))
+ // Only the query polling interval is controlled; browser input and rendering stay real.
+ vi.useFakeTimers({ toFake: ['setInterval', 'clearInterval'] })
+})
+afterEach(() => vi.useRealTimers())
+
+it('replaces live progress with the completed total and a usable knowledge link after polling settles', async () => {
+ const response = createDeferred<KnowledgeFsUpgradeJobResponse>()
+ api.status.mockReturnValue(response.promise)
+ const { wrapper: QueryProvider } = createConsoleQueryWrapper()
+ await render(
+ <QueryProvider>
+ <KnowledgeUpgradeProvider onUpgradeStarted={() => {}}>
+ <PollingOwner />
+ </KnowledgeUpgradeProvider>
+ </QueryProvider>,
+ )
+ await expect.element(page.getByLabelText('knowledgeSpace.documents: 12/52')).toBeVisible()
+ await expect
+ .element(page.getByText('knowledgeUpgrade.upgrade.statusUpgrading', { exact: true }))
+ .toBeVisible()
+ await vi.advanceTimersByTimeAsync(2000)
+ await expect.poll(() => api.status.mock.calls.length).toBe(1)
+ response.resolve({ ...job, completed_documents: 52, stage: 'completed', status: 'succeeded' })
+
+ const link = page.getByRole('link', { name: 'Support knowledge', exact: true })
+ await expect.element(link).toBeVisible()
+ await expect.element(link).toHaveAttribute('href', '/datasets/new/space-1')
+ await expect.element(link.getByLabelText('knowledgeSpace.documents: 52')).toBeVisible()
+ await expect
+ .element(page.getByText('knowledgeUpgrade.upgrade.statusUpgrading', { exact: true }))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByLabelText('Tracked upgrade'))
+ .toHaveTextContent('upgrade-1:succeeded')
+ await expect
+ .element(page.getByRole('link', { name: 'Continue to knowledge' }))
+ .toHaveAttribute('href', '/datasets/new/space-1')
+ // The completed card is a native keyboard target rather than the fake header from the old suite.
+ await userEvent.keyboard('{Tab}')
+ await expect.element(link).toHaveFocus()
+})
+
+it.each(['failed', 'succeeded'] as const)(
+ 'shows total documents for a %s migration and does not poll a terminal job',
+ async (status) => {
+ await renderCard({
+ ...upgrade,
+ job: { ...job, status, stage: status === 'succeeded' ? 'completed' : 'submitting_documents' },
+ })
+ await expect.element(page.getByLabelText('knowledgeSpace.documents: 52')).toBeVisible()
+ await vi.advanceTimersByTimeAsync(4000)
+ expect(api.status).not.toHaveBeenCalled()
+ },
+)
+
+it('shows the backend failure and exposes retry only when discovery permits it', async () => {
+ const failedUpgrade: KnowledgeUpgrade = {
+ ...upgrade,
+ canRetry: true,
+ job: { ...job, status: 'failed', last_error_message: 'The source could not be migrated' },
+ }
+ const screen = await renderCard(failedUpgrade)
+ await expect
+ .element(page.getByText('The source could not be migrated', { exact: true }))
+ .toBeVisible()
+ const retry = page.getByRole('button', { name: 'common.operation.retry', exact: true })
+ await expect.element(retry).toBeVisible()
+ await screen.rerender({ ...failedUpgrade, canRetry: false })
+ await expect.element(retry).not.toBeInTheDocument()
+ await expect
+ .element(page.getByText('The source could not be migrated', { exact: true }))
+ .toBeVisible()
+})
diff --git a/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-card.spec.tsx b/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-card.spec.tsx
deleted file mode 100644
index 6f9360beae7..00000000000
--- a/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-card.spec.tsx
+++ /dev/null
@@ -1,208 +0,0 @@
-import type { KnowledgeFsUpgradeJobResponse } from '@dify/contracts/api/console/datasets/types.gen'
-import type { KnowledgeUpgrade } from '../knowledge-upgrade-context-value'
-import { QueryClient } from '@tanstack/react-query'
-import { act, screen, waitFor } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { consoleQuery } from '@/service/console'
-import { renderWithConsoleQuery } from '@/test/console/query-data'
-import { createDatasetFixture } from '@/test/fixtures/dataset'
-import { KnowledgeUpgradeCard } from '../knowledge-upgrade-card'
-import { KnowledgeUpgradeProvider } from '../knowledge-upgrade-context'
-import { KnowledgeUpgradeContext, useKnowledgeUpgrade } from '../knowledge-upgrade-context-value'
-
-const requestMock = vi.hoisted(() => vi.fn(() => new Promise<Response>(() => {})))
-
-vi.mock('@/service/base', async (importOriginal) => {
- const original = await importOriginal<typeof import('@/service/base')>()
- return { ...original, request: requestMock }
-})
-
-vi.mock('@/app/components/datasets/list/dataset-card/components/dataset-card-header', () => ({
- default: ({ dataset }: { dataset: { name: string } }) => <div>{dataset.name}</div>,
-}))
-
-vi.mock('../knowledge-upgrade-dialog', () => ({
- KnowledgeUpgradeDialog: () => null,
-}))
-
-const job = {
- completed_documents: 12,
- completed_sources: 1,
- id: 'upgrade-1',
- new_control_space_id: 'space-1',
- old_dataset_id: 'dataset-1',
- snapshot_at: '2026-08-18T00:00:00Z',
- stage: 'submitting_documents',
- status: 'running',
- total_documents: 52,
- total_sources: 1,
-} satisfies KnowledgeFsUpgradeJobResponse
-
-const upgrade: KnowledgeUpgrade = {
- canRetry: false,
- dataset: createDatasetFixture({
- app_count: 2,
- description: 'Support articles',
- document_count: 52,
- name: 'Support knowledge',
- }),
- job,
-}
-
-const renderCard = (
- value: KnowledgeUpgrade,
- callbacks: {
- onSettled?: (upgrade: KnowledgeUpgrade) => void
- onSucceeded?: (controlSpaceId: string) => void
- } = {},
-) =>
- renderWithConsoleQuery(
- <KnowledgeUpgradeContext
- value={{
- dismissUpgrade: vi.fn(),
- enabled: true,
- requestUpgrade: vi.fn(),
- settleUpgrade: vi.fn(),
- upgrades: [value],
- }}
- >
- <KnowledgeUpgradeCard upgrade={value} {...callbacks} />
- </KnowledgeUpgradeContext>,
- )
-
-describe('KnowledgeUpgradeCard', () => {
- beforeEach(() => {
- requestMock.mockClear()
- })
-
- it('shows completed and total document counts while migration is active', () => {
- renderCard(upgrade)
-
- expect(screen.getByText('12/52')).toBeInTheDocument()
- })
-
- it.each(['failed', 'succeeded'] as const)(
- 'shows only the total document count for a %s migration',
- (status) => {
- renderCard({
- ...upgrade,
- job: {
- ...job,
- stage: status === 'succeeded' ? 'completed' : 'submitting_documents',
- status,
- },
- })
-
- expect(screen.getByText('52')).toBeInTheDocument()
- expect(screen.queryByText('52/52')).not.toBeInTheDocument()
- },
- )
-
- it('shows the backend failure message and only offers retry when discovery allows it', () => {
- const failedUpgrade: KnowledgeUpgrade = {
- ...upgrade,
- canRetry: true,
- job: {
- ...job,
- last_error_message: 'The source could not be migrated',
- status: 'failed',
- },
- }
-
- renderCard(failedUpgrade)
-
- expect(screen.getByText('The source could not be migrated')).toBeInTheDocument()
- expect(screen.getByRole('button', { name: 'common.operation.retry' })).toBeInTheDocument()
- })
-
- it('does not request status for a terminal upgrade before retry', async () => {
- const failedUpgrade: KnowledgeUpgrade = {
- ...upgrade,
- canRetry: true,
- job: {
- ...job,
- status: 'failed',
- },
- }
- const queryClient = new QueryClient({
- defaultOptions: { queries: { retry: false, staleTime: 0 } },
- })
-
- renderWithConsoleQuery(<KnowledgeUpgradeCard upgrade={failedUpgrade} />, { queryClient })
- await act(async () => Promise.resolve())
-
- expect(requestMock).not.toHaveBeenCalled()
- })
-
- it('settles a locally tracked upgrade when polling reaches a terminal status', async () => {
- const onSettled = vi.fn()
- const onSucceeded = vi.fn()
- const { queryClient } = renderCard(upgrade, { onSettled, onSucceeded })
- const queryKey = consoleQuery.datasets.byDatasetId.knowledgeFsUpgrades.byJobId.get.queryOptions(
- {
- input: {
- params: {
- dataset_id: job.old_dataset_id,
- job_id: job.id,
- },
- },
- },
- ).queryKey
-
- await act(async () => {
- queryClient.setQueryData(queryKey, {
- ...job,
- completed_documents: job.total_documents,
- stage: 'completed',
- status: 'succeeded',
- })
- })
-
- await waitFor(() => {
- expect(onSettled).toHaveBeenCalledWith(
- expect.objectContaining({
- canRetry: false,
- dataset: upgrade.dataset,
- job: expect.objectContaining({ id: job.id, status: 'succeeded' }),
- }),
- )
- expect(onSucceeded).toHaveBeenCalledWith(job.new_control_space_id)
- })
- })
-
- it('keeps a recovered upgrade in provider state after it settles', async () => {
- const user = userEvent.setup()
-
- function SettlementHarness() {
- const { settleUpgrade, upgrades } = useKnowledgeUpgrade()
- return (
- <>
- <button
- type="button"
- onClick={() =>
- settleUpgrade({
- ...upgrade,
- job: { ...job, stage: 'completed', status: 'succeeded' },
- })
- }
- >
- Settle recovered upgrade
- </button>
- <output>
- {upgrades.map((entry) => `${entry.job.id}:${entry.job.status}`).join(',')}
- </output>
- </>
- )
- }
-
- renderWithConsoleQuery(
- <KnowledgeUpgradeProvider onUpgradeStarted={vi.fn()}>
- <SettlementHarness />
- </KnowledgeUpgradeProvider>,
- )
-
- await user.click(screen.getByRole('button', { name: 'Settle recovered upgrade' }))
-
- expect(screen.getByText('upgrade-1:succeeded')).toBeInTheDocument()
- })
-})
diff --git a/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-dialog.browser.spec.tsx b/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-dialog.browser.spec.tsx
new file mode 100644
index 00000000000..30f10a09025
--- /dev/null
+++ b/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-dialog.browser.spec.tsx
@@ -0,0 +1,297 @@
+import type { KnowledgeFsUpgradePreparationResponse } from '@dify/contracts/api/console/datasets/types.gen'
+import { ORPCError } from '@orpc/client'
+import { useRef } from 'react'
+import { page } from 'vite-plus/test/browser'
+import { render } from 'vitest-browser-react'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import {
+ upgradeDataset as dataset,
+ expectedUpgradeModels as expectedPayload,
+ upgradeJob as job,
+ upgradeModelCatalogs as modelCatalogs,
+ recommendedUpgradeModels as recommendedModels,
+ seedUpgradeModels,
+} from '@/test/new-rag-upgrade'
+import { QueryTestingAdapter } from '@/test/query-state-testing-adapter'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { KnowledgeUpgradeCard } from '../knowledge-upgrade-card'
+import { KnowledgeUpgradeProvider } from '../knowledge-upgrade-context'
+import { useKnowledgeUpgrade } from '../knowledge-upgrade-context-value'
+
+const startUpgradeMock = vi.hoisted(() => vi.fn())
+const discoverUpgradeMock = vi.hoisted(() => vi.fn())
+const getModelsMock = vi.hoisted(() => vi.fn())
+
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleResponses } = await import('@/test/console/service-responses')
+ return {
+ ...actual,
+ consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ 'datasets.byDatasetId.knowledgeFsUpgrades.get': discoverUpgradeMock,
+ 'datasets.byDatasetId.knowledgeFsUpgrades.post': startUpgradeMock,
+ 'workspaces.current.models.modelTypes.byModelType.get': getModelsMock,
+ 'datasets.byDatasetId.knowledgeFsUpgrades.byJobId.get': () => new Promise(() => {}),
+ }),
+ }
+})
+
+// Exercise dialog callbacks through their production owner: cancel removes it and start adds a card.
+function UpgradeOwner() {
+ const { requestUpgrade, settleUpgrade, upgrades } = useKnowledgeUpgrade()
+ const triggerRef = useRef<HTMLButtonElement>(null)
+ return (
+ <>
+ <button ref={triggerRef} type="button" onClick={() => requestUpgrade(dataset, triggerRef)}>
+ Upgrade support knowledge
+ </button>
+ <ul aria-label="Upgrades" className="w-80">
+ {upgrades.map((upgrade) => (
+ <KnowledgeUpgradeCard key={upgrade.job.id} upgrade={upgrade} onSettled={settleUpgrade} />
+ ))}
+ </ul>
+ </>
+ )
+}
+async function renderDialog() {
+ const { queryClient, wrapper: QueryProvider } = createConsoleQueryWrapper()
+ seedUpgradeModels(queryClient)
+ await render(
+ <QueryProvider>
+ <QueryTestingAdapter>
+ <KnowledgeUpgradeProvider onUpgradeStarted={() => {}}>
+ <UpgradeOwner />
+ </KnowledgeUpgradeProvider>
+ </QueryTestingAdapter>
+ </QueryProvider>,
+ )
+ await page.getByRole('button', { name: 'Upgrade support knowledge' }).click()
+ await expect.element(page.getByRole('alertdialog')).toBeVisible()
+}
+const startButton = () =>
+ page.getByRole('button', { name: 'knowledgeUpgrade.upgrade.start', exact: true })
+const reasoningSelector = () =>
+ page.getByRole('button', { name: /knowledgeSettings.settings.systemReasoningModelLabel/ })
+async function waitForRecommendedModels() {
+ await expect.element(reasoningSelector().getByText('gpt-4o', { exact: true })).toBeVisible()
+ await expect.element(startButton()).toBeEnabled()
+}
+
+async function expectStarted() {
+ await expect.element(page.getByRole('alertdialog')).not.toBeInTheDocument()
+ await expect
+ .element(
+ page.getByRole('list', { name: 'Upgrades' }).getByText('Support knowledge', { exact: true }),
+ )
+ .toBeVisible()
+ await expect
+ .element(page.getByText('knowledgeUpgrade.upgrade.statusUpgrading', { exact: true }))
+ .toBeVisible()
+}
+describe('KnowledgeUpgradeDialog', () => {
+ beforeEach(async ({ onTestFinished }) => {
+ onTestFinished(guardUnexpectedFetch())
+ await page.viewport(640, 600)
+ startUpgradeMock.mockReset().mockResolvedValue(job)
+ vi.clearAllMocks()
+ discoverUpgradeMock.mockResolvedValue({
+ can_retry: false,
+ can_upgrade: true,
+ job: null,
+ models: recommendedModels,
+ } satisfies KnowledgeFsUpgradePreparationResponse)
+ getModelsMock.mockImplementation(({ params }: { params: { model_type: string } }) =>
+ Promise.resolve({
+ data: modelCatalogs
+ .map((provider) => ({
+ ...provider,
+ models: provider.models.filter((model) => model.model_type === params.model_type),
+ }))
+ .filter((provider) => provider.models.length),
+ }),
+ )
+ })
+
+ it('offers upgrade details and documentation before requiring an explicit confirmation', async () => {
+ await renderDialog()
+
+ await expect.element(page.getByText('knowledgeUpgrade.upgrade.dialogDuration')).toBeVisible()
+ await expect.element(page.getByText('knowledgeUpgrade.upgrade.dialogLinkedApps')).toBeVisible()
+ const learnMore = page.getByRole('link', { name: 'knowledgeSpace.learnMore' })
+ await expect
+ .element(learnMore)
+ .toHaveAttribute(
+ 'href',
+ expect.stringMatching(/\/use-dify\/knowledge-base\/upgrade-from-classic$/),
+ )
+ await expect.element(learnMore).toHaveAttribute('target', '_blank')
+ await expect.element(page.getByText(/knowledgeUpgrade\.upgrade\.summary/)).toBeVisible()
+ await expect
+ .element(
+ page
+ .getByRole('region', { name: 'knowledgeSpace.modelCost.title' })
+ .getByText('knowledgeUpgrade.upgrade.modelCostDescription', { exact: true }),
+ )
+ .toBeVisible()
+ // Vitest's description matcher drops the body of a labelled region here, whereas
+ // Chromium's accessibility tree includes it. Verify the public ARIA reference and its
+ // visible cost content without encoding that matcher artifact as a product defect.
+ await expect.element(startButton()).toHaveAttribute('aria-describedby')
+ const descriptionId = startButton().element().getAttribute('aria-describedby')!
+ const description = document.getElementById(descriptionId)
+ await expect
+ .element(description)
+ .toMatchTextContent('knowledgeUpgrade.upgrade.modelCostDescription')
+ await waitForRecommendedModels()
+ expect(startUpgradeMock).not.toHaveBeenCalled()
+
+ await page.getByRole('button', { name: 'common.operation.cancel' }).click()
+ await expect.element(page.getByRole('alertdialog')).not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('button', { name: 'Upgrade support knowledge' }))
+ .toHaveFocus()
+ expect(startUpgradeMock).not.toHaveBeenCalled()
+ })
+
+ it('prefills recommended models and sends them with the upgrade request', async () => {
+ startUpgradeMock.mockResolvedValue(job)
+ await renderDialog()
+
+ await expect
+ .element(
+ page.getByRole('button', {
+ name: /knowledgeSettings.settings.embeddingModelLabel.*text-embedding-3-small/,
+ }),
+ )
+ .toBeInTheDocument()
+ await expect
+ .element(page.getByRole('region', { name: 'knowledgeCreate.modelSettings' }))
+ .toBeInTheDocument()
+ await startButton().click()
+
+ await expectStarted()
+ expect(startUpgradeMock).toHaveBeenCalledWith({
+ body: { models: expectedPayload },
+ headers: { 'Idempotency-Key': expect.any(String) },
+ params: { dataset_id: 'dataset-1' },
+ })
+ })
+
+ it('requires a choice when a recommended model is unavailable', async () => {
+ discoverUpgradeMock.mockResolvedValue({
+ can_retry: false,
+ can_upgrade: true,
+ job: null,
+ models: {
+ ...recommendedModels,
+ reasoning: {
+ available: false,
+ source: 'legacy',
+ unavailable_reason: 'not_found',
+ value: { model: 'retired-model', provider: 'langgenius/openai/openai' },
+ },
+ },
+ } satisfies KnowledgeFsUpgradePreparationResponse)
+ startUpgradeMock.mockResolvedValue(job)
+ await renderDialog()
+
+ await expect
+ .element(page.getByText('knowledgeSettings.settings.systemReasoningModelRequired'))
+ .toBeVisible()
+ await expect.element(reasoningSelector()).not.toMatchTextContent('retired-model')
+ await expect.element(startButton()).toBeDisabled()
+
+ await reasoningSelector().click()
+ await page.getByRole('button', { name: 'gpt-4o-mini' }).click()
+ await expect.element(startButton()).toBeEnabled()
+ await startButton().click()
+
+ await expect
+ .poll(() => startUpgradeMock.mock.calls.at(-1)?.[0])
+ .toEqual(
+ expect.objectContaining({
+ body: {
+ models: {
+ ...expectedPayload,
+ reasoning: { model: 'gpt-4o-mini', provider: 'langgenius/openai/openai' },
+ },
+ },
+ }),
+ )
+ await expectStarted()
+ })
+
+ it('reuses the idempotency key for retries and rotates it when the model choice changes', async () => {
+ startUpgradeMock
+ .mockRejectedValueOnce(new Error('response lost'))
+ .mockRejectedValueOnce(new Error('response lost'))
+ .mockResolvedValueOnce(job)
+ await renderDialog()
+
+ await waitForRecommendedModels()
+ await startButton().click()
+ await expect
+ .element(page.getByRole('alert'))
+ .toHaveTextContent('knowledgeUpgrade.upgrade.startFailed')
+ await startButton().click()
+ await expect.poll(() => startUpgradeMock.mock.calls.length).toBe(2)
+
+ await reasoningSelector().click()
+ await page.getByRole('button', { name: 'gpt-4o-mini' }).click()
+ await startButton().click()
+
+ await expectStarted()
+ const keys = startUpgradeMock.mock.calls.map(([input]) => input.headers['Idempotency-Key'])
+ expect(keys[1]).toBe(keys[0])
+ expect(keys[2]).not.toBe(keys[0])
+ expect(discoverUpgradeMock).toHaveBeenCalledWith({ params: { dataset_id: 'dataset-1' } })
+ })
+
+ it('keeps the dialog open and marks rejected models when the backend reports them unavailable', async () => {
+ startUpgradeMock.mockRejectedValueOnce(
+ new ORPCError('knowledge_fs_upgrade_models_unavailable', {
+ defined: true,
+ status: 422,
+ data: {
+ code: 'knowledge_fs_upgrade_models_unavailable',
+ message: 'Models unavailable',
+ status: 422,
+ details: {
+ issues: [
+ {
+ field: 'reasoning',
+ model: 'gpt-4o',
+ provider: 'langgenius/openai/openai',
+ reason: 'quota-exceeded',
+ },
+ ],
+ },
+ },
+ }),
+ )
+ await renderDialog()
+
+ await waitForRecommendedModels()
+ getModelsMock.mockClear()
+ await startButton().click()
+
+ await expect
+ .element(page.getByRole('alert'))
+ .toHaveTextContent('knowledgeUpgrade.upgrade.modelsUnavailable')
+ await expect
+ .element(reasoningSelector())
+ .toHaveAccessibleDescription(expect.stringContaining('knowledgeCreate.modelUnavailable'))
+ await expect.element(startButton()).toBeDisabled()
+ await expect
+ .poll(() => getModelsMock.mock.calls.map(([input]) => input))
+ .toContainEqual({ params: { model_type: 'llm' } })
+
+ await reasoningSelector().click()
+ await page.getByRole('button', { name: 'gpt-4o-mini' }).click()
+ await expect.element(page.getByRole('alert')).not.toBeInTheDocument()
+ await expect
+ .element(reasoningSelector())
+ .not.toHaveAccessibleDescription(expect.stringContaining('knowledgeCreate.modelUnavailable'))
+ await expect.element(startButton()).toBeEnabled()
+ })
+})
diff --git a/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-dialog.spec.tsx b/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-dialog.spec.tsx
deleted file mode 100644
index a5386ef70d7..00000000000
--- a/web/features/new-rag/upgrade/__tests__/knowledge-upgrade-dialog.spec.tsx
+++ /dev/null
@@ -1,310 +0,0 @@
-import type {
- KnowledgeFsUpgradeJobResponse,
- KnowledgeFsUpgradePreparationResponse,
-} from '@dify/contracts/api/console/datasets/types.gen'
-import { ORPCError } from '@orpc/client'
-import { screen, waitFor } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import {
- createCatalogModelFixture,
- createModelCatalogFixture,
- seedModelProviderQueries,
-} from '@/test/console/model-provider'
-import { createConsoleQueryClient, renderWithConsoleQuery } from '@/test/console/query-data'
-import { createDatasetFixture } from '@/test/fixtures/dataset'
-import { QueryTestingAdapter } from '@/test/query-state-testing-adapter'
-import { KnowledgeUpgradeDialog } from '../knowledge-upgrade-dialog'
-
-const startUpgradeMock = vi.hoisted(() => vi.fn())
-const discoverUpgradeMock = vi.hoisted(() => vi.fn())
-const getModelsMock = vi.hoisted(() => vi.fn())
-
-vi.mock('@/service/console', async (importOriginal) => {
- const actual = await importOriginal<typeof import('@/service/console')>()
- const { withConsoleResponses } = await import('@/test/console/service-responses')
- return {
- ...actual,
- consoleQuery: withConsoleResponses(actual.consoleQuery, {
- 'datasets.byDatasetId.knowledgeFsUpgrades.get': discoverUpgradeMock,
- 'datasets.byDatasetId.knowledgeFsUpgrades.post': startUpgradeMock,
- 'workspaces.current.models.modelTypes.byModelType.get': getModelsMock,
- }),
- }
-})
-
-const dataset = createDatasetFixture({ name: 'Support knowledge' })
-
-const job = {
- completed_documents: 0,
- completed_sources: 0,
- id: 'upgrade-1',
- old_dataset_id: dataset.id,
- snapshot_at: '2026-08-18T00:00:00Z',
- stage: 'validating',
- status: 'queued',
- total_documents: 0,
- total_sources: 0,
-} satisfies KnowledgeFsUpgradeJobResponse
-
-const modelCatalogs = [
- createModelCatalogFixture({
- provider: 'langgenius/openai/openai',
- models: [
- ...['gpt-4o', 'gpt-4o-mini'].map((model) =>
- createCatalogModelFixture({ model, label: { en_US: model }, model_type: 'llm' }),
- ),
- createCatalogModelFixture({
- model: 'text-embedding-3-small',
- label: { en_US: 'text-embedding-3-small' },
- model_type: 'text-embedding',
- }),
- ],
- }),
- createModelCatalogFixture({
- provider: 'langgenius/cohere/cohere',
- models: ['rerank-english', 'rerank-multilingual'].map((model) =>
- createCatalogModelFixture({ model, label: { en_US: model }, model_type: 'rerank' }),
- ),
- }),
-]
-
-const recommendedModels = {
- embedding: {
- available: true,
- source: 'legacy',
- value: { model: 'text-embedding-3-small', provider: 'openai' },
- },
- rerank: {
- available: true,
- source: 'workspace_default',
- value: { model: 'rerank-english', provider: 'langgenius/cohere/cohere' },
- },
- reasoning: {
- available: true,
- source: 'workspace_default',
- value: { model: 'gpt-4o', provider: 'langgenius/openai/openai' },
- },
-} satisfies NonNullable<KnowledgeFsUpgradePreparationResponse['models']>
-
-const expectedPayload = {
- embedding: { model: 'text-embedding-3-small', provider: 'langgenius/openai/openai' },
- rerank: { model: 'rerank-english', provider: 'langgenius/cohere/cohere' },
- reasoning: { model: 'gpt-4o', provider: 'langgenius/openai/openai' },
-}
-
-function renderDialog({ onCancel = vi.fn(), onStarted = vi.fn() } = {}) {
- const queryClient = createConsoleQueryClient()
- seedModelProviderQueries(queryClient, modelCatalogs)
- return renderWithConsoleQuery(
- <QueryTestingAdapter>
- <KnowledgeUpgradeDialog dataset={dataset} onCancel={onCancel} onStarted={onStarted} />
- </QueryTestingAdapter>,
- { queryClient },
- )
-}
-
-const startButton = () => screen.getByRole('button', { name: 'knowledgeUpgrade.upgrade.start' })
-// The start button only reports its loading state through data attributes, so wait for the
-// recommended models to render before treating the dialog as ready.
-async function waitForRecommendedModels() {
- await screen.findByRole('button', {
- name: /knowledgeSettings.settings.systemReasoningModelLabel.*gpt-4o/,
- })
- await waitFor(() => expect(startButton()).toBeEnabled())
-}
-const reasoningSelector = () =>
- screen.getByRole('button', { name: /knowledgeSettings.settings.systemReasoningModelLabel/ })
-
-describe('KnowledgeUpgradeDialog', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- discoverUpgradeMock.mockResolvedValue({
- can_retry: false,
- can_upgrade: true,
- job: null,
- models: recommendedModels,
- } satisfies KnowledgeFsUpgradePreparationResponse)
- getModelsMock.mockImplementation(({ params }: { params: { model_type: string } }) =>
- Promise.resolve({
- data: modelCatalogs
- .map((provider) => ({
- ...provider,
- models: provider.models.filter((model) => model.model_type === params.model_type),
- }))
- .filter((provider) => provider.models.length),
- }),
- )
- })
-
- it('offers upgrade details and documentation before requiring an explicit confirmation', async () => {
- const user = userEvent.setup()
- const onCancel = vi.fn()
- renderDialog({ onCancel })
-
- expect(screen.getByText('knowledgeUpgrade.upgrade.dialogDuration')).toBeVisible()
- expect(screen.getByText('knowledgeUpgrade.upgrade.dialogLinkedApps')).toBeVisible()
- const learnMore = screen.getByRole('link', { name: 'knowledgeSpace.learnMore' })
- expect(learnMore.getAttribute('href')).toMatch(
- /\/use-dify\/knowledge-base\/upgrade-from-classic$/,
- )
- expect(learnMore).toHaveAttribute('target', '_blank')
- expect(screen.getByText(/knowledgeUpgrade\.upgrade\.summary/)).toBeVisible()
- expect(
- screen.getByRole('region', { name: 'knowledgeSpace.modelCost.title' }),
- ).toHaveTextContent('knowledgeUpgrade.upgrade.modelCostDescription')
- expect(startButton()).toHaveAccessibleDescription(
- expect.stringContaining('knowledgeUpgrade.upgrade.modelCostDescription'),
- )
- await waitForRecommendedModels()
- expect(startUpgradeMock).not.toHaveBeenCalled()
-
- await user.click(screen.getByRole('button', { name: 'common.operation.cancel' }))
- expect(onCancel).toHaveBeenCalledOnce()
- expect(startUpgradeMock).not.toHaveBeenCalled()
- })
-
- it('prefills recommended models and sends them with the upgrade request', async () => {
- startUpgradeMock.mockResolvedValue(job)
- const onStarted = vi.fn()
- const user = userEvent.setup()
- renderDialog({ onStarted })
-
- expect(
- await screen.findByRole('button', {
- name: /knowledgeSettings.settings.embeddingModelLabel.*text-embedding-3-small/,
- }),
- ).toBeInTheDocument()
- expect(
- screen.getByRole('region', { name: 'knowledgeCreate.modelSettings' }),
- ).toBeInTheDocument()
- await user.click(startButton())
-
- await waitFor(() => expect(onStarted).toHaveBeenCalledWith(dataset, job))
- expect(startUpgradeMock).toHaveBeenCalledWith({
- body: { models: expectedPayload },
- headers: { 'Idempotency-Key': expect.any(String) },
- params: { dataset_id: 'dataset-1' },
- })
- })
-
- it('requires a choice when a recommended model is unavailable', async () => {
- discoverUpgradeMock.mockResolvedValue({
- can_retry: false,
- can_upgrade: true,
- job: null,
- models: {
- ...recommendedModels,
- reasoning: {
- available: false,
- source: 'legacy',
- unavailable_reason: 'not_found',
- value: { model: 'retired-model', provider: 'langgenius/openai/openai' },
- },
- },
- } satisfies KnowledgeFsUpgradePreparationResponse)
- startUpgradeMock.mockResolvedValue(job)
- const user = userEvent.setup()
- renderDialog()
-
- expect(
- await screen.findByText('knowledgeSettings.settings.systemReasoningModelRequired'),
- ).toBeVisible()
- expect(reasoningSelector()).not.toHaveTextContent('retired-model')
- expect(startButton()).toBeDisabled()
-
- await user.click(reasoningSelector())
- await user.click(await screen.findByRole('button', { name: 'gpt-4o-mini' }))
- await waitFor(() => expect(startButton()).toBeEnabled())
- await user.click(startButton())
-
- await waitFor(() =>
- expect(startUpgradeMock).toHaveBeenCalledWith(
- expect.objectContaining({
- body: {
- models: {
- ...expectedPayload,
- reasoning: { model: 'gpt-4o-mini', provider: 'langgenius/openai/openai' },
- },
- },
- }),
- ),
- )
- })
-
- it('reuses the idempotency key for retries and rotates it when the model choice changes', async () => {
- startUpgradeMock
- .mockRejectedValueOnce(new Error('response lost'))
- .mockRejectedValueOnce(new Error('response lost'))
- .mockResolvedValueOnce(job)
- const onStarted = vi.fn()
- const user = userEvent.setup()
- renderDialog({ onStarted })
-
- await waitForRecommendedModels()
- await user.click(startButton())
- expect(await screen.findByRole('alert')).toHaveTextContent(
- 'knowledgeUpgrade.upgrade.startFailed',
- )
- await user.click(startButton())
- await waitFor(() => expect(startUpgradeMock).toHaveBeenCalledTimes(2))
-
- await user.click(reasoningSelector())
- await user.click(await screen.findByRole('button', { name: 'gpt-4o-mini' }))
- await user.click(startButton())
-
- await waitFor(() => expect(onStarted).toHaveBeenCalledWith(dataset, job))
- const keys = startUpgradeMock.mock.calls.map(([input]) => input.headers['Idempotency-Key'])
- expect(keys[1]).toBe(keys[0])
- expect(keys[2]).not.toBe(keys[0])
- expect(discoverUpgradeMock).toHaveBeenCalledWith({ params: { dataset_id: 'dataset-1' } })
- })
-
- it('keeps the dialog open and marks rejected models when the backend reports them unavailable', async () => {
- startUpgradeMock.mockRejectedValueOnce(
- new ORPCError('knowledge_fs_upgrade_models_unavailable', {
- defined: true,
- status: 422,
- data: {
- code: 'knowledge_fs_upgrade_models_unavailable',
- message: 'Models unavailable',
- status: 422,
- details: {
- issues: [
- {
- field: 'reasoning',
- model: 'gpt-4o',
- provider: 'langgenius/openai/openai',
- reason: 'quota-exceeded',
- },
- ],
- },
- },
- }),
- )
- const user = userEvent.setup()
- renderDialog()
-
- await waitForRecommendedModels()
- getModelsMock.mockClear()
- await user.click(startButton())
-
- expect(await screen.findByRole('alert')).toHaveTextContent(
- 'knowledgeUpgrade.upgrade.modelsUnavailable',
- )
- expect(reasoningSelector()).toHaveAccessibleDescription(
- expect.stringContaining('knowledgeCreate.modelUnavailable'),
- )
- expect(startButton()).toBeDisabled()
- await waitFor(() =>
- expect(getModelsMock).toHaveBeenCalledWith({ params: { model_type: 'llm' } }),
- )
-
- await user.click(reasoningSelector())
- await user.click(await screen.findByRole('button', { name: 'gpt-4o-mini' }))
- expect(screen.queryByRole('alert')).not.toBeInTheDocument()
- expect(reasoningSelector()).not.toHaveAccessibleDescription(
- expect.stringContaining('knowledgeCreate.modelUnavailable'),
- )
- await waitFor(() => expect(startButton()).toBeEnabled())
- })
-})
diff --git a/web/test/new-rag-upgrade.ts b/web/test/new-rag-upgrade.ts
new file mode 100644
index 00000000000..0066d74e822
--- /dev/null
+++ b/web/test/new-rag-upgrade.ts
@@ -0,0 +1,75 @@
+import type {
+ KnowledgeFsUpgradeJobResponse,
+ KnowledgeFsUpgradePreparationResponse,
+} from '@dify/contracts/api/console/datasets/types.gen'
+import type { QueryClient } from '@tanstack/react-query'
+import {
+ createCatalogModelFixture,
+ createModelCatalogFixture,
+ seedModelProviderQueries,
+} from '@/test/console/model-provider'
+import { createDatasetFixture } from '@/test/fixtures/dataset'
+
+export const upgradeDataset = createDatasetFixture({ name: 'Support knowledge' })
+
+export const upgradeJob = {
+ completed_documents: 0,
+ completed_sources: 0,
+ id: 'upgrade-1',
+ old_dataset_id: upgradeDataset.id,
+ snapshot_at: '2026-08-18T00:00:00Z',
+ stage: 'validating',
+ status: 'queued',
+ total_documents: 0,
+ total_sources: 0,
+} satisfies KnowledgeFsUpgradeJobResponse
+
+export const upgradeModelCatalogs = [
+ createModelCatalogFixture({
+ provider: 'langgenius/openai/openai',
+ models: [
+ ...['gpt-4o', 'gpt-4o-mini'].map((model) =>
+ createCatalogModelFixture({ model, label: { en_US: model }, model_type: 'llm' }),
+ ),
+ createCatalogModelFixture({
+ model: 'text-embedding-3-small',
+ label: { en_US: 'text-embedding-3-small' },
+ model_type: 'text-embedding',
+ }),
+ ],
+ }),
+ createModelCatalogFixture({
+ provider: 'langgenius/cohere/cohere',
+ models: ['rerank-english', 'rerank-multilingual'].map((model) =>
+ createCatalogModelFixture({ model, label: { en_US: model }, model_type: 'rerank' }),
+ ),
+ }),
+]
+
+export const recommendedUpgradeModels = {
+ embedding: {
+ available: true,
+ source: 'legacy',
+ value: { model: 'text-embedding-3-small', provider: 'openai' },
+ },
+ rerank: {
+ available: true,
+ source: 'workspace_default',
+ value: { model: 'rerank-english', provider: 'langgenius/cohere/cohere' },
+ },
+ reasoning: {
+ available: true,
+ source: 'workspace_default',
+ value: { model: 'gpt-4o', provider: 'langgenius/openai/openai' },
+ },
+} satisfies NonNullable<KnowledgeFsUpgradePreparationResponse['models']>
+
+export const expectedUpgradeModels = {
+ embedding: { model: 'text-embedding-3-small', provider: 'langgenius/openai/openai' },
+ rerank: { model: 'rerank-english', provider: 'langgenius/cohere/cohere' },
+ reasoning: { model: 'gpt-4o', provider: 'langgenius/openai/openai' },
+}
+
+export function seedUpgradeModels(client: QueryClient) {
+ seedModelProviderQueries(client, upgradeModelCatalogs)
+}