RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import {
act,
fireEvent,
render,
screen,
waitFor,
} from '@testing-library/react';
import { useEffect as mockUseEffect } from 'react';
import { useFormContext as mockUseFormContext } from 'react-hook-form';
import { AxiosHeaders } from 'axios';
import { applyDatasetParserConfig } from '@/services/knowledge-service';
import DatasetSetting from './index';
const mockSave = jest.fn();
const mockTranslate = (key: string) => key;
const mockInitialValues = {
name: 'Dataset',
parse_type: 1,
parser_id: 'general',
pipeline_id: '',
pipeline_version_id: '',
parser_config: { 'Parser:One': { value: 1 } },
};
let mockDataset = { id: 'kb-1', document_count: 2, chunk_count: 0 };
const mockSourceData: unknown[] = [];
jest.mock('react-i18next', () => ({
useTranslation: () => ({ t: mockTranslate }),
}));
jest.mock('@/services/knowledge-service', () => ({
applyDatasetParserConfig: jest.fn(),
}));
jest.mock('@/components/ui/message', () => ({
__esModule: true,
default: { success: jest.fn() },
}));
jest.mock('./form-schema', () => {
const { z } = require('zod');
return { buildFormSchema: () => z.object({}).passthrough() };
});
jest.mock('./hooks', () => ({
useFetchDatasetSettingOnMount: (form: {
reset: (values: unknown) => void;
}) => {
mockUseEffect(() => form.reset(mockInitialValues), [form]);
return {
knowledgeDetails: mockDataset,
loading: false,
sourceData: mockSourceData,
};
},
useSaveDatasetSetting: () => ({ handleSave: mockSave, loading: false }),
usePipelineDataList: () => [],
useConnectorHandlers: () => ({}),
}));
jest.mock('./general-form', () => ({
GeneralForm: () => {
const form = mockUseFormContext();
return (
<>
<input aria-label="name" {...form.register('name')} />
<input
aria-label="parser value"
{...form.register('parser_config.Parser:One.value', {
valueAsNumber: true,
})}
/>
<input
aria-label="pipeline version"
{...form.register('pipeline_version_id')}
/>
</>
);
},
}));
jest.mock('@/components/parser-tree-select', () => ({
ParserTreeSelect: () => null,
}));
jest.mock('@/components/parser-tree-select/use-parser-tree-data', () => ({
useParserTreeData: () => ({ selectedLeafExists: true, loading: false }),
}));
jest.mock('@/components/pipeline-operator-tabs', () => ({
__esModule: true,
default: () => null,
}));
jest.mock('./chunk-method-learn-more', () => ({
__esModule: true,
default: () => null,
}));
jest.mock('./components/link-data-source', () => ({
__esModule: true,
default: () => null,
}));
jest.mock('@/hooks/use-parser-select-handler', () => ({
useParserSelectHandler: () => jest.fn(),
}));
jest.mock('@/hooks/use-parser-options', () => ({
buildParserSelectValue: () => '',
}));
jest.mock('@/hooks/use-pipeline-operator', () => ({
useActiveTab: () => ({ activeTab: '', setActiveTab: jest.fn() }),
usePipelineOperatorNodes: () => ({ operatorNodes: [], loading: false }),
useResetParserConfigOnPipelineChange: jest.fn(),
}));
jest.mock('@/utils/pipeline-operator', () => ({
buildParserConfigFromNodes: () => ({}),
}));
jest.mock('./parser-config', () => ({
normalizeParserConfigForComparison: (config: unknown) => config,
}));
jest.mock('@/hooks/use-pipeline-version-request', () => ({
useFetchPipelineVersionList: () => ({ data: [] }),
}));
jest.mock('./use-reveal-submit-errors', () => ({
useRevealSubmitErrors: () => ({}),
}));
const mockApply = jest.mocked(applyDatasetParserConfig);
function response(data: Record<string, unknown>) {
return {
data,
status: 200,
statusText: 'OK',
headers: {},
config: { headers: new AxiosHeaders() },
};
}
function setup() {
const queryClient = new QueryClient({
defaultOptions: { mutations: { retry: false } },
});
render(
<QueryClientProvider client={queryClient}>
<DatasetSetting />
</QueryClientProvider>,
);
}
function saveParserChanges() {
fireEvent.change(screen.getByLabelText('parser value'), {
target: { value: '2' },
});
fireEvent.click(
screen.getByRole('button', { name: 'knowledgeConfiguration.save' }),
);
}
beforeEach(() => {
mockSave.mockReset().mockResolvedValue({ code: 0 });
mockApply.mockReset().mockResolvedValue(
response({
code: 0,
data: {
dataset_id: 'kb-1',
total_documents: 2,
updated_documents: 2,
unchanged_documents: 0,
},
}),
);
mockDataset = { id: 'kb-1', document_count: 2, chunk_count: 0 };
});
it('saves before prompting, including existing files without chunks, and defaults to No', async () => {
let finishSave!: (value: { code: number }) => void;
mockSave.mockReturnValue(
new Promise((resolve) => {
finishSave = resolve;
}),
);
setup();
saveParserChanges();
await waitFor(() => expect(mockSave).toHaveBeenCalledTimes(1));
expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument();
expect(mockApply).not.toHaveBeenCalled();
await act(async () => finishSave({ code: 0 }));
await screen.findByRole('alertdialog');
expect(
Array.from(screen.getByRole('alertdialog').querySelectorAll('button')),
).toEqual([
screen.getByRole('button', { name: 'common.yes' }),
screen.getByRole('button', { name: 'common.no' }),
]);
expect(screen.getByRole('button', { name: 'common.no' })).toHaveFocus();
expect(screen.getByRole('button', { name: 'common.no' })).toHaveClass(
'bg-text-primary',
'text-bg-base',
);
expect(screen.getByRole('button', { name: 'common.yes' })).toHaveClass(
'bg-bg-input',
'text-text-secondary',
);
fireEvent.click(screen.getByRole('button', { name: 'common.no' }));
await waitFor(() =>
expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument(),
);
expect(mockApply).not.toHaveBeenCalled();
expect(mockSave).toHaveBeenCalledTimes(1);
});
it('applies the saved settings only after Yes', async () => {
setup();
saveParserChanges();
await screen.findByRole('alertdialog');
expect(mockApply).not.toHaveBeenCalled();
fireEvent.click(screen.getByRole('button', { name: 'common.yes' }));
await waitFor(() => expect(mockApply).toHaveBeenCalledWith('kb-1'));
await waitFor(() =>
expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument(),
);
expect(mockSave).toHaveBeenCalledTimes(1);
});
it('does not prompt when saving fails', async () => {
mockSave.mockResolvedValue({ code: 101 });
setup();
saveParserChanges();
await waitFor(() => expect(mockSave).toHaveBeenCalledTimes(1));
expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument();
expect(mockApply).not.toHaveBeenCalled();
});
it.each(['unchanged parser settings', 'empty dataset'])(
'does not prompt for %s',
async (scenario) => {
if (scenario === 'empty dataset') mockDataset.document_count = 0;
setup();
if (scenario === 'unchanged parser settings') {
fireEvent.change(screen.getByLabelText('name'), {
target: { value: 'Renamed' },
});
fireEvent.click(
screen.getByRole('button', { name: 'knowledgeConfiguration.save' }),
);
} else {
saveParserChanges();
}
await waitFor(() => expect(mockSave).toHaveBeenCalledTimes(1));
expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument();
},
);
it('prompts for a pipeline version change', async () => {
setup();
fireEvent.change(screen.getByLabelText('pipeline version'), {
target: { value: 'version-2' },
});
fireEvent.click(
screen.getByRole('button', { name: 'knowledgeConfiguration.save' }),
);
await screen.findByRole('alertdialog');
expect(mockApply).not.toHaveBeenCalled();
});
it('keeps the dialog open after failure and retries without saving again', async () => {
mockApply.mockResolvedValueOnce(
response({ code: 409, message: 'Stop parsing first' }),
);
setup();
saveParserChanges();
await screen.findByRole('alertdialog');
fireEvent.click(screen.getByRole('button', { name: 'common.yes' }));
expect(await screen.findByRole('alert')).toHaveTextContent(
'knowledgeConfiguration.parserSettingsApplyFailed',
);
expect(screen.getByRole('alert')).toHaveTextContent('Stop parsing first');
fireEvent.click(screen.getByRole('button', { name: 'common.yes' }));
await waitFor(() =>
expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument(),
);
expect(mockApply).toHaveBeenCalledTimes(2);
expect(mockSave).toHaveBeenCalledTimes(1);
});
it('treats Escape as No', async () => {
setup();
saveParserChanges();
const dialog = await screen.findByRole('alertdialog');
fireEvent.keyDown(dialog, { key: 'Escape', code: 'Escape' });
await waitFor(() =>
expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument(),
);
expect(mockApply).not.toHaveBeenCalled();
});
it('disables both choices while applying settings', async () => {
let finishApply!: (value: ReturnType<typeof response>) => void;
mockApply.mockReturnValue(
new Promise((resolve) => {
finishApply = resolve;
}),
);
setup();
saveParserChanges();
const dialog = await screen.findByRole('alertdialog');
fireEvent.click(screen.getByRole('button', { name: 'common.yes' }));
await waitFor(() => {
expect(screen.getByRole('button', { name: 'common.yes' })).toBeDisabled();
expect(screen.getByRole('button', { name: 'common.no' })).toBeDisabled();
});
fireEvent.keyDown(dialog, { key: 'Escape', code: 'Escape' });
expect(screen.getByRole('alertdialog')).toBeInTheDocument();
await act(async () => finishApply(response({ code: 0, data: {} })));
await waitFor(() =>
expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument(),
);
expect(mockApply).toHaveBeenCalledTimes(1);
});