Skip to content

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

feat(e2e): dashboard, settings, resources coverage + route manifest sweep

Sergey Kozyrenko5cb0522818c3
diff --git a/frontend/e2e/mocks/cassettes/dashboard.ts b/frontend/e2e/mocks/cassettes/dashboard.ts
new file mode 100644
index 00000000..7ce6e0fd
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/dashboard.ts
@@ -0,0 +1,153 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type {
+ FlowsExecutionStatsByPeriodDocument,
+ FlowsStatsByPeriodDocument,
+ FlowsStatsTotalDocument,
+ ToolcallsStatsByFunctionDocument,
+ ToolcallsStatsByPeriodDocument,
+ ToolcallsStatsTotalDocument,
+ UsageStatsByAgentTypeDocument,
+ UsageStatsByModelDocument,
+ UsageStatsByPeriodDocument,
+ UsageStatsByProviderDocument,
+ UsageStatsFragmentFragment,
+ UsageStatsTotalDocument,
+} from '@/graphql/types';
+
+import { AgentType } from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { entity, mergeCassettes } from '../cassette.ts';
+import { baseQueries, baseRest } from './base.ts';
+
+const DATES = ['2026-01-15', '2026-01-14', '2026-01-13'];
+
+const usageStats = (seed: number): UsageStatsFragmentFragment =>
+ entity('UsageStats', {
+ totalUsageCacheIn: seed * 5,
+ totalUsageCacheOut: seed * 3,
+ totalUsageCostIn: seed * 0.01,
+ totalUsageCostOut: seed * 0.02,
+ totalUsageIn: seed * 100,
+ totalUsageOut: seed * 40,
+ });
+
+const usageStatsByPeriod: ResultOf<typeof UsageStatsByPeriodDocument> = {
+ usageStatsByPeriod: DATES.map((date, index) => entity('DailyUsageStats', { date, stats: usageStats(index + 1) })),
+};
+
+const toolcallsStatsByPeriod: ResultOf<typeof ToolcallsStatsByPeriodDocument> = {
+ toolcallsStatsByPeriod: DATES.map((date, index) =>
+ entity('DailyToolcallsStats', {
+ date,
+ stats: entity('ToolcallsStats', { totalCount: index + 2, totalDurationSeconds: (index + 1) * 6 }),
+ }),
+ ),
+};
+
+const flowsStatsByPeriod: ResultOf<typeof FlowsStatsByPeriodDocument> = {
+ flowsStatsByPeriod: DATES.map((date, index) =>
+ entity('DailyFlowsStats', {
+ date,
+ stats: entity('FlowsStats', {
+ totalAssistantsCount: index,
+ totalFlowsCount: index + 1,
+ totalSubtasksCount: (index + 1) * 3,
+ totalTasksCount: (index + 1) * 2,
+ }),
+ }),
+ ),
+};
+
+const flowsExecutionStatsByPeriod: ResultOf<typeof FlowsExecutionStatsByPeriodDocument> = {
+ flowsExecutionStatsByPeriod: [
+ entity('FlowExecutionStats', {
+ flowId: '5',
+ flowTitle: 'E2E Alpha',
+ tasks: [
+ entity('TaskExecutionStats', {
+ subtasks: [
+ entity('SubtaskExecutionStats', {
+ subtaskId: '21',
+ subtaskTitle: 'E2E Subtask',
+ totalDurationSeconds: 30,
+ totalToolcallsCount: 2,
+ }),
+ ],
+ taskId: '11',
+ taskTitle: 'E2E Task',
+ totalDurationSeconds: 60,
+ totalToolcallsCount: 4,
+ }),
+ ],
+ totalAssistantsCount: 1,
+ totalDurationSeconds: 120,
+ totalToolcallsCount: 7,
+ }),
+ ],
+};
+
+const usageStatsTotal: ResultOf<typeof UsageStatsTotalDocument> = { usageStatsTotal: usageStats(10) };
+
+const usageStatsByProvider: ResultOf<typeof UsageStatsByProviderDocument> = {
+ usageStatsByProvider: [entity('ProviderUsageStats', { provider: 'e2e-provider', stats: usageStats(3) })],
+};
+
+const usageStatsByModel: ResultOf<typeof UsageStatsByModelDocument> = {
+ usageStatsByModel: [
+ entity('ModelUsageStats', { model: 'e2e-model', provider: 'e2e-provider', stats: usageStats(2) }),
+ ],
+};
+
+const usageStatsByAgentType: ResultOf<typeof UsageStatsByAgentTypeDocument> = {
+ usageStatsByAgentType: [entity('AgentTypeUsageStats', { agentType: AgentType.Pentester, stats: usageStats(1) })],
+};
+
+const toolcallsStatsTotal: ResultOf<typeof ToolcallsStatsTotalDocument> = {
+ toolcallsStatsTotal: entity('ToolcallsStats', { totalCount: 42, totalDurationSeconds: 360 }),
+};
+
+const toolcallsStatsByFunction: ResultOf<typeof ToolcallsStatsByFunctionDocument> = {
+ toolcallsStatsByFunction: [
+ entity('FunctionToolcallsStats', {
+ avgDurationSeconds: 2,
+ functionName: 'e2e_terminal',
+ isAgent: false,
+ totalCount: 21,
+ totalDurationSeconds: 42,
+ }),
+ ],
+};
+
+const flowsStatsTotal: ResultOf<typeof FlowsStatsTotalDocument> = {
+ flowsStatsTotal: entity('FlowsStats', {
+ totalAssistantsCount: 1,
+ totalFlowsCount: 8,
+ totalSubtasksCount: 34,
+ totalTasksCount: 13,
+ }),
+};
+
+export const dashboardCassette = (override: Cassette = {}): Cassette =>
+ mergeCassettes(
+ {
+ queries: {
+ ...baseQueries(),
+ flowsExecutionStatsByPeriod: [{ data: flowsExecutionStatsByPeriod }],
+ flowsStatsByPeriod: [{ data: flowsStatsByPeriod }],
+ flowsStatsTotal: [{ data: flowsStatsTotal }],
+ toolcallsStatsByFunction: [{ data: toolcallsStatsByFunction }],
+ toolcallsStatsByPeriod: [{ data: toolcallsStatsByPeriod }],
+ toolcallsStatsTotal: [{ data: toolcallsStatsTotal }],
+ usageStatsByAgentType: [{ data: usageStatsByAgentType }],
+ usageStatsByModel: [{ data: usageStatsByModel }],
+ usageStatsByPeriod: [{ data: usageStatsByPeriod }],
+ usageStatsByProvider: [{ data: usageStatsByProvider }],
+ usageStatsTotal: [{ data: usageStatsTotal }],
+ },
+ rest: baseRest(),
+ },
+ override,
+ );
diff --git a/frontend/e2e/mocks/cassettes/resources.ts b/frontend/e2e/mocks/cassettes/resources.ts
new file mode 100644
index 00000000..b896e3d0
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/resources.ts
@@ -0,0 +1,53 @@
+import type { RestResourceEntry, RestResourceList } from '@/features/resources/resources-rest';
+import type { UserResourceFragmentFragment } from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { entity, mergeCassettes } from '../cassette.ts';
+import { baseQueries, baseRest } from './base.ts';
+
+const T = '2026-01-15T09:00:00Z';
+
+const makeRestResource = (id: number, name: string, size: number, isDir: boolean): RestResourceEntry => ({
+ created_at: T,
+ id,
+ is_dir: isDir,
+ name,
+ path: name,
+ size,
+ updated_at: T,
+ user_id: 1,
+});
+
+export const FOLDER_RESOURCE = makeRestResource(1, 'reports', 0, true);
+export const FILE_RESOURCE = makeRestResource(2, 'notes.txt', 1234, false);
+
+export const CREATED_FOLDER: UserResourceFragmentFragment = entity('UserResource', {
+ createdAt: '2026-01-15T12:00:00Z',
+ id: '3',
+ isDir: true,
+ name: 'new-folder',
+ path: 'new-folder',
+ size: 0,
+ updatedAt: '2026-01-15T12:00:00Z',
+ userId: '1',
+});
+
+const seededList: RestResourceList = { items: [FOLDER_RESOURCE, FILE_RESOURCE], total: 2 };
+
+export const emptyResourcesCassette = (): Cassette => ({
+ queries: baseQueries(),
+ rest: baseRest(),
+});
+
+export const resourcesCassette = (override: Cassette = {}): Cassette =>
+ mergeCassettes(
+ {
+ queries: baseQueries(),
+ rest: {
+ ...baseRest(),
+ 'GET /api/v1/resources/': [{ body: { data: seededList, status: 'success' } }],
+ },
+ },
+ override,
+ );
diff --git a/frontend/e2e/mocks/cassettes/settings-prompts.ts b/frontend/e2e/mocks/cassettes/settings-prompts.ts
new file mode 100644
index 00000000..de4be793
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/settings-prompts.ts
@@ -0,0 +1,71 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type { DefaultPromptFragmentFragment, SettingsPromptsDocument } from '@/graphql/types';
+
+import { PromptType } from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { entity, mergeCassettes } from '../cassette.ts';
+import { baseQueries, baseRest } from './base.ts';
+
+export const promptTemplate = (type: PromptType): string => `E2E template for ${type}`;
+
+const prompt = (type: PromptType): DefaultPromptFragmentFragment =>
+ entity('DefaultPrompt', { template: promptTemplate(type), type, variables: ['Input'] });
+
+const agentPrompt = (system: PromptType) => entity('AgentPrompt', { system: prompt(system) });
+
+const agentPromptPair = (system: PromptType, human: PromptType) =>
+ entity('AgentPrompts', { human: prompt(human), system: prompt(system) });
+
+const settingsPrompts: ResultOf<typeof SettingsPromptsDocument> = {
+ settingsPrompts: entity('PromptsConfig', {
+ default: entity('DefaultPrompts', {
+ agents: entity('AgentsPrompts', {
+ adviser: agentPromptPair(PromptType.Adviser, PromptType.QuestionAdviser),
+ assistant: agentPrompt(PromptType.Assistant),
+ coder: agentPromptPair(PromptType.Coder, PromptType.QuestionCoder),
+ enricher: agentPromptPair(PromptType.Enricher, PromptType.QuestionEnricher),
+ generator: agentPromptPair(PromptType.SubtasksGenerator, PromptType.Generator),
+ installer: agentPromptPair(PromptType.Installer, PromptType.QuestionInstaller),
+ memorist: agentPromptPair(PromptType.Memorist, PromptType.QuestionMemorist),
+ pentester: agentPromptPair(PromptType.Pentester, PromptType.QuestionPentester),
+ primaryAgent: agentPrompt(PromptType.PrimaryAgent),
+ refiner: agentPromptPair(PromptType.SubtasksRefiner, PromptType.Refiner),
+ reflector: agentPromptPair(PromptType.Reflector, PromptType.QuestionReflector),
+ reporter: agentPromptPair(PromptType.Reporter, PromptType.TaskReporter),
+ searcher: agentPromptPair(PromptType.Searcher, PromptType.QuestionSearcher),
+ summarizer: agentPrompt(PromptType.Summarizer),
+ toolCallFixer: agentPromptPair(PromptType.ToolcallFixer, PromptType.InputToolcallFixer),
+ }),
+ tools: entity('ToolsPrompts', {
+ chooseDockerImage: prompt(PromptType.ImageChooser),
+ chooseUserLanguage: prompt(PromptType.LanguageChooser),
+ collectToolCallId: prompt(PromptType.ToolCallIdCollector),
+ detectToolCallIdPattern: prompt(PromptType.ToolCallIdDetector),
+ getExecutionLogs: prompt(PromptType.ExecutionLogs),
+ getFlowDescription: prompt(PromptType.FlowDescriptor),
+ getFullExecutionContext: prompt(PromptType.FullExecutionContext),
+ getShortExecutionContext: prompt(PromptType.ShortExecutionContext),
+ getTaskDescription: prompt(PromptType.TaskDescriptor),
+ monitorAgentExecution: prompt(PromptType.QuestionExecutionMonitor),
+ planAgentTask: prompt(PromptType.QuestionTaskPlanner),
+ wrapAgentTask: prompt(PromptType.TaskAssignmentWrapper),
+ }),
+ }),
+ userDefined: [],
+ }),
+};
+
+export const settingsPromptsCassette = (override: Cassette = {}): Cassette =>
+ mergeCassettes(
+ {
+ queries: {
+ ...baseQueries(),
+ settingsPrompts: [{ data: settingsPrompts }],
+ },
+ rest: baseRest(),
+ },
+ override,
+ );
diff --git a/frontend/e2e/mocks/cassettes/settings-providers.ts b/frontend/e2e/mocks/cassettes/settings-providers.ts
new file mode 100644
index 00000000..ed0f4b5b
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/settings-providers.ts
@@ -0,0 +1,117 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type {
+ AgentConfigFragmentFragment,
+ AgentsConfigFragmentFragment,
+ ProviderConfigFragmentFragment,
+ SettingsProvidersDocument,
+} from '@/graphql/types';
+
+import { ProviderType } from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { entity, mergeCassettes } from '../cassette.ts';
+import { baseQueries, baseRest } from './base.ts';
+
+const T = '2026-01-15T09:00:00Z';
+
+const agentConfig = (): AgentConfigFragmentFragment =>
+ entity('AgentConfig', {
+ frequencyPenalty: null,
+ maxLength: null,
+ maxTokens: null,
+ minLength: null,
+ model: 'e2e-model',
+ presencePenalty: null,
+ price: null,
+ reasoning: null,
+ repetitionPenalty: null,
+ temperature: null,
+ topK: null,
+ topP: null,
+ });
+
+const agentsConfig = (): AgentsConfigFragmentFragment =>
+ entity('AgentsConfig', {
+ adviser: agentConfig(),
+ assistant: agentConfig(),
+ coder: agentConfig(),
+ enricher: agentConfig(),
+ generator: agentConfig(),
+ installer: agentConfig(),
+ pentester: agentConfig(),
+ primaryAgent: agentConfig(),
+ refiner: agentConfig(),
+ reflector: agentConfig(),
+ searcher: agentConfig(),
+ simple: agentConfig(),
+ simpleJson: agentConfig(),
+ });
+
+const defaultConfig = (id: string, type: ProviderType): ProviderConfigFragmentFragment =>
+ entity('ProviderConfig', {
+ agents: agentsConfig(),
+ createdAt: T,
+ id,
+ name: `default-${type}`,
+ type,
+ updatedAt: T,
+ });
+
+const noProviders: ResultOf<typeof SettingsProvidersDocument> = {
+ settingsProviders: entity('ProvidersConfig', {
+ default: entity('DefaultProvidersConfig', {
+ anthropic: defaultConfig('default-anthropic', ProviderType.Anthropic),
+ bedrock: null,
+ custom: null,
+ deepseek: null,
+ gemini: null,
+ glm: null,
+ kimi: null,
+ minimax: null,
+ ollama: null,
+ openai: defaultConfig('default-openai', ProviderType.Openai),
+ qwen: null,
+ }),
+ enabled: entity('ProvidersReadinessStatus', {
+ anthropic: false,
+ bedrock: false,
+ custom: false,
+ deepseek: false,
+ gemini: false,
+ glm: false,
+ kimi: false,
+ minimax: false,
+ ollama: false,
+ openai: false,
+ qwen: false,
+ }),
+ models: entity('ProvidersModelsList', {
+ anthropic: [],
+ bedrock: [],
+ custom: [],
+ deepseek: [],
+ gemini: [],
+ glm: [],
+ kimi: [],
+ minimax: [],
+ ollama: [],
+ openai: [],
+ qwen: [],
+ }),
+ userDefined: [],
+ }),
+};
+
+export const settingsProvidersCassette = (override: Cassette = {}): Cassette =>
+ mergeCassettes(
+ {
+ queries: {
+ ...baseQueries(),
+ settingsProviders: [{ data: noProviders }],
+ },
+ rest: baseRest(),
+ },
+ override,
+ );
diff --git a/frontend/e2e/routes.ts b/frontend/e2e/routes.ts
new file mode 100644
index 00000000..2359f8f6
--- /dev/null
+++ b/frontend/e2e/routes.ts
@@ -0,0 +1,85 @@
+import type { Locator, Page } from '@playwright/test';
+
+import { routes } from '@/lib/routes';
+
+import type { Cassette } from './mocks/cassette.ts';
+
+import { apiTokensCassette } from './mocks/cassettes/api-tokens.ts';
+import { dashboardCassette } from './mocks/cassettes/dashboard.ts';
+import { flowsCassette } from './mocks/cassettes/flows.ts';
+import { knowledgesCassette } from './mocks/cassettes/knowledges.ts';
+import { resourcesCassette } from './mocks/cassettes/resources.ts';
+import { settingsPromptsCassette } from './mocks/cassettes/settings-prompts.ts';
+import { settingsProvidersCassette } from './mocks/cassettes/settings-providers.ts';
+import { templatesCassette } from './mocks/cassettes/templates.ts';
+
+export interface RouteManifestEntry {
+ cassette: () => Cassette;
+ path: string;
+ /** The route counts as rendered when this locator is visible. */
+ ready: (page: Page) => Locator;
+ /** Owning src/ areas — the substrate for changed-files → affected-routes mapping. */
+ sources: string[];
+}
+
+/**
+ * One entry per navigable route, consumed by the NAV sweep, per-route specs,
+ * and (later) CI diff-scoping and the exploratory agent. Paths come from the
+ * app's own routes module so a route rename breaks this file at compile time.
+ */
+export const ROUTE_MANIFEST: RouteManifestEntry[] = [
+ {
+ cassette: flowsCassette,
+ path: routes.flows,
+ ready: (page) => page.getByRole('row', { name: /E2E Alpha/ }),
+ sources: ['src/pages/flows', 'src/features/flows', 'src/providers/flows-provider.tsx'],
+ },
+ {
+ cassette: flowsCassette,
+ path: routes.flow('5'),
+ ready: (page) => page.getByRole('button', { name: 'Flow actions' }),
+ sources: ['src/pages/flows', 'src/features/flows', 'src/providers/flow-provider.tsx'],
+ },
+ {
+ cassette: templatesCassette,
+ path: routes.templates,
+ ready: (page) => page.getByRole('row', { name: /E2E Seed Template/ }),
+ sources: ['src/pages/templates', 'src/providers/templates-provider.tsx'],
+ },
+ {
+ cassette: knowledgesCassette,
+ path: routes.knowledges,
+ ready: (page) => page.getByRole('row', { name: /E2E Seed Question/ }),
+ sources: ['src/pages/knowledges', 'src/features/knowledges', 'src/providers/knowledges-provider.tsx'],
+ },
+ {
+ cassette: apiTokensCassette,
+ path: routes.settings.apiTokens,
+ ready: (page) => page.getByRole('row', { name: /E2E seed token/ }),
+ sources: ['src/pages/settings/settings-api-tokens.tsx'],
+ },
+ {
+ cassette: dashboardCassette,
+ path: routes.dashboard,
+ ready: (page) => page.getByRole('heading', { name: 'Flows Activity Over Time' }),
+ sources: ['src/pages/dashboard', 'src/components/dashboard'],
+ },
+ {
+ cassette: settingsPromptsCassette,
+ path: routes.settings.prompts,
+ ready: (page) => page.getByRole('heading', { name: 'Agent Prompts' }),
+ sources: ['src/pages/settings/settings-prompts.tsx'],
+ },
+ {
+ cassette: settingsProvidersCassette,
+ path: routes.settings.providers,
+ ready: (page) => page.getByText('No providers configured'),
+ sources: ['src/pages/settings/settings-providers.tsx', 'src/pages/settings/settings-provider.tsx'],
+ },
+ {
+ cassette: resourcesCassette,
+ path: routes.resources,
+ ready: (page) => page.getByRole('treeitem', { name: /reports/ }),
+ sources: ['src/pages/resources', 'src/features/resources', 'src/components/shared/file-manager'],
+ },
+];
diff --git a/frontend/e2e/specs/cross/nav.spec.ts b/frontend/e2e/specs/cross/nav.spec.ts
new file mode 100644
index 00000000..232cf6af
--- /dev/null
+++ b/frontend/e2e/specs/cross/nav.spec.ts
@@ -0,0 +1,18 @@
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { ROUTE_MANIFEST } from '../../routes.ts';
+
+test.describe('route sweep', { tag: '@cross' }, () => {
+ for (const entry of ROUTE_MANIFEST) {
+ test.describe(entry.path, () => {
+ test.use({ cassette: entry.cassette() });
+
+ test('renders with a clean page', async ({ page, pageErrorLog }) => {
+ await page.goto(entry.path);
+
+ await expect(entry.ready(page)).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+ }
+});
diff --git a/frontend/e2e/specs/crud/resources.spec.ts b/frontend/e2e/specs/crud/resources.spec.ts
new file mode 100644
index 00000000..3e7fce57
--- /dev/null
+++ b/frontend/e2e/specs/crud/resources.spec.ts
@@ -0,0 +1,67 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type { ResourceAddedDocument } from '@/graphql/types';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { CREATED_FOLDER, emptyResourcesCassette, resourcesCassette } from '../../mocks/cassettes/resources.ts';
+
+test.describe('resources', { tag: '@coverage' }, () => {
+ test.describe('listing', () => {
+ test.use({ cassette: resourcesCassette() });
+
+ test('renders seeded entries with sortable column headers', async ({ page, pageErrorLog }) => {
+ await page.goto('/resources');
+
+ await expect(page.getByRole('treeitem', { name: /reports/ })).toBeVisible();
+ await expect(page.getByRole('treeitem', { name: /notes\.txt/ })).toBeVisible();
+ await expect(page.getByRole('button', { name: 'Sort by name (ascending)' })).toBeVisible();
+ await expect(page.getByRole('button', { name: 'Sort by size (ascending)' })).toBeVisible();
+ await expect(page.getByRole('button', { name: 'Sort by modified date (ascending)' })).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('mkdir', () => {
+ const added: ResultOf<typeof ResourceAddedDocument> = { resourceAdded: CREATED_FOLDER };
+
+ test.use({
+ cassette: resourcesCassette({
+ rest: {
+ 'POST /api/v1/resources/mkdir': [
+ { body: { data: {}, status: 'success' }, setFlag: 'folder-created' },
+ ],
+ },
+ subscriptions: {
+ resourceAdded: [{ frames: [{ payload: { data: added }, whenFlag: 'folder-created' }] }],
+ },
+ }),
+ });
+
+ test('creates a directory and the new row arrives via subscription', async ({ page, pageErrorLog }) => {
+ await page.goto('/resources');
+ await page.getByRole('button', { name: 'New folder' }).click();
+
+ const dialog = page.getByRole('dialog');
+
+ await expect(dialog.getByRole('heading', { name: 'Create directory' })).toBeVisible();
+ await expect(dialog.getByLabel('Path')).toHaveValue('new-folder');
+ await dialog.getByRole('button', { name: 'Create' }).click();
+
+ await expect(page.getByText('Directory created')).toBeVisible();
+ await expect(page.getByRole('treeitem', { name: /new-folder/ })).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('empty state', () => {
+ test.use({ cassette: emptyResourcesCassette() });
+
+ test('shows the upload call to action', async ({ page, pageErrorLog }) => {
+ await page.goto('/resources');
+
+ await expect(page.getByText('No resources yet')).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+});
diff --git a/frontend/e2e/specs/dashboard/dashboard.spec.ts b/frontend/e2e/specs/dashboard/dashboard.spec.ts
new file mode 100644
index 00000000..2956ccd6
--- /dev/null
+++ b/frontend/e2e/specs/dashboard/dashboard.spec.ts
@@ -0,0 +1,103 @@
+import type { Page } from '@playwright/test';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { dashboardCassette } from '../../mocks/cassettes/dashboard.ts';
+
+const CHART_TITLES = ['Flows Activity Over Time', 'Tool Calls Over Time', 'Token Usage Over Time', 'Cost Over Time'];
+
+const cardWith = (page: Page, heading: string) =>
+ page.locator('[data-slot="card"]', { has: page.getByRole('heading', { exact: true, name: heading }) });
+
+test.describe('dashboard', { tag: '@coverage' }, () => {
+ test.describe('happy path', () => {
+ test.use({ cassette: dashboardCassette() });
+
+ test('analytics tab renders the four chart cards', async ({ page, pageErrorLog }) => {
+ await page.goto('/dashboard');
+
+ for (const title of CHART_TITLES) {
+ await expect(page.getByRole('heading', { exact: true, name: title })).toBeVisible();
+ }
+
+ await expect(page.getByText('E2E Alpha')).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+
+ test('overview tab loads lazily and renders metrics and usage tables', async ({ page, pageErrorLog }) => {
+ await page.goto('/dashboard');
+ await page.getByRole('tab', { name: 'Overview' }).click();
+
+ for (const title of ['Total Flows', 'Tool Calls', 'Total Tokens', 'Total Cost']) {
+ await expect(page.getByRole('heading', { exact: true, name: title })).toBeVisible();
+ }
+
+ await expect(page.getByRole('heading', { exact: true, name: 'Usage by Provider' })).toBeVisible();
+ await expect(page.getByRole('heading', { exact: true, name: 'Usage by Model' })).toBeVisible();
+ await expect(page.getByRole('cell', { exact: true, name: 'e2e-provider' })).toBeVisible();
+ await expect(page.getByRole('cell', { name: 'e2e-model (e2e-provider)' })).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+
+ test('period switch refetches the charts for the month', async ({ page, pageErrorLog }) => {
+ await page.goto('/dashboard');
+
+ await expect(page.getByRole('heading', { exact: true, name: 'Flows Activity Over Time' })).toBeVisible();
+
+ const monthRequest = page.waitForRequest((request) => {
+ if (request.method() !== 'POST' || !request.url().includes('/api/v1/graphql')) {
+ return false;
+ }
+
+ const { operationName, variables } = request.postDataJSON() as {
+ operationName?: string;
+ variables?: { period?: string };
+ };
+
+ return operationName === 'usageStatsByPeriod' && variables?.period === 'month';
+ });
+
+ await page.getByRole('tab', { name: 'Month' }).click();
+ await monthRequest;
+
+ await expect(page.getByRole('tab', { name: 'Month' })).toHaveAttribute('aria-selected', 'true');
+
+ for (const title of CHART_TITLES) {
+ await expect(page.getByRole('heading', { exact: true, name: title })).toBeVisible();
+ }
+
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('partial errors', () => {
+ test.use({
+ cassette: dashboardCassette({
+ queries: {
+ flowsStatsTotal: [{ errors: [{ message: 'e2e induced failure' }] }],
+ usageStatsByPeriod: [{ errors: [{ message: 'e2e induced failure' }] }],
+ },
+ }),
+ });
+
+ test('a failed query degrades only its own card', async ({ page, pageErrorLog }) => {
+ await page.goto('/dashboard');
+
+ await expect(cardWith(page, 'Token Usage Over Time').getByText("Couldn't load")).toBeVisible();
+ await expect(cardWith(page, 'Flows Activity Over Time').getByText("Couldn't load")).toBeHidden();
+
+ await page.getByRole('tab', { name: 'Overview' }).click();
+
+ const totalFlowsCard = cardWith(page, 'Total Flows');
+
+ await expect(totalFlowsCard.getByText("Couldn't load")).toBeVisible();
+ await expect(totalFlowsCard.getByText('—')).toBeVisible();
+
+ const toolCallsCard = cardWith(page, 'Tool Calls');
+
+ await expect(toolCallsCard.getByText('42')).toBeVisible();
+ await expect(toolCallsCard.getByText("Couldn't load")).toBeHidden();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+});
diff --git a/frontend/e2e/specs/settings/prompts.spec.ts b/frontend/e2e/specs/settings/prompts.spec.ts
new file mode 100644
index 00000000..ce050b01
--- /dev/null
+++ b/frontend/e2e/specs/settings/prompts.spec.ts
@@ -0,0 +1,30 @@
+import { PromptType } from '@/graphql/types';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { promptTemplate, settingsPromptsCassette } from '../../mocks/cassettes/settings-prompts.ts';
+
+test.describe('settings prompts', { tag: '@coverage' }, () => {
+ test.use({ cassette: settingsPromptsCassette() });
+
+ test('renders agent and tool tables and expands an agent row to its templates', async ({ page, pageErrorLog }) => {
+ await page.goto('/settings/prompts');
+
+ await expect(page.getByRole('heading', { name: 'Agent Prompts' })).toBeVisible();
+ await expect(page.getByRole('heading', { name: 'Tool Prompts' })).toBeVisible();
+
+ const pentesterRow = page.getByRole('row', { name: /Pentester/ });
+
+ await expect(pentesterRow).toBeVisible();
+ await expect(page.getByRole('row', { name: /Get Flow Description/ })).toBeVisible();
+
+ await pentesterRow.click();
+
+ await expect(page.getByRole('heading', { name: 'System Prompt' })).toBeVisible();
+ await expect(page.getByRole('heading', { name: 'Human Prompt' })).toBeVisible();
+ await expect(page.getByText(promptTemplate(PromptType.Pentester))).toBeVisible();
+ await expect(page.getByText(promptTemplate(PromptType.QuestionPentester))).toBeVisible();
+
+ expectCleanPage(pageErrorLog);
+ });
+});
diff --git a/frontend/e2e/specs/settings/providers.spec.ts b/frontend/e2e/specs/settings/providers.spec.ts
new file mode 100644
index 00000000..876b770f
--- /dev/null
+++ b/frontend/e2e/specs/settings/providers.spec.ts
@@ -0,0 +1,29 @@
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { settingsProvidersCassette } from '../../mocks/cassettes/settings-providers.ts';
+
+test.describe('settings providers', { tag: '@coverage' }, () => {
+ test.use({ cassette: settingsProvidersCassette() });
+
+ test('shows the empty state when no providers are configured', async ({ page, pageErrorLog }) => {
+ await page.goto('/settings/providers');
+
+ await expect(page.getByText('No providers configured')).toBeVisible();
+ await expect(page.getByRole('button', { name: 'Add Provider' })).toBeVisible();
+
+ expectCleanPage(pageErrorLog);
+ });
+
+ test('opens the create form from the empty state', async ({ page, pageErrorLog }) => {
+ await page.goto('/settings/providers');
+ await page.getByRole('button', { name: 'Add Provider' }).click();
+
+ await expect(page).toHaveURL(/\/settings\/providers\/new$/);
+ await expect(page.getByRole('heading', { name: 'Create a new provider' })).toBeVisible();
+ await expect(page.getByText('Type', { exact: true })).toBeVisible();
+ await expect(page.getByRole('button', { name: 'Select provider' })).toBeVisible();
+ await expect(page.getByLabel('Name', { exact: true })).toBeVisible();
+
+ expectCleanPage(pageErrorLog);
+ });
+});