Skip to content

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

test: close the coverage gaps flagged by the review

Sergey Kozyrenkod3c46c715863
diff --git a/backend/pkg/providers/get_providers_test.go b/backend/pkg/providers/get_providers_test.go
index 1e2420bb..f6e1321a 100644
--- a/backend/pkg/providers/get_providers_test.go
+++ b/backend/pkg/providers/get_providers_test.go
@@ -47,3 +47,24 @@ func TestGetProviders_SkipsUserProviderOfDisabledType(t *testing.T) {
assert.Contains(t, got, provider.ProviderName("openai-default"), "enabled providers stay reachable")
assert.NotContains(t, got, provider.ProviderName("stale-minimax"), "the unavailable provider is skipped")
}
+
+func TestGetProviders_StaleUserRowSpansValidSibling(t *testing.T) {
+ pc := &providerController{
+ cfg: &config.Config{},
+ db: stubProvidersQuerier{rows: []database.Provider{
+ // ollama.New builds with no API key and makes no network call (pull/load
+ // off under the empty config), so this row clears the real NewProvider.
+ {Name: "ollama-user", Type: "ollama"},
+ {Name: "stale-minimax", Type: "minimax"}, // type absent from ListTypes()
+ }},
+ Providers: provider.Providers{
+ "ollama-default": stubTypedProvider{ptype: provider.ProviderOllama},
+ },
+ }
+
+ got, err := pc.GetProviders(context.Background(), 1)
+
+ require.NoError(t, err, "a stale sibling row must not fail the whole query")
+ assert.Contains(t, got, provider.ProviderName("ollama-user"), "a valid user provider survives a stale sibling")
+ assert.NotContains(t, got, provider.ProviderName("stale-minimax"), "the unbuildable sibling is skipped")
+}
diff --git a/frontend/src/features/knowledges/knowledge-form-blocker.test.tsx b/frontend/src/features/knowledges/knowledge-form-blocker.test.tsx
new file mode 100644
index 00000000..71944e33
--- /dev/null
+++ b/frontend/src/features/knowledges/knowledge-form-blocker.test.tsx
@@ -0,0 +1,100 @@
+import { render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { type Control, Controller } from 'react-hook-form';
+import { createMemoryRouter, Link, RouterProvider } from 'react-router-dom';
+import { describe, expect, it, vi } from 'vitest';
+
+import { KnowledgeAnswerType, KnowledgeDocType } from '@/graphql/types';
+
+import type { FormValues, SubmitResult } from './knowledge-form';
+
+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: ({ saveButton }: { saveButton?: React.ReactNode }) => <div>{saveButton}</div>,
+}));
+
+import { KnowledgeForm } from './knowledge-form';
+
+const newValues: FormValues = {
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: '',
+ content: '',
+ description: '',
+ docType: KnowledgeDocType.Answer,
+ guideType: undefined,
+ question: '',
+};
+
+describe('KnowledgeForm — Save and leave (data router)', () => {
+ it('proceeds the blocked navigation without honoring a CREATE redirect', async () => {
+ const user = userEvent.setup();
+ const onSubmit = vi
+ .fn<(values: FormValues, dirty: unknown) => Promise<SubmitResult>>()
+ .mockResolvedValue({ redirectTo: '/knowledges/new-id' });
+
+ const router = createMemoryRouter(
+ [
+ {
+ element: (
+ <>
+ <Link to="/elsewhere">go elsewhere</Link>
+ <KnowledgeForm
+ initialValues={newValues}
+ isNew
+ onSubmit={onSubmit}
+ />
+ </>
+ ),
+ path: '/',
+ },
+ { element: <div>elsewhere page</div>, path: '/elsewhere' },
+ { element: <div>new doc page</div>, path: '/knowledges/new-id' },
+ ],
+ { initialEntries: ['/'] },
+ );
+
+ render(<RouterProvider router={router} />);
+
+ await user.type(screen.getByLabelText('content'), 'hello world');
+ await user.type(screen.getByLabelText('question'), 'why');
+
+ await user.click(screen.getByRole('link', { name: 'go elsewhere' }));
+
+ const dialog = await screen.findByRole('dialog');
+ await user.click(within(dialog).getByRole('button', { name: 'Save' }));
+
+ await waitFor(() => expect(screen.getByText('elsewhere page')).toBeInTheDocument());
+ expect(screen.queryByText('new doc page')).not.toBeInTheDocument();
+ expect(onSubmit).toHaveBeenCalledOnce();
+ });
+});
diff --git a/frontend/src/features/knowledges/knowledge-form.test.tsx b/frontend/src/features/knowledges/knowledge-form.test.tsx
index 26664054..c4468638 100644
--- a/frontend/src/features/knowledges/knowledge-form.test.tsx
+++ b/frontend/src/features/knowledges/knowledge-form.test.tsx
@@ -3,6 +3,8 @@ import userEvent from '@testing-library/user-event';
import { type Control, Controller } from 'react-hook-form';
import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { KnowledgeDocumentFragmentFragment } from '@/graphql/types';
+
import { KnowledgeAnswerType, KnowledgeDocType } from '@/graphql/types';
import type { FormValues, SubmitResult } from './knowledge-form';
@@ -152,10 +154,60 @@ describe('KnowledgeForm — update', () => {
expect(values.question).toBe('updated question');
expect(dirty).toMatchObject({ question: true });
- await new Promise((resolve) => setTimeout(resolve, 0));
+ // Save re-disables once the post-save reset clears isDirty — a deterministic
+ // anchor for the negative navigate assertion below.
+ await waitFor(() => expect(screen.getByRole('button', { name: 'Save' })).toBeDisabled());
expect(navigate).not.toHaveBeenCalled();
});
+ it('resets untouched fields to the server document returned by onSubmit', async () => {
+ const user = userEvent.setup();
+ // Server normalizes `content` (a field the user never edits here). The form's
+ // resetOptions keep DIRTY fields at their typed value, so asserting the reset
+ // applied the server document means asserting on an untouched field.
+ const serverDocument = {
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: null,
+ content: 'server normalized content',
+ description: null,
+ docType: KnowledgeDocType.Answer,
+ flowId: null,
+ guideType: null,
+ id: 'doc-1',
+ manual: false,
+ partSize: 0,
+ question: 'updated question',
+ subtaskId: null,
+ taskId: null,
+ totalSize: 0,
+ userId: 'u-1',
+ } satisfies KnowledgeDocumentFragmentFragment;
+
+ const onSubmit = vi
+ .fn<(values: FormValues, dirty: unknown) => Promise<SubmitResult>>()
+ .mockResolvedValue({ document: serverDocument });
+
+ 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());
+
+ // editValues.content is 'existing content'; reaching the server value proves the
+ // form took `documentToFormValues(result.document)`, not the local `values` fallback.
+ await waitFor(() => expect(screen.getByLabelText('content')).toHaveValue('server normalized content'));
+ expect(screen.getByRole('button', { name: 'Save' })).toBeDisabled();
+ });
+
it('keeps Save disabled until the form is dirty', async () => {
const user = userEvent.setup();
const onSubmit = vi.fn().mockResolvedValue({});
diff --git a/frontend/src/pages/settings/settings-provider.test.tsx b/frontend/src/pages/settings/settings-provider.test.tsx
new file mode 100644
index 00000000..5688c160
--- /dev/null
+++ b/frontend/src/pages/settings/settings-provider.test.tsx
@@ -0,0 +1,127 @@
+import { render } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ProviderType } from '@/graphql/types';
+import { routes } from '@/lib/routes';
+
+const { navigate } = vi.hoisted(() => ({ navigate: vi.fn() }));
+
+const state = vi.hoisted(() => ({ params: new URLSearchParams() }));
+
+const setSearch = (search: string) => {
+ state.params = new URLSearchParams(search);
+};
+
+const enabled = {
+ anthropic: true,
+ bedrock: true,
+ custom: false,
+ deepseek: true,
+ gemini: true,
+ glm: true,
+ kimi: true,
+ minimax: false,
+ ollama: true,
+ openai: true,
+ qwen: true,
+};
+
+const emptyProvider = { agents: {} };
+
+const userDefined = [
+ {
+ agents: {},
+ createdAt: '',
+ id: 'disabled-1',
+ name: 'My MiniMax',
+ type: ProviderType.Minimax,
+ updatedAt: '',
+ },
+];
+
+const settingsProviders = {
+ default: {
+ anthropic: emptyProvider,
+ openai: emptyProvider,
+ },
+ enabled,
+ models: { anthropic: [], minimax: [], openai: [] },
+ userDefined,
+};
+
+// A stable `data` identity matters: the page's seeding effect lists `data` as a
+// dependency, so a fresh object each render would loop it (Apollo returns a
+// cached reference in production).
+const queryResult = { data: { settingsProviders }, error: undefined, loading: false };
+
+vi.mock('@apollo/client/react', () => ({
+ useMutation: () => [vi.fn(), {}],
+ useQuery: () => queryResult,
+}));
+
+// `useBlocker` throws outside a data router; the guard only needs a stable inert
+// blocker for these render/guard tests.
+vi.mock('react-router-dom', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('react-router-dom')>()),
+ useBlocker: () => ({ proceed: undefined, reset: undefined, state: 'unblocked' }),
+ useNavigate: () => navigate,
+ useParams: () => ({ providerId: 'new' }),
+ useSearchParams: () => [state.params, vi.fn()],
+}));
+
+vi.mock('@/hooks/use-breakpoint', () => ({
+ useBreakpoint: () => ({ isDesktop: true, isMobile: false }),
+}));
+
+// AppHeader pulls in SidebarTrigger (needs a SidebarProvider context); stub the
+// whole family so the guard effect under test renders without that scaffolding.
+vi.mock('@/components/layouts/app/app-header', () => {
+ const Pass = ({ children }: { children?: React.ReactNode }) => <div>{children}</div>;
+
+ return {
+ AppHeader: Pass,
+ AppHeaderAction: Pass,
+ AppHeaderActions: Pass,
+ AppHeaderContent: Pass,
+ AppHeaderTitle: Pass,
+ };
+});
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), info: vi.fn(), success: vi.fn() } }));
+
+import SettingsProvider from './settings-provider';
+
+beforeEach(() => {
+ navigate.mockClear();
+ setSearch('');
+});
+
+describe('SettingsProvider create-form type guards', () => {
+ it('bounces ?type= for a disabled type', () => {
+ setSearch('type=minimax');
+ render(<SettingsProvider />);
+
+ expect(navigate).toHaveBeenCalledWith(routes.settings.providers, { replace: true });
+ });
+
+ it('bounces ?type= for an unknown type', () => {
+ setSearch('type=not-a-real-provider');
+ render(<SettingsProvider />);
+
+ expect(navigate).toHaveBeenCalledWith(routes.settings.providers, { replace: true });
+ });
+
+ it('bounces ?id= cloning a provider whose type is disabled', () => {
+ setSearch('id=disabled-1');
+ render(<SettingsProvider />);
+
+ expect(navigate).toHaveBeenCalledWith(routes.settings.providers, { replace: true });
+ });
+
+ it('renders the create form for an enabled ?type=', () => {
+ setSearch('type=anthropic');
+ render(<SettingsProvider />);
+
+ expect(navigate).not.toHaveBeenCalled();
+ });
+});