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 { act, renderHook } from '@testing-library/react';
import { Edge, Node } from '@xyflow/react';
import { NodeHandleId, Operator } from '../constant';
import useGraphStore from '../store';
import { useBeforeDelete } from './use-before-delete';
const createNode = (
id: string,
label: Operator,
options: Record<string, unknown> = {},
) => ({
id,
type: 'ragNode',
position: { x: 0, y: 0 },
data: {
label,
name: id,
form: {},
},
...options,
});
const createEdge = (
id: string,
source: string,
target: string,
options: Partial<Edge> = {},
): Edge => ({
id,
source,
target,
...options,
});
// OnBeforeDelete's declared return includes `boolean`, but this hook always
// resolves to the nodes/edges object; the assertions below only read that form.
type BeforeDeleteResult = {
nodes: Node[];
edges: Edge[];
};
describe('useBeforeDelete', () => {
beforeEach(() => {
useGraphStore.setState({
nodes: [],
edges: [],
selectedNodeIds: [],
selectedEdgeIds: [],
clickedNodeId: '',
clickedToolId: '',
});
});
it('expands iteration deletion to descendants and all touching edges', async () => {
const nodes = [
createNode('iteration:0', Operator.Iteration, { type: 'group' }),
createNode('iterationStart:0', Operator.IterationStart, {
parentId: 'iteration:0',
type: 'iterationStartNode',
}),
createNode('message:0', Operator.Message, { parentId: 'iteration:0' }),
createNode('message:1', Operator.Message, { parentId: 'message:0' }),
createNode('generate:0', Operator.Retrieval),
];
const edges = [
createEdge('e1', 'iterationStart:0', 'message:0'),
createEdge('e2', 'message:0', 'message:1'),
createEdge('e3', 'message:0', 'generate:0'),
createEdge('e4', 'generate:0', 'message:1'),
];
useGraphStore.setState({ nodes, edges });
const { result } = renderHook(() => useBeforeDelete());
let deletion: BeforeDeleteResult | undefined;
await act(async () => {
deletion = (await result.current.handleBeforeDelete({
nodes: [nodes[0] as any],
edges: [],
})) as BeforeDeleteResult;
});
expect(deletion?.nodes.map((node) => node.id).sort()).toEqual(
['iteration:0', 'iterationStart:0', 'message:0', 'message:1'].sort(),
);
expect(deletion?.edges.map((edge) => edge.id).sort()).toEqual(
['e1', 'e2', 'e3', 'e4'].sort(),
);
});
it('keeps begin and detached iteration-start protected', async () => {
const beginNode = createNode('begin', Operator.Begin);
const iterationNode = createNode('iteration:0', Operator.Iteration, {
type: 'group',
});
const iterationStartNode = createNode(
'iterationStart:0',
Operator.IterationStart,
{
parentId: 'iteration:0',
type: 'iterationStartNode',
},
);
useGraphStore.setState({
nodes: [beginNode, iterationNode, iterationStartNode],
edges: [],
});
const { result } = renderHook(() => useBeforeDelete());
let beginDeletion: BeforeDeleteResult | undefined;
let startDeletion: BeforeDeleteResult | undefined;
await act(async () => {
beginDeletion = (await result.current.handleBeforeDelete({
nodes: [beginNode as any],
edges: [],
})) as BeforeDeleteResult;
startDeletion = (await result.current.handleBeforeDelete({
nodes: [iterationStartNode as any],
edges: [],
})) as BeforeDeleteResult;
});
expect(beginDeletion?.nodes).toEqual([]);
expect(startDeletion?.nodes).toEqual([]);
});
it('allows deleting a selected edge inside iteration without deleting nodes', async () => {
const nodes = [
createNode('iteration:0', Operator.Iteration, { type: 'group' }),
createNode('iterationStart:0', Operator.IterationStart, {
parentId: 'iteration:0',
type: 'iterationStartNode',
}),
createNode('message:0', Operator.Message, { parentId: 'iteration:0' }),
createNode('message:1', Operator.Message, { parentId: 'iteration:0' }),
];
const selectedEdge = createEdge('e1', 'message:0', 'message:1');
const edges = [
createEdge('e0', 'iterationStart:0', 'message:0'),
selectedEdge,
];
useGraphStore.setState({ nodes, edges });
const { result } = renderHook(() => useBeforeDelete());
let deletion: BeforeDeleteResult | undefined;
await act(async () => {
deletion = (await result.current.handleBeforeDelete({
nodes: [],
edges: [selectedEdge],
})) as BeforeDeleteResult;
});
expect(deletion?.nodes).toEqual([]);
expect(deletion?.edges.map((edge) => edge.id)).toEqual(['e1']);
});
it('does not delete edges of protected nodes when those nodes are rejected', async () => {
const beginNode = createNode('begin', Operator.Begin);
const messageNode = createNode('message:0', Operator.Message);
const edge = createEdge('e1', 'begin', 'message:0');
useGraphStore.setState({
nodes: [beginNode, messageNode],
edges: [edge],
});
const { result } = renderHook(() => useBeforeDelete());
let deletion: BeforeDeleteResult | undefined;
await act(async () => {
deletion = (await result.current.handleBeforeDelete({
nodes: [beginNode as any],
edges: [edge],
})) as BeforeDeleteResult;
});
expect(deletion?.nodes).toEqual([]);
expect(deletion?.edges).toEqual([]);
});
it('deletes edges of a protected node when the other end is deleted', async () => {
const beginNode = createNode('begin', Operator.Begin);
const messageNode = createNode('message:0', Operator.Message);
const edge = createEdge('e1', 'begin', 'message:0');
useGraphStore.setState({
nodes: [beginNode, messageNode],
edges: [edge],
});
const { result } = renderHook(() => useBeforeDelete());
let deletion: BeforeDeleteResult | undefined;
await act(async () => {
deletion = (await result.current.handleBeforeDelete({
nodes: [beginNode as any, messageNode as any],
edges: [edge],
})) as BeforeDeleteResult;
});
expect(deletion?.nodes.map((node) => node.id)).toEqual(['message:0']);
expect(deletion?.edges.map((edge) => edge.id)).toEqual(['e1']);
});
it('preserves agent downstream cleanup', async () => {
const nodes = [
createNode('agent:0', Operator.Agent),
createNode('tool:0', Operator.Tool),
createNode('message:0', Operator.Message),
];
const edges = [
createEdge('e1', 'agent:0', 'tool:0', {
sourceHandle: NodeHandleId.AgentBottom,
}),
createEdge('e2', 'tool:0', 'message:0', {
sourceHandle: NodeHandleId.Tool,
}),
];
useGraphStore.setState({ nodes, edges });
const { result } = renderHook(() => useBeforeDelete());
let deletion: BeforeDeleteResult | undefined;
await act(async () => {
deletion = (await result.current.handleBeforeDelete({
nodes: [nodes[0] as any],
edges,
})) as BeforeDeleteResult;
});
expect(deletion?.nodes.map((node) => node.id).sort()).toEqual(
['agent:0', 'tool:0', 'message:0'].sort(),
);
expect(deletion?.edges.map((edge) => edge.id).sort()).toEqual(
['e1', 'e2'].sort(),
);
});
it('expands iteration deletion to nested agent tool chains', async () => {
const nodes = [
createNode('iteration:0', Operator.Iteration, { type: 'group' }),
createNode('iterationStart:0', Operator.IterationStart, {
parentId: 'iteration:0',
type: 'iterationStartNode',
}),
createNode('agent:0', Operator.Agent, { parentId: 'iteration:0' }),
createNode('tool:0', Operator.Tool),
createNode('message:0', Operator.Message),
createNode('generate:0', Operator.Retrieval),
];
const edges = [
createEdge('e1', 'iterationStart:0', 'agent:0'),
createEdge('e2', 'agent:0', 'tool:0', {
sourceHandle: NodeHandleId.AgentBottom,
}),
createEdge('e3', 'tool:0', 'message:0', {
sourceHandle: NodeHandleId.Tool,
}),
createEdge('e4', 'generate:0', 'message:0'),
];
useGraphStore.setState({ nodes, edges });
const { result } = renderHook(() => useBeforeDelete());
let deletion: BeforeDeleteResult | undefined;
await act(async () => {
deletion = (await result.current.handleBeforeDelete({
nodes: [nodes[0] as any],
edges: [],
})) as BeforeDeleteResult;
});
expect(deletion?.nodes.map((node) => node.id).sort()).toEqual(
[
'iteration:0',
'iterationStart:0',
'agent:0',
'tool:0',
'message:0',
].sort(),
);
expect(deletion?.edges.map((edge) => edge.id).sort()).toEqual(
['e1', 'e2', 'e3', 'e4'].sort(),
);
});
});