From d7eb018245f48f71bb0c8af14e94da7e2844a43c Mon Sep 17 00:00:00 2001 From: Andrii Arsenin Date: Wed, 7 Oct 2026 18:13:18 +0300 Subject: [PATCH] feat: browser notifications for scenario runs - add RunEventsService and emit run.started / run.finished from the scheduler - stream run events over SSE at GET /api/v1/scenarios/runs/events with a heartbeat - add useRunNotifications hook and NotificationToggle (opt-in bell in the side panel footer) - refresh runs lists when a run finishes - document the events stream and notifications Closes #12 --- .../stories/NotificationToggle.stories.tsx | 17 +++ client/src/App.module.css | 6 + client/src/App.tsx | 11 +- client/src/api/client.ts | 3 + client/src/api/types.ts | 10 ++ client/src/hooks/useRunNotifications.ts | 124 ++++++++++++++++++ client/src/i18n/locales/en.json | 11 ++ .../NotificationToggle.module.css | 41 ++++++ .../NotificationToggle/NotificationToggle.tsx | 39 ++++++ client/src/ui/index.ts | 2 + docs/architecture.md | 4 +- docs/development.md | 2 +- docs/scenario.md | 14 ++ server/src/scenario/run-events.service.ts | 31 +++++ .../scenario/scenario-scheduler.service.ts | 49 ++++++- server/src/scenario/scenario.controller.ts | 28 ++++ server/src/scenario/scenario.module.ts | 8 +- server/test/run-events.spec.ts | 109 +++++++++++++++ 18 files changed, 503 insertions(+), 6 deletions(-) create mode 100644 client/.storybook/stories/NotificationToggle.stories.tsx create mode 100644 client/src/hooks/useRunNotifications.ts create mode 100644 client/src/ui/NotificationToggle/NotificationToggle.module.css create mode 100644 client/src/ui/NotificationToggle/NotificationToggle.tsx create mode 100644 server/src/scenario/run-events.service.ts create mode 100644 server/test/run-events.spec.ts diff --git a/client/.storybook/stories/NotificationToggle.stories.tsx b/client/.storybook/stories/NotificationToggle.stories.tsx new file mode 100644 index 0000000..780c11d --- /dev/null +++ b/client/.storybook/stories/NotificationToggle.stories.tsx @@ -0,0 +1,17 @@ +import type { Meta, StoryObj } from '@storybook/react-vite'; +import { fn } from 'storybook/test'; +import { NotificationToggle } from '../../src/ui/NotificationToggle/NotificationToggle'; + +const meta: Meta = { + title: 'UI/NotificationToggle', + component: NotificationToggle, + parameters: { layout: 'centered' }, + tags: ['autodocs'], + args: { onToggle: fn() }, +}; +export default meta; +type Story = StoryObj; + +export const Off: Story = { args: { state: 'off' } }; +export const On: Story = { args: { state: 'on' } }; +export const Blocked: Story = { args: { state: 'blocked' } }; diff --git a/client/src/App.module.css b/client/src/App.module.css index 4b18c1f..0d41f0b 100644 --- a/client/src/App.module.css +++ b/client/src/App.module.css @@ -36,6 +36,12 @@ min-height: 100%; } +.footerButtons { + display: flex; + align-items: center; + gap: var(--space-1); +} + .sideFooter { margin-top: auto; padding: var(--space-3) var(--space-2) var(--space-2); diff --git a/client/src/App.tsx b/client/src/App.tsx index 7af36dd..8edb6f9 100644 --- a/client/src/App.tsx +++ b/client/src/App.tsx @@ -4,9 +4,10 @@ import { useTranslation } from 'react-i18next'; import { Globe, Monitor, ClipboardList, Activity, KeyRound, Braces, Upload } from 'lucide-react'; import type { LucideIcon } from 'lucide-react'; import styles from './App.module.css'; -import { SidePanel, ThemeSwitcher } from './ui'; +import { NotificationToggle, SidePanel, ThemeSwitcher } from './ui'; import liqaLogo from './assets/liqa.svg'; import { useManifest } from './hooks/useManifest'; +import { useRunNotifications } from './hooks/useRunNotifications'; const EnvironmentsPage = lazy(() => import('./pages/environment/EnvironmentsPage').then((m) => ({ default: m.EnvironmentsPage })), @@ -109,6 +110,7 @@ const NAV: ({ path: string; labelKey: string; Icon: LucideIcon } | { separator: export default function App() { const { t } = useTranslation(); const { version } = useManifest(); + const notifications = useRunNotifications(); return (
@@ -141,7 +143,12 @@ export default function App() {
- +
+ + {notifications && ( + + )} +
(path: string, init?: RequestInit): Promise { let res: Response; try { diff --git a/client/src/api/types.ts b/client/src/api/types.ts index f88d238..21b26d6 100644 --- a/client/src/api/types.ts +++ b/client/src/api/types.ts @@ -234,3 +234,13 @@ export interface ImportedItem { export interface ImportResult { imported: ImportedItem[]; } + +/** Run lifecycle event pushed by the server on `GET /scenarios/runs/events`. */ +export interface RunEvent { + type: 'run.started' | 'run.finished'; + runId: string; + scenarioId: string; + scenarioName: string; + status: ScenarioRunStatus; + at: string; +} diff --git a/client/src/hooks/useRunNotifications.ts b/client/src/hooks/useRunNotifications.ts new file mode 100644 index 0000000..18fa612 --- /dev/null +++ b/client/src/hooks/useRunNotifications.ts @@ -0,0 +1,124 @@ +import { useCallback, useEffect, useRef, useState } from 'react'; +import { useQueryClient } from '@tanstack/react-query'; +import { useNavigate } from 'react-router-dom'; +import { useTranslation } from 'react-i18next'; +import { RUN_EVENTS_URL } from '../api/client'; +import type { RunEvent } from '../api/types'; +import type { NotificationToggleState } from '../ui'; + +const STORAGE_KEY = 'liqa-run-notifications'; + +function supported(): boolean { + return typeof window !== 'undefined' && 'Notification' in window && 'EventSource' in window; +} + +function readEnabled(): boolean { + try { + return localStorage.getItem(STORAGE_KEY) === '1'; + } catch { + return false; + } +} + +function writeEnabled(enabled: boolean): void { + try { + localStorage.setItem(STORAGE_KEY, enabled ? '1' : '0'); + } catch { + // storage unavailable: the choice just doesn't persist + } +} + +/** + * Opt-in browser notifications for run start/finish, driven by the server's + * run events stream (so runs started from the API, MCP or the scheduler are + * covered too). Returns `null` when the browser lacks Notification/EventSource. + */ +export function useRunNotifications(): { + state: NotificationToggleState; + toggle: () => void; +} | null { + const isSupported = supported(); + const { t } = useTranslation(); + const navigate = useNavigate(); + const queryClient = useQueryClient(); + const [enabled, setEnabled] = useState(readEnabled); + const [permission, setPermission] = useState(() => + isSupported ? Notification.permission : 'denied', + ); + + // Latest callbacks without reopening the stream when they change + const handlers = useRef({ t, navigate }); + useEffect(() => { + handlers.current = { t, navigate }; + }); + + const active = isSupported && enabled && permission === 'granted'; + + useEffect(() => { + if (!active) return; + const source = new EventSource(RUN_EVENTS_URL); + + const onEvent = (message: MessageEvent) => { + let event: RunEvent; + try { + event = JSON.parse(message.data) as RunEvent; + } catch { + return; + } + if (event.type === 'run.finished') { + void queryClient.invalidateQueries({ queryKey: ['runs'] }); + } + const { t: translate, navigate: go } = handlers.current; + const key = + event.type === 'run.started' + ? 'run_started' + : event.status === 'pass' + ? 'run_pass' + : 'run_fail'; + const notification = new Notification( + translate(`notifications.${key}_title`, { scenario: event.scenarioName }), + { + body: translate(`notifications.${key}_body`), + // finished replaces started for the same run + tag: event.runId, + }, + ); + notification.onclick = () => { + window.focus(); + go(`/scenarios/${event.scenarioId}/runs/${event.runId}`); + notification.close(); + }; + }; + + source.addEventListener('run.started', onEvent as EventListener); + source.addEventListener('run.finished', onEvent as EventListener); + return () => source.close(); + }, [active, queryClient]); + + const toggle = useCallback(() => { + if (!isSupported) return; + if (Notification.permission === 'default') { + void Notification.requestPermission().then((result) => { + setPermission(result); + if (result === 'granted') { + setEnabled(true); + writeEnabled(true); + } + }); + return; + } + if (Notification.permission !== 'granted') { + setPermission(Notification.permission); + return; + } + const next = !enabled; + setEnabled(next); + writeEnabled(next); + }, [isSupported, enabled]); + + if (!isSupported) return null; + return { + state: permission === 'denied' ? 'blocked' : active ? 'on' : 'off', + toggle, + }; +} diff --git a/client/src/i18n/locales/en.json b/client/src/i18n/locales/en.json index 7bc449e..a0e9bab 100644 --- a/client/src/i18n/locales/en.json +++ b/client/src/i18n/locales/en.json @@ -235,6 +235,17 @@ "light_mode": "Light mode", "dark_mode": "Dark mode" }, + "notifications": { + "enable": "Enable browser notifications for runs", + "disable": "Disable browser notifications for runs", + "blocked": "Notifications are blocked in your browser settings", + "run_started_title": "Run started: {{scenario}}", + "run_started_body": "The scenario run is in progress.", + "run_pass_title": "Run passed: {{scenario}}", + "run_pass_body": "All steps passed.", + "run_fail_title": "Run failed: {{scenario}}", + "run_fail_body": "The scenario run failed." + }, "revealable": { "hidden": "Hidden so secrets aren't exposed on screen.", "reveal": "Reveal", diff --git a/client/src/ui/NotificationToggle/NotificationToggle.module.css b/client/src/ui/NotificationToggle/NotificationToggle.module.css new file mode 100644 index 0000000..9e60379 --- /dev/null +++ b/client/src/ui/NotificationToggle/NotificationToggle.module.css @@ -0,0 +1,41 @@ +.btn { + display: flex; + align-items: center; + justify-content: center; + width: 28px; + height: 28px; + padding: 0; + background: none; + border: var(--border-width) solid var(--color-border); + border-radius: var(--radius-md); + color: var(--color-text-muted); + cursor: pointer; + flex-shrink: 0; + transition: background var(--transition), color var(--transition), border-color var(--transition); +} + +.btn:hover { + background: var(--color-bg-subtle); + color: var(--color-text); + border-color: var(--color-text-muted); +} + +.btn:active { + background: var(--color-secondary); + color: var(--color-secondary-fg); +} + +.btn:disabled { + opacity: 0.5; + cursor: not-allowed; +} + +.btn:disabled:hover { + background: none; + color: var(--color-text-muted); + border-color: var(--color-border); +} + +.btn[aria-pressed='true'] { + color: var(--color-text); +} diff --git a/client/src/ui/NotificationToggle/NotificationToggle.tsx b/client/src/ui/NotificationToggle/NotificationToggle.tsx new file mode 100644 index 0000000..8e84661 --- /dev/null +++ b/client/src/ui/NotificationToggle/NotificationToggle.tsx @@ -0,0 +1,39 @@ +import { Bell, BellOff } from 'lucide-react'; +import { useTranslation } from 'react-i18next'; +import styles from './NotificationToggle.module.css'; + +/** + * - `on`: notifications are enabled + * - `off`: available, but not enabled (or permission not asked yet) + * - `blocked`: the browser denied the permission + */ +export type NotificationToggleState = 'on' | 'off' | 'blocked'; + +export interface NotificationToggleProps { + state: NotificationToggleState; + onToggle: () => void; +} + +export function NotificationToggle({ state, onToggle }: NotificationToggleProps) { + const { t } = useTranslation(); + const label = + state === 'on' + ? t('notifications.disable') + : state === 'blocked' + ? t('notifications.blocked') + : t('notifications.enable'); + + return ( + + ); +} diff --git a/client/src/ui/index.ts b/client/src/ui/index.ts index 3d2e9d1..5609de5 100644 --- a/client/src/ui/index.ts +++ b/client/src/ui/index.ts @@ -26,6 +26,8 @@ export { Breadcrumbs } from './Breadcrumbs/Breadcrumbs'; export type { BreadcrumbsProps, BreadcrumbItem } from './Breadcrumbs/Breadcrumbs'; export { ThemeSwitcher } from './ThemeSwitcher/ThemeSwitcher'; +export { NotificationToggle } from './NotificationToggle/NotificationToggle'; +export type { NotificationToggleState } from './NotificationToggle/NotificationToggle'; export { ToastProvider } from './Toast/ToastProvider'; export type { ToastProviderProps } from './Toast/ToastProvider'; diff --git a/docs/architecture.md b/docs/architecture.md index beed6d3..9a81a2d 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -75,8 +75,10 @@ A React 19 + TypeScript SPA. During development it's served by the Vite dev serv The client calls the server REST endpoints directly — there is no separate BFF layer. Routing uses `BrowserRouter`; the server answers any GET outside `/api`, `/mcp`, `/docs`, `/health` and `/manifest.json` with the client's `index.html`, so client-side routes survive a page refresh. -Pages: scenarios (with steps, versions, credentials, used snippets and files), runs, snippets, credentials, environments, sessions, and the central import page. The sidebar footer contains the theme switcher and the app version. +Pages: scenarios (with steps, versions, credentials, used snippets and files), runs, snippets, credentials, environments, sessions, and the central import page. The sidebar footer contains the theme switcher, the browser notifications toggle and the app version. `GET /manifest.json` is the server's public configuration for the client: the app `name` and `version`, and settings the UI needs (currently `runLogs.dataLimits`, from `RUN_LOG_DATA_COLLAPSE_BYTES` / `RUN_LOG_DATA_COLLAPSE_LINES`). The client reads it through `client/src/lib/manifest.ts` and the `useManifest()` hook, stale-while-revalidate: the copy cached in `localStorage` (or built-in defaults on first visit) is used right away, and the manifest is refetched once per page load and when the tab becomes visible again after 5 minutes. The server sends it with `Cache-Control: no-cache` and an ETag, so an unchanged manifest costs a 304. Add new client-facing settings to the manifest (`server/src/manifest/`) rather than as build-time Vite variables. +Run notifications: `RunEventsService` (`scenario/`) is an in-process rxjs subject. The scheduler emits `run.started` and `run.finished` (once per run, from the run's single exit points rather than each pass/fail transition), and `GET /api/v1/scenarios/runs/events` streams them as SSE. The `useRunNotifications` hook opens an `EventSource` to it, only while the user has enabled notifications and the browser permission is granted, and shows a `Notification` per event. See [scenario.md](scenario.md#run-events-and-browser-notifications). + See [development.md](development.md) for the full client tech stack and directory layout. diff --git a/docs/development.md b/docs/development.md index f74c170..3d83091 100644 --- a/docs/development.md +++ b/docs/development.md @@ -320,7 +320,7 @@ client/ src/ api/ API client (client.ts) and types (types.ts) components/ modals/ - run, export, export logs and delete confirmation modals - hooks/ useTheme, usePageTitle, useRunDefaults, useImportFile + hooks/ useTheme, usePageTitle, useRunDefaults, useImportFile, useRunNotifications i18n/ i18next bootstrap + locales/en.json lib/ highlight.js setup, API error toast events pages/ scenario/, run/, snippet/, credential/, environment/, session/, import/ diff --git a/docs/scenario.md b/docs/scenario.md index d808904..2a0e182 100644 --- a/docs/scenario.md +++ b/docs/scenario.md @@ -128,6 +128,20 @@ Traces are off by default because they often reach ~10 MB per run. Traces are run artifacts, so they expire after `FILE_RUN_EXPIRATION_DAYS` like other run files. +## Run events and browser notifications + +The server publishes run lifecycle events on a server-sent events (SSE) stream, `GET /api/v1/scenarios/runs/events`, regardless of how the run was started (UI, REST API, MCP or the scheduler). Each message is named after its `type` and carries a JSON body: + +```json +{ "type": "run.finished", "runId": "...", "scenarioId": "...", "scenarioName": "Login", "status": "pass", "at": "2026-01-01T12:00:00.000Z" } +``` + +- `run.started` is sent when a run becomes `in_progress` (`status` is `in_progress`). +- `run.finished` is sent exactly once per run, with the final `status` (`pass` or `fail`), including runs that fail during setup, time out, or are failed on server restart. +- A `ping` event is sent every 25 s to keep idle connections open through proxies. + +The UI uses this stream for opt-in browser notifications: the bell button in the side panel footer asks for the notification permission and then shows "Run started / passed / failed: " notifications while the UI is open in a tab; clicking one opens the run. The choice is stored in the browser's `localStorage`. Browsers only offer notifications in a secure context (HTTPS or `localhost`), so over plain HTTP on another host the bell has no effect. When the permission is blocked, the button is disabled; re-allow it in the browser's site settings. Finished runs also refresh the runs lists immediately. + ## Statuses Run status: diff --git a/server/src/scenario/run-events.service.ts b/server/src/scenario/run-events.service.ts new file mode 100644 index 0000000..4393fef --- /dev/null +++ b/server/src/scenario/run-events.service.ts @@ -0,0 +1,31 @@ +import { Injectable } from "@nestjs/common"; +import { Observable, Subject } from "rxjs"; + +export type RunEventStatus = "pending" | "in_progress" | "pass" | "fail"; + +export interface RunEvent { + type: "run.started" | "run.finished"; + runId: string; + scenarioId: string; + scenarioName: string; + status: RunEventStatus; + /** ISO timestamp of the transition. */ + at: string; +} + +/** + * In-process event bus for scenario run lifecycle transitions. The scheduler + * emits; the SSE endpoint (and tests) subscribe. + */ +@Injectable() +export class RunEventsService { + private readonly subject = new Subject(); + + emit(event: RunEvent): void { + this.subject.next(event); + } + + stream(): Observable { + return this.subject.asObservable(); + } +} diff --git a/server/src/scenario/scenario-scheduler.service.ts b/server/src/scenario/scenario-scheduler.service.ts index 0633158..3ea4cbe 100644 --- a/server/src/scenario/scenario-scheduler.service.ts +++ b/server/src/scenario/scenario-scheduler.service.ts @@ -30,6 +30,7 @@ import { SnippetService } from "../snippet/snippet.service"; import { ScenarioRunLogEntity } from "./scenario-run-log.entity"; import { ScenarioRunStepEntity } from "./scenario-run-step.entity"; import { ScenarioRunEntity } from "./scenario-run.entity"; +import { RunEventsService } from "./run-events.service"; import { ScenarioService } from "./scenario.service"; interface BrowserHandle { @@ -80,6 +81,7 @@ export class ScenarioSchedulerService implements OnModuleInit { private readonly sessionService: SessionService, private readonly sessionContextService: SessionContextService, private readonly fileStorageService: FileStorageService, + private readonly runEvents: RunEventsService, configService: ConfigService, ) { this.defaultTraceMode = configService.get("PLAYWRIGHT_TRACE_MODE"); @@ -109,7 +111,7 @@ export class ScenarioSchedulerService implements OnModuleInit { this.failRun( run.id, "Run aborted: server restarted and playwright session could not be recovered", - ), + ).then(() => this.emitFinished(run.id)), ).pipe( Effect.catchAll((err) => Effect.sync(() => @@ -149,6 +151,48 @@ export class ScenarioSchedulerService implements OnModuleInit { this.persistLog(runId, null, "error", reason, "run"); } + /** + * Publishes a run lifecycle event. Never throws: a notification problem + * must not affect the run itself. + */ + private async emitRunEvent( + type: "run.started" | "run.finished", + runId: string, + ): Promise { + try { + const run = await this.runRepo.findOneBy({ id: runId }); + if (!run) return; + if (type === "run.finished" && run.status !== "pass" && run.status !== "fail") { + return; + } + const scenario = await this.scenarioService + .findOne(run.scenarioId) + .catch(() => null); + this.runEvents.emit({ + type, + runId, + scenarioId: run.scenarioId, + scenarioName: scenario?.name ?? run.scenarioId, + status: run.status, + at: new Date().toISOString(), + }); + } catch (err) { + this.logger.warn( + `Run #${runId}: failed to emit ${type} event — ${String(err)}`, + ); + } + } + + /** + * Emits `run.finished` with the run's final status. Called exactly once per + * run, from the single exit point of each run's lifecycle (the `finally` of + * processRunToCompletion, setup failure, stale-run cleanup), never from the + * individual pass/fail transitions. + */ + private emitFinished(runId: string): Promise { + return this.emitRunEvent("run.finished", runId); + } + private persistLog( runId: string, stepRunId: string | null, @@ -214,6 +258,7 @@ export class ScenarioSchedulerService implements OnModuleInit { run.status = "in_progress"; await this.runRepo.save(run); this.logger.log(`Run #${run.id} → in_progress`); + await this.emitRunEvent("run.started", run.id); const credMap = await this.scenarioService .buildCredentialMap(run.scenarioId) .catch(() => ({}) as Record); @@ -267,6 +312,7 @@ export class ScenarioSchedulerService implements OnModuleInit { run.id, `Run setup failed: ${String(err)}`, ).catch(() => {}); + await this.emitFinished(run.id); }), ), ); @@ -315,6 +361,7 @@ export class ScenarioSchedulerService implements OnModuleInit { ); await this.failRun(runId, `Unexpected error: ${(err as Error).message}`); } finally { + await this.emitFinished(runId); // Before runLogSeq is cleared, so the trace log entry keeps its order await this.saveTrace(runId); this.activeRuns.delete(runId); diff --git a/server/src/scenario/scenario.controller.ts b/server/src/scenario/scenario.controller.ts index 583e343..7117e7b 100644 --- a/server/src/scenario/scenario.controller.ts +++ b/server/src/scenario/scenario.controller.ts @@ -11,12 +11,14 @@ import { Post, Query, Res, + Sse, UseInterceptors, UploadedFile, } from "@nestjs/common"; import { FileInterceptor } from "@nestjs/platform-express"; import { ApiOperation, ApiResponse, ApiTags } from "@nestjs/swagger"; import { Response } from "express"; +import { interval, map, merge, type Observable } from "rxjs"; import type { File as MulterFile } from "multer"; import { stringify as yamlStringify } from "yaml"; import { AddScenarioCredentialDto } from "./dto/add-scenario-credential.dto"; @@ -28,15 +30,24 @@ import { RunsQueryDto } from "./dto/runs-query.dto"; import { ExportEntity, ScenarioExportDto } from "./dto/scenario-export.dto"; import { UpdateScenarioStepDto } from "./dto/update-scenario-step.dto"; import { UpdateScenarioDto } from "./dto/update-scenario.dto"; +import { RunEventsService } from "./run-events.service"; import { ScenarioService } from "./scenario.service"; import { E2eExportService } from "./e2e-export.service"; +interface SseMessage { + type: string; + data: object; +} + @ApiTags("scenarios") @Controller("scenarios") export class ScenarioController { + private static readonly HEARTBEAT_MS = 25_000; + constructor( private readonly scenarioService: ScenarioService, private readonly e2eExportService: E2eExportService, + private readonly runEvents: RunEventsService, ) {} // ── Scenarios ───────────────────────────────────────────────────────────── @@ -73,6 +84,23 @@ export class ScenarioController { return this.scenarioService.findAllRuns(query); } + @Sse("runs/events") + @ApiOperation({ + summary: + "Server-sent events stream of run lifecycle events (run.started, run.finished) for all scenarios", + }) + @ApiResponse({ status: 200, description: "text/event-stream" }) + streamRunEvents(): Observable { + const events = this.runEvents + .stream() + .pipe(map((event): SseMessage => ({ type: event.type, data: event }))); + // Periodic named event so proxies don't drop an idle connection + const heartbeat = interval(ScenarioController.HEARTBEAT_MS).pipe( + map((): SseMessage => ({ type: "ping", data: {} })), + ); + return merge(events, heartbeat); + } + @Get("run-defaults") @ApiOperation({ summary: "Get server-configured defaults for new runs" }) @ApiResponse({ status: 200 }) diff --git a/server/src/scenario/scenario.module.ts b/server/src/scenario/scenario.module.ts index 9079394..2a8a945 100644 --- a/server/src/scenario/scenario.module.ts +++ b/server/src/scenario/scenario.module.ts @@ -13,6 +13,7 @@ import { ScenarioCredentialEntity } from "./scenario-credential.entity"; import { ScenarioRunLogEntity } from "./scenario-run-log.entity"; import { ScenarioRunStepEntity } from "./scenario-run-step.entity"; import { ScenarioRunEntity } from "./scenario-run.entity"; +import { RunEventsService } from "./run-events.service"; import { ScenarioSchedulerService } from "./scenario-scheduler.service"; import { ScenarioVersionEntity } from "./scenario-version.entity"; import { ScenarioStepEntity } from "./scenario-step.entity"; @@ -43,7 +44,12 @@ import { E2eExportService } from "./e2e-export.service"; FileModule, ], controllers: [ScenarioController], - providers: [ScenarioService, ScenarioSchedulerService, E2eExportService], + providers: [ + ScenarioService, + ScenarioSchedulerService, + E2eExportService, + RunEventsService, + ], exports: [ScenarioService, E2eExportService], }) export class ScenarioModule {} diff --git a/server/test/run-events.spec.ts b/server/test/run-events.spec.ts new file mode 100644 index 0000000..4b12327 --- /dev/null +++ b/server/test/run-events.spec.ts @@ -0,0 +1,109 @@ +import { INestApplication } from "@nestjs/common"; +import { DataSource } from "typeorm"; +import { buildTestApp } from "./app.harness"; +import { EnvironmentEntity } from "../src/environment/environment.entity"; +import { + RunEvent, + RunEventsService, +} from "../src/scenario/run-events.service"; +import { ScenarioController } from "../src/scenario/scenario.controller"; +import { ScenarioSchedulerService } from "../src/scenario/scenario-scheduler.service"; +import { ScenarioService } from "../src/scenario/scenario.service"; + +describe("run events", () => { + let app: INestApplication; + let dataSource: DataSource; + let scenarioService: ScenarioService; + let scheduler: ScenarioSchedulerService; + let events: RunEvent[]; + let subscription: { unsubscribe(): void }; + + beforeAll(async () => { + app = await buildTestApp(); + dataSource = app.get(DataSource); + scenarioService = app.get(ScenarioService); + scheduler = app.get(ScenarioSchedulerService); + }); + + beforeEach(() => { + events = []; + subscription = app + .get(RunEventsService) + .stream() + .subscribe((e) => events.push(e)); + }); + + afterEach(() => subscription.unsubscribe()); + + afterAll(async () => { + await app.close(); + }); + + async function runScenario(name: string, codes: string[]) { + const scenario = await scenarioService.create({ name }); + for (const execCode of codes) { + await scenarioService.createStep(scenario.id, { execCode }); + } + const repo = dataSource.getRepository(EnvironmentEntity); + const env = await repo.save( + repo.create({ name: `env-${Math.random()}`, data: {} }), + ); + const run = await scenarioService.createRun(scenario.id, env.id); + await scheduler.pickUpPendingRuns(); + await scenarioService.waitForRun(scenario.id, run.id, 10_000); + // run.finished is emitted just after the status becomes terminal + await waitFor(() => events.some((e) => e.type === "run.finished")); + // give a double emit the chance to show up + await new Promise((r) => setTimeout(r, 200)); + return { scenario, run }; + } + + async function waitFor(cond: () => boolean) { + for (let i = 0; i < 100 && !cond(); i++) { + await new Promise((r) => setTimeout(r, 50)); + } + } + + it("emits started then finished(pass) for a passing run", async () => { + const { scenario, run } = await runScenario("events-pass", ["return 1;"]); + + expect(events.map((e) => [e.type, e.status])).toEqual([ + ["run.started", "in_progress"], + ["run.finished", "pass"], + ]); + expect(events[0]).toMatchObject({ + runId: run.id, + scenarioId: scenario.id, + scenarioName: "events-pass", + }); + expect(Number.isNaN(Date.parse(events[1].at))).toBe(false); + }); + + it("emits finished(fail) exactly once for a failing run", async () => { + await runScenario("events-fail", ["throw new Error('boom');", "return 2;"]); + + expect(events.map((e) => [e.type, e.status])).toEqual([ + ["run.started", "in_progress"], + ["run.finished", "fail"], + ]); + }); + + it("exposes events through the SSE controller stream", () => { + const received: { type: string; data: object }[] = []; + const sub = app + .get(ScenarioController) + .streamRunEvents() + .subscribe((m) => received.push(m)); + app.get(RunEventsService).emit({ + type: "run.started", + runId: "r", + scenarioId: "s", + scenarioName: "n", + status: "in_progress", + at: new Date().toISOString(), + }); + sub.unsubscribe(); + expect(received).toHaveLength(1); + expect(received[0].type).toBe("run.started"); + }); +});