342 lines
12 KiB
TypeScript
342 lines
12 KiB
TypeScript
import { expect, test, type Page, type Route } from '@playwright/test';
|
|
|
|
import type { StubAuthSession } from '../../src/app/testing/auth-fixtures';
|
|
|
|
const releaseOperatorSession: StubAuthSession = {
|
|
subjectId: 'release-e2e-user',
|
|
tenant: 'tenant-default',
|
|
scopes: ['admin', 'ui.read', 'release:read', 'policy:read', 'signer:read', 'vex:export'],
|
|
};
|
|
|
|
const mockConfig = {
|
|
authority: {
|
|
issuer: '/authority',
|
|
clientId: 'stella-ops-ui',
|
|
authorizeEndpoint: '/authority/connect/authorize',
|
|
tokenEndpoint: '/authority/connect/token',
|
|
logoutEndpoint: '/authority/connect/logout',
|
|
redirectUri: 'https://127.0.0.1:4400/auth/callback',
|
|
postLogoutRedirectUri: 'https://127.0.0.1:4400/',
|
|
scope: 'openid profile email ui.read',
|
|
audience: '/gateway',
|
|
dpopAlgorithms: ['ES256'],
|
|
refreshLeewaySeconds: 60,
|
|
},
|
|
apiBaseUrls: {
|
|
authority: '/authority',
|
|
scanner: '/scanner',
|
|
policy: '/policy',
|
|
concelier: '/concelier',
|
|
attestor: '/attestor',
|
|
gateway: '/gateway',
|
|
},
|
|
quickstartMode: true,
|
|
setup: 'complete',
|
|
};
|
|
|
|
const runDetail = {
|
|
runId: 'run-e2e',
|
|
releaseId: 'rel-e2e',
|
|
releaseName: 'Billing API',
|
|
releaseSlug: 'billing-api',
|
|
releaseType: 'standard',
|
|
releaseVersionId: 'ver-e2e',
|
|
releaseVersionNumber: 42,
|
|
releaseVersionDigest: 'sha256:release-e2e',
|
|
lane: 'standard',
|
|
status: 'running',
|
|
outcome: 'in_progress',
|
|
targetEnvironment: 'prod',
|
|
targetRegion: 'eu-west',
|
|
scopeSummary: 'stage->prod',
|
|
requestedAt: '2026-03-07T10:00:00Z',
|
|
updatedAt: '2026-03-07T10:24:00Z',
|
|
needsApproval: true,
|
|
blockedByDataIntegrity: false,
|
|
correlationKey: 'corr-e2e',
|
|
statusRow: {
|
|
runStatus: 'running',
|
|
gateStatus: 'warn',
|
|
approvalStatus: 'pending',
|
|
dataTrustStatus: 'healthy',
|
|
},
|
|
};
|
|
|
|
const runTimeline = {
|
|
runId: 'run-e2e',
|
|
events: [
|
|
{
|
|
eventId: 'evt-ingest',
|
|
eventClass: 'scan',
|
|
phase: 'ingest',
|
|
status: 'completed',
|
|
occurredAt: '2026-03-07T10:02:00Z',
|
|
message: 'Ingest completed successfully.',
|
|
},
|
|
{
|
|
eventId: 'evt-gate',
|
|
eventClass: 'gate',
|
|
phase: 'gate',
|
|
status: 'warn',
|
|
occurredAt: '2026-03-07T10:07:00Z',
|
|
message: 'Gate requires operator review.',
|
|
},
|
|
{
|
|
eventId: 'evt-approval',
|
|
eventClass: 'approval',
|
|
phase: 'approval',
|
|
status: 'pending',
|
|
occurredAt: '2026-03-07T10:11:00Z',
|
|
message: 'Awaiting manual approval.',
|
|
},
|
|
{
|
|
eventId: 'evt-evidence',
|
|
eventClass: 'evidence',
|
|
phase: 'evidence',
|
|
status: 'completed',
|
|
occurredAt: '2026-03-07T10:18:00Z',
|
|
message: 'Evidence bundle prepared.',
|
|
},
|
|
],
|
|
};
|
|
|
|
const liveGraph = {
|
|
id: 'run-e2e',
|
|
name: 'Billing API Run',
|
|
layoutAlgorithm: 'dagre',
|
|
nodes: [
|
|
{ id: 'ingest', label: 'Ingest & Scan', type: 'task', status: 'succeeded', duration: 120000 },
|
|
{ id: 'gate', label: 'Policy Gate', type: 'gate', status: 'running', duration: 240000 },
|
|
{ id: 'approval', label: 'Approval', type: 'approval', status: 'pending', duration: 0 },
|
|
{ id: 'evidence', label: 'Evidence', type: 'task', status: 'succeeded', duration: 60000 },
|
|
],
|
|
edges: [
|
|
{ id: 'ingest-gate', source: 'ingest', target: 'gate', type: 'dependency' },
|
|
{ id: 'gate-approval', source: 'gate', target: 'approval', type: 'dependency' },
|
|
{ id: 'approval-evidence', source: 'approval', target: 'evidence', type: 'dependency' },
|
|
],
|
|
positions: [
|
|
{ nodeId: 'ingest', x: 180, y: 180 },
|
|
{ nodeId: 'gate', x: 420, y: 180 },
|
|
{ nodeId: 'approval', x: 660, y: 180 },
|
|
{ nodeId: 'evidence', x: 900, y: 180 },
|
|
],
|
|
metadata: {
|
|
runId: 'run-e2e',
|
|
releaseId: 'rel-e2e',
|
|
},
|
|
};
|
|
|
|
async function fulfillJson(route: Route, body: unknown, status = 200): Promise<void> {
|
|
await route.fulfill({
|
|
status,
|
|
contentType: 'application/json',
|
|
body: JSON.stringify(body),
|
|
});
|
|
}
|
|
|
|
async function setupHarness(page: Page): Promise<void> {
|
|
await page.addInitScript((session) => {
|
|
(window as { __stellaopsTestSession?: unknown }).__stellaopsTestSession = session;
|
|
}, releaseOperatorSession);
|
|
|
|
await page.route('**/api/**', (route) => fulfillJson(route, {}));
|
|
await page.route('**/platform/envsettings.json', (route) => fulfillJson(route, mockConfig));
|
|
await page.route('**/platform/i18n/*.json', (route) => fulfillJson(route, {}));
|
|
await page.route('**/config.json', (route) => fulfillJson(route, mockConfig));
|
|
await page.route('**/.well-known/openid-configuration', (route) =>
|
|
fulfillJson(route, {
|
|
issuer: 'https://127.0.0.1:4400/authority',
|
|
authorization_endpoint: 'https://127.0.0.1:4400/authority/connect/authorize',
|
|
token_endpoint: 'https://127.0.0.1:4400/authority/connect/token',
|
|
jwks_uri: 'https://127.0.0.1:4400/authority/.well-known/jwks.json',
|
|
response_types_supported: ['code'],
|
|
subject_types_supported: ['public'],
|
|
id_token_signing_alg_values_supported: ['RS256'],
|
|
}),
|
|
);
|
|
await page.route('**/authority/.well-known/jwks.json', (route) => fulfillJson(route, { keys: [] }));
|
|
await page.route('**/authority/console/tenants**', (route) =>
|
|
fulfillJson(route, {
|
|
tenants: [
|
|
{
|
|
tenantId: releaseOperatorSession.tenant,
|
|
displayName: 'Default Tenant',
|
|
isDefault: true,
|
|
isActive: true,
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
await page.route('**/console/branding**', (route) =>
|
|
fulfillJson(route, {
|
|
tenantId: releaseOperatorSession.tenant,
|
|
appName: 'Stella Ops',
|
|
logoUrl: null,
|
|
cssVariables: {},
|
|
}),
|
|
);
|
|
await page.route('**/console/profile**', (route) =>
|
|
fulfillJson(route, {
|
|
subjectId: releaseOperatorSession.subjectId,
|
|
username: 'release-e2e',
|
|
displayName: 'Release E2E',
|
|
tenant: releaseOperatorSession.tenant,
|
|
roles: ['release-operator'],
|
|
scopes: releaseOperatorSession.scopes,
|
|
}),
|
|
);
|
|
await page.route('**/console/token/introspect**', (route) =>
|
|
fulfillJson(route, {
|
|
active: true,
|
|
tenant: releaseOperatorSession.tenant,
|
|
subject: releaseOperatorSession.subjectId,
|
|
scopes: releaseOperatorSession.scopes,
|
|
}),
|
|
);
|
|
await page.route('**/api/v2/context/regions**', (route) =>
|
|
fulfillJson(route, [{ regionId: 'eu-west', displayName: 'EU West', sortOrder: 1, enabled: true }]),
|
|
);
|
|
await page.route('**/api/v2/context/environments**', (route) =>
|
|
fulfillJson(route, [
|
|
{
|
|
environmentId: 'prod',
|
|
regionId: 'eu-west',
|
|
environmentType: 'prod',
|
|
displayName: 'Prod',
|
|
sortOrder: 1,
|
|
enabled: true,
|
|
},
|
|
]),
|
|
);
|
|
await page.route('**/api/v2/context/preferences**', (route) =>
|
|
fulfillJson(route, {
|
|
tenantId: releaseOperatorSession.tenant,
|
|
actorId: releaseOperatorSession.subjectId,
|
|
regions: ['eu-west'],
|
|
environments: ['prod'],
|
|
timeWindow: '24h',
|
|
stage: 'all',
|
|
updatedAt: '2026-03-07T12:00:00Z',
|
|
updatedBy: releaseOperatorSession.subjectId,
|
|
}),
|
|
);
|
|
await page.route('**/doctor/api/v1/doctor/trends**', (route) => fulfillJson(route, []));
|
|
await page.route('**/api/v1/approvals**', (route) => fulfillJson(route, []));
|
|
await page.route('**/api/v1/telemetry/ttfs', (route) => fulfillJson(route, { accepted: true }, 202));
|
|
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e(?:\?.*)?$/, (route) => fulfillJson(route, runDetail));
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e\/timeline(?:\?.*)?$/, (route) => fulfillJson(route, runTimeline));
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e\/gate-decision(?:\?.*)?$/, (route) =>
|
|
fulfillJson(route, {
|
|
runId: 'run-e2e',
|
|
verdict: 'warn',
|
|
blockers: ['manual-review'],
|
|
riskBudgetDelta: 14,
|
|
}),
|
|
);
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e\/approvals(?:\?.*)?$/, (route) =>
|
|
fulfillJson(route, {
|
|
runId: 'run-e2e',
|
|
checkpoints: [{ checkpointId: 'approve-prod', status: 'pending', approvedAt: null }],
|
|
}),
|
|
);
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e\/deployments(?:\?.*)?$/, (route) =>
|
|
fulfillJson(route, {
|
|
runId: 'run-e2e',
|
|
targets: [
|
|
{
|
|
targetId: 'prod-1',
|
|
targetName: 'billing-api-prod',
|
|
environment: 'prod',
|
|
region: 'eu-west',
|
|
status: 'queued',
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e\/security-inputs(?:\?.*)?$/, (route) =>
|
|
fulfillJson(route, {
|
|
runId: 'run-e2e',
|
|
reachabilityCoveragePercent: 94,
|
|
feedFreshnessStatus: 'healthy',
|
|
vexStatementsApplied: 3,
|
|
exceptionsApplied: 1,
|
|
}),
|
|
);
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e\/evidence(?:\?.*)?$/, (route) =>
|
|
fulfillJson(route, {
|
|
runId: 'run-e2e',
|
|
replayDeterminismVerdict: 'match',
|
|
replayMismatch: false,
|
|
signatureStatus: 'verified',
|
|
}),
|
|
);
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e\/replay(?:\?.*)?$/, (route) =>
|
|
fulfillJson(route, {
|
|
runId: 'run-e2e',
|
|
verdict: 'match',
|
|
}),
|
|
);
|
|
await page.route(/\/api\/v2\/releases\/runs\/run-e2e\/audit(?:\?.*)?$/, (route) =>
|
|
fulfillJson(route, {
|
|
runId: 'run-e2e',
|
|
entries: [
|
|
{
|
|
auditId: 'audit-001',
|
|
action: 'release.run.updated',
|
|
actorId: 'ops@example.com',
|
|
occurredAt: '2026-03-07T10:19:00Z',
|
|
correlationKey: 'corr-e2e',
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
await page.route(/\/api\/v1\/workflows\/run-e2e\/graph(?:\?.*)?$/, (route) => fulfillJson(route, liveGraph));
|
|
await page.route(/\/api\/v1\/workflows\/run-e2e\/critical-path(?:\?.*)?$/, (route) =>
|
|
fulfillJson(route, {
|
|
path: ['ingest', 'gate', 'approval', 'evidence'],
|
|
totalDuration: 420000,
|
|
}),
|
|
);
|
|
}
|
|
|
|
test.beforeEach(async ({ page }) => {
|
|
await setupHarness(page);
|
|
});
|
|
|
|
test('run workspace supports timeline drill-in and evidence replay handoff', async ({ page }) => {
|
|
await page.goto('/releases/runs/run-e2e/graph?step=gate', { waitUntil: 'domcontentloaded' });
|
|
|
|
await expect(page.getByTestId('run-graph-replay-page')).toBeVisible();
|
|
await expect(page.getByTestId('run-workspace-tab-graph')).toHaveClass(/active/);
|
|
await expect(page.getByRole('button', { name: 'Critical path only' })).toBeVisible();
|
|
|
|
await page.getByTestId('run-workspace-tab-timeline').click();
|
|
await expect(page).toHaveURL(/\/releases\/runs\/run-e2e\/timeline\?.*step=gate/);
|
|
await page.getByTestId('run-timeline-row-evt-approval').click();
|
|
await expect(page).toHaveURL(/\/releases\/runs\/run-e2e\/timeline\?.*step=approval/);
|
|
await expect(page.getByTestId('run-step-drawer')).toContainText('Approval');
|
|
|
|
await page.getByTestId('run-workspace-tab-replay').click();
|
|
await expect(page).toHaveURL(/\/releases\/runs\/run-e2e\/replay\?.*step=approval/);
|
|
await expect(page.getByText('Replay verdict')).toBeVisible();
|
|
await expect(page.getByText('Debug Session')).toBeVisible();
|
|
|
|
await page.getByRole('button', { name: 'Open evidence entry' }).click();
|
|
await expect(page).toHaveURL(/\/evidence\/verify-replay\?.*releaseId=rel-e2e.*runId=run-e2e/);
|
|
await expect(page.getByRole('heading', { name: 'Verdict Replay' })).toBeVisible();
|
|
|
|
await page.getByRole('button', { name: 'Open run replay workspace' }).click();
|
|
await expect(page).toHaveURL(/\/releases\/runs\/run-e2e\/replay\?.*releaseId=rel-e2e.*returnTo=/);
|
|
await expect(page.getByRole('button', { name: 'Return to previous context' })).toBeVisible();
|
|
});
|
|
|
|
test('legacy workflow visualization aliases redirect into the canonical run shell', async ({ page }) => {
|
|
await page.goto('/workflow-visualization/run-e2e/graph?step=evidence', { waitUntil: 'domcontentloaded' });
|
|
|
|
await expect(page).toHaveURL(/\/releases\/runs\/run-e2e\/graph\?.*step=evidence/);
|
|
await expect(page.getByTestId('run-workspace-tab-graph')).toHaveClass(/active/);
|
|
});
|