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 recovery and source forms in browser (#45528)

Stephen Zhoude1f6b3670b6
diff --git a/web/features/new-rag/list/__tests__/new-knowledge-list.browser.spec.tsx b/web/features/new-rag/list/__tests__/new-knowledge-list.browser.spec.tsx
new file mode 100644
index 00000000000..7f6021e1f6e
--- /dev/null
+++ b/web/features/new-rag/list/__tests__/new-knowledge-list.browser.spec.tsx
@@ -0,0 +1,791 @@
+import type { KnowledgeFsUpgradeJobResponse } from '@dify/contracts/api/console/datasets/types.gen'
+import type { consoleClient } from '@/service/console'
+import type { ConsoleQueryTestOptions } from '@/test/console/query-data'
+import { page, userEvent } from 'vite-plus/test/browser'
+import { render } from 'vitest-browser-react'
+import { consoleQuery } from '@/service/console'
+import { createHttpError } from '@/service/http-error'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { createDeferred } from '@/test/deferred'
+import { createDatasetFixture } from '@/test/fixtures/dataset'
+import { createNuqsTestWrapper } from '@/test/nuqs-testing'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { KnowledgeUpgradeProvider } from '../../upgrade/knowledge-upgrade-context'
+import { NewKnowledgeList } from '../new-knowledge-list'
+
+const api = vi.hoisted(() => ({
+ spaces: vi.fn<typeof consoleClient.knowledgeFs.spaces.get>(),
+ deleteSpace: vi.fn<typeof consoleClient.knowledgeFs.spaces.byControlSpaceId.delete>(),
+ members: vi.fn<typeof consoleClient.workspaces.current.members.get>(),
+ upgradeJobs: vi.fn<typeof consoleClient.datasets.knowledgeFsUpgradeJobs.get>(),
+ upgradeJob: vi.fn<typeof consoleClient.datasets.byDatasetId.knowledgeFsUpgrades.byJobId.get>(),
+ datasets: vi.fn<typeof consoleClient.datasets.get>(),
+ push: vi.fn(),
+}))
+
+vi.mock('@/next/navigation', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/next/navigation')>()),
+ useRouter: () => ({ push: api.push }),
+}))
+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.get': api.spaces,
+ 'knowledgeFs.spaces.byControlSpaceId.delete': api.deleteSpace,
+ 'workspaces.current.members.get': api.members,
+ 'datasets.knowledgeFsUpgradeJobs.get': api.upgradeJobs,
+ 'datasets.get': api.datasets,
+ 'datasets.byDatasetId.knowledgeFsUpgrades.byJobId.get': api.upgradeJob,
+ 'datasets.apiBaseInfo.get': async () => ({ api_base_url: 'https://api.example.com' }),
+ 'datasets.externalKnowledgeApi.get': async () => ({
+ data: [],
+ has_more: false,
+ limit: 100,
+ page: 1,
+ total: 0,
+ }),
+ 'tags.get': async () => [
+ { binding_count: '1', id: 'tag-1', name: 'Customer support', type: 'knowledge' },
+ { binding_count: '1', id: 'tag-2', name: 'Public docs', type: 'knowledge' },
+ ],
+ }),
+ }
+})
+
+type KnowledgeFsSpaceListResponse = Awaited<ReturnType<typeof consoleClient.knowledgeFs.spaces.get>>
+type KnowledgeFsSpaceListItemResponse = KnowledgeFsSpaceListResponse['data'][number]
+type DatasetListResponse = Awaited<ReturnType<typeof consoleClient.datasets.get>>
+
+const space = (
+ id: string,
+ name: string,
+ overrides: Partial<KnowledgeFsSpaceListItemResponse> = {},
+): KnowledgeFsSpaceListItemResponse => ({
+ control_space_id: id,
+ created_at: '2026-07-15T00:00:00Z',
+ knowledge_space_id: id,
+ linked_apps: 0,
+ owner_account_id: 'account-1',
+ permission_keys: ['knowledge_space_read'],
+ resource_version: 1,
+ state: 'active',
+ technical_status: 'available',
+ technical_summary: {
+ description: null,
+ document_count: 0,
+ icon: null,
+ knowledge_space_id: id,
+ name,
+ revision: 1,
+ slug: id,
+ },
+ updated_at: '2026-07-18T00:00:00Z',
+ visibility: 'only_me',
+ ...overrides,
+})
+
+const spacesPage = (
+ data: KnowledgeFsSpaceListItemResponse[] = [],
+ { page = 1, hasMore = false } = {},
+): KnowledgeFsSpaceListResponse => ({ data, has_more: hasMore, limit: 30, page })
+
+const job = (
+ overrides: Partial<KnowledgeFsUpgradeJobResponse> = {},
+): KnowledgeFsUpgradeJobResponse => ({
+ completed_documents: 4,
+ completed_sources: 1,
+ id: 'upgrade-1',
+ old_dataset_id: 'dataset-1',
+ snapshot_at: '2026-08-18T00:00:00Z',
+ stage: 'submitting_documents',
+ status: 'running',
+ total_documents: 10,
+ total_sources: 1,
+ ...overrides,
+})
+
+const legacyDataset = (
+ latestJob: KnowledgeFsUpgradeJobResponse,
+ discovery: { can_retry?: boolean; can_upgrade?: boolean } = {},
+) => ({
+ ...createDatasetFixture({ id: latestJob.old_dataset_id, name: 'Support knowledge' }),
+ knowledge_fs_upgrade: {
+ can_retry: false,
+ can_upgrade: false,
+ ...discovery,
+ job: latestJob,
+ },
+})
+
+const datasetsPage = (data: DatasetListResponse['data']): DatasetListResponse => ({
+ data,
+ has_more: false,
+ limit: 50,
+ page: 1,
+ total: data.length,
+})
+
+const members = [
+ { id: 'account-1', name: 'Alice', status: 'active' },
+ { id: 'account-2', name: 'Bob', status: 'active' },
+ { id: 'account-pending', name: 'Pending member', status: 'pending' },
+].map((member) => ({
+ ...member,
+ avatar_url: null,
+ email: `${member.id}@example.test`,
+ role: 'normal' as const,
+}))
+
+const knowledgeList = () => page.getByRole('list', { name: 'dataset.knowledge' })
+const upgradeCards = (name: string) =>
+ knowledgeList().getByRole('listitem').filter({ hasText: name })
+const search = () => page.getByRole('searchbox', { name: 'common.operation.search' })
+const recoveryKeys = () => [
+ consoleQuery.knowledgeFs.spaces.get.key(),
+ consoleQuery.datasets.knowledgeFsUpgradeJobs.get.key(),
+ consoleQuery.datasets.get.key(),
+]
+const lastSpacesQuery = () => api.spaces.mock.calls.at(-1)?.[0]?.query
+
+async function setup({
+ searchParams = '',
+ ...options
+}: ConsoleQueryTestOptions & { searchParams?: string } = {}) {
+ const { wrapper: UrlState, onUrlUpdate } = createNuqsTestWrapper({
+ searchParams,
+ hasMemory: true,
+ })
+ const { queryClient, wrapper: QueryProvider } = createConsoleQueryWrapper({
+ accountProfile: { id: 'account-1' },
+ features: { enable_knowledge_fs: true },
+ knowledgeFsFeatures: { upload_enabled: true },
+ workspacePermissionKeys: ['dataset.create_and_management', 'dataset.external.connect'],
+ ...options,
+ })
+ const rendered = await render(
+ <QueryProvider>
+ <UrlState>
+ <KnowledgeUpgradeProvider onUpgradeStarted={() => {}}>
+ <NewKnowledgeList />
+ </KnowledgeUpgradeProvider>
+ </UrlState>
+ </QueryProvider>,
+ )
+ const refresh = (...queryKeys: readonly unknown[][]) =>
+ Promise.all(queryKeys.map((queryKey) => queryClient.invalidateQueries({ queryKey })))
+ return { ...rendered, queryClient, onUrlUpdate, refresh }
+}
+
+const lastSearchParams = (onUrlUpdate: Awaited<ReturnType<typeof setup>>['onUrlUpdate']) =>
+ onUrlUpdate.mock.calls.at(-1)?.[0].searchParams
+
+describe('NewKnowledgeList', () => {
+ beforeEach(async () => {
+ await page.viewport(1000, 760)
+ onTestFinished(guardUnexpectedFetch())
+ api.spaces.mockResolvedValue(spacesPage())
+ api.deleteSpace.mockResolvedValue({ result: 'success' })
+ api.members.mockResolvedValue({ accounts: members })
+ api.upgradeJobs.mockResolvedValue({ data: [] })
+ api.upgradeJob.mockImplementation(() => new Promise(() => {}))
+ api.datasets.mockResolvedValue(datasetsPage([]))
+ })
+
+ describe('collection', () => {
+ it('shows a loading state until the first page resolves', async () => {
+ api.spaces.mockReturnValue(new Promise(() => {}))
+ await setup()
+
+ await expect.element(page.getByRole('status', { name: 'common.loading' })).toBeInTheDocument()
+ })
+
+ it('links each knowledge space card to its detail shell with summary details', async () => {
+ api.spaces.mockResolvedValue(
+ spacesPage([
+ space('space-1', 'Support knowledge', {
+ linked_apps: 3,
+ tags: [
+ { id: 'tag-1', name: 'Customer support', type: 'knowledge' },
+ { id: 'tag-2', name: 'Public docs', type: 'knowledge' },
+ ],
+ technical_summary: {
+ description: 'Answers for customer support',
+ document_count: 12,
+ icon: 'builtin:camera',
+ knowledge_space_id: 'space-1',
+ name: 'Support knowledge',
+ revision: 1,
+ slug: 'support-knowledge',
+ },
+ }),
+ space('space-2', 'Engineering handbook'),
+ ]),
+ )
+ await setup()
+
+ const support = page.getByRole('link', { name: 'Support knowledge' })
+ const supportItem = knowledgeList().getByRole('listitem').filter({ has: support })
+ await expect.element(support).toHaveAttribute('href', '/datasets/new/space-1')
+ await expect
+ .element(support)
+ .toHaveAccessibleDescription(
+ 'Answers for customer support knowledgeOverview.overview.linkedApps: 3',
+ )
+ await expect
+ .element(supportItem.getByText('Answers for customer support'))
+ .toBeInTheDocument()
+ await expect.element(supportItem.getByText('12')).toBeInTheDocument()
+ await expect
+ .element(
+ supportItem.getByRole('combobox', {
+ name: 'Customer support, Public docs: Support knowledge',
+ }),
+ )
+ .toBeDisabled()
+ await expect
+ .element(page.getByRole('link', { name: 'Engineering handbook' }))
+ .toHaveAttribute('href', '/datasets/new/space-2')
+ await expect
+ .element(knowledgeList().getByText('knowledgeSpace.noDescription'))
+ .toBeInTheDocument()
+ expect(api.spaces).toHaveBeenCalledWith({ query: { limit: 30, page: 1 } })
+ })
+
+ it('loads the next server page while search is active', async () => {
+ const user = userEvent
+ api.spaces.mockImplementation(async (input) =>
+ input?.query?.page === 1
+ ? spacesPage([space('space-1', 'Support knowledge')], { hasMore: true })
+ : spacesPage([space('space-2', 'Support handbook')], { page: 2 }),
+ )
+ await setup()
+
+ await search().fill('support')
+ await vi.waitFor(() =>
+ expect(lastSpacesQuery()).toEqual({ limit: 30, page: 1, query: 'support' }),
+ )
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.loadMore' }))
+
+ await expect.element(page.getByRole('link', { name: 'Support handbook' })).toBeInTheDocument()
+ await expect.element(page.getByRole('link', { name: 'Support knowledge' })).toBeVisible()
+ expect(lastSpacesQuery()).toEqual({ limit: 30, page: 2, query: 'support' })
+ await expect
+ .element(page.getByRole('button', { name: 'knowledgeSpace.loadMore' }))
+ .not.toBeInTheDocument()
+ })
+
+ it('retries a failed next page from one inline action', async () => {
+ const user = userEvent
+ api.spaces
+ .mockResolvedValueOnce(
+ spacesPage([space('space-1', 'Support knowledge')], { hasMore: true }),
+ )
+ .mockRejectedValueOnce(new Error('request failed'))
+ .mockResolvedValueOnce(spacesPage([space('space-2', 'Engineering handbook')], { page: 2 }))
+ await setup()
+
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.loadMore' }))
+ const alert = page.getByRole('alert')
+ await user.click(alert.getByRole('button', { name: 'common.operation.retry' }))
+
+ await expect
+ .element(page.getByRole('link', { name: 'Engineering handbook' }))
+ .toBeInTheDocument()
+ })
+
+ it.each([404, 503])(
+ 'shows an unavailable state without retry for a %s response',
+ async (status) => {
+ api.spaces.mockRejectedValue(createHttpError(new Response(null, { status })))
+ await setup()
+
+ await expect.element(page.getByText('knowledgeSpace.unavailableTitle')).toBeInTheDocument()
+ await expect
+ .element(page.getByRole('button', { name: 'common.operation.retry' }))
+ .not.toBeInTheDocument()
+ },
+ )
+
+ it('retries other collection failures', async () => {
+ const user = userEvent
+ api.spaces
+ .mockRejectedValueOnce(new Error('request failed'))
+ .mockResolvedValueOnce(spacesPage([space('space-1', 'Support knowledge')]))
+ await setup()
+
+ await expect.element(page.getByText('knowledgeSpace.errorTitle')).toBeInTheDocument()
+ await user.click(page.getByRole('button', { name: 'common.operation.retry' }))
+
+ await expect
+ .element(page.getByRole('link', { name: 'Support knowledge' }))
+ .toBeInTheDocument()
+ })
+ })
+
+ describe('card actions', () => {
+ it('keeps card actions outside the link and opens edit settings', async () => {
+ const user = userEvent
+ api.spaces.mockResolvedValue(
+ spacesPage([
+ space('space-1', 'Support knowledge', {
+ permission_keys: [
+ 'knowledge_space_delete',
+ 'knowledge_space_edit',
+ 'knowledge_space_read',
+ ],
+ }),
+ ]),
+ )
+ await setup()
+
+ const cardLink = page.getByRole('link', { name: 'Support knowledge' })
+ const actions = page.getByRole('button', { name: 'common.operation.more' })
+ await expect.element(cardLink.getByRole('button')).not.toBeInTheDocument()
+
+ await user.click(actions)
+
+ await expect
+ .element(page.getByRole('menuitem', { name: 'common.operation.edit' }))
+ .toHaveAttribute('href', '/datasets/new/space-1/settings')
+ })
+
+ it('deletes after the exact name is confirmed and refreshes the collection', async () => {
+ const user = userEvent
+ api.spaces
+ .mockResolvedValueOnce(
+ spacesPage([
+ space('space-1', 'Support knowledge', {
+ permission_keys: ['knowledge_space_delete', 'knowledge_space_read'],
+ }),
+ ]),
+ )
+ .mockResolvedValue(spacesPage())
+ await setup()
+
+ await user.click(page.getByRole('button', { name: 'common.operation.more' }))
+ await user.click(page.getByRole('menuitem', { name: 'common.operation.delete' }))
+ const dialog = page.getByRole('alertdialog')
+ const confirmation = dialog.getByRole('textbox')
+ await expect.element(confirmation).toHaveFocus()
+ const deleteButton = dialog.getByRole('button', { name: 'common.operation.confirm' })
+
+ await user.type(confirmation, 'Support')
+ await expect.element(deleteButton).toBeDisabled()
+ await user.type(confirmation, ' knowledge')
+ await user.click(deleteButton)
+
+ await expect.element(dialog).not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('link', { name: 'Support knowledge' }))
+ .not.toBeInTheDocument()
+ await expect.element(page.getByRole('region', { name: 'knowledgeSpace.new' })).toHaveFocus()
+ expect(api.deleteSpace).toHaveBeenCalledWith({ params: { control_space_id: 'space-1' } })
+ })
+
+ it('keeps the confirmation open with the failure when deletion fails', async () => {
+ const user = userEvent
+ api.spaces.mockResolvedValue(
+ spacesPage([
+ space('space-1', 'Support knowledge', {
+ permission_keys: ['knowledge_space_delete', 'knowledge_space_read'],
+ }),
+ ]),
+ )
+ api.deleteSpace.mockRejectedValueOnce(new Error('network down'))
+ await setup()
+
+ await user.click(page.getByRole('button', { name: 'common.operation.more' }))
+ await user.click(page.getByRole('menuitem', { name: 'common.operation.delete' }))
+ const dialog = page.getByRole('alertdialog')
+ const confirmation = dialog.getByRole('textbox')
+ await confirmation.fill('Support knowledge')
+ await expect.element(confirmation).toHaveValue('Support knowledge')
+ await user.keyboard('{Enter}')
+
+ await expect.element(dialog.getByRole('alert')).toHaveTextContent('common.api.actionFailed')
+ await expect.element(confirmation).toHaveValue('Support knowledge')
+ await expect.element(dialog).toBeVisible()
+ })
+ })
+
+ describe('filters', () => {
+ it('syncs tag and search filters to the URL and collection request', async () => {
+ const user = userEvent
+ api.spaces.mockImplementation(async (input) =>
+ spacesPage([
+ input?.query?.query
+ ? space('search-result', 'Customer support search')
+ : input?.query?.tag_ids?.length
+ ? space('tagged-result', 'Tagged support knowledge')
+ : space('all-result', 'All knowledge'),
+ ]),
+ )
+ const { onUrlUpdate } = await setup()
+ await expect.element(page.getByRole('link', { name: 'All knowledge' })).toBeVisible()
+
+ await user.click(page.getByRole('combobox', { name: 'common.tag.placeholder' }))
+ await user.click(page.getByRole('option', { name: 'Customer support' }))
+ await user.click(page.getByRole('option', { name: 'Public docs' }))
+ await user.keyboard('{Escape}')
+
+ await vi.waitFor(() =>
+ expect(lastSearchParams(onUrlUpdate)?.get('tag_ids')).toBe('tag-1;tag-2'),
+ )
+ await vi.waitFor(() =>
+ expect(lastSpacesQuery()).toEqual({ limit: 30, page: 1, tag_ids: ['tag-1', 'tag-2'] }),
+ )
+
+ await expect
+ .element(page.getByRole('link', { name: 'Tagged support knowledge' }))
+ .toBeVisible()
+ await expect
+ .element(page.getByRole('link', { name: 'All knowledge' }))
+ .not.toBeInTheDocument()
+ await user.click(page.getByRole('button', { name: 'common.operation.clear' }))
+ await expect.element(page.getByRole('link', { name: 'All knowledge' })).toBeVisible()
+ await vi.waitFor(() => expect(lastSearchParams(onUrlUpdate)?.has('tag_ids')).toBe(false))
+
+ await search().fill('customer support')
+ await vi.waitFor(() =>
+ expect(lastSpacesQuery()).toEqual({ limit: 30, page: 1, query: 'customer support' }),
+ )
+ await expect
+ .element(page.getByRole('link', { name: 'Customer support search' }))
+ .toBeVisible()
+ await expect
+ .element(page.getByRole('link', { name: 'All knowledge' }))
+ .not.toBeInTheDocument()
+ expect(lastSearchParams(onUrlUpdate)?.get('query')).toBe('customer support')
+ })
+
+ it('restores filters from the URL into the collection request', async () => {
+ await setup({ searchParams: '?tag_ids=tag-1%3Btag-2&creator_ids=account-2' })
+
+ await vi.waitFor(() =>
+ expect(api.spaces).toHaveBeenCalledWith({
+ query: { creator_ids: ['account-2'], limit: 30, page: 1, tag_ids: ['tag-1', 'tag-2'] },
+ }),
+ )
+ await expect
+ .element(page.getByRole('combobox', { name: 'dataset.creatorFilter.creators: 1' }))
+ .toBeInTheDocument()
+ })
+
+ it('shows the no-results state for a restored search and clears it', async () => {
+ api.spaces.mockImplementation(async (input) =>
+ input?.query?.query ? spacesPage() : spacesPage([space('space-1', 'Support knowledge')]),
+ )
+ const { onUrlUpdate } = await setup({ searchParams: '?query=no%20matching%20knowledge' })
+
+ await expect.element(search()).toHaveValue('no matching knowledge')
+ await expect
+ .element(page.getByText('common.operation.noSearchResults:{"content":"dataset.knowledge"}'))
+ .toBeInTheDocument()
+
+ await page
+ .getByRole('button', { name: 'common.operation.clear', exact: true })
+ .filter({ hasText: 'common.operation.clear' })
+ .click()
+
+ await expect.element(search()).toHaveValue('')
+ await expect.element(page.getByRole('link', { name: 'Support knowledge' })).toBeVisible()
+ await vi.waitFor(() => expect(lastSearchParams(onUrlUpdate)?.has('query')).toBe(false))
+ })
+
+ it('filters by active creators and resets the filter', async () => {
+ const user = userEvent
+ const { onUrlUpdate } = await setup()
+
+ await user.click(page.getByRole('combobox', { name: 'dataset.creatorFilter.creators' }))
+ await user.click(page.getByRole('option', { name: /Alice/ }))
+ await user.click(page.getByRole('option', { name: /Bob/ }))
+
+ await expect
+ .element(page.getByRole('option', { name: /Pending member/ }))
+ .not.toBeInTheDocument()
+ await vi.waitFor(() =>
+ expect(lastSearchParams(onUrlUpdate)?.get('creator_ids')).toBe('account-1;account-2'),
+ )
+ await vi.waitFor(() =>
+ expect(lastSpacesQuery()).toEqual({
+ creator_ids: ['account-1', 'account-2'],
+ limit: 30,
+ page: 1,
+ }),
+ )
+
+ await user.click(page.getByRole('button', { name: 'app.studio.filters.reset' }))
+
+ await vi.waitFor(() => expect(lastSearchParams(onUrlUpdate)?.has('creator_ids')).toBe(false))
+ })
+
+ it('caps creator filters at the API contract limit', async () => {
+ const user = userEvent
+ const accounts = Array.from({ length: 101 }, (_, index) => ({
+ ...members[0]!,
+ id: `account-${index + 1}`,
+ name: `Member ${index + 1}`,
+ }))
+ api.members.mockResolvedValue({ accounts })
+ await setup({
+ searchParams: `?creator_ids=${accounts.map((account) => account.id).join(';')}`,
+ })
+
+ await user.click(page.getByRole('combobox', { name: 'dataset.creatorFilter.creators: 100' }))
+
+ const unselected = page.getByRole('option', { name: /Member 101/ })
+ await expect.element(unselected).toHaveAttribute('aria-disabled', 'true')
+ await expect
+ .element(unselected)
+ .toHaveAccessibleDescription('dataset.creatorFilter.maxCreators: 100')
+ expect(lastSpacesQuery()?.creator_ids).toHaveLength(100)
+ })
+
+ it('retries a failed members request while keeping cached creators', async () => {
+ const user = userEvent
+ const { refresh } = await setup()
+ await user.click(page.getByRole('combobox', { name: 'dataset.creatorFilter.creators' }))
+ await expect.element(page.getByRole('option', { name: /Alice/ })).toBeVisible()
+
+ api.members.mockRejectedValueOnce(new Error('request failed'))
+ await refresh(consoleQuery.workspaces.current.members.get.key())
+
+ await expect.element(page.getByRole('alert')).toMatchTextContent(/common\.error/)
+ await expect.element(page.getByRole('option', { name: /Alice/ })).toBeInTheDocument()
+ await user.click(page.getByRole('button', { name: 'common.operation.retry' }))
+ await expect.element(page.getByRole('alert')).not.toBeInTheDocument()
+ })
+ })
+
+ describe('empty workspace', () => {
+ it('links available creation modes', async () => {
+ await setup()
+
+ const connectSource = page.getByRole('link', {
+ name: 'knowledgeSpace.connectSource',
+ })
+ await expect
+ .element(connectSource)
+ .toHaveAttribute('href', '/datasets/new/create?start=source')
+ await expect
+ .element(connectSource)
+ .toHaveAccessibleDescription(
+ 'knowledgeSpace.connectSourceDescription dataset.firstEmpty.recommended',
+ )
+ await expect
+ .element(page.getByRole('link', { name: 'knowledgeSpace.uploadFiles' }))
+ .toHaveAttribute('href', '/datasets/new/create?start=upload')
+ await expect
+ .element(page.getByRole('link', { name: 'knowledgeSpace.startEmpty' }))
+ .toHaveAttribute('href', '/datasets/new/create?start=empty')
+ await expect
+ .element(page.getByRole('link', { name: 'common.operation.create' }))
+ .toHaveAttribute('href', '/datasets/new/create')
+ })
+
+ it('keeps upload unavailable when KnowledgeFS upload is disabled', async () => {
+ await setup({ knowledgeFsFeatures: { upload_enabled: false } })
+
+ const uploadFiles = page.getByRole('button', { name: 'knowledgeSpace.uploadFiles' })
+ await expect.element(uploadFiles).toBeDisabled()
+ await expect
+ .element(uploadFiles)
+ .toHaveAccessibleDescription(
+ 'knowledgeSpace.uploadFilesDescription dataset.cornerLabel.unavailable',
+ )
+ })
+
+ it.each([
+ ['external-connect only', ['dataset.external.connect']],
+ ['read-only', []],
+ ])('hides creation entries from %s users', async (_, workspacePermissionKeys) => {
+ await setup({ workspacePermissionKeys })
+
+ await expect.element(page.getByText('knowledgeSpace.readOnlyEmpty')).toBeInTheDocument()
+ await expect
+ .element(page.getByRole('link', { name: 'common.operation.create' }))
+ .not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('link', { name: 'knowledgeSpace.connectSource' }))
+ .not.toBeInTheDocument()
+ })
+ })
+
+ describe('upgrade recovery', () => {
+ it('restores upgrade cards from exact legacy dataset lookups', async () => {
+ const failed = job({ status: 'failed' })
+ api.upgradeJobs.mockResolvedValue({ data: [failed] })
+ api.datasets.mockResolvedValue(datasetsPage([legacyDataset(failed, { can_retry: true })]))
+ await setup()
+
+ const card = upgradeCards('Support knowledge')
+ await expect.element(card).toBeVisible()
+ await expect
+ .element(card.getByRole('button', { name: 'common.operation.retry' }))
+ .toBeInTheDocument()
+ expect(api.datasets).toHaveBeenCalledWith({ query: { ids: ['dataset-1'] } })
+ })
+
+ it('batches legacy dataset lookups and bounds failed-job recovery', async () => {
+ const jobs = [
+ ...Array.from({ length: 51 }, (_, index) =>
+ job({ id: `running-${index}`, old_dataset_id: `dataset-${index}` }),
+ ),
+ ...Array.from({ length: 101 }, (_, index) =>
+ job({
+ id: `failed-${index}`,
+ old_dataset_id: `failed-dataset-${index}`,
+ status: 'failed',
+ }),
+ ),
+ ]
+ api.upgradeJobs.mockResolvedValue({ data: jobs })
+ await setup()
+
+ await vi.waitFor(() => expect(api.datasets).toHaveBeenCalledTimes(4))
+ const batches = api.datasets.mock.calls.map(([input]) => input?.query?.ids ?? [])
+ expect(batches.every((ids) => ids.length <= 50)).toBe(true)
+ expect(batches.flat()).toEqual(jobs.slice(0, 151).map((item) => item.old_dataset_id))
+ })
+
+ it('keeps the empty workspace loading while upgrade datasets are restored', async () => {
+ api.upgradeJobs.mockResolvedValue({ data: [job()] })
+ const datasets = createDeferred<DatasetListResponse>()
+ api.datasets.mockReturnValue(datasets.promise)
+ await setup()
+
+ await vi.waitFor(() => expect(api.datasets).toHaveBeenCalled())
+ await expect.element(page.getByRole('status', { name: 'common.loading' })).toBeInTheDocument()
+ await expect.element(page.getByText('knowledgeSpace.emptyTitle')).not.toBeInTheDocument()
+ })
+
+ it('retries a failed upgrade recovery', async () => {
+ const user = userEvent
+ const running = job()
+ api.upgradeJobs.mockResolvedValue({ data: [running] })
+ api.datasets
+ .mockRejectedValueOnce(new Error('request failed'))
+ .mockResolvedValue(datasetsPage([legacyDataset(running)]))
+ await setup()
+
+ await expect
+ .element(page.getByRole('heading', { name: 'knowledgeSpace.errorTitle' }))
+ .toBeInTheDocument()
+ await user.click(page.getByRole('button', { name: 'common.operation.retry' }))
+
+ await expect.poll(() => upgradeCards('Support knowledge').elements().length).toBe(1)
+ })
+
+ it('keeps historical failures for one dataset distinct by job', async () => {
+ const older = job({ id: 'upgrade-1', status: 'failed' })
+ const newer = job({ id: 'upgrade-2', status: 'failed' })
+ api.upgradeJobs.mockResolvedValue({ data: [older, newer] })
+ api.datasets.mockResolvedValue(datasetsPage([legacyDataset(newer, { can_retry: true })]))
+ await setup()
+
+ await expect.poll(() => upgradeCards('Support knowledge').elements().length).toBe(2)
+ expect(api.datasets).toHaveBeenCalledWith({ query: { ids: ['dataset-1'] } })
+ })
+
+ it('offers retry for an older failure after a newer migration succeeds', async () => {
+ const failed = job({ id: 'upgrade-failed', status: 'failed' })
+ api.upgradeJobs.mockResolvedValue({ data: [failed] })
+ api.datasets.mockResolvedValue(
+ datasetsPage([
+ legacyDataset(
+ job({
+ id: 'upgrade-succeeded',
+ new_control_space_id: 'space-1',
+ stage: 'completed',
+ status: 'succeeded',
+ }),
+ { can_upgrade: true },
+ ),
+ ]),
+ )
+ await setup()
+
+ await expect
+ .element(page.getByRole('button', { name: 'common.operation.retry' }))
+ .toBeInTheDocument()
+ })
+
+ it('keeps server retry eligibility authoritative over a stale local upgrade', async () => {
+ const running = job()
+ const failed = job({ status: 'failed', last_error_message: 'The import failed' })
+ api.upgradeJobs.mockResolvedValue({ data: [running] })
+ api.datasets.mockResolvedValue(datasetsPage([legacyDataset(running)]))
+ const detail = createDeferred<KnowledgeFsUpgradeJobResponse>()
+ api.upgradeJob.mockReturnValue(detail.promise)
+ const { refresh } = await setup()
+ await expect.element(upgradeCards('Support knowledge')).toBeVisible()
+ api.upgradeJobs.mockResolvedValue({ data: [failed] })
+ api.datasets.mockResolvedValue(datasetsPage([legacyDataset(failed)]))
+ detail.resolve(failed)
+ await expect.element(page.getByText('The import failed')).toBeVisible()
+ await refresh(...recoveryKeys())
+ await expect.poll(() => upgradeCards('Support knowledge').elements().length).toBe(1)
+ await expect
+ .element(page.getByRole('button', { name: 'common.operation.retry' }))
+ .not.toBeInTheDocument()
+ })
+
+ it('hides a knowledge space behind its active upgrade card', async () => {
+ const running = job({ new_control_space_id: 'space-1' })
+ api.spaces.mockResolvedValue(spacesPage([space('space-1', 'space-1')]))
+ api.upgradeJobs.mockResolvedValue({ data: [running] })
+ api.datasets.mockResolvedValue(datasetsPage([legacyDataset(running)]))
+ await setup()
+
+ await expect.poll(() => upgradeCards('Support knowledge').elements().length).toBe(1)
+ await expect.element(page.getByRole('link', { name: 'space-1' })).not.toBeInTheDocument()
+ })
+
+ it('dismisses a completed local upgrade only after its space is visible and the job leaves recovery', async () => {
+ const running = job()
+ const succeeded = job({
+ completed_documents: 10,
+ new_control_space_id: 'space-1',
+ stage: 'completed',
+ status: 'succeeded',
+ })
+ api.upgradeJobs.mockResolvedValue({ data: [running] })
+ api.datasets.mockResolvedValue(datasetsPage([legacyDataset(running)]))
+ api.upgradeJob.mockResolvedValue(succeeded)
+ const { refresh } = await setup()
+ await expect
+ .element(page.getByRole('link', { name: 'Support knowledge' }))
+ .toHaveAttribute('href', '/datasets/new/space-1')
+
+ api.upgradeJobs.mockResolvedValue({ data: [] })
+ api.spaces.mockResolvedValue(spacesPage([space('space-2', 'Engineering handbook')]))
+ await refresh(...recoveryKeys())
+ // Wait for the new response to reach the DOM before checking retention of the old card.
+ await expect.element(page.getByRole('link', { name: 'Engineering handbook' })).toBeVisible()
+ await expect.element(page.getByRole('link', { name: 'Support knowledge' })).toBeVisible()
+ api.upgradeJobs.mockResolvedValue({ data: [running] })
+ api.spaces.mockResolvedValue(spacesPage([space('space-1', 'Upgraded knowledge')]))
+ await refresh(...recoveryKeys())
+ await expect.element(page.getByRole('link', { name: 'Upgraded knowledge' })).toBeVisible()
+ // A temporarily missing space must still retain the locally completed card while recovery owns the job.
+ api.spaces.mockResolvedValue(spacesPage())
+ await refresh(consoleQuery.knowledgeFs.spaces.get.key())
+ await expect.element(page.getByRole('link', { name: 'Support knowledge' })).toBeVisible()
+
+ api.spaces.mockResolvedValue(spacesPage([space('space-1', 'Upgraded knowledge')]))
+ api.upgradeJobs.mockResolvedValue({ data: [] })
+ await refresh(...recoveryKeys())
+ await expect.element(page.getByRole('link', { name: 'Upgraded knowledge' })).toBeVisible()
+ // After successful handoff, a collection refresh must not resurrect a dismissed local card.
+ api.spaces.mockResolvedValue(spacesPage())
+ await refresh(consoleQuery.knowledgeFs.spaces.get.key())
+ await expect.element(page.getByText('knowledgeSpace.emptyTitle')).toBeVisible()
+ await expect
+ .element(page.getByRole('link', { name: 'Support knowledge' }))
+ .not.toBeInTheDocument()
+ })
+ })
+})
diff --git a/web/features/new-rag/list/__tests__/new-knowledge-list.spec.tsx b/web/features/new-rag/list/__tests__/new-knowledge-list.spec.tsx
deleted file mode 100644
index bac59becf4f..00000000000
--- a/web/features/new-rag/list/__tests__/new-knowledge-list.spec.tsx
+++ /dev/null
@@ -1,737 +0,0 @@
-import type { KnowledgeFsUpgradeJobResponse } from '@dify/contracts/api/console/datasets/types.gen'
-import type { ReactElement } from 'react'
-import type { KnowledgeUpgrade } from '../../upgrade/knowledge-upgrade-context-value'
-import type { consoleClient } from '@/service/console'
-import type { ConsoleQueryTestOptions } from '@/test/console/query-data'
-import { act, screen, waitFor, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { consoleQuery } from '@/service/console'
-import { createHttpError } from '@/service/http-error'
-import { renderWithConsoleQuery } from '@/test/console/query-data'
-import { createDeferred } from '@/test/deferred'
-import { createDatasetFixture } from '@/test/fixtures/dataset'
-import { createNuqsTestWrapper } from '@/test/nuqs-testing'
-import { KnowledgeUpgradeContext } from '../../upgrade/knowledge-upgrade-context-value'
-import { NewKnowledgeList } from '../new-knowledge-list'
-
-const api = vi.hoisted(() => ({
- spaces: vi.fn<typeof consoleClient.knowledgeFs.spaces.get>(),
- deleteSpace: vi.fn<typeof consoleClient.knowledgeFs.spaces.byControlSpaceId.delete>(),
- members: vi.fn<typeof consoleClient.workspaces.current.members.get>(),
- upgradeJobs: vi.fn<typeof consoleClient.datasets.knowledgeFsUpgradeJobs.get>(),
- datasets: vi.fn<typeof consoleClient.datasets.get>(),
- push: vi.fn(),
- toast: { error: vi.fn(), info: vi.fn(), success: vi.fn() },
-}))
-
-vi.mock('@/app/notifications', () => ({ toast: api.toast }))
-vi.mock('@/next/navigation', async (importOriginal) => ({
- ...(await importOriginal<typeof import('@/next/navigation')>()),
- useRouter: () => ({ push: api.push }),
-}))
-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.get': api.spaces,
- 'knowledgeFs.spaces.byControlSpaceId.delete': api.deleteSpace,
- 'workspaces.current.members.get': api.members,
- 'datasets.knowledgeFsUpgradeJobs.get': api.upgradeJobs,
- 'datasets.get': api.datasets,
- 'datasets.byDatasetId.knowledgeFsUpgrades.byJobId.get': () => new Promise(() => {}),
- 'datasets.apiBaseInfo.get': async () => ({ api_base_url: 'https://api.example.com' }),
- 'datasets.externalKnowledgeApi.get': async () => ({
- data: [],
- has_more: false,
- limit: 100,
- page: 1,
- total: 0,
- }),
- 'tags.get': async () => [
- { binding_count: '1', id: 'tag-1', name: 'Customer support', type: 'knowledge' },
- { binding_count: '1', id: 'tag-2', name: 'Public docs', type: 'knowledge' },
- ],
- }),
- }
-})
-
-type KnowledgeFsSpaceListResponse = Awaited<ReturnType<typeof consoleClient.knowledgeFs.spaces.get>>
-type KnowledgeFsSpaceListItemResponse = KnowledgeFsSpaceListResponse['data'][number]
-type DatasetListResponse = Awaited<ReturnType<typeof consoleClient.datasets.get>>
-
-const space = (
- id: string,
- name: string,
- overrides: Partial<KnowledgeFsSpaceListItemResponse> = {},
-): KnowledgeFsSpaceListItemResponse => ({
- control_space_id: id,
- created_at: '2026-07-15T00:00:00Z',
- knowledge_space_id: id,
- linked_apps: 0,
- owner_account_id: 'account-1',
- permission_keys: ['knowledge_space_read'],
- resource_version: 1,
- state: 'active',
- technical_status: 'available',
- technical_summary: {
- description: null,
- document_count: 0,
- icon: null,
- knowledge_space_id: id,
- name,
- revision: 1,
- slug: id,
- },
- updated_at: '2026-07-18T00:00:00Z',
- visibility: 'only_me',
- ...overrides,
-})
-
-const spacesPage = (
- data: KnowledgeFsSpaceListItemResponse[] = [],
- { page = 1, hasMore = false } = {},
-): KnowledgeFsSpaceListResponse => ({ data, has_more: hasMore, limit: 30, page })
-
-const job = (
- overrides: Partial<KnowledgeFsUpgradeJobResponse> = {},
-): KnowledgeFsUpgradeJobResponse => ({
- completed_documents: 4,
- completed_sources: 1,
- id: 'upgrade-1',
- old_dataset_id: 'dataset-1',
- snapshot_at: '2026-08-18T00:00:00Z',
- stage: 'submitting_documents',
- status: 'running',
- total_documents: 10,
- total_sources: 1,
- ...overrides,
-})
-
-const legacyDataset = (
- latestJob: KnowledgeFsUpgradeJobResponse,
- discovery: { can_retry?: boolean; can_upgrade?: boolean } = {},
-) => ({
- ...createDatasetFixture({ id: latestJob.old_dataset_id, name: 'Support knowledge' }),
- knowledge_fs_upgrade: {
- can_retry: false,
- can_upgrade: false,
- ...discovery,
- job: latestJob,
- },
-})
-
-const datasetsPage = (data: DatasetListResponse['data']): DatasetListResponse => ({
- data,
- has_more: false,
- limit: 50,
- page: 1,
- total: data.length,
-})
-
-const members = [
- { id: 'account-1', name: 'Alice', status: 'active' },
- { id: 'account-2', name: 'Bob', status: 'active' },
- { id: 'account-pending', name: 'Pending member', status: 'pending' },
-].map((member) => ({
- ...member,
- avatar_url: null,
- email: `${member.id}@example.test`,
- role: 'normal' as const,
-}))
-
-const knowledgeList = () => screen.getByRole('list', { name: 'dataset.knowledge' })
-const upgradeCards = (name: string) =>
- within(knowledgeList())
- .getAllByRole('listitem')
- .filter((item) => within(item).queryByText(name))
-const search = () => screen.getByRole('searchbox', { name: 'common.operation.search' })
-const recoveryKeys = () => [
- consoleQuery.knowledgeFs.spaces.get.key(),
- consoleQuery.datasets.knowledgeFsUpgradeJobs.get.key(),
- consoleQuery.datasets.get.key(),
-]
-const lastSpacesQuery = () => api.spaces.mock.calls.at(-1)?.[0]?.query
-
-function setup({
- searchParams = '',
- upgrades = [],
- ...options
-}: ConsoleQueryTestOptions & { searchParams?: string; upgrades?: KnowledgeUpgrade[] } = {}) {
- const { wrapper: UrlState, onUrlUpdate } = createNuqsTestWrapper({
- searchParams,
- hasMemory: true,
- })
- const dismissUpgrade = vi.fn()
- const ui = (): ReactElement => (
- <UrlState>
- <KnowledgeUpgradeContext
- value={{
- dismissUpgrade,
- enabled: true,
- requestUpgrade: vi.fn(),
- settleUpgrade: vi.fn(),
- upgrades,
- }}
- >
- <NewKnowledgeList />
- </KnowledgeUpgradeContext>
- </UrlState>
- )
- const rendered = renderWithConsoleQuery(ui(), {
- accountProfile: { id: 'account-1' },
- features: { enable_knowledge_fs: true },
- knowledgeFsFeatures: { upload_enabled: true },
- workspacePermissionKeys: ['dataset.create_and_management', 'dataset.external.connect'],
- ...options,
- })
- const refresh = (...queryKeys: readonly unknown[][]) =>
- act(() =>
- Promise.all(
- queryKeys.map((queryKey) => rendered.queryClient.invalidateQueries({ queryKey })),
- ).then(() => undefined),
- )
- return { ...rendered, dismissUpgrade, onUrlUpdate, refresh }
-}
-
-const lastSearchParams = (onUrlUpdate: ReturnType<typeof setup>['onUrlUpdate']) =>
- onUrlUpdate.mock.calls.at(-1)?.[0].searchParams
-
-describe('NewKnowledgeList', () => {
- beforeEach(() => {
- api.spaces.mockResolvedValue(spacesPage())
- api.deleteSpace.mockResolvedValue({ result: 'success' })
- api.members.mockResolvedValue({ accounts: members })
- api.upgradeJobs.mockResolvedValue({ data: [] })
- api.datasets.mockResolvedValue(datasetsPage([]))
- })
-
- describe('collection', () => {
- it('shows a loading state until the first page resolves', () => {
- api.spaces.mockReturnValue(new Promise(() => {}))
- setup()
-
- expect(screen.getByRole('status', { name: 'common.loading' })).toBeInTheDocument()
- })
-
- it('links each knowledge space card to its detail shell with summary details', async () => {
- api.spaces.mockResolvedValue(
- spacesPage([
- space('space-1', 'Support knowledge', {
- linked_apps: 3,
- tags: [
- { id: 'tag-1', name: 'Customer support', type: 'knowledge' },
- { id: 'tag-2', name: 'Public docs', type: 'knowledge' },
- ],
- technical_summary: {
- description: 'Answers for customer support',
- document_count: 12,
- icon: 'builtin:camera',
- knowledge_space_id: 'space-1',
- name: 'Support knowledge',
- revision: 1,
- slug: 'support-knowledge',
- },
- }),
- space('space-2', 'Engineering handbook'),
- ]),
- )
- setup()
-
- const support = await screen.findByRole('link', { name: 'Support knowledge' })
- const supportItem = support.closest('li')!
- expect(support).toHaveAttribute('href', '/datasets/new/space-1')
- expect(support).toHaveAccessibleDescription(
- 'Answers for customer support knowledgeOverview.overview.linkedApps: 3',
- )
- expect(within(support).getByTitle('camera')).toBeInTheDocument()
- expect(within(supportItem).getByText('Answers for customer support')).toBeInTheDocument()
- expect(within(supportItem).getByText('12')).toBeInTheDocument()
- expect(
- within(supportItem).getByRole('combobox', {
- name: 'Customer support, Public docs: Support knowledge',
- }),
- ).toBeDisabled()
- expect(screen.getByRole('link', { name: 'Engineering handbook' })).toHaveAttribute(
- 'href',
- '/datasets/new/space-2',
- )
- expect(within(knowledgeList()).getByText('knowledgeSpace.noDescription')).toBeInTheDocument()
- expect(api.spaces).toHaveBeenCalledWith({ query: { limit: 30, page: 1 } })
- })
-
- it('loads the next server page while search is active', async () => {
- const user = userEvent.setup()
- api.spaces.mockImplementation(async (input) =>
- input?.query?.page === 1
- ? spacesPage([space('space-1', 'Support knowledge')], { hasMore: true })
- : spacesPage([space('space-2', 'Support handbook')], { page: 2 }),
- )
- setup()
-
- await user.type(search(), 'support')
- await waitFor(() =>
- expect(lastSpacesQuery()).toEqual({ limit: 30, page: 1, query: 'support' }),
- )
- await user.click(await screen.findByRole('button', { name: 'knowledgeSpace.loadMore' }))
-
- expect(await screen.findByRole('link', { name: 'Support handbook' })).toBeInTheDocument()
- expect(lastSpacesQuery()).toEqual({ limit: 30, page: 2, query: 'support' })
- expect(
- screen.queryByRole('button', { name: 'knowledgeSpace.loadMore' }),
- ).not.toBeInTheDocument()
- })
-
- it('retries a failed next page from one inline action', async () => {
- const user = userEvent.setup()
- api.spaces
- .mockResolvedValueOnce(
- spacesPage([space('space-1', 'Support knowledge')], { hasMore: true }),
- )
- .mockRejectedValueOnce(new Error('request failed'))
- .mockResolvedValueOnce(spacesPage([space('space-2', 'Engineering handbook')], { page: 2 }))
- setup()
-
- await user.click(await screen.findByRole('button', { name: 'knowledgeSpace.loadMore' }))
- const alert = await screen.findByRole('alert')
- await user.click(within(alert).getByRole('button', { name: 'common.operation.retry' }))
-
- expect(await screen.findByRole('link', { name: 'Engineering handbook' })).toBeInTheDocument()
- })
-
- it.each([404, 503])(
- 'shows an unavailable state without retry for a %s response',
- async (status) => {
- api.spaces.mockRejectedValue(createHttpError(new Response(null, { status })))
- setup()
-
- expect(await screen.findByText('knowledgeSpace.unavailableTitle')).toBeInTheDocument()
- expect(
- screen.queryByRole('button', { name: 'common.operation.retry' }),
- ).not.toBeInTheDocument()
- },
- )
-
- it('retries other collection failures', async () => {
- const user = userEvent.setup()
- api.spaces
- .mockRejectedValueOnce(new Error('request failed'))
- .mockResolvedValueOnce(spacesPage([space('space-1', 'Support knowledge')]))
- setup()
-
- expect(await screen.findByText('knowledgeSpace.errorTitle')).toBeInTheDocument()
- await user.click(screen.getByRole('button', { name: 'common.operation.retry' }))
-
- expect(await screen.findByRole('link', { name: 'Support knowledge' })).toBeInTheDocument()
- })
- })
-
- describe('card actions', () => {
- it('keeps card actions outside the link and opens edit settings', async () => {
- const user = userEvent.setup()
- api.spaces.mockResolvedValue(
- spacesPage([
- space('space-1', 'Support knowledge', {
- permission_keys: [
- 'knowledge_space_delete',
- 'knowledge_space_edit',
- 'knowledge_space_read',
- ],
- }),
- ]),
- )
- setup()
-
- const cardLink = await screen.findByRole('link', { name: 'Support knowledge' })
- const actions = screen.getByRole('button', { name: 'common.operation.more' })
- expect(cardLink).not.toContainElement(actions)
-
- await user.click(actions)
-
- expect(screen.getByRole('menuitem', { name: 'common.operation.edit' })).toHaveAttribute(
- 'href',
- '/datasets/new/space-1/settings',
- )
- })
-
- it('deletes after the exact name is confirmed and refreshes the collection', async () => {
- const user = userEvent.setup()
- api.spaces
- .mockResolvedValueOnce(
- spacesPage([
- space('space-1', 'Support knowledge', {
- permission_keys: ['knowledge_space_delete', 'knowledge_space_read'],
- }),
- ]),
- )
- .mockResolvedValue(spacesPage())
- setup()
-
- await user.click(await screen.findByRole('button', { name: 'common.operation.more' }))
- await user.click(screen.getByRole('menuitem', { name: 'common.operation.delete' }))
- const dialog = await screen.findByRole('alertdialog')
- const confirmation = within(dialog).getByRole('textbox')
- expect(confirmation).toHaveFocus()
- const deleteButton = within(dialog).getByRole('button', { name: 'common.operation.confirm' })
-
- await user.type(confirmation, 'Support')
- expect(deleteButton).toBeDisabled()
- await user.type(confirmation, ' knowledge')
- await user.click(deleteButton)
-
- await waitFor(() =>
- expect(screen.queryByRole('link', { name: 'Support knowledge' })).not.toBeInTheDocument(),
- )
- expect(api.deleteSpace).toHaveBeenCalledWith({ params: { control_space_id: 'space-1' } })
- })
-
- it('keeps the confirmation open with the failure when deletion fails', async () => {
- const user = userEvent.setup()
- api.spaces.mockResolvedValue(
- spacesPage([
- space('space-1', 'Support knowledge', {
- permission_keys: ['knowledge_space_delete', 'knowledge_space_read'],
- }),
- ]),
- )
- api.deleteSpace.mockRejectedValueOnce(new Error('network down'))
- setup()
-
- await user.click(await screen.findByRole('button', { name: 'common.operation.more' }))
- await user.click(screen.getByRole('menuitem', { name: 'common.operation.delete' }))
- const dialog = await screen.findByRole('alertdialog')
- const confirmation = within(dialog).getByRole('textbox')
- await user.type(confirmation, 'Support knowledge{Enter}')
-
- expect(await within(dialog).findByRole('alert')).toHaveTextContent('common.api.actionFailed')
- expect(confirmation).toHaveValue('Support knowledge')
- expect(
- screen.getByRole('link', { name: 'Support knowledge', hidden: true }),
- ).toBeInTheDocument()
- })
- })
-
- describe('filters', () => {
- it('syncs tag and search filters to the URL and collection request', async () => {
- const user = userEvent.setup()
- const { onUrlUpdate } = setup()
-
- await user.click(await screen.findByRole('combobox', { name: 'common.tag.placeholder' }))
- await user.click(await screen.findByRole('option', { name: 'Customer support' }))
- await user.click(screen.getByRole('option', { name: 'Public docs' }))
- await user.keyboard('{Escape}')
-
- await waitFor(() => expect(lastSearchParams(onUrlUpdate)?.get('tag_ids')).toBe('tag-1;tag-2'))
- await waitFor(() =>
- expect(lastSpacesQuery()).toEqual({ limit: 30, page: 1, tag_ids: ['tag-1', 'tag-2'] }),
- )
-
- await user.click(screen.getByRole('button', { name: 'common.operation.clear' }))
- await waitFor(() => expect(lastSearchParams(onUrlUpdate)?.has('tag_ids')).toBe(false))
-
- await user.type(search(), 'customer support')
- await waitFor(() =>
- expect(lastSpacesQuery()).toEqual({ limit: 30, page: 1, query: 'customer support' }),
- )
- expect(lastSearchParams(onUrlUpdate)?.get('query')).toBe('customer support')
- })
-
- it('restores filters from the URL into the collection request', async () => {
- setup({ searchParams: '?tag_ids=tag-1%3Btag-2&creator_ids=account-2' })
-
- await waitFor(() =>
- expect(api.spaces).toHaveBeenCalledWith({
- query: { creator_ids: ['account-2'], limit: 30, page: 1, tag_ids: ['tag-1', 'tag-2'] },
- }),
- )
- expect(
- screen.getByRole('combobox', { name: 'dataset.creatorFilter.creators: 1' }),
- ).toBeInTheDocument()
- })
-
- it('shows the no-results state for a restored search and clears it', async () => {
- const user = userEvent.setup()
- const { onUrlUpdate } = setup({ searchParams: '?query=no%20matching%20knowledge' })
-
- expect(search()).toHaveValue('no matching knowledge')
- expect(
- await screen.findByText('common.operation.noSearchResults:{"content":"dataset.knowledge"}'),
- ).toBeInTheDocument()
-
- await user.click(screen.getByText('common.operation.clear', { selector: 'button' }))
-
- expect(search()).toHaveValue('')
- await waitFor(() => expect(lastSearchParams(onUrlUpdate)?.has('query')).toBe(false))
- })
-
- it('filters by active creators and resets the filter', async () => {
- const user = userEvent.setup()
- const { onUrlUpdate } = setup()
-
- await user.click(screen.getByRole('combobox', { name: 'dataset.creatorFilter.creators' }))
- await user.click(await screen.findByRole('option', { name: /Alice/ }))
- await user.click(screen.getByRole('option', { name: /Bob/ }))
-
- expect(screen.queryByRole('option', { name: /Pending member/ })).not.toBeInTheDocument()
- await waitFor(() =>
- expect(lastSearchParams(onUrlUpdate)?.get('creator_ids')).toBe('account-1;account-2'),
- )
- await waitFor(() =>
- expect(lastSpacesQuery()).toEqual({
- creator_ids: ['account-1', 'account-2'],
- limit: 30,
- page: 1,
- }),
- )
-
- await user.click(screen.getByRole('button', { name: 'app.studio.filters.reset' }))
-
- await waitFor(() => expect(lastSearchParams(onUrlUpdate)?.has('creator_ids')).toBe(false))
- })
-
- it('caps creator filters at the API contract limit', async () => {
- const user = userEvent.setup()
- const accounts = Array.from({ length: 101 }, (_, index) => ({
- ...members[0]!,
- id: `account-${index + 1}`,
- name: `Member ${index + 1}`,
- }))
- api.members.mockResolvedValue({ accounts })
- setup({ searchParams: `?creator_ids=${accounts.map((account) => account.id).join(';')}` })
-
- await user.click(
- screen.getByRole('combobox', { name: 'dataset.creatorFilter.creators: 100' }),
- )
-
- const unselected = await screen.findByRole('option', { name: /Member 101/ })
- expect(unselected).toHaveAttribute('aria-disabled', 'true')
- expect(unselected).toHaveAccessibleDescription('dataset.creatorFilter.maxCreators: 100')
- expect(lastSpacesQuery()?.creator_ids).toHaveLength(100)
- })
-
- it('retries a failed members request while keeping cached creators', async () => {
- const user = userEvent.setup()
- const { refresh } = setup()
- await user.click(screen.getByRole('combobox', { name: 'dataset.creatorFilter.creators' }))
- await screen.findByRole('option', { name: /Alice/ })
-
- api.members.mockRejectedValueOnce(new Error('request failed'))
- await refresh(consoleQuery.workspaces.current.members.get.key())
-
- expect(await screen.findByRole('alert')).toHaveTextContent('common.error')
- expect(screen.getByRole('option', { name: /Alice/ })).toBeInTheDocument()
- await user.click(screen.getByRole('button', { name: 'common.operation.retry' }))
- await waitFor(() => expect(screen.queryByRole('alert')).not.toBeInTheDocument())
- })
- })
-
- describe('empty workspace', () => {
- it('links available creation modes', async () => {
- setup()
-
- const connectSource = await screen.findByRole('link', {
- name: 'knowledgeSpace.connectSource',
- })
- expect(connectSource).toHaveAttribute('href', '/datasets/new/create?start=source')
- expect(connectSource).toHaveAccessibleDescription(
- 'knowledgeSpace.connectSourceDescription dataset.firstEmpty.recommended',
- )
- expect(screen.getByRole('link', { name: 'knowledgeSpace.uploadFiles' })).toHaveAttribute(
- 'href',
- '/datasets/new/create?start=upload',
- )
- expect(screen.getByRole('link', { name: 'knowledgeSpace.startEmpty' })).toHaveAttribute(
- 'href',
- '/datasets/new/create?start=empty',
- )
- expect(screen.getByRole('link', { name: 'common.operation.create' })).toHaveAttribute(
- 'href',
- '/datasets/new/create',
- )
- })
-
- it('keeps upload unavailable when KnowledgeFS upload is disabled', async () => {
- setup({ knowledgeFsFeatures: { upload_enabled: false } })
-
- const uploadFiles = await screen.findByRole('button', { name: 'knowledgeSpace.uploadFiles' })
- expect(uploadFiles).toBeDisabled()
- expect(uploadFiles).toHaveAccessibleDescription(
- 'knowledgeSpace.uploadFilesDescription dataset.cornerLabel.unavailable',
- )
- })
-
- it.each([
- ['external-connect only', ['dataset.external.connect']],
- ['read-only', []],
- ])('hides creation entries from %s users', async (_, workspacePermissionKeys) => {
- setup({ workspacePermissionKeys })
-
- expect(await screen.findByText('knowledgeSpace.readOnlyEmpty')).toBeInTheDocument()
- expect(
- screen.queryByRole('link', { name: 'common.operation.create' }),
- ).not.toBeInTheDocument()
- expect(
- screen.queryByRole('link', { name: 'knowledgeSpace.connectSource' }),
- ).not.toBeInTheDocument()
- })
- })
-
- describe('upgrade recovery', () => {
- it('restores upgrade cards from exact legacy dataset lookups', async () => {
- const failed = job({ status: 'failed' })
- api.upgradeJobs.mockResolvedValue({ data: [failed] })
- api.datasets.mockResolvedValue(datasetsPage([legacyDataset(failed, { can_retry: true })]))
- setup()
-
- const [card] = await waitFor(() => {
- const cards = upgradeCards('Support knowledge')
- expect(cards).toHaveLength(1)
- return cards
- })
- expect(
- within(card!).getByRole('button', { name: 'common.operation.retry' }),
- ).toBeInTheDocument()
- expect(api.datasets).toHaveBeenCalledWith({ query: { ids: ['dataset-1'] } })
- })
-
- it('batches legacy dataset lookups and bounds failed-job recovery', async () => {
- const jobs = [
- ...Array.from({ length: 51 }, (_, index) =>
- job({ id: `running-${index}`, old_dataset_id: `dataset-${index}` }),
- ),
- ...Array.from({ length: 101 }, (_, index) =>
- job({
- id: `failed-${index}`,
- old_dataset_id: `failed-dataset-${index}`,
- status: 'failed',
- }),
- ),
- ]
- api.upgradeJobs.mockResolvedValue({ data: jobs })
- setup()
-
- await waitFor(() => expect(api.datasets).toHaveBeenCalledTimes(4))
- const batches = api.datasets.mock.calls.map(([input]) => input?.query?.ids ?? [])
- expect(batches.every((ids) => ids.length <= 50)).toBe(true)
- expect(batches.flat()).toEqual(jobs.slice(0, 151).map((item) => item.old_dataset_id))
- })
-
- it('keeps the empty workspace loading while upgrade datasets are restored', async () => {
- api.upgradeJobs.mockResolvedValue({ data: [job()] })
- const datasets = createDeferred<DatasetListResponse>()
- api.datasets.mockReturnValue(datasets.promise)
- setup()
-
- await waitFor(() => expect(api.datasets).toHaveBeenCalled())
- expect(screen.getByRole('status', { name: 'common.loading' })).toBeInTheDocument()
- expect(screen.queryByText('knowledgeSpace.emptyTitle')).not.toBeInTheDocument()
- })
-
- it('retries a failed upgrade recovery', async () => {
- const user = userEvent.setup()
- const running = job()
- api.upgradeJobs.mockResolvedValue({ data: [running] })
- api.datasets
- .mockRejectedValueOnce(new Error('request failed'))
- .mockResolvedValue(datasetsPage([legacyDataset(running)]))
- setup()
-
- expect(
- await screen.findByRole('heading', { name: 'knowledgeSpace.errorTitle' }),
- ).toBeInTheDocument()
- await user.click(screen.getByRole('button', { name: 'common.operation.retry' }))
-
- await waitFor(() => expect(upgradeCards('Support knowledge')).toHaveLength(1))
- })
-
- it('keeps historical failures for one dataset distinct by job', async () => {
- const older = job({ id: 'upgrade-1', status: 'failed' })
- const newer = job({ id: 'upgrade-2', status: 'failed' })
- api.upgradeJobs.mockResolvedValue({ data: [older, newer] })
- api.datasets.mockResolvedValue(datasetsPage([legacyDataset(newer, { can_retry: true })]))
- setup()
-
- await waitFor(() => expect(upgradeCards('Support knowledge')).toHaveLength(2))
- expect(api.datasets).toHaveBeenCalledWith({ query: { ids: ['dataset-1'] } })
- })
-
- it('offers retry for an older failure after a newer migration succeeds', async () => {
- const failed = job({ id: 'upgrade-failed', status: 'failed' })
- api.upgradeJobs.mockResolvedValue({ data: [failed] })
- api.datasets.mockResolvedValue(
- datasetsPage([
- legacyDataset(
- job({
- id: 'upgrade-succeeded',
- new_control_space_id: 'space-1',
- stage: 'completed',
- status: 'succeeded',
- }),
- { can_upgrade: true },
- ),
- ]),
- )
- setup()
-
- expect(
- await screen.findByRole('button', { name: 'common.operation.retry' }),
- ).toBeInTheDocument()
- })
-
- it('keeps server retry eligibility authoritative over a stale local upgrade', async () => {
- const failed = job({ status: 'failed' })
- const dataset = legacyDataset(failed)
- api.upgradeJobs.mockResolvedValue({ data: [failed] })
- api.datasets.mockResolvedValue(datasetsPage([dataset]))
- setup({ upgrades: [{ canRetry: true, dataset, job: failed }] })
-
- await waitFor(() => expect(upgradeCards('Support knowledge')).toHaveLength(1))
- expect(
- screen.queryByRole('button', { name: 'common.operation.retry' }),
- ).not.toBeInTheDocument()
- })
-
- it('hides a knowledge space behind its active upgrade card', async () => {
- const running = job({ new_control_space_id: 'space-1' })
- api.spaces.mockResolvedValue(spacesPage([space('space-1', 'space-1')]))
- api.upgradeJobs.mockResolvedValue({ data: [running] })
- api.datasets.mockResolvedValue(datasetsPage([legacyDataset(running)]))
- setup()
-
- await waitFor(() => expect(upgradeCards('Support knowledge')).toHaveLength(1))
- expect(screen.queryByRole('link', { name: 'space-1' })).not.toBeInTheDocument()
- })
-
- it('dismisses a completed local upgrade only after its space is visible and the job leaves recovery', async () => {
- const succeeded = job({
- completed_documents: 10,
- new_control_space_id: 'space-1',
- stage: 'completed',
- status: 'succeeded',
- })
- const dataset = legacyDataset(succeeded)
- const { dismissUpgrade, refresh } = setup({
- upgrades: [{ canRetry: false, dataset, job: succeeded }],
- })
-
- expect(await screen.findByRole('link', { name: 'Support knowledge' })).toHaveAttribute(
- 'href',
- '/datasets/new/space-1',
- )
-
- api.spaces.mockResolvedValue(spacesPage([space('space-1', 'Upgraded knowledge')]))
- api.upgradeJobs.mockResolvedValue({ data: [{ ...succeeded, status: 'running' }] })
- api.datasets.mockResolvedValue(datasetsPage([dataset]))
- await refresh(...recoveryKeys())
-
- expect(await screen.findByRole('link', { name: 'Upgraded knowledge' })).toBeInTheDocument()
- expect(dismissUpgrade).not.toHaveBeenCalled()
-
- api.upgradeJobs.mockResolvedValue({ data: [] })
- await refresh(...recoveryKeys())
-
- await waitFor(() => expect(dismissUpgrade).toHaveBeenCalledWith('upgrade-1'))
- })
- })
-})
diff --git a/web/features/new-rag/sources/create/__tests__/crawl-selection-form.browser.spec.tsx b/web/features/new-rag/sources/create/__tests__/crawl-selection-form.browser.spec.tsx
new file mode 100644
index 00000000000..f644df4b863
--- /dev/null
+++ b/web/features/new-rag/sources/create/__tests__/crawl-selection-form.browser.spec.tsx
@@ -0,0 +1,408 @@
+import type { KnowledgeFsSettingsResponse } from '@dify/contracts/api/console/knowledge-fs/types.gen'
+import type { SyncPolicyValue } from '../../setup/sync-policy-field'
+import type { Source, SourceWorkflowRun } from '../../source-models'
+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 { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { CrawlSelectionForm } from '../crawl-selection-form'
+
+const clientMock = vi.hoisted(() => ({ asyncImport: vi.fn() }))
+const routerMock = vi.hoisted(() => ({ push: vi.fn() }))
+const settingsState = vi.hoisted(() => ({
+ configurationState: 'active' as 'active' | 'setup-required',
+}))
+
+const workflowApiResponse = vi.hoisted(() => (workflow: SourceWorkflowRun) => ({
+ canceled_at: workflow.canceledAt ?? null,
+ checkpoint: workflow.checkpoint,
+ completed_at: workflow.completedAt ?? null,
+ created_at: workflow.createdAt,
+ cursor: workflow.cursor ?? null,
+ execution_attempts: workflow.executionAttempts,
+ id: workflow.id,
+ knowledge_space_id: workflow.knowledgeSpaceId,
+ kind: workflow.kind,
+ last_error_code: workflow.lastErrorCode ?? null,
+ max_execution_attempts: workflow.maxExecutionAttempts,
+ progress_completed: workflow.progressCompleted,
+ progress_failed: workflow.progressFailed,
+ progress_skipped: workflow.progressSkipped,
+ progress_total: workflow.progressTotal ?? null,
+ source_id: workflow.sourceId ?? null,
+ state: workflow.state,
+ updated_at: workflow.updatedAt,
+}))
+
+const settingsResponse = vi.hoisted(() => (): KnowledgeFsSettingsResponse => {
+ const active = settingsState.configurationState === 'active'
+ return {
+ active_profile_available: active,
+ active_profile_revisions: active ? { embedding: 1, retrieval: 1 } : {},
+ capabilities: {
+ deep: active,
+ index: active,
+ ingest: active,
+ query: active,
+ research: active,
+ source_sync: active,
+ },
+ configuration_state: settingsState.configurationState,
+ embedding: null,
+ issues: [],
+ retrieval: null,
+ revision: 1,
+ }
+})
+
+vi.mock('@/next/navigation', () => ({
+ usePathname: () => '/datasets/new/space-1/sources/new/website',
+ useRouter: () => routerMock,
+}))
+
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleClientResponses, withConsoleResponses } =
+ await import('@/test/console/service-responses')
+ return {
+ ...actual,
+ consoleClient: withConsoleClientResponses(actual.consoleClient, {
+ 'knowledgeFs.spaces.byControlSpaceId.sources.bySourceId.asyncImport.post': async (
+ input: never,
+ ) => workflowApiResponse(await clientMock.asyncImport(input)),
+ }),
+ consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ 'knowledgeFs.spaces.byControlSpaceId.settings.get': async () => settingsResponse(),
+ }),
+ }
+})
+
+const source: Source = {
+ connectionId: 'connection-1',
+ createdAt: '2026-07-20T10:00:00Z',
+ id: 'source-1',
+ knowledgeSpaceId: 'space-1',
+ metadata: {},
+ name: 'Dify docs',
+ status: 'disabled',
+ type: 'web',
+ updatedAt: '2026-07-20T10:00:00Z',
+ uri: 'https://docs.dify.ai/',
+ version: 3,
+}
+
+const run: SourceWorkflowRun = {
+ checkpoint: 'crawl',
+ createdAt: '2026-07-20T10:00:00Z',
+ executionAttempts: 1,
+ id: 'run-1',
+ knowledgeSpaceId: 'space-1',
+ kind: 'crawl-preview',
+ maxExecutionAttempts: 3,
+ progressCompleted: 3,
+ progressFailed: 1,
+ progressSkipped: 0,
+ progressTotal: 4,
+ sourceId: source.id,
+ state: 'succeeded',
+ updatedAt: '2026-07-20T10:01:00Z',
+}
+
+const pages = [
+ {
+ pageId: 'page-1',
+ sourceUrl: 'https://docs.dify.ai/getting-started',
+ title: 'Getting started',
+ },
+ {
+ pageId: 'page-2',
+ sourceUrl: 'https://docs.dify.ai/guides',
+ title: 'Guides',
+ },
+ {
+ pageId: 'off-domain',
+ sourceUrl: 'https://github.com/langgenius/dify/edit/main/docs.md',
+ title: 'Edit this page',
+ },
+]
+
+async function renderSelectionForm({
+ initialSelectedPageIds,
+ initialSyncMode,
+ syncPolicyValue,
+ workflowUncertain = false,
+ previewPages = pages,
+}: {
+ initialSelectedPageIds?: readonly string[]
+ initialSyncMode?: 'custom' | 'interval' | 'manual'
+ syncPolicyValue?: SyncPolicyValue
+ workflowUncertain?: boolean
+ previewPages?: typeof pages
+} = {}) {
+ function SourceSetup() {
+ const [locked, setLocked] = useState(false)
+ const [canceled, setCanceled] = useState(false)
+ const [recrawling, setRecrawling] = useState(false)
+ const [accepted, setAccepted] = useState<SourceWorkflowRun>()
+ return (
+ <>
+ <button disabled={locked} type="button">
+ Leave source setup
+ </button>
+ {recrawling && <p>Preview requested</p>}
+ {canceled ? (
+ <p>Source setup closed</p>
+ ) : (
+ <CrawlSelectionForm
+ discardRequested={() => false}
+ initialSelectedPageIds={initialSelectedPageIds}
+ initialSyncMode={initialSyncMode}
+ knowledgeSpaceId="space-1"
+ onCancel={() => setCanceled(true)}
+ onInteractionLockChange={setLocked}
+ onRecrawl={() => setRecrawling(true)}
+ onSubmissionUncertainChange={() => {}}
+ onSubmitted={() => {}}
+ onWorkflowPending={() => {}}
+ onWorkflowRun={setAccepted}
+ pages={previewPages}
+ rootUrl="https://docs.dify.ai/"
+ run={run}
+ showSyncPolicyField={!syncPolicyValue}
+ source={source}
+ syncPolicyValue={syncPolicyValue}
+ workflowUncertain={workflowUncertain}
+ />
+ )}
+ {accepted && (
+ <output aria-label="Accepted import">
+ {accepted.id}: {accepted.state}
+ </output>
+ )}
+ </>
+ )
+ }
+ const { wrapper: QueryProvider } = createConsoleQueryWrapper()
+ return render(
+ <QueryProvider>
+ <SourceSetup />
+ </QueryProvider>,
+ )
+}
+
+async function selectSyncPolicy(user: typeof userEvent, mode: 'custom' | 'interval' | 'manual') {
+ const optionNames = {
+ custom: 'knowledgeSources.syncPolicyCustom',
+ interval: 'knowledgeSources.syncPolicyDaily',
+ manual: 'knowledgeSources.syncPolicyManual',
+ }
+ await user.click(page.getByRole('combobox', { name: 'knowledgeSources.syncPolicy' }))
+ await user.click(page.getByRole('option', { name: optionNames[mode] }))
+}
+
+describe('CrawlSelectionForm', () => {
+ beforeEach(async () => {
+ await page.viewport(1000, 760)
+ onTestFinished(guardUnexpectedFetch())
+ clientMock.asyncImport.mockResolvedValue({ ...run, checkpoint: 'import', state: 'queued' })
+ settingsState.configurationState = 'active'
+ })
+
+ it('prompts for model setup before submitting the import', async () => {
+ const user = userEvent
+ // The guard reads the native query string, so establish this route's query at the browser boundary.
+ const runnerUrl = window.location.href
+ onTestFinished(() => window.history.replaceState(null, '', runnerUrl))
+ window.history.replaceState(null, '', window.location.pathname)
+ settingsState.configurationState = 'setup-required'
+ await renderSelectionForm()
+ await user.click(page.getByRole('checkbox', { name: 'Getting started' }))
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.addSource' }))
+
+ expect(clientMock.asyncImport).not.toHaveBeenCalled()
+ await user.click(
+ page.getByRole('button', { name: 'modelProvider.modelProvider.selector.configure' }),
+ )
+ expect(routerMock.push).toHaveBeenCalledWith(
+ '/datasets/new/space-1/settings?returnTo=%2Fdatasets%2Fnew%2Fspace-1%2Fsources%2Fnew%2Fwebsite&capability=ingest',
+ )
+ })
+
+ it('preserves the sync policy selected before crawl review', async () => {
+ await renderSelectionForm({ initialSyncMode: 'manual' })
+ await expect
+ .element(page.getByRole('combobox', { name: 'knowledgeSources.syncPolicy' }))
+ .toHaveTextContent('knowledgeSources.syncPolicyManual')
+ })
+
+ it('selects only valid same-domain pages', async () => {
+ const user = userEvent
+ await renderSelectionForm()
+ const addSource = page.getByRole('button', { name: 'knowledgeSpace.addSource' })
+ await expect.element(addSource).toBeDisabled()
+ await expect
+ .element(page.getByRole('checkbox', { name: 'Edit this page' }))
+ .toHaveAttribute('aria-disabled', 'true')
+
+ await user.click(page.getByRole('checkbox', { name: 'Getting started' }))
+ await expect.element(addSource).toBeEnabled()
+ await expect
+ .element(page.getByRole('checkbox', { name: 'knowledgeSources.selectAll' }))
+ .toHaveAttribute('aria-checked', 'mixed')
+ await user.click(page.getByRole('checkbox', { name: 'knowledgeSources.selectAll' }))
+ await expect.element(page.getByRole('checkbox', { name: 'Guides' })).toBeChecked()
+ await expect.element(page.getByRole('checkbox', { name: 'Edit this page' })).not.toBeChecked()
+ })
+
+ it('keeps only valid initial selections', async () => {
+ await renderSelectionForm({ initialSelectedPageIds: ['page-1', 'off-domain'] })
+ await expect.element(page.getByRole('checkbox', { name: 'Getting started' })).toBeChecked()
+ await expect.element(page.getByRole('checkbox', { name: 'Edit this page' })).not.toBeChecked()
+ })
+
+ it('locks stale selections while keeping recrawl and cancel available', async () => {
+ await renderSelectionForm({ workflowUncertain: true })
+ await expect
+ .element(page.getByRole('checkbox', { name: 'Getting started' }))
+ .toHaveAttribute('aria-disabled', 'true')
+ await expect
+ .element(page.getByRole('button', { name: 'knowledgeSpace.addSource' }))
+ .toBeDisabled()
+ await page.getByRole('button', { name: 'knowledgeSources.reCrawl' }).click()
+ await expect.element(page.getByText('Preview requested')).toBeVisible()
+ await page.getByRole('button', { name: 'knowledgeSources.cancelAddSource' }).click()
+ await expect.element(page.getByText('Source setup closed')).toBeVisible()
+ await expect
+ .element(page.getByRole('checkbox', { name: 'Getting started' }))
+ .not.toBeInTheDocument()
+ })
+
+ it('never submits more page IDs than the async import contract accepts', async () => {
+ const longPageList = Array.from({ length: 201 }, (_, index) => ({
+ pageId: `page-${index + 1}`,
+ sourceUrl: `https://docs.dify.ai/page-${index + 1}`,
+ title: `Page ${index + 1}`,
+ }))
+ const user = userEvent
+ await renderSelectionForm({ previewPages: longPageList })
+ await user.click(page.getByRole('checkbox', { name: 'knowledgeSources.selectAll' }))
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.addSource' }))
+
+ await vi.waitFor(() => expect(clientMock.asyncImport).toHaveBeenCalledOnce())
+ expect(clientMock.asyncImport.mock.calls[0]?.[0].body.pageIds).toHaveLength(200)
+ })
+
+ it('submits custom policy in one request and navigates on acceptance', async () => {
+ const user = userEvent
+ await renderSelectionForm()
+ await user.click(page.getByRole('checkbox', { name: 'Getting started' }))
+ await selectSyncPolicy(user, 'custom')
+ const dialog = page.getByRole('dialog', {
+ name: 'knowledgeSources.syncPolicyCustom',
+ })
+ const interval = dialog.getByRole('textbox', {
+ name: 'knowledgeSources.syncPolicyCustom knowledgeSpace.syncPolicyUnit.hours',
+ })
+ await interval.fill('6')
+ await expect.element(interval).toHaveValue('6')
+ await user.keyboard('{Enter}')
+ await expect.element(dialog).not.toBeInTheDocument()
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.addSource' }))
+
+ await vi.waitFor(() =>
+ expect(routerMock.push).toHaveBeenCalledWith('/datasets/new/space-1/sources'),
+ )
+ expect(clientMock.asyncImport).toHaveBeenCalledWith({
+ body: {
+ kind: 'crawl-preview-selection',
+ pageIds: ['page-1'],
+ previewWorkflowId: 'run-1',
+ syncPolicy: {
+ customIntervalSeconds: 21600,
+ enabled: true,
+ mode: 'custom',
+ },
+ },
+ headers: { 'Idempotency-Key': expect.any(String) },
+ params: { control_space_id: 'space-1', source_id: 'source-1' },
+ })
+ await expect
+ .element(page.getByRole('status', { name: 'Accepted import' }))
+ .toHaveTextContent('run-1: queued')
+ })
+
+ it.each([
+ { enabled: false, mode: 'manual' },
+ { enabled: true, mode: 'interval' },
+ ] as const)('includes the $mode policy in the async import', async ({ enabled, mode }) => {
+ const user = userEvent
+ await renderSelectionForm()
+ await user.click(page.getByRole('checkbox', { name: 'Getting started' }))
+ await selectSyncPolicy(user, mode)
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.addSource' }))
+
+ await vi.waitFor(() => expect(clientMock.asyncImport).toHaveBeenCalledOnce())
+ expect(clientMock.asyncImport.mock.calls[0]?.[0].body.syncPolicy).toEqual({ enabled, mode })
+ })
+
+ it('keeps the form locked only until the async submission is accepted', async () => {
+ const request = createDeferred<SourceWorkflowRun>()
+ clientMock.asyncImport.mockReturnValue(request.promise)
+ const user = userEvent
+ await renderSelectionForm()
+ await user.click(page.getByRole('checkbox', { name: 'Getting started' }))
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.addSource' }))
+
+ await expect.element(page.getByRole('button', { name: 'Leave source setup' })).toBeDisabled()
+ await expect
+ .element(page.getByRole('checkbox', { name: 'Getting started' }))
+ .toHaveAttribute('aria-disabled', 'true')
+ await expect
+ .element(page.getByRole('combobox', { name: 'knowledgeSources.syncPolicy' }))
+ .toBeDisabled()
+ request.resolve({ ...run, checkpoint: 'import', state: 'queued' })
+ await expect
+ .element(page.getByRole('status', { name: 'Accepted import' }))
+ .toHaveTextContent('run-1: queued')
+ await expect.element(page.getByRole('button', { name: 'Leave source setup' })).toBeEnabled()
+ await expect
+ .element(page.getByRole('checkbox', { name: 'Getting started' }))
+ .not.toHaveAttribute('aria-disabled', 'true')
+ })
+
+ it('reuses the idempotency key when an async import response is lost', async () => {
+ clientMock.asyncImport
+ .mockRejectedValueOnce(new Error('response lost'))
+ .mockResolvedValueOnce({ ...run, checkpoint: 'import', state: 'queued' })
+ const user = userEvent
+ await renderSelectionForm()
+ await user.click(page.getByRole('checkbox', { name: 'Getting started' }))
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.addSource' }))
+
+ await expect
+ .element(page.getByRole('alert'))
+ .toHaveTextContent('knowledgeSources.addSourceFailed')
+ await expect.element(page.getByRole('button', { name: 'Leave source setup' })).toBeDisabled()
+ await expect
+ .element(page.getByRole('checkbox', { name: 'Getting started' }))
+ .toHaveAttribute('aria-disabled', 'true')
+ await expect
+ .element(page.getByRole('combobox', { name: 'knowledgeSources.syncPolicy' }))
+ .toBeDisabled()
+ await user.click(page.getByRole('button', { name: 'knowledgeSpace.addSource' }))
+
+ await vi.waitFor(() => expect(clientMock.asyncImport).toHaveBeenCalledTimes(2))
+ expect(clientMock.asyncImport.mock.calls[0]?.[0].headers).toEqual(
+ clientMock.asyncImport.mock.calls[1]?.[0].headers,
+ )
+ await vi.waitFor(() =>
+ expect(routerMock.push).toHaveBeenCalledWith('/datasets/new/space-1/sources'),
+ )
+ await expect
+ .element(page.getByRole('status', { name: 'Accepted import' }))
+ .toHaveTextContent('run-1: queued')
+ await expect.element(page.getByRole('button', { name: 'Leave source setup' })).toBeEnabled()
+ })
+})
diff --git a/web/features/new-rag/sources/create/__tests__/crawl-selection-form.spec.tsx b/web/features/new-rag/sources/create/__tests__/crawl-selection-form.spec.tsx
deleted file mode 100644
index dc0fcb4f051..00000000000
--- a/web/features/new-rag/sources/create/__tests__/crawl-selection-form.spec.tsx
+++ /dev/null
@@ -1,393 +0,0 @@
-import type { KnowledgeFsSettingsResponse } from '@dify/contracts/api/console/knowledge-fs/types.gen'
-import type { SyncPolicyValue } from '../../setup/sync-policy-field'
-import type { Source, SourceWorkflowRun } from '../../source-models'
-import { screen, waitFor, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { consoleQuery } from '@/service/console'
-import { renderWithConsoleQuery } from '@/test/console/query-data'
-import { CrawlSelectionForm } from '../crawl-selection-form'
-
-const clientMock = vi.hoisted(() => ({ asyncImport: vi.fn() }))
-const routerMock = vi.hoisted(() => ({ push: vi.fn() }))
-const settingsState = vi.hoisted(() => ({
- configurationState: 'active' as 'active' | 'setup-required',
-}))
-
-const workflowApiResponse = vi.hoisted(() => (workflow: SourceWorkflowRun) => ({
- canceled_at: workflow.canceledAt ?? null,
- checkpoint: workflow.checkpoint,
- completed_at: workflow.completedAt ?? null,
- created_at: workflow.createdAt,
- cursor: workflow.cursor ?? null,
- execution_attempts: workflow.executionAttempts,
- id: workflow.id,
- knowledge_space_id: workflow.knowledgeSpaceId,
- kind: workflow.kind,
- last_error_code: workflow.lastErrorCode ?? null,
- max_execution_attempts: workflow.maxExecutionAttempts,
- progress_completed: workflow.progressCompleted,
- progress_failed: workflow.progressFailed,
- progress_skipped: workflow.progressSkipped,
- progress_total: workflow.progressTotal ?? null,
- source_id: workflow.sourceId ?? null,
- state: workflow.state,
- updated_at: workflow.updatedAt,
-}))
-
-const settingsResponse = vi.hoisted(() => (): KnowledgeFsSettingsResponse => {
- const active = settingsState.configurationState === 'active'
- return {
- active_profile_available: active,
- active_profile_revisions: active ? { embedding: 1, retrieval: 1 } : {},
- capabilities: {
- deep: active,
- index: active,
- ingest: active,
- query: active,
- research: active,
- source_sync: active,
- },
- configuration_state: settingsState.configurationState,
- embedding: null,
- issues: [],
- retrieval: null,
- revision: 1,
- }
-})
-
-vi.mock('@/next/navigation', () => ({
- usePathname: () => '/datasets/new/space-1/sources/new/website',
- useRouter: () => routerMock,
-}))
-
-vi.mock('@/service/console', async (importOriginal) => {
- const actual = await importOriginal<typeof import('@/service/console')>()
- const { withConsoleClientResponses, withConsoleResponses } =
- await import('@/test/console/service-responses')
- return {
- ...actual,
- consoleClient: withConsoleClientResponses(actual.consoleClient, {
- 'knowledgeFs.spaces.byControlSpaceId.sources.bySourceId.asyncImport.post': async (
- input: never,
- ) => workflowApiResponse(await clientMock.asyncImport(input)),
- }),
- consoleQuery: withConsoleResponses(actual.consoleQuery, {
- 'knowledgeFs.spaces.byControlSpaceId.settings.get': async () => settingsResponse(),
- }),
- }
-})
-
-const source: Source = {
- connectionId: 'connection-1',
- createdAt: '2026-07-20T10:00:00Z',
- id: 'source-1',
- knowledgeSpaceId: 'space-1',
- metadata: {},
- name: 'Dify docs',
- status: 'disabled',
- type: 'web',
- updatedAt: '2026-07-20T10:00:00Z',
- uri: 'https://docs.dify.ai/',
- version: 3,
-}
-
-const run: SourceWorkflowRun = {
- checkpoint: 'crawl',
- createdAt: '2026-07-20T10:00:00Z',
- executionAttempts: 1,
- id: 'run-1',
- knowledgeSpaceId: 'space-1',
- kind: 'crawl-preview',
- maxExecutionAttempts: 3,
- progressCompleted: 3,
- progressFailed: 1,
- progressSkipped: 0,
- progressTotal: 4,
- sourceId: source.id,
- state: 'succeeded',
- updatedAt: '2026-07-20T10:01:00Z',
-}
-
-const pages = [
- {
- pageId: 'page-1',
- sourceUrl: 'https://docs.dify.ai/getting-started',
- title: 'Getting started',
- },
- {
- pageId: 'page-2',
- sourceUrl: 'https://docs.dify.ai/guides',
- title: 'Guides',
- },
- {
- pageId: 'off-domain',
- sourceUrl: 'https://github.com/langgenius/dify/edit/main/docs.md',
- title: 'Edit this page',
- },
-]
-
-function deferred<T>() {
- let resolve!: (value: T) => void
- const promise = new Promise<T>((nextResolve) => {
- resolve = nextResolve
- })
- return { promise, resolve }
-}
-
-function renderSelectionForm({
- initialSelectedPageIds,
- initialSyncMode,
- onCancel = vi.fn(),
- syncPolicyValue,
- workflowUncertain = false,
-}: {
- initialSelectedPageIds?: readonly string[]
- initialSyncMode?: 'custom' | 'interval' | 'manual'
- onCancel?: () => void
- syncPolicyValue?: SyncPolicyValue
- workflowUncertain?: boolean
-} = {}) {
- const onInteractionLockChange = vi.fn()
- const onRecrawl = vi.fn()
- const onSubmissionUncertainChange = vi.fn()
- const onSubmitted = vi.fn()
- const onWorkflowPending = vi.fn()
- const onWorkflowRun = vi.fn()
- const view = renderWithConsoleQuery(
- <CrawlSelectionForm
- discardRequested={() => false}
- initialSelectedPageIds={initialSelectedPageIds}
- initialSyncMode={initialSyncMode}
- knowledgeSpaceId="space-1"
- onCancel={onCancel}
- onInteractionLockChange={onInteractionLockChange}
- onRecrawl={onRecrawl}
- onSubmissionUncertainChange={onSubmissionUncertainChange}
- onSubmitted={onSubmitted}
- onWorkflowPending={onWorkflowPending}
- onWorkflowRun={onWorkflowRun}
- pages={pages}
- rootUrl="https://docs.dify.ai/"
- run={run}
- showSyncPolicyField={!syncPolicyValue}
- source={source}
- syncPolicyValue={syncPolicyValue}
- workflowUncertain={workflowUncertain}
- />,
- )
- return {
- ...view,
- onInteractionLockChange,
- onRecrawl,
- onSubmissionUncertainChange,
- onSubmitted,
- onWorkflowPending,
- onWorkflowRun,
- }
-}
-
-async function selectSyncPolicy(
- user: ReturnType<typeof userEvent.setup>,
- mode: 'custom' | 'interval' | 'manual',
-) {
- const optionNames = {
- custom: 'knowledgeSources.syncPolicyCustom',
- interval: 'knowledgeSources.syncPolicyDaily',
- manual: 'knowledgeSources.syncPolicyManual',
- }
- await user.click(screen.getByRole('combobox', { name: 'knowledgeSources.syncPolicy' }))
- await user.click(screen.getByRole('option', { name: optionNames[mode] }))
-}
-
-describe('CrawlSelectionForm', () => {
- beforeEach(() => {
- clientMock.asyncImport.mockResolvedValue({ ...run, checkpoint: 'import', state: 'queued' })
- settingsState.configurationState = 'active'
- })
-
- it('prompts for model setup before submitting the import', async () => {
- const user = userEvent.setup()
- settingsState.configurationState = 'setup-required'
- renderSelectionForm()
- await user.click(screen.getByRole('checkbox', { name: 'Getting started' }))
- await user.click(screen.getByRole('button', { name: 'knowledgeSpace.addSource' }))
-
- expect(clientMock.asyncImport).not.toHaveBeenCalled()
- await user.click(
- await screen.findByRole('button', { name: 'modelProvider.modelProvider.selector.configure' }),
- )
- expect(routerMock.push).toHaveBeenCalledWith(
- '/datasets/new/space-1/settings?returnTo=%2Fdatasets%2Fnew%2Fspace-1%2Fsources%2Fnew%2Fwebsite&capability=ingest',
- )
- })
-
- it('preserves the sync policy selected before crawl review', () => {
- renderSelectionForm({ initialSyncMode: 'manual' })
- expect(screen.getByRole('combobox', { name: 'knowledgeSources.syncPolicy' })).toHaveTextContent(
- 'knowledgeSources.syncPolicyManual',
- )
- })
-
- it('selects only valid same-domain pages', async () => {
- const user = userEvent.setup()
- renderSelectionForm()
- const addSource = screen.getByRole('button', { name: 'knowledgeSpace.addSource' })
- expect(addSource).toBeDisabled()
- expect(screen.getByRole('checkbox', { name: 'Edit this page' })).toHaveAttribute(
- 'aria-disabled',
- 'true',
- )
-
- await user.click(screen.getByRole('checkbox', { name: 'Getting started' }))
- expect(addSource).toBeEnabled()
- expect(screen.getByRole('checkbox', { name: 'knowledgeSources.selectAll' })).toHaveAttribute(
- 'aria-checked',
- 'mixed',
- )
- await user.click(screen.getByRole('checkbox', { name: 'knowledgeSources.selectAll' }))
- expect(screen.getByRole('checkbox', { name: 'Guides' })).toBeChecked()
- expect(screen.getByRole('checkbox', { name: 'Edit this page' })).not.toBeChecked()
- })
-
- it('keeps only valid initial selections', () => {
- renderSelectionForm({ initialSelectedPageIds: ['page-1', 'off-domain'] })
- expect(screen.getByRole('checkbox', { name: 'Getting started' })).toBeChecked()
- expect(screen.getByRole('checkbox', { name: 'Edit this page' })).not.toBeChecked()
- })
-
- it('locks stale selections while keeping recrawl and cancel available', async () => {
- const onCancel = vi.fn()
- const user = userEvent.setup()
- const { onRecrawl } = renderSelectionForm({ onCancel, workflowUncertain: true })
- expect(screen.getByRole('checkbox', { name: 'Getting started' })).toHaveAttribute(
- 'aria-disabled',
- 'true',
- )
- expect(screen.getByRole('button', { name: 'knowledgeSpace.addSource' })).toBeDisabled()
- await user.click(screen.getByRole('button', { name: 'knowledgeSources.reCrawl' }))
- await user.click(screen.getByRole('button', { name: 'knowledgeSources.cancelAddSource' }))
- expect(onRecrawl).toHaveBeenCalledOnce()
- expect(onCancel).toHaveBeenCalledOnce()
- })
-
- it('never submits more page IDs than the async import contract accepts', async () => {
- const longPageList = Array.from({ length: 201 }, (_, index) => ({
- pageId: `page-${index + 1}`,
- sourceUrl: `https://docs.dify.ai/page-${index + 1}`,
- title: `Page ${index + 1}`,
- }))
- const user = userEvent.setup()
- renderWithConsoleQuery(
- <CrawlSelectionForm
- discardRequested={() => false}
- knowledgeSpaceId="space-1"
- onCancel={vi.fn()}
- onRecrawl={vi.fn()}
- onSubmissionUncertainChange={vi.fn()}
- onSubmitted={vi.fn()}
- onWorkflowPending={vi.fn()}
- onWorkflowRun={vi.fn()}
- pages={longPageList}
- rootUrl="https://docs.dify.ai/"
- run={run}
- source={source}
- />,
- )
- await user.click(screen.getByRole('checkbox', { name: 'knowledgeSources.selectAll' }))
- await user.click(screen.getByRole('button', { name: 'knowledgeSpace.addSource' }))
-
- await waitFor(() => expect(clientMock.asyncImport).toHaveBeenCalledOnce())
- expect(clientMock.asyncImport.mock.calls[0]?.[0].body.pageIds).toHaveLength(200)
- })
-
- it('submits custom policy in one request and navigates on acceptance', async () => {
- const user = userEvent.setup()
- const { onSubmitted, onWorkflowRun, queryClient } = renderSelectionForm()
- const sourcesKey = consoleQuery.knowledgeFs.spaces.byControlSpaceId.sources.get.queryKey({
- input: { params: { control_space_id: 'space-1' } },
- })
- queryClient.setQueryData(sourcesKey, { data: [] })
- await user.click(screen.getByRole('checkbox', { name: 'Getting started' }))
- await selectSyncPolicy(user, 'custom')
- const dialog = await screen.findByRole('dialog', {
- name: 'knowledgeSources.syncPolicyCustom',
- })
- const interval = within(dialog).getByRole('textbox', {
- name: 'knowledgeSources.syncPolicyCustom knowledgeSpace.syncPolicyUnit.hours',
- })
- await user.clear(interval)
- await user.type(interval, '6')
- await user.click(
- within(dialog).getByRole('button', { name: 'knowledgeSources.syncPolicyApply' }),
- )
- await user.click(screen.getByRole('button', { name: 'knowledgeSpace.addSource' }))
-
- await waitFor(() =>
- expect(routerMock.push).toHaveBeenCalledWith('/datasets/new/space-1/sources'),
- )
- expect(clientMock.asyncImport).toHaveBeenCalledWith({
- body: {
- kind: 'crawl-preview-selection',
- pageIds: ['page-1'],
- previewWorkflowId: 'run-1',
- syncPolicy: {
- customIntervalSeconds: 21600,
- enabled: true,
- mode: 'custom',
- },
- },
- headers: { 'Idempotency-Key': expect.any(String) },
- params: { control_space_id: 'space-1', source_id: 'source-1' },
- })
- expect(onWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ state: 'queued' }))
- expect(onSubmitted).toHaveBeenCalledOnce()
- expect(queryClient.getQueryState(sourcesKey)?.isInvalidated).toBe(true)
- })
-
- it.each([
- { enabled: false, mode: 'manual' },
- { enabled: true, mode: 'interval' },
- ] as const)('includes the $mode policy in the async import', async ({ enabled, mode }) => {
- const user = userEvent.setup()
- renderSelectionForm()
- await user.click(screen.getByRole('checkbox', { name: 'Getting started' }))
- await selectSyncPolicy(user, mode)
- await user.click(screen.getByRole('button', { name: 'knowledgeSpace.addSource' }))
-
- await waitFor(() => expect(clientMock.asyncImport).toHaveBeenCalledOnce())
- expect(clientMock.asyncImport.mock.calls[0]?.[0].body.syncPolicy).toEqual({ enabled, mode })
- })
-
- it('keeps the form locked only until the async submission is accepted', async () => {
- const request = deferred<SourceWorkflowRun>()
- clientMock.asyncImport.mockReturnValue(request.promise)
- const user = userEvent.setup()
- const { onInteractionLockChange } = renderSelectionForm()
- await user.click(screen.getByRole('checkbox', { name: 'Getting started' }))
- await user.click(screen.getByRole('button', { name: 'knowledgeSpace.addSource' }))
-
- await waitFor(() => expect(onInteractionLockChange).toHaveBeenLastCalledWith(true))
- request.resolve({ ...run, checkpoint: 'import', state: 'queued' })
- await waitFor(() => expect(onInteractionLockChange).toHaveBeenLastCalledWith(false))
- })
-
- it('reuses the idempotency key when an async import response is lost', async () => {
- clientMock.asyncImport
- .mockRejectedValueOnce(new Error('response lost'))
- .mockResolvedValueOnce({ ...run, checkpoint: 'import', state: 'queued' })
- const user = userEvent.setup()
- const { onSubmissionUncertainChange } = renderSelectionForm()
- await user.click(screen.getByRole('checkbox', { name: 'Getting started' }))
- await user.click(screen.getByRole('button', { name: 'knowledgeSpace.addSource' }))
-
- expect(await screen.findByRole('alert')).toHaveTextContent('knowledgeSources.addSourceFailed')
- expect(onSubmissionUncertainChange).toHaveBeenLastCalledWith(true)
- await user.click(screen.getByRole('button', { name: 'knowledgeSpace.addSource' }))
-
- await waitFor(() => expect(clientMock.asyncImport).toHaveBeenCalledTimes(2))
- expect(clientMock.asyncImport.mock.calls[0]?.[0].headers).toEqual(
- clientMock.asyncImport.mock.calls[1]?.[0].headers,
- )
- expect(routerMock.push).toHaveBeenCalledWith('/datasets/new/space-1/sources')
- })
-})
diff --git a/web/features/new-rag/sources/setup/__tests__/sync-policy-field.browser.spec.tsx b/web/features/new-rag/sources/setup/__tests__/sync-policy-field.browser.spec.tsx
new file mode 100644
index 00000000000..76e88c9881a
--- /dev/null
+++ b/web/features/new-rag/sources/setup/__tests__/sync-policy-field.browser.spec.tsx
@@ -0,0 +1,241 @@
+import type { SyncPolicyValue } from '../sync-policy-field'
+import { useState } from 'react'
+import { page, userEvent } from 'vite-plus/test/browser'
+import { render } from 'vitest-browser-react'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { SyncPolicyField } from '../sync-policy-field'
+
+const i18nLanguage = vi.hoisted(() => ({ current: 'en-US' }))
+
+vi.mock('react-i18next', async () => {
+ const { createReactI18nextMock } = await import('@/test/i18n-mock')
+ const mock = createReactI18nextMock({
+ 'common.operation.cancel': 'Cancel',
+ 'knowledgeSources.syncPolicy': 'Sync policy',
+ 'knowledgeSources.syncPolicyApply': 'Apply',
+ 'knowledgeSources.syncPolicyCustom': 'Custom interval',
+ 'knowledgeSources.syncPolicyCustomDescription':
+ 'First sync runs right after creation, then {{interval}}.',
+ 'knowledgeSources.syncPolicyCustomHelp': 'From 1 hour to 30 days. Will sync {{interval}}.',
+ 'knowledgeSources.syncPolicyCustomValue': 'Custom · {{interval}}',
+ 'knowledgeSources.syncPolicyDaily': 'Every 24 hours',
+ 'knowledgeSources.syncPolicyEditCustom': 'Edit custom interval',
+ 'knowledgeSources.syncPolicyEvery': 'Every',
+ 'knowledgeSources.syncPolicyEveryValue': 'Every {{interval}}',
+ 'knowledgeSources.syncPolicyManual': 'Manual sync',
+ 'knowledgeSpace.syncPolicyUnit.days': 'days',
+ 'knowledgeSpace.syncPolicyUnit.hours': 'hours',
+ })
+ return {
+ ...mock,
+ useTranslation: ((...args: Parameters<typeof mock.useTranslation>) => {
+ const result = mock.useTranslation(...args)
+ return {
+ ...result,
+ i18n: {
+ ...result.i18n,
+ language: i18nLanguage.current,
+ resolvedLanguage: i18nLanguage.current,
+ },
+ }
+ }) as typeof mock.useTranslation,
+ }
+})
+
+function SyncPolicyFieldHarness() {
+ const [value, setValue] = useState<SyncPolicyValue>({ mode: 'interval' })
+ return (
+ <>
+ <output aria-label="Saved sync policy">{JSON.stringify(value)}</output>
+ <SyncPolicyField value={value} onChange={setValue} />
+ </>
+ )
+}
+
+describe('SyncPolicyField', () => {
+ beforeEach(async () => {
+ await page.viewport(640, 600)
+ onTestFinished(guardUnexpectedFetch())
+ i18nLanguage.current = 'en-US'
+ })
+
+ it('shows sync timing for default and preset intervals but not manual sync', async () => {
+ const user = userEvent
+ await render(<SyncPolicyFieldHarness />)
+
+ const trigger = page.getByRole('combobox', { name: 'Sync policy' })
+ await expect.element(trigger).toHaveTextContent('Every 24 hours')
+ await expect
+ .element(page.getByText('First sync runs right after creation, then every 24 hours.'))
+ .toBeVisible()
+
+ await user.click(trigger)
+ await user.click(page.getByRole('option', { name: 'Every 3 days' }))
+ await expect
+ .element(page.getByText('First sync runs right after creation, then every 3 days.'))
+ .toBeVisible()
+
+ await user.click(trigger)
+ await user.click(page.getByRole('option', { name: 'Manual sync' }))
+ await expect.element(trigger).toHaveTextContent('Manual sync')
+ await expect
+ .element(page.getByText(/^First sync runs right after creation/))
+ .not.toBeInTheDocument()
+ })
+
+ it('separates numbers from units in Simplified Chinese interval labels', async () => {
+ i18nLanguage.current = 'zh-Hans'
+ const user = userEvent
+ await render(<SyncPolicyFieldHarness />)
+
+ await user.click(page.getByRole('combobox', { name: 'Sync policy' }))
+
+ await expect.element(page.getByRole('option', { name: 'Every 6 小时' })).toBeInTheDocument()
+ await expect.element(page.getByRole('option', { name: 'Every 3 天' })).toBeInTheDocument()
+ })
+
+ it('offers the designed presets and applies a custom day interval explicitly', async () => {
+ const user = userEvent
+ await render(<SyncPolicyFieldHarness />)
+
+ const trigger = page.getByRole('combobox', { name: 'Sync policy' })
+ await user.click(trigger)
+ await expect.element(page.getByRole('option', { name: 'Manual sync' })).toBeInTheDocument()
+ await expect.element(page.getByRole('option', { name: 'Every 6 hours' })).toBeInTheDocument()
+ await expect.element(page.getByRole('option', { name: 'Every 12 hours' })).toBeInTheDocument()
+ await expect.element(page.getByRole('option', { name: 'Every 24 hours' })).toBeInTheDocument()
+ await expect.element(page.getByRole('option', { name: 'Every 3 days' })).toBeInTheDocument()
+ await expect.element(page.getByRole('option', { name: 'Every 7 days' })).toBeInTheDocument()
+
+ await user.click(page.getByRole('option', { name: 'Custom interval' }))
+ const popover = page.getByRole('dialog')
+ await expect
+ .element(page.getByRole('status', { name: 'Saved sync policy' }))
+ .toHaveTextContent('{"mode":"interval"}')
+
+ const interval = popover.getByRole('textbox', {
+ name: 'Custom interval hours',
+ })
+ await expect.element(interval).toBeVisible()
+ await interval.fill('2')
+ await user.click(popover.getByRole('combobox', { name: 'Custom interval' }))
+ await user.click(page.getByRole('option', { name: 'days' }))
+ await expect
+ .element(page.getByRole('status', { name: 'Saved sync policy' }))
+ .toHaveTextContent('{"mode":"interval"}')
+
+ await user.click(popover.getByRole('button', { name: 'Apply' }))
+ await expect.element(popover).not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('status', { name: 'Saved sync policy' }))
+ .toHaveTextContent('{"customIntervalSeconds":172800,"mode":"custom"}')
+ await expect.element(trigger).toHaveTextContent('Every 2 days')
+ await expect
+ .element(page.getByText('First sync runs right after creation, then every 2 days.'))
+ .toBeInTheDocument()
+
+ await user.click(trigger)
+ await expect
+ .element(page.getByRole('option', { name: 'Custom · every 2 days' }))
+ .toBeInTheDocument()
+ await user.click(page.getByRole('option', { name: 'Edit custom interval' }))
+ const reopenedPopover = page.getByRole('dialog')
+ await expect
+ .element(reopenedPopover.getByRole('textbox', { name: 'Custom interval days' }))
+ .toHaveValue('2')
+ })
+
+ it('applies the custom interval through its own form without submitting an enclosing form', async () => {
+ const user = userEvent
+ function SourceForm() {
+ const [submitted, setSubmitted] = useState(false)
+ return (
+ <form
+ onSubmit={(event) => {
+ event.preventDefault()
+ setSubmitted(true)
+ }}
+ >
+ <SyncPolicyFieldHarness />
+ <button type="submit">Create source</button>
+ {submitted && <p>Source submitted</p>}
+ </form>
+ )
+ }
+ await render(<SourceForm />)
+
+ await user.click(page.getByRole('combobox', { name: 'Sync policy' }))
+ await user.click(page.getByRole('option', { name: 'Custom interval' }))
+ const popover = page.getByRole('dialog')
+ const interval = popover.getByRole('textbox', { name: 'Custom interval hours' })
+ await interval.fill('8')
+ await expect.element(interval).toHaveValue('8')
+ await user.keyboard('{Enter}')
+
+ await expect
+ .element(page.getByRole('status', { name: 'Saved sync policy' }))
+ .toHaveTextContent('{"customIntervalSeconds":28800,"mode":"custom"}')
+ await expect.element(popover).not.toBeInTheDocument()
+ await expect.element(page.getByText('Source submitted')).not.toBeInTheDocument()
+ await page.getByRole('button', { name: 'Create source' }).click()
+ await expect.element(page.getByText('Source submitted')).toBeVisible()
+ })
+
+ it('closes the custom interval popover on Escape and resets its draft when reopened', async () => {
+ const user = userEvent
+ await render(<SyncPolicyFieldHarness />)
+
+ const trigger = page.getByRole('combobox', { name: 'Sync policy' })
+ await user.click(trigger)
+ await user.click(page.getByRole('option', { name: 'Custom interval' }))
+ let popover = page.getByRole('dialog')
+ const interval = popover.getByRole('textbox', { name: 'Custom interval hours' })
+ await interval.fill('5')
+ await user.keyboard('{Escape}')
+
+ await expect.element(page.getByRole('dialog')).not.toBeInTheDocument()
+ await user.click(trigger)
+ await user.click(page.getByRole('option', { name: 'Custom interval' }))
+ popover = page.getByRole('dialog')
+ await expect
+ .element(popover.getByRole('textbox', { name: 'Custom interval hours' }))
+ .toHaveValue('36')
+ })
+
+ it('discards edits on cancel and clamps the value to 30 days', async () => {
+ const user = userEvent
+ await render(<SyncPolicyFieldHarness />)
+
+ const trigger = page.getByRole('combobox', { name: 'Sync policy' })
+ await user.click(trigger)
+ await user.click(page.getByRole('option', { name: 'Custom interval' }))
+ let popover = page.getByRole('dialog')
+ await popover.getByRole('textbox', { name: 'Custom interval hours' }).fill('5')
+ await user.click(popover.getByRole('button', { name: 'Cancel' }))
+ await expect.element(popover).not.toBeInTheDocument()
+ await expect
+ .element(page.getByRole('status', { name: 'Saved sync policy' }))
+ .toHaveTextContent('{"mode":"interval"}')
+
+ await user.click(trigger)
+ await user.click(page.getByRole('option', { name: 'Custom interval' }))
+ popover = page.getByRole('dialog')
+ const interval = popover.getByRole('textbox', {
+ name: 'Custom interval hours',
+ })
+ await expect.element(interval).toBeVisible()
+ await interval.fill('40')
+ await user.click(popover.getByRole('combobox', { name: 'Custom interval' }))
+ await user.click(page.getByRole('option', { name: 'days' }))
+ const days = popover.getByRole('textbox', { name: 'Custom interval days' })
+ await days.click()
+ await user.tab()
+ await expect.element(days).toHaveValue('30')
+ await user.click(popover.getByRole('button', { name: 'Apply' }))
+ await expect.element(popover).not.toBeInTheDocument()
+
+ await expect
+ .element(page.getByRole('status', { name: 'Saved sync policy' }))
+ .toHaveTextContent('{"customIntervalSeconds":2592000,"mode":"custom"}')
+ })
+})
diff --git a/web/features/new-rag/sources/setup/__tests__/sync-policy-field.spec.tsx b/web/features/new-rag/sources/setup/__tests__/sync-policy-field.spec.tsx
deleted file mode 100644
index 79915313297..00000000000
--- a/web/features/new-rag/sources/setup/__tests__/sync-policy-field.spec.tsx
+++ /dev/null
@@ -1,219 +0,0 @@
-import type { SyncPolicyValue } from '../sync-policy-field'
-import { screen, waitFor, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { useState } from 'react'
-import { render } from '@/test/console/render'
-import { createReactI18nextMock } from '@/test/i18n-mock'
-import { SyncPolicyField } from '../sync-policy-field'
-
-const i18nLanguage = vi.hoisted(() => ({ current: 'en-US' }))
-
-vi.mock('react-i18next', () => {
- const mock = createReactI18nextMock({
- 'common.operation.cancel': 'Cancel',
- 'knowledgeSources.syncPolicy': 'Sync policy',
- 'knowledgeSources.syncPolicyApply': 'Apply',
- 'knowledgeSources.syncPolicyCustom': 'Custom interval',
- 'knowledgeSources.syncPolicyCustomDescription':
- 'First sync runs right after creation, then {{interval}}.',
- 'knowledgeSources.syncPolicyCustomHelp': 'From 1 hour to 30 days. Will sync {{interval}}.',
- 'knowledgeSources.syncPolicyCustomValue': 'Custom · {{interval}}',
- 'knowledgeSources.syncPolicyDaily': 'Every 24 hours',
- 'knowledgeSources.syncPolicyEditCustom': 'Edit custom interval',
- 'knowledgeSources.syncPolicyEvery': 'Every',
- 'knowledgeSources.syncPolicyEveryValue': 'Every {{interval}}',
- 'knowledgeSources.syncPolicyManual': 'Manual sync',
- 'knowledgeSpace.syncPolicyUnit.days': 'days',
- 'knowledgeSpace.syncPolicyUnit.hours': 'hours',
- })
- return {
- ...mock,
- useTranslation: ((...args: Parameters<typeof mock.useTranslation>) => {
- const result = mock.useTranslation(...args)
- return {
- ...result,
- i18n: {
- ...result.i18n,
- language: i18nLanguage.current,
- resolvedLanguage: i18nLanguage.current,
- },
- }
- }) as typeof mock.useTranslation,
- }
-})
-
-function SyncPolicyFieldHarness() {
- const [value, setValue] = useState<SyncPolicyValue>({ mode: 'interval' })
- return (
- <>
- <output data-testid="policy-value">{JSON.stringify(value)}</output>
- <SyncPolicyField value={value} onChange={setValue} />
- </>
- )
-}
-
-describe('SyncPolicyField', () => {
- beforeEach(() => {
- i18nLanguage.current = 'en-US'
- })
-
- it('shows sync timing for default and preset intervals but not manual sync', async () => {
- const user = userEvent.setup()
- render(<SyncPolicyFieldHarness />)
-
- const trigger = screen.getByRole('combobox', { name: 'Sync policy' })
- expect(trigger).toHaveTextContent('Every 24 hours')
- expect(
- screen.getByText('First sync runs right after creation, then every 24 hours.'),
- ).toBeVisible()
-
- await user.click(trigger)
- await user.click(screen.getByRole('option', { name: 'Every 3 days' }))
- expect(
- screen.getByText('First sync runs right after creation, then every 3 days.'),
- ).toBeVisible()
-
- await user.click(trigger)
- await user.click(screen.getByRole('option', { name: 'Manual sync' }))
- expect(trigger).toHaveTextContent('Manual sync')
- expect(screen.queryByText(/^First sync runs right after creation/)).not.toBeInTheDocument()
- })
-
- it('separates numbers from units in Simplified Chinese interval labels', async () => {
- i18nLanguage.current = 'zh-Hans'
- const user = userEvent.setup()
- render(<SyncPolicyFieldHarness />)
-
- await user.click(screen.getByRole('combobox', { name: 'Sync policy' }))
-
- expect(screen.getByRole('option', { name: 'Every 6 小时' })).toBeInTheDocument()
- expect(screen.getByRole('option', { name: 'Every 3 天' })).toBeInTheDocument()
- })
-
- it('offers the designed presets and applies a custom day interval explicitly', async () => {
- const user = userEvent.setup()
- render(<SyncPolicyFieldHarness />)
-
- const trigger = screen.getByRole('combobox', { name: 'Sync policy' })
- await user.click(trigger)
- expect(screen.getByRole('option', { name: 'Manual sync' })).toBeInTheDocument()
- expect(screen.getByRole('option', { name: 'Every 6 hours' })).toBeInTheDocument()
- expect(screen.getByRole('option', { name: 'Every 12 hours' })).toBeInTheDocument()
- expect(screen.getByRole('option', { name: 'Every 24 hours' })).toBeInTheDocument()
- expect(screen.getByRole('option', { name: 'Every 3 days' })).toBeInTheDocument()
- expect(screen.getByRole('option', { name: 'Every 7 days' })).toBeInTheDocument()
-
- await user.click(screen.getByRole('option', { name: 'Custom interval' }))
- const popover = await screen.findByRole('dialog')
- expect(screen.getByTestId('policy-value')).toHaveTextContent('{"mode":"interval"}')
-
- const interval = within(popover).getByRole('textbox', {
- name: 'Custom interval hours',
- })
- await user.clear(interval)
- await user.type(interval, '2')
- await user.click(within(popover).getByRole('combobox', { name: 'Custom interval' }))
- await user.click(screen.getByRole('option', { name: 'days' }))
- expect(screen.getByTestId('policy-value')).toHaveTextContent('{"mode":"interval"}')
-
- await user.click(within(popover).getByRole('button', { name: 'Apply' }))
- expect(screen.getByTestId('policy-value')).toHaveTextContent(
- '{"customIntervalSeconds":172800,"mode":"custom"}',
- )
- expect(trigger).toHaveTextContent('Every 2 days')
- expect(
- screen.getByText('First sync runs right after creation, then every 2 days.'),
- ).toBeInTheDocument()
-
- await user.click(trigger)
- expect(screen.getByRole('option', { name: 'Custom · every 2 days' })).toBeInTheDocument()
- await user.click(screen.getByRole('option', { name: 'Edit custom interval' }))
- const reopenedPopover = await screen.findByRole('dialog')
- expect(
- within(reopenedPopover).getByRole('textbox', { name: 'Custom interval days' }),
- ).toHaveValue('2')
- })
-
- it('applies the custom interval through its own form without submitting an enclosing form', async () => {
- const user = userEvent.setup()
- const onOuterSubmit = vi.fn((event: { preventDefault: () => void }) => event.preventDefault())
- render(
- <form onSubmit={onOuterSubmit}>
- <SyncPolicyFieldHarness />
- </form>,
- )
-
- await user.click(screen.getByRole('combobox', { name: 'Sync policy' }))
- await user.click(screen.getByRole('option', { name: 'Custom interval' }))
- const popover = await screen.findByRole('dialog')
- expect(within(popover).getByRole('button', { name: 'Apply' })).toHaveAttribute('type', 'submit')
- expect(within(popover).getByRole('button', { name: 'Cancel' })).toHaveAttribute(
- 'type',
- 'button',
- )
-
- const interval = within(popover).getByRole('textbox', { name: 'Custom interval hours' })
- await user.clear(interval)
- await user.type(interval, '8{Enter}')
-
- expect(screen.getByTestId('policy-value')).toHaveTextContent(
- '{"customIntervalSeconds":28800,"mode":"custom"}',
- )
- expect(onOuterSubmit).not.toHaveBeenCalled()
- })
-
- it('closes the custom interval popover on Escape and resets its draft when reopened', async () => {
- const user = userEvent.setup()
- render(<SyncPolicyFieldHarness />)
-
- const trigger = screen.getByRole('combobox', { name: 'Sync policy' })
- await user.click(trigger)
- await user.click(screen.getByRole('option', { name: 'Custom interval' }))
- let popover = await screen.findByRole('dialog')
- const interval = within(popover).getByRole('textbox', { name: 'Custom interval hours' })
- await user.clear(interval)
- await user.type(interval, '5')
- await user.keyboard('{Escape}')
-
- await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
- await user.click(trigger)
- await user.click(screen.getByRole('option', { name: 'Custom interval' }))
- popover = await screen.findByRole('dialog')
- expect(within(popover).getByRole('textbox', { name: 'Custom interval hours' })).toHaveValue(
- '36',
- )
- })
-
- it('discards edits on cancel and clamps the value to 30 days', async () => {
- const user = userEvent.setup()
- render(<SyncPolicyFieldHarness />)
-
- const trigger = screen.getByRole('combobox', { name: 'Sync policy' })
- await user.click(trigger)
- await user.click(screen.getByRole('option', { name: 'Custom interval' }))
- let popover = await screen.findByRole('dialog')
- await user.click(within(popover).getByRole('button', { name: 'Cancel' }))
- expect(screen.getByTestId('policy-value')).toHaveTextContent('{"mode":"interval"}')
-
- await user.click(trigger)
- await user.click(screen.getByRole('option', { name: 'Custom interval' }))
- popover = await screen.findByRole('dialog')
- const interval = within(popover).getByRole('textbox', {
- name: 'Custom interval hours',
- })
- await user.clear(interval)
- await user.type(interval, '40')
- await user.click(within(popover).getByRole('combobox', { name: 'Custom interval' }))
- await user.click(screen.getByRole('option', { name: 'days' }))
- await user.click(interval)
- await user.tab()
- expect(interval).toHaveValue('30')
- await user.click(within(popover).getByRole('button', { name: 'Apply' }))
-
- await waitFor(() =>
- expect(screen.getByTestId('policy-value')).toHaveTextContent(
- '{"customIntervalSeconds":2592000,"mode":"custom"}',
- ),
- )
- })
-})