- default PLAYWRIGHT_TRACE_MODE to off since traces often reach ~10 MB per run; traces can still be enabled per run or via the setting
321 lines
9.7 KiB
TypeScript
321 lines
9.7 KiB
TypeScript
import { useCallback, useEffect, useRef, useState } from 'react';
|
|
import { useNavigate } from 'react-router-dom';
|
|
import { useTranslation } from 'react-i18next';
|
|
import { usePageTitle } from '../../hooks/usePageTitle';
|
|
import { Play, Plus, Trash2, Download, ClipboardList } from 'lucide-react';
|
|
import { parse as yamlParse } from 'yaml';
|
|
import { environments, scenarios } from '../../api';
|
|
import type { Environment, Scenario, ScenarioVersion, TraceMode } from '../../api';
|
|
import { RunScenarioModal } from '../../components/modals';
|
|
import { useRunDefaults } from '../../hooks/useRunDefaults';
|
|
import {
|
|
Badge,
|
|
Breadcrumbs,
|
|
Button,
|
|
Modal,
|
|
Table,
|
|
type TableColumn,
|
|
type SortDirection,
|
|
Timestamp,
|
|
UuidBadge,
|
|
useToast,
|
|
} from '../../ui';
|
|
import type { BadgeVariant } from '../../ui';
|
|
import type { ScenarioRunStatus } from '../../api';
|
|
import styles from '../Page.module.css';
|
|
|
|
const LAST_RUN_VARIANT: Record<ScenarioRunStatus, BadgeVariant> = {
|
|
pending: 'neutral',
|
|
in_progress: 'info',
|
|
pass: 'success',
|
|
fail: 'error',
|
|
};
|
|
|
|
const LAST_RUN_LABEL: Record<ScenarioRunStatus, string> = {
|
|
pending: 'Pending',
|
|
in_progress: 'Running',
|
|
pass: 'Pass',
|
|
fail: 'Fail',
|
|
};
|
|
|
|
export function ScenariosPage() {
|
|
const { t } = useTranslation();
|
|
usePageTitle(t('scenarios.title'));
|
|
const navigate = useNavigate();
|
|
const toast = useToast();
|
|
const [items, setItems] = useState<Scenario[]>([]);
|
|
const [loading, setLoading] = useState(true);
|
|
const [deleteId, setDeleteId] = useState<string | null>(null);
|
|
const [deleting, setDeleting] = useState(false);
|
|
const [runScenarioId, setRunScenarioId] = useState<string | null>(null);
|
|
const [running, setRunning] = useState(false);
|
|
const [saveSessionFlag, setSaveSessionFlag] = useState(false);
|
|
// null = use the server's configured default
|
|
const [traceModeOverride, setTraceModeOverride] = useState<TraceMode | null>(null);
|
|
const runDefaults = useRunDefaults();
|
|
const [runVersions, setRunVersions] = useState<ScenarioVersion[]>([]);
|
|
// null = latest
|
|
const [runVersion, setRunVersion] = useState<number | null>(null);
|
|
const traceMode = traceModeOverride ?? runDefaults?.traceMode ?? 'off';
|
|
const [envs, setEnvs] = useState<Environment[]>([]);
|
|
const [selectedEnvId, setSelectedEnvId] = useState('');
|
|
|
|
const fileInputRef = useRef<HTMLInputElement>(null);
|
|
|
|
const [sortBy, setSortBy] = useState('updatedAt');
|
|
const [sortDir, setSortDir] = useState<SortDirection>('desc');
|
|
const [page, setPage] = useState(1);
|
|
const [pageSize, setPageSize] = useState(10);
|
|
const [total, setTotal] = useState(0);
|
|
|
|
const load = useCallback(
|
|
(orderBy: string, orderDir: SortDirection, p: number, limit: number) => {
|
|
setLoading(true);
|
|
Promise.all([
|
|
scenarios.list(p, limit, orderBy, orderDir === 'asc' ? 'ASC' : 'DESC'),
|
|
environments.list(1, 200),
|
|
])
|
|
.then(([scenarioRes, envRes]) => {
|
|
setItems(scenarioRes?.data ?? []);
|
|
setTotal(scenarioRes?.total ?? 0);
|
|
setEnvs(envRes?.data ?? []);
|
|
})
|
|
.catch((err) => {
|
|
toast.error((err as Error).message);
|
|
})
|
|
.finally(() => setLoading(false));
|
|
},
|
|
[toast],
|
|
);
|
|
|
|
useEffect(() => {
|
|
load('updatedAt', 'desc', 1, 10);
|
|
}, [load]);
|
|
|
|
const handleSort = (key: string, dir: SortDirection) => {
|
|
setSortBy(key);
|
|
setSortDir(dir);
|
|
setPage(1);
|
|
load(key, dir, 1, pageSize);
|
|
};
|
|
|
|
const handlePageChange = (p: number) => {
|
|
setPage(p);
|
|
load(sortBy, sortDir, p, pageSize);
|
|
};
|
|
|
|
const handlePageSizeChange = (size: number) => {
|
|
setPageSize(size);
|
|
setPage(1);
|
|
load(sortBy, sortDir, 1, size);
|
|
};
|
|
|
|
const openRunModal = (id: string) => {
|
|
setRunScenarioId(id);
|
|
setTraceModeOverride(null);
|
|
setRunVersion(null);
|
|
setRunVersions([]);
|
|
scenarios
|
|
.versions(id)
|
|
.then(setRunVersions)
|
|
.catch(() => undefined);
|
|
const scenario = items.find((s) => s.id === id);
|
|
const preferred = scenario?.environmentId ?? null;
|
|
const exists = preferred ? envs.some((e) => e.id === preferred) : false;
|
|
setSelectedEnvId(exists ? preferred! : envs[0]?.id || '');
|
|
};
|
|
|
|
const handleRun = async () => {
|
|
if (!runScenarioId || !selectedEnvId) return;
|
|
setRunning(true);
|
|
try {
|
|
const run = await scenarios.run(
|
|
runScenarioId,
|
|
selectedEnvId,
|
|
saveSessionFlag,
|
|
traceModeOverride ?? undefined,
|
|
runVersion ?? undefined,
|
|
);
|
|
toast.success(t('scenarios.run_started'));
|
|
navigate(`/scenarios/${runScenarioId}/runs/${run.id}`);
|
|
setRunScenarioId(null);
|
|
setSaveSessionFlag(false);
|
|
} catch (err) {
|
|
toast.error((err as Error).message);
|
|
} finally {
|
|
setRunning(false);
|
|
}
|
|
};
|
|
|
|
const handleDelete = async () => {
|
|
if (!deleteId) return;
|
|
setDeleting(true);
|
|
try {
|
|
await scenarios.remove(deleteId);
|
|
load(sortBy, sortDir, page, pageSize);
|
|
setDeleteId(null);
|
|
} finally {
|
|
setDeleting(false);
|
|
}
|
|
};
|
|
|
|
const handleImport = async (e: React.ChangeEvent<HTMLInputElement>) => {
|
|
const file = e.target.files?.[0];
|
|
if (!file) return;
|
|
e.target.value = '';
|
|
try {
|
|
const text = await file.text();
|
|
const payload = yamlParse(text) as unknown;
|
|
const imported = await scenarios.importScenario(payload);
|
|
navigate(`/scenarios/${imported.id}`);
|
|
} catch {
|
|
// Import errors are silently ignored
|
|
}
|
|
};
|
|
|
|
const columns: TableColumn<Scenario>[] = [
|
|
{ key: 'id', header: t('scenarios.col_id'), render: (s) => <UuidBadge id={s.id} />, width: 60 },
|
|
{ key: 'name', header: t('scenarios.col_name'), render: (s) => s.name, sortable: true },
|
|
{
|
|
key: 'version',
|
|
header: t('scenarios.col_version'),
|
|
width: 80,
|
|
render: (s) => `v${s.version}`,
|
|
},
|
|
{
|
|
key: 'lastRunStatus',
|
|
header: t('scenarios.col_last_run'),
|
|
width: 160,
|
|
render: (s) =>
|
|
s.lastRunStatus ? (
|
|
<span style={{ display: 'inline-flex', alignItems: 'center', gap: 6 }}>
|
|
<span style={{ display: 'inline-flex', minWidth: 62 }}>
|
|
<Badge variant={LAST_RUN_VARIANT[s.lastRunStatus]}>
|
|
{LAST_RUN_LABEL[s.lastRunStatus]}
|
|
</Badge>
|
|
</span>
|
|
{s.lastRunAt && <Timestamp value={s.lastRunAt} />}
|
|
</span>
|
|
) : (
|
|
<span style={{ color: 'var(--color-text-muted)', fontSize: '0.8em' }}>—</span>
|
|
),
|
|
},
|
|
{
|
|
key: 'updatedAt',
|
|
header: t('scenarios.col_updated'),
|
|
width: 140,
|
|
sortable: true,
|
|
render: (s) => <Timestamp value={s.updatedAt} />,
|
|
},
|
|
{
|
|
key: 'actions',
|
|
header: '',
|
|
width: 100,
|
|
align: 'right',
|
|
render: (s) => (
|
|
<span style={{ display: 'inline-flex', gap: 6 }}>
|
|
<Button
|
|
size="sm"
|
|
title={t('scenarios.action_run')}
|
|
onClick={(e) => {
|
|
e.stopPropagation();
|
|
openRunModal(s.id);
|
|
}}
|
|
>
|
|
<Play size={14} />
|
|
</Button>
|
|
<Button
|
|
variant="danger"
|
|
size="sm"
|
|
title={t('scenarios.action_delete')}
|
|
onClick={(e) => {
|
|
e.stopPropagation();
|
|
setDeleteId(s.id);
|
|
}}
|
|
>
|
|
<Trash2 size={14} />
|
|
</Button>
|
|
</span>
|
|
),
|
|
},
|
|
];
|
|
|
|
return (
|
|
<div>
|
|
<div className={styles.pageToolbar}>
|
|
<Breadcrumbs items={[{ label: t('scenarios.title'), icon: <ClipboardList size={14} /> }]} />
|
|
<div className={styles.toolbarActions}>
|
|
<input
|
|
ref={fileInputRef}
|
|
type="file"
|
|
accept=".yaml,.yml,.json"
|
|
style={{ display: 'none' }}
|
|
onChange={handleImport}
|
|
/>
|
|
<Button variant="secondary" size="sm" onClick={() => fileInputRef.current?.click()}>
|
|
<Download size={14} />
|
|
{t('scenarios.action_import')}
|
|
</Button>
|
|
<Button size="sm" onClick={() => navigate('/scenarios/new')}>
|
|
<Plus size={14} />
|
|
{t('scenarios.action_add')}
|
|
</Button>
|
|
</div>
|
|
</div>
|
|
<Table
|
|
columns={columns}
|
|
data={items}
|
|
rowKey={(s) => s.id}
|
|
loading={loading}
|
|
emptyMessage={t('scenarios.empty')}
|
|
pageSize={pageSize}
|
|
pageSizeOptions={[10, 25, 50]}
|
|
onRowClick={(s) => navigate(`/scenarios/${s.id}`)}
|
|
sortBy={sortBy}
|
|
sortDir={sortDir}
|
|
onSort={handleSort}
|
|
total={total}
|
|
page={page}
|
|
onPageChange={handlePageChange}
|
|
onPageSizeChange={handlePageSizeChange}
|
|
/>
|
|
|
|
<Modal
|
|
open={deleteId != null}
|
|
title={t('scenarios.action_delete')}
|
|
onClose={() => !deleting && setDeleteId(null)}
|
|
footer={
|
|
<>
|
|
<Button variant="secondary" onClick={() => setDeleteId(null)} disabled={deleting}>
|
|
{t('common.button_cancel')}
|
|
</Button>
|
|
<Button variant="danger" onClick={handleDelete} disabled={deleting}>
|
|
{t('scenarios.action_delete')}
|
|
</Button>
|
|
</>
|
|
}
|
|
>
|
|
{t('common.confirm_delete_scenario')}
|
|
</Modal>
|
|
|
|
<RunScenarioModal
|
|
open={runScenarioId != null}
|
|
environments={envs}
|
|
selectedEnvId={selectedEnvId}
|
|
onEnvSelect={setSelectedEnvId}
|
|
saveSessionFlag={saveSessionFlag}
|
|
onSaveSessionChange={setSaveSessionFlag}
|
|
versions={runVersions}
|
|
selectedVersion={runVersion}
|
|
onVersionChange={setRunVersion}
|
|
traceMode={traceMode}
|
|
defaultTraceMode={runDefaults?.traceMode ?? null}
|
|
onTraceModeChange={setTraceModeOverride}
|
|
onClose={() => setRunScenarioId(null)}
|
|
onRun={handleRun}
|
|
isRunning={running}
|
|
/>
|
|
</div>
|
|
);
|
|
}
|