Skip to content

Fully autonomous AI Agents system capable of performing complex penetration testing tasks

test(knowledges): cover knowledge-form save/navigation + partial-update mapping

Sergey Kozyrenko4664cf8f535f
diff --git a/frontend/src/features/knowledges/knowledge-form-helpers.test.tsx b/frontend/src/features/knowledges/knowledge-form-helpers.test.tsx
new file mode 100644
index 00000000..3c0238bb
--- /dev/null
+++ b/frontend/src/features/knowledges/knowledge-form-helpers.test.tsx
@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'vitest';
+
+import type { KnowledgeDocumentFragmentFragment } from '@/graphql/types';
+
+import { KnowledgeAnswerType, KnowledgeDocType, KnowledgeGuideType } from '@/graphql/types';
+
+import type { DirtyFlags, FormValues } from './knowledge-form';
+
+import { documentToFormValues, formSchema, formValuesToCreateInput, formValuesToUpdateInput } from './knowledge-form';
+
+const baseValues: FormValues = {
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: '',
+ content: 'some content',
+ description: '',
+ docType: KnowledgeDocType.Answer,
+ guideType: undefined,
+ question: 'a question',
+};
+
+const baseFragment: KnowledgeDocumentFragmentFragment = {
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: null,
+ content: 'frag content',
+ description: null,
+ docType: KnowledgeDocType.Answer,
+ flowId: null,
+ guideType: null,
+ id: '42',
+ manual: true,
+ partSize: 1,
+ question: 'frag question',
+ subtaskId: null,
+ taskId: null,
+ totalSize: 1,
+ userId: '7',
+};
+
+describe('formValuesToCreateInput', () => {
+ it('sends all required fields', () => {
+ const input = formValuesToCreateInput({
+ ...baseValues,
+ codeLang: 'python',
+ description: 'desc',
+ docType: KnowledgeDocType.Code,
+ });
+
+ expect(input).toEqual({
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: 'python',
+ content: 'some content',
+ description: 'desc',
+ docType: KnowledgeDocType.Code,
+ guideType: undefined,
+ question: 'a question',
+ });
+ });
+
+ it('maps empty optional fields to undefined, not ""', () => {
+ const input = formValuesToCreateInput({ ...baseValues, codeLang: '', description: '' });
+
+ expect(input.codeLang).toBeUndefined();
+ expect(input.description).toBeUndefined();
+ });
+});
+
+describe('formValuesToUpdateInput', () => {
+ it('always sends content and omits untouched fields', () => {
+ const input = formValuesToUpdateInput(baseValues, {});
+
+ expect(input).toEqual({ content: 'some content' });
+ expect('description' in input).toBe(false);
+ expect('question' in input).toBe(false);
+ expect('docType' in input).toBe(false);
+ });
+
+ it('emits a dirty+cleared description as "" (not undefined)', () => {
+ const input = formValuesToUpdateInput({ ...baseValues, description: '' }, { description: true });
+
+ expect(input.description).toBe('');
+ });
+
+ it('emits a dirty+cleared codeLang as ""', () => {
+ const input = formValuesToUpdateInput({ ...baseValues, codeLang: '' }, { codeLang: true });
+
+ expect(input.codeLang).toBe('');
+ });
+
+ it.each<[keyof DirtyFlags, Partial<FormValues>, unknown]>([
+ ['docType', { docType: KnowledgeDocType.Guide }, KnowledgeDocType.Guide],
+ ['question', { question: 'new q' }, 'new q'],
+ ['guideType', { guideType: KnowledgeGuideType.Pentest }, KnowledgeGuideType.Pentest],
+ ['answerType', { answerType: KnowledgeAnswerType.Tool }, KnowledgeAnswerType.Tool],
+ ])('includes %s only when dirty', (field, overrides, expected) => {
+ const values = { ...baseValues, ...overrides };
+
+ expect(formValuesToUpdateInput(values, {})[field]).toBeUndefined();
+ expect(formValuesToUpdateInput(values, { [field]: true })[field]).toBe(expected);
+ });
+});
+
+describe('documentToFormValues', () => {
+ it('coerces nullish subtypes to undefined and nullish text to ""', () => {
+ expect(documentToFormValues(baseFragment)).toEqual({
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: '',
+ content: 'frag content',
+ description: '',
+ docType: KnowledgeDocType.Answer,
+ guideType: undefined,
+ question: 'frag question',
+ });
+ });
+
+ it('preserves present values', () => {
+ const values = documentToFormValues({
+ ...baseFragment,
+ codeLang: 'go',
+ description: 'a desc',
+ guideType: KnowledgeGuideType.Install,
+ });
+
+ expect(values.codeLang).toBe('go');
+ expect(values.description).toBe('a desc');
+ expect(values.guideType).toBe(KnowledgeGuideType.Install);
+ });
+});
+
+describe('formSchema', () => {
+ const valid: FormValues = {
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: '',
+ content: 'content',
+ description: '',
+ docType: KnowledgeDocType.Answer,
+ guideType: undefined,
+ question: 'question',
+ };
+
+ it('accepts a valid Answer document', () => {
+ expect(formSchema.safeParse(valid).success).toBe(true);
+ });
+
+ it('requires content', () => {
+ const result = formSchema.safeParse({ ...valid, content: '' });
+
+ expect(result.success).toBe(false);
+ expect(result.error?.issues.find((i) => i.path[0] === 'content')?.message).toBe('Content is required');
+ });
+
+ it('requires question', () => {
+ const result = formSchema.safeParse({ ...valid, question: '' });
+
+ expect(result.success).toBe(false);
+ expect(result.error?.issues.find((i) => i.path[0] === 'question')?.message).toBe('Question is required');
+ });
+
+ it('enforces the question max-length message', () => {
+ const result = formSchema.safeParse({ ...valid, question: 'x'.repeat(2049) });
+
+ expect(result.success).toBe(false);
+ expect(result.error?.issues.find((i) => i.path[0] === 'question')?.message).toBe(
+ 'Question must be 2048 characters or fewer',
+ );
+ });
+
+ it('enforces the description max-length message', () => {
+ const result = formSchema.safeParse({ ...valid, description: 'x'.repeat(1001) });
+
+ expect(result.success).toBe(false);
+ expect(result.error?.issues.find((i) => i.path[0] === 'description')?.message).toBe(
+ 'Description must be 1000 characters or fewer',
+ );
+ });
+
+ it.each<[KnowledgeDocType, keyof FormValues, string]>([
+ [KnowledgeDocType.Answer, 'answerType', 'Answer type is required'],
+ [KnowledgeDocType.Code, 'codeLang', 'Code language is required'],
+ [KnowledgeDocType.Guide, 'guideType', 'Guide type is required'],
+ ])('requires the %s subtype field', (docType, field, message) => {
+ const result = formSchema.safeParse({
+ ...valid,
+ answerType: undefined,
+ codeLang: '',
+ docType,
+ guideType: undefined,
+ });
+
+ expect(result.success).toBe(false);
+ const issue = result.error?.issues.find((i) => i.path[0] === field);
+ expect(issue?.message).toBe(message);
+ });
+
+ it.each<[KnowledgeDocType, Partial<FormValues>]>([
+ [KnowledgeDocType.Answer, { answerType: KnowledgeAnswerType.Tool }],
+ [KnowledgeDocType.Code, { codeLang: 'rust' }],
+ [KnowledgeDocType.Guide, { guideType: KnowledgeGuideType.Use }],
+ ])('passes the superRefine for %s when its subtype is present', (docType, overrides) => {
+ const result = formSchema.safeParse({
+ ...valid,
+ answerType: undefined,
+ codeLang: '',
+ docType,
+ guideType: undefined,
+ ...overrides,
+ });
+
+ expect(result.success).toBe(true);
+ });
+});
diff --git a/frontend/src/features/knowledges/knowledge-form.test.tsx b/frontend/src/features/knowledges/knowledge-form.test.tsx
new file mode 100644
index 00000000..26664054
--- /dev/null
+++ b/frontend/src/features/knowledges/knowledge-form.test.tsx
@@ -0,0 +1,195 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { type Control, Controller } from 'react-hook-form';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { KnowledgeAnswerType, KnowledgeDocType } from '@/graphql/types';
+
+import type { FormValues, SubmitResult } from './knowledge-form';
+
+const { navigate } = vi.hoisted(() => ({ navigate: vi.fn() }));
+
+// `useBlocker` throws outside a data router; the guard only needs a stable
+// inert blocker for these save/navigation tests.
+vi.mock('react-router-dom', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('react-router-dom')>();
+
+ return {
+ ...actual,
+ useBlocker: () => ({ proceed: undefined, reset: undefined, state: 'unblocked' }),
+ useNavigate: () => navigate,
+ };
+});
+
+vi.mock('@/hooks/use-breakpoint', () => ({
+ useBreakpoint: () => ({ isDesktop: true, isMobile: false }),
+}));
+
+vi.mock('@apollo/client/react', () => ({ useMutation: () => [vi.fn(), {}] }));
+
+vi.mock('@/providers/user-provider', () => ({
+ useUser: () => ({ authInfo: { privileges: ['anonymize.call'] } }),
+}));
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), info: vi.fn(), success: vi.fn() } }));
+
+vi.mock('./knowledge-form-layout', () => {
+ const Layout = ({ control }: { control: Control<FormValues> }) => (
+ <>
+ <Controller
+ control={control}
+ name="content"
+ render={({ field }) => <textarea aria-label="content" {...field} />}
+ />
+ <Controller
+ control={control}
+ name="question"
+ render={({ field }) => <input aria-label="question" {...field} />}
+ />
+ </>
+ );
+
+ return { KnowledgeFormLayoutDesktop: Layout, KnowledgeFormLayoutMobile: Layout };
+});
+
+vi.mock('./knowledge-header', () => ({
+ KnowledgeHeader: ({
+ isAnonymizeDisabled,
+ saveButton,
+ }: {
+ isAnonymizeDisabled?: boolean;
+ saveButton?: React.ReactNode;
+ }) => (
+ <div>
+ {saveButton}
+ <button
+ disabled={isAnonymizeDisabled}
+ type="button"
+ >
+ Anonymize
+ </button>
+ </div>
+ ),
+}));
+
+import { KnowledgeForm } from './knowledge-form';
+
+const newValues: FormValues = {
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: '',
+ content: '',
+ description: '',
+ docType: KnowledgeDocType.Answer,
+ guideType: undefined,
+ question: '',
+};
+
+const editValues: FormValues = {
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: '',
+ content: 'existing content',
+ description: '',
+ docType: KnowledgeDocType.Answer,
+ guideType: undefined,
+ question: 'existing question',
+};
+
+beforeEach(() => {
+ navigate.mockClear();
+});
+
+describe('KnowledgeForm — create', () => {
+ it('submits values and navigates to the redirect target', async () => {
+ const user = userEvent.setup();
+ const onSubmit = vi.fn<(values: FormValues, dirty: unknown) => Promise<SubmitResult>>().mockResolvedValue({
+ redirectTo: '/knowledges/123',
+ });
+
+ render(
+ <KnowledgeForm
+ initialValues={newValues}
+ isNew
+ onSubmit={onSubmit}
+ />,
+ );
+
+ await user.type(screen.getByLabelText('content'), 'hello world');
+ await user.type(screen.getByLabelText('question'), 'why');
+ await user.click(screen.getByRole('button', { name: 'Create' }));
+
+ await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
+ const [values, dirty] = onSubmit.mock.lastCall!;
+ expect(values.content).toBe('hello world');
+ expect(values.question).toBe('why');
+ expect(dirty).toMatchObject({ content: true, question: true });
+
+ await waitFor(() => expect(navigate).toHaveBeenCalledWith('/knowledges/123'));
+ });
+});
+
+describe('KnowledgeForm — update', () => {
+ it('submits the edited field and does NOT navigate without a redirect', async () => {
+ const user = userEvent.setup();
+ const onSubmit = vi
+ .fn<(values: FormValues, dirty: unknown) => Promise<SubmitResult>>()
+ .mockResolvedValue({ document: undefined });
+
+ render(
+ <KnowledgeForm
+ initialValues={editValues}
+ isNew={false}
+ onSubmit={onSubmit}
+ />,
+ );
+
+ const question = screen.getByLabelText('question');
+ await user.clear(question);
+ await user.type(question, 'updated question');
+ await user.click(screen.getByRole('button', { name: 'Save' }));
+
+ await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
+ const [values, dirty] = onSubmit.mock.lastCall!;
+ expect(values.question).toBe('updated question');
+ expect(dirty).toMatchObject({ question: true });
+
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(navigate).not.toHaveBeenCalled();
+ });
+
+ it('keeps Save disabled until the form is dirty', async () => {
+ const user = userEvent.setup();
+ const onSubmit = vi.fn().mockResolvedValue({});
+
+ render(
+ <KnowledgeForm
+ initialValues={editValues}
+ isNew={false}
+ onSubmit={onSubmit}
+ />,
+ );
+
+ expect(screen.getByRole('button', { name: 'Save' })).toBeDisabled();
+
+ await user.type(screen.getByLabelText('question'), '!');
+ await waitFor(() => expect(screen.getByRole('button', { name: 'Save' })).toBeEnabled());
+ });
+});
+
+describe('KnowledgeForm — anonymize wiring', () => {
+ it('disables the anonymize control until content is non-empty', async () => {
+ const user = userEvent.setup();
+
+ render(
+ <KnowledgeForm
+ initialValues={newValues}
+ isNew
+ onSubmit={vi.fn().mockResolvedValue({})}
+ />,
+ );
+
+ expect(screen.getByRole('button', { name: 'Anonymize' })).toBeDisabled();
+
+ await user.type(screen.getByLabelText('content'), 'secret data');
+ await waitFor(() => expect(screen.getByRole('button', { name: 'Anonymize' })).toBeEnabled());
+ });
+});