Fully autonomous AI Agents system capable of performing complex penetration testing tasks
Go ai-agentsai-security-toolanthropicautonomous-agentsgolanggptgraphqlmulti-agent-systemoffensive-securityopen-sourceopenaipenetration-testingpenetration-testing-toolsreactsecurity-automationsecurity-testingsecurity-toolsself-hosted
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.goindex 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.tsxnew file mode 100644index 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.tsxindex 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.tsxnew file mode 100644index 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();+ });+});