feat(ui): persist guardrails state in the URL

The Guardrails page now keeps its tab, table sort and page, detail tab, garden search, card and filters, test playground selection and search, and submission search, status and open submission in query params. Non-admins land on Submitted Guardrails instead of an empty tab strip.

The Guardrails Monitor keeps its date range, overview sort, detail tab and log viewer filter, sample size and open request in the URL. The logs query key now includes the date range so changing it refetches logs. LogViewer takes optional view state and keeps its own state when none is passed, so ToolDetail is unchanged.
This commit is contained in:
ryan-crabbe-berri 2026-09-16 10:27:59 -07:00
parent 8bb4317c75
commit 0bb89fd559
29 changed files with 1295 additions and 205 deletions

View file

@ -1,8 +1,9 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import userEvent from "@testing-library/user-event";
import { render, screen, waitFor } from "@testing-library/react";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import type { UrlUpdateEvent } from "nuqs/adapters/testing";
import { renderWithProviders, screen, testQueryClient, waitFor } from "@/../tests/test-utils";
import type { GuardrailUsageDetail } from "@/app/(dashboard)/hooks/guardrails/useGuardrailsUsage";
import type { LogViewerState } from "@/components/GuardrailsMonitor/useLogViewerState";
import { GuardrailDetail } from "./GuardrailDetail";
const mockUseGuardrailsUsageDetail = vi.fn();
@ -16,7 +17,20 @@ vi.mock("@/components/networking", () => ({
}));
vi.mock("@/components/GuardrailsMonitor/LogViewer", () => ({
LogViewer: ({ guardrailName }: { guardrailName: string }) => <div data-testid="log-viewer">{guardrailName}</div>,
LogViewer: ({ guardrailName, viewState }: { guardrailName: string; viewState?: LogViewerState }) => (
<div
data-testid="log-viewer"
data-filter={viewState?.filter}
data-sample={viewState?.sampleSize}
data-request={viewState?.requestId ?? ""}
>
<span>{guardrailName}</span>
<button onClick={() => viewState?.setFilter("blocked")}>show blocked</button>
<button onClick={() => viewState?.setSampleSize(50)}>sample 50</button>
<button onClick={() => viewState?.setRequestId("req-9")}>open req-9</button>
<button onClick={() => viewState?.setRequestId(null)}>close request</button>
</div>
),
}));
vi.mock("./EvaluationSettingsModal", () => ({
@ -59,15 +73,19 @@ const defaultProps = {
endDate: "2026-07-24",
};
function renderDetail(props: Partial<typeof defaultProps> = {}) {
const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
return render(<GuardrailDetail {...defaultProps} {...props} />, {
wrapper: ({ children }) => <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>,
});
function renderDetail(
props: Partial<typeof defaultProps> = {},
urlOptions: { searchParams?: string; onUrlUpdate?: (event: UrlUpdateEvent) => void } = {},
) {
return renderWithProviders(<GuardrailDetail {...defaultProps} {...props} />, urlOptions);
}
const lastUrlUpdate = (onUrlUpdate: ReturnType<typeof vi.fn<(event: UrlUpdateEvent) => void>>) =>
onUrlUpdate.mock.calls.at(-1)?.[0];
describe("GuardrailDetail", () => {
beforeEach(() => {
testQueryClient.clear();
vi.clearAllMocks();
mockUseGuardrailsUsageDetail.mockReturnValue(loaded(detail));
mockGetGuardrailsUsageLogs.mockResolvedValue({ logs: [], total: 0 });
@ -152,6 +170,19 @@ describe("GuardrailDetail", () => {
expect(screen.getByTestId("log-viewer")).toHaveTextContent("pii-detector");
});
it("should request the logs again when the date range changes", async () => {
const { rerender } = renderDetail();
await waitFor(() => expect(mockGetGuardrailsUsageLogs).toHaveBeenCalledTimes(1));
rerender(<GuardrailDetail {...defaultProps} startDate="2026-06-01" endDate="2026-06-15" />);
await waitFor(() => expect(mockGetGuardrailsUsageLogs).toHaveBeenCalledTimes(2));
expect(mockGetGuardrailsUsageLogs).toHaveBeenLastCalledWith(
"test-token",
expect.objectContaining({ guardrailId: "pii-detector", startDate: "2026-06-01", endDate: "2026-06-15" }),
);
});
it("should keep the evaluation settings modal closed until its button is clicked", async () => {
const user = userEvent.setup();
renderDetail();
@ -171,4 +202,92 @@ describe("GuardrailDetail", () => {
);
expect(mockGetGuardrailsUsageLogs).not.toHaveBeenCalled();
});
describe("URL state", () => {
it("should select the Logs tab when ?tab=logs", async () => {
renderDetail({}, { searchParams: "?tab=logs" });
expect(await screen.findByRole("tab", { name: "Logs" })).toHaveAttribute("aria-selected", "true");
expect(screen.getByRole("tab", { name: "Overview" })).toHaveAttribute("aria-selected", "false");
});
it("should write the clicked tab to ?tab= and drop it for the overview", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<(event: UrlUpdateEvent) => void>();
renderDetail({}, { onUrlUpdate });
await user.click(await screen.findByRole("tab", { name: "Logs" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("tab")).toBe("logs"));
await user.click(screen.getByRole("tab", { name: "Overview" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("tab")).toBe(false));
expect(screen.getByRole("tab", { name: "Overview" })).toHaveAttribute("aria-selected", "true");
});
it("should hand the log filter, sample size and open request from the URL to the log viewer", async () => {
renderDetail({}, { searchParams: "?tab=logs&log_filter=blocked&log_sample=50&request_id=req-3" });
const viewer = await screen.findByTestId("log-viewer");
expect(viewer).toHaveAttribute("data-filter", "blocked");
expect(viewer).toHaveAttribute("data-sample", "50");
expect(viewer).toHaveAttribute("data-request", "req-3");
});
it("should fall back to all logs and a sample of 10 for unknown values", async () => {
renderDetail({}, { searchParams: "?log_filter=everything&log_sample=7" });
const viewer = await screen.findByTestId("log-viewer");
expect(viewer).toHaveAttribute("data-filter", "all");
expect(viewer).toHaveAttribute("data-sample", "10");
expect(viewer).toHaveAttribute("data-request", "");
});
it("should write the log viewer's filter, sample size and open request to the URL", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<(event: UrlUpdateEvent) => void>();
renderDetail({}, { onUrlUpdate });
await user.click(await screen.findByRole("button", { name: "show blocked" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("log_filter")).toBe("blocked"));
expect(screen.getByTestId("log-viewer")).toHaveAttribute("data-filter", "blocked");
await user.click(screen.getByRole("button", { name: "sample 50" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("log_sample")).toBe("50"));
await user.click(screen.getByRole("button", { name: "open req-9" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("request_id")).toBe("req-9"));
expect(lastUrlUpdate(onUrlUpdate)?.options.history).toBe("push");
await user.click(screen.getByRole("button", { name: "close request" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("request_id")).toBe(false));
expect(lastUrlUpdate(onUrlUpdate)?.options.history).toBe("replace");
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("log_filter")).toBe("blocked");
});
it("should drop the detail tab and log viewer state when going back", async () => {
const user = userEvent.setup();
const onBack = vi.fn();
const onUrlUpdate = vi.fn<(event: UrlUpdateEvent) => void>();
renderDetail(
{ onBack },
{
searchParams:
"?guardrail=pii-detector&start_date=2026-07-01&tab=logs&log_filter=blocked&log_sample=100&request_id=req-3",
onUrlUpdate,
},
);
await user.click(await screen.findByRole("button", { name: /back to overview/i }));
expect(onBack).toHaveBeenCalledOnce();
await waitFor(() => expect(onUrlUpdate).toHaveBeenCalled());
const update = lastUrlUpdate(onUrlUpdate);
for (const key of ["tab", "log_filter", "log_sample", "request_id"]) {
expect(update?.searchParams.has(key)).toBe(false);
}
expect(update?.searchParams.get("guardrail")).toBe("pii-detector");
expect(update?.searchParams.get("start_date")).toBe("2026-07-01");
expect(update?.options.history).toBe("replace");
});
});
});

View file

@ -13,6 +13,7 @@ import { GuardrailUsageBreakdown } from "./GuardrailUsageBreakdown";
import { LogViewer } from "@/components/GuardrailsMonitor/LogViewer";
import { MetricCard } from "@/components/GuardrailsMonitor/MetricCard";
import type { LogEntry } from "@/components/GuardrailsMonitor/mockData";
import { useGuardrailDetailUrlState } from "./useGuardrailDetailUrlState";
interface GuardrailDetailProps {
guardrailId: string;
@ -29,7 +30,7 @@ const STATUS_TONE: Record<string, StatusTone> = {
};
export function GuardrailDetail({ guardrailId, onBack, accessToken = null, startDate, endDate }: GuardrailDetailProps) {
const [activeTab, setActiveTab] = useState("overview");
const { tab: activeTab, setTab: setActiveTab, logViewerState, clear: clearUrlState } = useGuardrailDetailUrlState();
const [evaluationModalOpen, setEvaluationModalOpen] = useState(false);
const [logsPage] = useState(1);
const logsPageSize = 50;
@ -40,7 +41,7 @@ export function GuardrailDetail({ guardrailId, onBack, accessToken = null, start
error: detailError,
} = useGuardrailsUsageDetail(guardrailId, { accessToken, startDate, endDate });
const { data: logsData, isLoading: logsLoading } = useQuery({
queryKey: ["guardrails-usage-logs", guardrailId, logsPage, logsPageSize],
queryKey: ["guardrails-usage-logs", guardrailId, startDate, endDate, logsPage, logsPageSize],
queryFn: () =>
getGuardrailsUsageLogs(accessToken!, {
guardrailId,
@ -90,6 +91,11 @@ export function GuardrailDetail({ guardrailId, onBack, accessToken = null, start
avgLatency: undefined as number | undefined,
};
const handleBack = () => {
clearUrlState();
onBack();
};
if (detailLoading && !detailData) {
return (
<div role="status" aria-busy="true" aria-label="Loading" className="flex items-center justify-center py-12">
@ -100,7 +106,7 @@ export function GuardrailDetail({ guardrailId, onBack, accessToken = null, start
if (detailError && !detailData) {
return (
<div>
<Button variant="link" onClick={onBack} className="mb-4 pl-0">
<Button variant="link" onClick={handleBack} className="mb-4 pl-0">
<ArrowLeft className="size-4" />
Back to Overview
</Button>
@ -109,23 +115,23 @@ export function GuardrailDetail({ guardrailId, onBack, accessToken = null, start
);
}
const logViewer = (filterAction?: "all") => (
const renderLogViewer = () => (
<LogViewer
guardrailName={data.name}
filterAction={filterAction}
logs={logs}
logsLoading={logsLoading}
totalLogs={logsData?.total ?? 0}
accessToken={accessToken}
startDate={startDate}
endDate={endDate}
viewState={logViewerState}
/>
);
return (
<div>
<div className="mb-6">
<Button variant="link" onClick={onBack} className="mb-4 pl-0">
<Button variant="link" onClick={handleBack} className="mb-4 pl-0">
<ArrowLeft className="size-4" />
Back to Overview
</Button>
@ -156,7 +162,7 @@ export function GuardrailDetail({ guardrailId, onBack, accessToken = null, start
</div>
</div>
<Tabs value={activeTab} onValueChange={(value) => setActiveTab(value as string)}>
<Tabs value={activeTab} onValueChange={setActiveTab}>
<TabsList variant="line">
<TabsTrigger value="overview" className="flex-none">
Overview
@ -194,11 +200,11 @@ export function GuardrailDetail({ guardrailId, onBack, accessToken = null, start
{detailData && <GuardrailUsageBreakdown detail={detailData} />}
{logViewer("all")}
{renderLogViewer()}
</TabsContent>
<TabsContent value="logs" className="mt-4">
{logViewer()}
{renderLogViewer()}
</TabsContent>
</Tabs>

View file

@ -1,9 +1,10 @@
import moment from "moment";
import { type UrlUpdateEvent } from "nuqs/adapters/testing";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import userEvent from "@testing-library/user-event";
import GuardrailsMonitorView from "./GuardrailsMonitorView";
import * as networking from "@/components/networking";
import { renderWithProviders, screen, testQueryClient, waitFor } from "@/../tests/test-utils";
import { fireEvent, renderWithProviders, screen, testQueryClient, waitFor } from "@/../tests/test-utils";
vi.mock("@/components/networking", () => ({
getGuardrailsUsageLogs: vi.fn(),
@ -149,4 +150,71 @@ describe("GuardrailsMonitorView", () => {
expect(await screen.findByRole("heading", { name: /Guardrails Monitor/i })).toBeInTheDocument();
});
});
describe("date range in the URL (?start_date= and ?end_date=)", () => {
const lastOverviewRange = () => {
const [options] = mockUseGuardrailsUsageOverview.mock.calls.at(-1) as [{ startDate: string; endDate: string }];
return { startDate: options.startDate, endDate: options.endDate };
};
afterEach(() => {
vi.unstubAllGlobals();
});
it("should request usage for the range in the URL and show it in the picker", () => {
renderWithProviders(<GuardrailsMonitorView accessToken="test-token" />, {
searchParams: "?start_date=2026-01-05&end_date=2026-01-20",
});
expect(lastOverviewRange()).toEqual({ startDate: "2026-01-05", endDate: "2026-01-20" });
expect(screen.getByRole("button", { name: "5 Jan, 00:00 - 20 Jan, 23:59" })).toBeInTheDocument();
});
it("should pass the URL range to the detail view as well", () => {
renderWithProviders(<GuardrailsMonitorView accessToken="test-token" />, {
searchParams: "?guardrail=gr-pii&start_date=2026-01-05&end_date=2026-01-20",
});
expect(mockUseGuardrailsUsageDetail).toHaveBeenLastCalledWith(
"gr-pii",
expect.objectContaining({ startDate: "2026-01-05", endDate: "2026-01-20" }),
);
});
it("should default to a seven day range ending today when the URL has none", () => {
renderWithProviders(<GuardrailsMonitorView accessToken="test-token" />);
const { startDate, endDate } = lastOverviewRange();
expect(endDate).toBe(moment().format("YYYY-MM-DD"));
expect(moment(endDate).diff(moment(startDate), "days")).toBe(7);
});
it("should ignore a malformed date and keep the other one", () => {
renderWithProviders(<GuardrailsMonitorView accessToken="test-token" />, {
searchParams: "?start_date=2026-02-30&end_date=2026-01-20",
});
const { startDate, endDate } = lastOverviewRange();
expect(endDate).toBe("2026-01-20");
expect(startDate).toBe(moment().subtract(7, "days").format("YYYY-MM-DD"));
});
it("should write the applied range to the URL and request usage for it", async () => {
vi.stubGlobal("requestIdleCallback", (callback: () => void) => setTimeout(callback, 0));
const onUrlUpdate = vi.fn<(event: UrlUpdateEvent) => void>();
renderWithProviders(<GuardrailsMonitorView accessToken="test-token" />, {
searchParams: "?start_date=2026-01-05&end_date=2026-01-20",
onUrlUpdate,
});
fireEvent.click(screen.getByRole("button", { name: "5 Jan, 00:00 - 20 Jan, 23:59" }));
fireEvent.change(screen.getByDisplayValue("2026-01-05"), { target: { value: "2026-03-01" } });
fireEvent.change(screen.getByDisplayValue("2026-01-20"), { target: { value: "2026-03-15" } });
fireEvent.click(screen.getByRole("button", { name: "Apply" }));
await waitFor(() => expect(onUrlUpdate.mock.calls.at(-1)?.[0].searchParams.get("start_date")).toBe("2026-03-01"));
expect(onUrlUpdate.mock.calls.at(-1)?.[0].searchParams.get("end_date")).toBe("2026-03-15");
expect(lastOverviewRange()).toEqual({ startDate: "2026-03-01", endDate: "2026-03-15" });
expect(screen.getByRole("button", { name: "1 Mar, 00:00 - 15 Mar, 23:59" })).toBeInTheDocument();
});
});
});

View file

@ -1,39 +1,19 @@
import type { DateRangePickerValue } from "@/components/shared/date_picker_types";
import { parseAsString, useQueryState } from "nuqs";
import React, { useCallback, useMemo, useState } from "react";
import { formatDate } from "@/components/networking";
import AdvancedDatePicker from "@/components/shared/advanced_date_picker";
import { GuardrailDetail } from "./GuardrailDetail";
import { GuardrailsOverview } from "./GuardrailsOverview";
import { useMonitorDateRange } from "./useMonitorDateRange";
interface GuardrailsMonitorViewProps {
accessToken?: string | null;
}
const defaultEnd = new Date();
const defaultStart = new Date();
defaultStart.setDate(defaultStart.getDate() - 7);
export default function GuardrailsMonitorView({ accessToken = null }: GuardrailsMonitorViewProps) {
const [selectedGuardrailId, setSelectedGuardrailId] = useQueryState(
"guardrail",
parseAsString.withOptions({ history: "push" }),
);
const initialFrom = useMemo(() => new Date(defaultStart), []);
const initialTo = useMemo(() => new Date(defaultEnd), []);
const [dateValue, setDateValue] = useState<DateRangePickerValue>({
from: initialFrom,
to: initialTo,
});
const startDate = dateValue.from ? formatDate(dateValue.from) : "";
const endDate = dateValue.to ? formatDate(dateValue.to) : "";
const handleDateChange = useCallback((newValue: DateRangePickerValue) => {
setDateValue(newValue);
}, []);
const { startDate, endDate, pickerValue, setPickerValue } = useMonitorDateRange();
const handleSelectGuardrail = (id: string) => {
void setSelectedGuardrailId(id);
@ -44,7 +24,7 @@ export default function GuardrailsMonitorView({ accessToken = null }: Guardrails
};
const dateRangeControl = (
<AdvancedDatePicker value={dateValue} onValueChange={handleDateChange} label="" showTimeRange={false} />
<AdvancedDatePicker value={pickerValue} onValueChange={setPickerValue} label="" showTimeRange={false} />
);
return (

View file

@ -1,5 +1,6 @@
import { render, screen, waitFor, within } from "@testing-library/react";
import { renderWithProviders, screen, waitFor, within } from "@/../tests/test-utils";
import userEvent from "@testing-library/user-event";
import type { OnUrlUpdateFunction } from "nuqs/adapters/testing";
import { beforeEach, describe, expect, it, vi } from "vitest";
import type {
GuardrailUsageOverview,
@ -80,14 +81,18 @@ const overview: GuardrailUsageOverview = {
totalUntrackedUsageUnits: { sensitiveInformationPolicyUnits: 250 },
};
function renderOverview(onSelectGuardrail = vi.fn()) {
return render(
function renderOverview(
onSelectGuardrail = vi.fn(),
urlOptions: { searchParams?: string; onUrlUpdate?: OnUrlUpdateFunction } = {},
) {
return renderWithProviders(
<GuardrailsOverview
accessToken="test-token"
startDate="2026-08-01"
endDate="2026-08-12"
onSelectGuardrail={onSelectGuardrail}
/>,
urlOptions,
);
}
@ -288,4 +293,47 @@ describe("GuardrailsOverview", () => {
expect(await screen.findByText("Failed to load data. Try again.")).toBeInTheDocument();
});
describe("sort in the URL (?sort_by= and ?sort_order=)", () => {
const rowOrder = () =>
screen
.getAllByRole("row")
.slice(1)
.map((r) => within(r).getAllByRole("button")[0].textContent);
it("orders rows by the column and direction in the URL", () => {
renderOverview(vi.fn(), { searchParams: "?sort_by=requestsEvaluated&sort_order=asc" });
expect(rowOrder()).toEqual(["Free Bedrock Guardrail", "High Failure Guardrail", "Low Failure Guardrail"]);
});
it("keeps guardrails with no known cost last when the URL sorts by cost ascending", () => {
renderOverview(vi.fn(), { searchParams: "?sort_by=cost&sort_order=asc" });
expect(rowOrder()).toEqual(["Free Bedrock Guardrail", "High Failure Guardrail", "Low Failure Guardrail"]);
});
it("falls back to the highest fail rate first for a column that cannot be sorted", () => {
renderOverview(vi.fn(), { searchParams: "?sort_by=name" });
expect(rowOrder()).toEqual(["High Failure Guardrail", "Low Failure Guardrail", "Free Bedrock Guardrail"]);
});
it("writes the clicked column and direction to the URL", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderOverview(vi.fn(), { onUrlUpdate });
const lastParams = () => onUrlUpdate.mock.calls.at(-1)?.[0].searchParams;
await user.click(screen.getByRole("button", { name: /Requests/ }));
await waitFor(() => expect(lastParams()?.get("sort_by")).toBe("requestsEvaluated"));
expect(lastParams()?.get("sort_order")).toBe("asc");
expect(rowOrder()).toEqual(["Free Bedrock Guardrail", "High Failure Guardrail", "Low Failure Guardrail"]);
await user.click(screen.getByRole("button", { name: /Requests/ }));
await waitFor(() => expect(lastParams()?.has("sort_order")).toBe(false));
expect(lastParams()?.get("sort_by")).toBe("requestsEvaluated");
expect(rowOrder()).toEqual(["Low Failure Guardrail", "High Failure Guardrail", "Free Bedrock Guardrail"]);
});
});
});

View file

@ -1,7 +1,12 @@
import type { ColumnDef, OnChangeFn, SortingState } from "@tanstack/react-table";
import type { ColumnDef } from "@tanstack/react-table";
import { CircleDollarSign, Download, HeartPulse, Settings, TrendingUp, TriangleAlert } from "lucide-react";
import React, { useMemo, useState } from "react";
import { DataTable, DataTableSortHeader } from "@/components/shared/DataTable";
import {
DataTable,
DataTableSortHeader,
useUrlTableState,
type UrlTableStateOptions,
} from "@/components/shared/DataTable";
import { MoneyCell } from "@/components/shared/table_cells/money_cell";
import { CellTooltip } from "@/components/shared/table_cells/cell_tooltip";
import {
@ -32,7 +37,12 @@ interface GuardrailsOverviewProps {
dateRangeControl?: React.ReactNode;
}
type SortKey = "failRate" | "requestsEvaluated" | "avgLatency" | "cost";
const TABLE_STATE_OPTIONS: UrlTableStateOptions<never> = {
sortFields: ["failRate", "requestsEvaluated", "avgLatency", "cost"],
defaultSort: { id: "failRate", desc: true },
defaultPageSize: 25,
filterColumns: [],
};
const providerColors: Record<string, string> = {
Bedrock: "bg-warning/15 text-warning border-warning/20",
@ -118,8 +128,7 @@ export function GuardrailsOverview({
onSelectGuardrail,
dateRangeControl,
}: GuardrailsOverviewProps) {
const [sortBy, setSortBy] = useState<SortKey>("failRate");
const [sortDir, setSortDir] = useState<"asc" | "desc">("desc");
const { sorting, onSortingChange } = useUrlTableState(TABLE_STATE_OPTIONS);
const [evaluationModalOpen, setEvaluationModalOpen] = useState(false);
const {
@ -144,15 +153,6 @@ export function GuardrailsOverview({
};
}, [guardrailsData, activeData]);
const chartData = guardrailsData?.chart;
const sorted = useMemo(() => {
const mult = sortDir === "desc" ? -1 : 1;
return [...activeData].sort((a, b) => {
const aVal = a[sortBy];
const bVal = b[sortBy];
if (aVal == null || bVal == null) return Number(aVal == null) - Number(bVal == null);
return (aVal - bVal) * mult;
});
}, [activeData, sortBy, sortDir]);
const isLoading = guardrailsLoading;
const error = guardrailsError;
@ -234,7 +234,9 @@ export function GuardrailsOverview({
},
{
header: ({ column }) => <DataTableSortHeader column={column} title="Avg. latency added" />,
accessorKey: "avgLatency",
id: "avgLatency",
accessorFn: (row) => row.avgLatency ?? undefined,
sortUndefined: "last",
meta: { numeric: true },
sortDescFirst: false,
cell: ({ row }) => (
@ -262,24 +264,15 @@ export function GuardrailsOverview({
},
{
header: ({ column }) => <DataTableSortHeader column={column} title="Cost" />,
accessorKey: "cost",
id: "cost",
accessorFn: (row) => row.cost ?? undefined,
sortUndefined: "last",
meta: { numeric: true },
sortDescFirst: false,
cell: ({ row }) => <CostCell row={row.original} />,
},
];
const sortableKeys: SortKey[] = ["failRate", "requestsEvaluated", "avgLatency", "cost"];
const sorting = useMemo<SortingState>(() => [{ id: sortBy, desc: sortDir === "desc" }], [sortBy, sortDir]);
const handleSortingChange: OnChangeFn<SortingState> = (updater) => {
const nextSorting = typeof updater === "function" ? updater(sorting) : updater;
const primarySort = nextSorting[0];
if (primarySort && sortableKeys.includes(primarySort.id as SortKey)) {
setSortBy(primarySort.id as SortKey);
setSortDir(primarySort.desc ? "desc" : "asc");
}
};
return (
<div>
<PageHeader
@ -346,15 +339,15 @@ export function GuardrailsOverview({
)}
<DataTable
columns={columns}
data={sorted}
data={activeData}
getRowId={(row) => row.id}
isLoading={isLoading}
noDataMessage="No data for this period"
onRowClick={(row) => onSelectGuardrail(row.id)}
rowClassName={() => "cursor-pointer"}
sortingMode="server"
sortingMode="client"
sorting={sorting}
onSortingChange={handleSortingChange}
onSortingChange={onSortingChange}
enableSortingRemoval={false}
size="compact"
toolbar={() => (

View file

@ -0,0 +1,37 @@
import { parseAsNumberLiteral, parseAsString, parseAsStringLiteral, useQueryStates } from "nuqs";
import { useCallback, useMemo } from "react";
import { LOG_FILTERS, LOG_SAMPLE_SIZES, type LogViewerState } from "@/components/GuardrailsMonitor/useLogViewerState";
import { useUrlTab } from "@/hooks/useUrlTab";
const DETAIL_TABS = ["overview", "logs"] as const;
const logParsers = {
log_filter: parseAsStringLiteral(LOG_FILTERS).withDefault("all"),
log_sample: parseAsNumberLiteral(LOG_SAMPLE_SIZES).withDefault(10),
request_id: parseAsString.withOptions({ history: "push" }),
};
export function useGuardrailDetailUrlState() {
const [tab, setTab] = useUrlTab(DETAIL_TABS, "overview");
const [{ log_filter, log_sample, request_id }, setLogParams] = useQueryStates(logParsers);
const logViewerState = useMemo<LogViewerState>(
() => ({
filter: log_filter,
setFilter: (filter) => void setLogParams({ log_filter: filter }),
sampleSize: log_sample,
setSampleSize: (size) => void setLogParams({ log_sample: size }),
requestId: request_id,
setRequestId: (requestId) =>
void setLogParams({ request_id: requestId }, requestId === null ? { history: "replace" } : {}),
}),
[log_filter, log_sample, request_id, setLogParams],
);
const clear = useCallback(() => {
setTab("overview");
void setLogParams(null, { history: "replace" });
}, [setTab, setLogParams]);
return { tab, setTab, logViewerState, clear };
}

View file

@ -0,0 +1,54 @@
import moment from "moment";
import { createParser, useQueryStates } from "nuqs";
import { useCallback, useMemo } from "react";
import type { DateRangePickerValue } from "@/components/shared/date_picker_types";
const DAY_FORMAT = "YYYY-MM-DD";
const DEFAULT_RANGE_DAYS = 7;
const formatDay = (date: Date) => moment(date).format(DAY_FORMAT);
const parseAsDay = createParser({
parse: (value: string) => {
const day = moment(value, DAY_FORMAT, true);
return day.isValid() ? day.format(DAY_FORMAT) : null;
},
serialize: (value: string) => value,
});
const buildParsers = (today: Date) => ({
start_date: parseAsDay.withDefault(formatDay(moment(today).subtract(DEFAULT_RANGE_DAYS, "days").toDate())),
end_date: parseAsDay.withDefault(formatDay(today)),
});
export interface MonitorDateRange {
startDate: string;
endDate: string;
pickerValue: DateRangePickerValue;
setPickerValue: (value: DateRangePickerValue) => void;
}
export function useMonitorDateRange(): MonitorDateRange {
const parsers = useMemo(() => buildParsers(new Date()), []);
const [{ start_date: startDate, end_date: endDate }, setRange] = useQueryStates(parsers);
const pickerValue = useMemo<DateRangePickerValue>(
() => ({
from: moment(startDate, DAY_FORMAT).startOf("day").toDate(),
to: moment(endDate, DAY_FORMAT).endOf("day").toDate(),
}),
[startDate, endDate],
);
const setPickerValue = useCallback(
({ from, to }: DateRangePickerValue) => {
void setRange({
start_date: from ? formatDay(from) : null,
end_date: to ? formatDay(to) : null,
});
},
[setRange],
);
return { startDate, endDate, pickerValue, setPickerValue };
}

View file

@ -1,5 +1,6 @@
import { render, screen, waitFor } from "@testing-library/react";
import { fireEvent, renderWithProviders, screen, waitFor, within } from "@/../tests/test-utils";
import userEvent from "@testing-library/user-event";
import type { OnUrlUpdateFunction } from "nuqs/adapters/testing";
import { beforeEach, describe, expect, it, vi } from "vitest";
import GuardrailTestPlayground from "./GuardrailTestPlayground";
@ -19,55 +20,118 @@ Object.defineProperty(window, "matchMedia", {
})),
});
const makeGuardrail = (id: string, name: string) => ({
guardrail_id: id,
guardrail_name: name,
litellm_params: {
guardrail: "presidio",
mode: "pre_call" as const,
default_on: false,
},
guardrail_info: {},
});
const sidebarItem = (name: string) => within(screen.getAllByRole("list")[0]).getByText(name);
const lastUrlUpdate = (onUrlUpdate: ReturnType<typeof vi.fn<OnUrlUpdateFunction>>) =>
onUrlUpdate.mock.calls.at(-1)?.[0];
describe("GuardrailTestPlayground", () => {
const mockAccessToken = "test-token";
const mockGuardrails = [
{
guardrail_id: "guard-1",
guardrail_name: "test-guardrail",
litellm_params: {
guardrail: "presidio",
mode: "pre_call",
default_on: false,
},
guardrail_info: {},
},
];
const mockGuardrails = [makeGuardrail("guard-1", "test-guardrail")];
const twoGuardrails = [makeGuardrail("guard-1", "pii, strict"), makeGuardrail("guard-2", "toxicity")];
const renderPlayground = (
guardrailsList = mockGuardrails,
searchParams?: string,
onUrlUpdate?: OnUrlUpdateFunction,
) =>
renderWithProviders(
<GuardrailTestPlayground
guardrailsList={guardrailsList}
isLoading={false}
accessToken={mockAccessToken}
onClose={vi.fn()}
/>,
{ searchParams, onUrlUpdate },
);
beforeEach(() => {
vi.clearAllMocks();
});
it("should allow selecting a guardrail and show test panel", async () => {
/**
* Tests that clicking on a guardrail selects it and displays the test panel.
* This validates the core workflow of selecting and testing guardrails.
*/
const user = userEvent.setup();
render(
<GuardrailTestPlayground
guardrailsList={mockGuardrails}
isLoading={false}
accessToken={mockAccessToken}
onClose={vi.fn()}
/>,
);
renderPlayground();
// Initially, the empty state should be shown
expect(screen.getByText("Select Guardrails to Test")).toBeInTheDocument();
// Click on the guardrail to select it
const guardrailItem = screen.getByText("test-guardrail");
await user.click(guardrailItem);
await user.click(screen.getByText("test-guardrail"));
// Verify the test panel is now shown
await waitFor(() => {
expect(screen.getByText("Test Guardrails:")).toBeInTheDocument();
expect(screen.getByPlaceholderText("Enter text to test with guardrails...")).toBeInTheDocument();
});
// Verify the selected count
expect(screen.getByText("1 of 1 selected")).toBeInTheDocument();
});
describe("URL state", () => {
it("should select the guardrails named in ?test_guardrails=, including names with commas", () => {
renderPlayground(twoGuardrails, `?test_guardrails=${encodeURIComponent("pii%2C strict")},toxicity`);
expect(screen.getByText("2 of 2 selected")).toBeInTheDocument();
expect(screen.getByText("Test 2 guardrails")).toBeInTheDocument();
});
it("should ignore names in ?test_guardrails= that are not in the guardrail list", () => {
renderPlayground(twoGuardrails, "?test_guardrails=deleted-guardrail");
expect(screen.getByText("0 of 2 selected")).toBeInTheDocument();
expect(screen.getByText("Select Guardrails to Test")).toBeInTheDocument();
});
it("should write each selection to ?test_guardrails= and remove the key once nothing is selected", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderPlayground(twoGuardrails, "?test_guardrails=deleted-guardrail", onUrlUpdate);
await user.click(sidebarItem("pii, strict"));
await waitFor(() =>
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("test_guardrails")).toBe("pii%2C strict"),
);
await user.click(sidebarItem("toxicity"));
await waitFor(() =>
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("test_guardrails")).toBe("pii%2C strict,toxicity"),
);
expect(screen.getByText("2 of 2 selected")).toBeInTheDocument();
await user.click(sidebarItem("pii, strict"));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("test_guardrails")).toBe("toxicity"));
await user.click(sidebarItem("toxicity"));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("test_guardrails")).toBe(false));
expect(screen.getByText("Select Guardrails to Test")).toBeInTheDocument();
});
it("should filter the list and prefill the search box from ?test_q=", () => {
renderPlayground(twoGuardrails, "?test_q=TOX");
expect(screen.getByPlaceholderText("Search guardrails...")).toHaveValue("TOX");
expect(screen.getByText("toxicity")).toBeInTheDocument();
expect(screen.queryByText("pii, strict")).not.toBeInTheDocument();
});
it("should write the search box to ?test_q=", async () => {
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderPlayground(twoGuardrails, undefined, onUrlUpdate);
fireEvent.change(screen.getByPlaceholderText("Search guardrails..."), { target: { value: "nothing" } });
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("test_q")).toBe("nothing"));
expect(screen.getByText("No guardrails match your search")).toBeInTheDocument();
});
});
});

View file

@ -1,5 +1,6 @@
import React, { useState } from "react";
import React, { useMemo, useState } from "react";
import { FlaskConical, Search } from "lucide-react";
import { parseAsArrayOf, parseAsString, useQueryState } from "nuqs";
import GuardrailTestPanel from "./GuardrailTestPanel";
import { applyGuardrail } from "@/components/networking";
import { toast } from "@/lib/toast";
@ -29,6 +30,9 @@ interface GuardrailTestPlaygroundProps {
onClose: () => void;
}
const selectedNamesParser = parseAsArrayOf(parseAsString).withDefault([]);
const searchParser = parseAsString.withDefault("");
interface TestResult {
guardrailName: string;
response_text: string;
@ -47,24 +51,28 @@ const GuardrailTestPlayground: React.FC<GuardrailTestPlaygroundProps> = ({
accessToken,
onClose,
}) => {
const [selectedGuardrails, setSelectedGuardrails] = useState<Set<string>>(new Set());
const [searchQuery, setSearchQuery] = useState("");
const [selectedNames, setSelectedNames] = useQueryState("test_guardrails", selectedNamesParser);
const [searchQuery, setSearchQuery] = useQueryState("test_q", searchParser);
const [testResults, setTestResults] = useState<TestResult[]>([]);
const [testErrors, setTestErrors] = useState<TestError[]>([]);
const [isTesting, setIsTesting] = useState(false);
const selectedGuardrails = useMemo(() => {
const knownNames = new Set(guardrailsList.map((guardrail) => guardrail.guardrail_name));
return new Set(selectedNames.filter((name) => knownNames.has(name)));
}, [guardrailsList, selectedNames]);
const filteredGuardrails = guardrailsList.filter((guardrail) =>
guardrail.guardrail_name?.toLowerCase().includes(searchQuery.toLowerCase()),
);
const toggleGuardrailSelection = (guardrailName: string) => {
const newSelection = new Set(selectedGuardrails);
if (newSelection.has(guardrailName)) {
newSelection.delete(guardrailName);
} else {
newSelection.add(guardrailName);
}
setSelectedGuardrails(newSelection);
const selected = Array.from(selectedGuardrails);
void setSelectedNames(
selectedGuardrails.has(guardrailName)
? selected.filter((name) => name !== guardrailName)
: [...selected, guardrailName],
);
};
const handleTestGuardrails = async (text: string, metadata?: Record<string, unknown> | null) => {
@ -131,7 +139,7 @@ const GuardrailTestPlayground: React.FC<GuardrailTestPlaygroundProps> = ({
<InputGroupInput
placeholder="Search guardrails..."
value={searchQuery}
onChange={(e) => setSearchQuery(e.target.value)}
onChange={(e) => void setSearchQuery(e.target.value)}
/>
</InputGroup>
</div>
@ -214,7 +222,7 @@ const GuardrailTestPlayground: React.FC<GuardrailTestPlaygroundProps> = ({
results={testResults.length > 0 ? testResults : null}
errors={testErrors.length > 0 ? testErrors : null}
isLoading={isTesting}
onClose={() => setSelectedGuardrails(new Set())}
onClose={() => void setSelectedNames(null)}
/>
</div>
)}

View file

@ -1,8 +1,8 @@
import { type UrlUpdateEvent } from "nuqs/adapters/testing";
import { NuqsTestingAdapter, type UrlUpdateEvent } from "nuqs/adapters/testing";
import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
import GuardrailsPanel from "./GuardrailsPanel";
import { getGuardrailsList, deleteGuardrailCall } from "@/components/networking";
import { fireEvent, renderWithProviders, screen, waitFor, within } from "@/../tests/test-utils";
import { fireEvent, render, renderWithProviders, screen, waitFor, within } from "@/../tests/test-utils";
vi.mock("@/components/networking", () => ({
getGuardrailsList: vi.fn(),
@ -204,6 +204,23 @@ describe("GuardrailsPanel", () => {
expect(await screen.findByTestId("guardrail-info-view")).toHaveTextContent("test-guardrail-1");
});
it("should drop the detail tab together with ?guardrail= when the info view is closed", async () => {
const onUrlUpdate = vi.fn<(event: UrlUpdateEvent) => void>();
renderWithProviders(<GuardrailsPanel {...defaultProps} />, {
searchParams: "?tab=guardrails&guardrail=test-guardrail-1&detail_tab=settings",
onUrlUpdate,
});
fireEvent.click(await screen.findByRole("button", { name: "Close Guardrail Info" }));
await waitFor(() => expect(onUrlUpdate).toHaveBeenCalled());
const lastUpdate = onUrlUpdate.mock.calls.at(-1)![0];
expect(lastUpdate.searchParams.has("guardrail")).toBe(false);
expect(lastUpdate.searchParams.has("detail_tab")).toBe(false);
expect(lastUpdate.searchParams.get("tab")).toBe("guardrails");
expect(lastUpdate.options.history).toBe("replace");
});
it("should clear ?guardrail= by replacing history when the info view is closed", async () => {
const onUrlUpdate = vi.fn<(event: UrlUpdateEvent) => void>();
renderWithProviders(<GuardrailsPanel {...defaultProps} />, {
@ -221,3 +238,73 @@ describe("GuardrailsPanel", () => {
});
});
});
describe("GuardrailsPanel tab in the URL", () => {
const lastTabUpdate = (onUrlUpdate: ReturnType<typeof vi.fn<(event: UrlUpdateEvent) => void>>) =>
onUrlUpdate.mock.calls.at(-1)?.[0].searchParams;
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getGuardrailsList).mockResolvedValue({ guardrails: [] });
});
it("should select the Guardrails tab for an admin when the URL names no tab", () => {
renderWithProviders(<GuardrailsPanel accessToken="test-token" userRole="admin" />);
expect(screen.getByRole("tab", { name: "Guardrails" })).toHaveAttribute("aria-selected", "true");
});
it("should select the tab named by ?tab=", () => {
renderWithProviders(<GuardrailsPanel accessToken="test-token" userRole="admin" />, {
searchParams: "?tab=garden",
});
expect(screen.getByRole("tab", { name: "Guardrail Garden" })).toHaveAttribute("aria-selected", "true");
expect(screen.getByRole("tab", { name: "Guardrails" })).toHaveAttribute("aria-selected", "false");
});
it("should write the clicked tab to ?tab= and drop it for the default tab", async () => {
const onUrlUpdate = vi.fn<(event: UrlUpdateEvent) => void>();
renderWithProviders(<GuardrailsPanel accessToken="test-token" userRole="admin" />, { onUrlUpdate });
fireEvent.click(screen.getByRole("tab", { name: "Test Playground" }));
await waitFor(() => expect(lastTabUpdate(onUrlUpdate)?.get("tab")).toBe("test"));
expect(screen.getByRole("tab", { name: "Test Playground" })).toHaveAttribute("aria-selected", "true");
fireEvent.click(screen.getByRole("tab", { name: "Submitted Guardrails" }));
await waitFor(() => expect(lastTabUpdate(onUrlUpdate)?.get("tab")).toBe("submitted"));
fireEvent.click(screen.getByRole("tab", { name: "Guardrails" }));
await waitFor(() => expect(lastTabUpdate(onUrlUpdate)?.has("tab")).toBe(false));
expect(screen.getByRole("tab", { name: "Guardrails" })).toHaveAttribute("aria-selected", "true");
});
it("should land a non-admin on Submitted Guardrails when the URL names no tab", () => {
renderWithProviders(<GuardrailsPanel accessToken="test-token" userRole="internal_user" />);
expect(screen.getByRole("tab", { name: "Submitted Guardrails" })).toHaveAttribute("aria-selected", "true");
expect(screen.queryByRole("tab", { name: "Guardrails" })).not.toBeInTheDocument();
expect(screen.getByText("Mock Team Guardrails Tab")).toBeInTheDocument();
});
it("should send a non-admin with an admin-only ?tab= to Submitted Guardrails and drop the param", async () => {
const onUrlUpdate = vi.fn<(event: UrlUpdateEvent) => void>();
render(<GuardrailsPanel accessToken="test-token" userRole="internal_user" />, {
wrapper: ({ children }) => (
<NuqsTestingAdapter
searchParams="?tab=guardrails&other=1"
onUrlUpdate={onUrlUpdate}
hasMemory
resetUrlUpdateQueueOnMount={false}
>
{children}
</NuqsTestingAdapter>
),
});
expect(screen.getByRole("tab", { name: "Submitted Guardrails" })).toHaveAttribute("aria-selected", "true");
await waitFor(() => expect(onUrlUpdate).toHaveBeenCalled());
expect(lastTabUpdate(onUrlUpdate)?.has("tab")).toBe(false);
expect(lastTabUpdate(onUrlUpdate)?.get("other")).toBe("1");
});
});

View file

@ -14,6 +14,7 @@ import { cn } from "@/lib/cva.config";
import AddGuardrailForm from "./add_guardrail_form";
import GuardrailTable from "./guardrail_table";
import { isAdminRole } from "@/utils/roles";
import { useUrlTab } from "@/hooks/useUrlTab";
import GuardrailInfoView from "./guardrail_info";
import GuardrailTestPlayground from "./GuardrailTestPlayground";
import { toast } from "@/lib/toast";
@ -23,6 +24,11 @@ import { formatGuardrailMode, getGuardrailLogoAndName } from "./guardrail_info_h
import { CustomCodeModal } from "./custom_code";
import GuardrailGarden from "./guardrail_garden";
import { TeamGuardrailsTab } from "./TeamGuardrailsTab";
import { GUARDRAIL_DETAIL_TAB_KEY } from "./useGuardrailDetailTab";
const ADMIN_TABS = ["garden", "guardrails", "test", "submitted"] as const;
type GuardrailsTab = (typeof ADMIN_TABS)[number];
const MEMBER_TABS: readonly GuardrailsTab[] = ["submitted"];
interface GuardrailsPanelProps {
accessToken: string | null;
@ -45,7 +51,9 @@ const GuardrailsPanel: React.FC<GuardrailsPanelProps> = ({ accessToken, userRole
"guardrail",
parseAsString.withOptions({ history: "push" }),
);
const [, setDetailTab] = useQueryState(GUARDRAIL_DETAIL_TAB_KEY);
const isAdmin = userRole ? isAdminRole(userRole) : false;
const [activeTab, setActiveTab] = useUrlTab(isAdmin ? ADMIN_TABS : MEMBER_TABS, isAdmin ? "guardrails" : "submitted");
const fetchGuardrails = async () => {
if (!accessToken) {
@ -69,6 +77,7 @@ const GuardrailsPanel: React.FC<GuardrailsPanelProps> = ({ accessToken, userRole
const closeGuardrailDetail = () => {
void setSelectedGuardrailId(null, { history: "replace" });
void setDetailTab(null);
};
const handleAddGuardrail = () => {
@ -133,7 +142,7 @@ const GuardrailsPanel: React.FC<GuardrailsPanelProps> = ({ accessToken, userRole
return (
<div className="w-full mx-auto flex-auto overflow-y-auto m-8 p-2">
<Tabs defaultValue="guardrails">
<Tabs value={activeTab} onValueChange={setActiveTab}>
<TabsList variant="line">
{isAdmin && (
<>
@ -143,7 +152,7 @@ const GuardrailsPanel: React.FC<GuardrailsPanelProps> = ({ accessToken, userRole
<TabsTrigger value="guardrails" className="flex-none">
Guardrails
</TabsTrigger>
<TabsTrigger value="playground" className="flex-none" disabled={!accessToken}>
<TabsTrigger value="test" className="flex-none" disabled={!accessToken}>
Test Playground
</TabsTrigger>
</>
@ -231,7 +240,7 @@ const GuardrailsPanel: React.FC<GuardrailsPanelProps> = ({ accessToken, userRole
/>
</TabsContent>
<TabsContent value="playground" keepMounted>
<TabsContent value="test" keepMounted>
<GuardrailTestPlayground
guardrailsList={guardrailsList}
isLoading={isLoading}

View file

@ -1,6 +1,7 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { renderWithProviders } from "@/../tests/test-utils";
import { screen, fireEvent } from "@testing-library/react";
import { screen, fireEvent, waitFor } from "@testing-library/react";
import type { OnUrlUpdateFunction } from "nuqs/adapters/testing";
import { TeamGuardrailsTab } from "./TeamGuardrailsTab";
import useAuthorized from "@/app/(dashboard)/hooks/useAuthorized";
@ -45,11 +46,15 @@ const pendingSubmission = {
submitted_at: "2026-05-09T00:00:00Z",
};
const baseAuth = {
const baseAuth: Omit<ReturnType<typeof useAuthorized>, "userRole"> = {
isLoading: false,
isAuthorized: true,
token: "test-token",
accessToken: "test-token",
userId: "user-1",
userEmail: "user@example.com",
userRoleLabel: "",
isViewOnly: false,
premiumUser: false,
disabledPersonalKeyCreation: null,
showSSOBanner: false,
@ -96,8 +101,8 @@ describe("TeamGuardrailsTab — approve/reject role gate", () => {
expect(screen.getByRole("button", { name: /reject/i })).toBeInTheDocument();
});
it("hides Approve and Reject buttons when userRole is undefined (defaults to non-admin)", async () => {
mockUseAuthorized.mockReturnValue({ ...baseAuth, userRole: undefined });
it("hides Approve and Reject buttons when the session has no role (defaults to non-admin)", async () => {
mockUseAuthorized.mockReturnValue({ ...baseAuth, userRole: "Undefined Role" });
renderWithProviders(<TeamGuardrailsTab accessToken="test-token" />);
await screen.findByText("test-pending-guardrail");
@ -140,3 +145,98 @@ describe("TeamGuardrailsTab — approve/reject role gate", () => {
expect(screen.getByLabelText("Remove x-request-id")).toBeInTheDocument();
});
});
describe("TeamGuardrailsTab URL state", () => {
const mockUseAuthorized = vi.mocked(useAuthorized);
const lastUrlUpdate = (onUrlUpdate: ReturnType<typeof vi.fn<OnUrlUpdateFunction>>) =>
onUrlUpdate.mock.calls.at(-1)?.[0];
beforeEach(() => {
vi.clearAllMocks();
mockUseAuthorized.mockReturnValue({ ...baseAuth, userRole: "Admin" });
vi.mocked(listGuardrailSubmissions).mockResolvedValue({
submissions: [pendingSubmission],
summary: { total: 1, pending_review: 1, active: 0, rejected: 0 },
});
});
it("loads submissions with the search and status from ?sub_q= and ?sub_status=", async () => {
renderWithProviders(<TeamGuardrailsTab accessToken="test-token" />, {
searchParams: "?sub_q=pii&sub_status=pending",
});
expect(screen.getByPlaceholderText("Search guardrails...")).toHaveValue("pii");
expect(screen.getByLabelText("Filter by status")).toHaveValue("pending");
await waitFor(() =>
expect(listGuardrailSubmissions).toHaveBeenCalledWith("test-token", { status: "pending_review", search: "pii" }),
);
expect(listGuardrailSubmissions).toHaveBeenCalledTimes(1);
});
it("treats an unknown ?sub_status= as all statuses", async () => {
renderWithProviders(<TeamGuardrailsTab accessToken="test-token" />, { searchParams: "?sub_status=archived" });
expect(screen.getByLabelText("Filter by status")).toHaveValue("all");
await waitFor(() =>
expect(listGuardrailSubmissions).toHaveBeenCalledWith("test-token", { status: undefined, search: undefined }),
);
});
it("writes the search box to ?sub_q=", async () => {
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderWithProviders(<TeamGuardrailsTab accessToken="test-token" />, { onUrlUpdate });
await screen.findByText("test-pending-guardrail");
fireEvent.change(screen.getByPlaceholderText("Search guardrails..."), { target: { value: "toxic" } });
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("sub_q")).toBe("toxic"));
await waitFor(() =>
expect(listGuardrailSubmissions).toHaveBeenLastCalledWith("test-token", { status: undefined, search: "toxic" }),
);
});
it("writes the status filter to ?sub_status= and removes it for all statuses", async () => {
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderWithProviders(<TeamGuardrailsTab accessToken="test-token" />, { onUrlUpdate });
await screen.findByText("test-pending-guardrail");
const statusSelect = screen.getByLabelText("Filter by status");
fireEvent.change(statusSelect, { target: { value: "rejected" } });
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("sub_status")).toBe("rejected"));
await waitFor(() =>
expect(listGuardrailSubmissions).toHaveBeenLastCalledWith("test-token", {
status: "rejected",
search: undefined,
}),
);
fireEvent.change(statusSelect, { target: { value: "all" } });
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("sub_status")).toBe(false));
});
it("opens the submission named by ?submission=", async () => {
renderWithProviders(<TeamGuardrailsTab accessToken="test-token" />, { searchParams: "?submission=guard-1" });
expect(await screen.findByText("Forward LiteLLM API Key")).toBeInTheDocument();
expect(screen.getByRole("button", { name: "Close detail panel" })).toBeInTheDocument();
});
it("pushes ?submission= when a submission is opened and replaces it away when the panel is closed", async () => {
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderWithProviders(<TeamGuardrailsTab accessToken="test-token" />, {
searchParams: "?sub_status=pending",
onUrlUpdate,
});
fireEvent.click(await screen.findByRole("button", { name: "Review" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("submission")).toBe("guard-1"));
expect(lastUrlUpdate(onUrlUpdate)?.options.history).toBe("push");
expect(await screen.findByText("Forward LiteLLM API Key")).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Close detail panel" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("submission")).toBe(false));
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("sub_status")).toBe("pending");
expect(lastUrlUpdate(onUrlUpdate)?.options.history).toBe("replace");
expect(screen.queryByText("Forward LiteLLM API Key")).not.toBeInTheDocument();
});
});

View file

@ -40,6 +40,7 @@ import { isValidUrl } from "@/lib/forms/urlValidation";
import { useZodForm } from "@/lib/forms/useZodForm";
import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
import { Button } from "@/components/ui/button";
import { useTeamGuardrailsUrlState } from "./useTeamGuardrailsUrlState";
const GUARDRAIL_MODES = [
{ value: "pre_call", label: "Pre Call" },
@ -823,10 +824,9 @@ export function TeamGuardrailsTab({ accessToken }: TeamGuardrailsTabProps) {
active: 0,
rejected: 0,
});
const [search, setSearch] = useState("");
const { search, setSearch, statusFilter, setStatusFilter, selectedId, openSubmission, closeSubmission } =
useTeamGuardrailsUrlState();
const [searchDebounced] = useDebouncedValue(search, { wait: DEBOUNCE_WAIT_MS });
const [statusFilter, setStatusFilter] = useState<"all" | GuardrailStatus>("all");
const [selectedId, setSelectedId] = useState<string | null>(null);
const [expandedHeaders, setExpandedHeaders] = useState<Set<string>>(new Set());
const [confirmAction, setConfirmAction] = useState<{
id: string;
@ -956,7 +956,7 @@ export function TeamGuardrailsTab({ accessToken }: TeamGuardrailsTabProps) {
try {
await approveGuardrailSubmission(accessToken, id);
setConfirmAction(null);
if (selectedId === id) setSelectedId(null);
if (selectedId === id) closeSubmission();
await fetchSubmissions();
toast.success("Guardrail approved");
} catch {
@ -969,7 +969,7 @@ export function TeamGuardrailsTab({ accessToken }: TeamGuardrailsTabProps) {
try {
await rejectGuardrailSubmission(accessToken, id);
setConfirmAction(null);
if (selectedId === id) setSelectedId(null);
if (selectedId === id) closeSubmission();
await fetchSubmissions();
toast.success("Guardrail rejected");
} catch {
@ -1009,7 +1009,7 @@ export function TeamGuardrailsTab({ accessToken }: TeamGuardrailsTabProps) {
<select
aria-label="Filter by status"
value={statusFilter}
onChange={(e) => setStatusFilter(e.target.value as typeof statusFilter)}
onChange={(e) => setStatusFilter(e.target.value)}
className="border border-border rounded-md px-3 py-2 text-sm text-foreground focus:outline-hidden focus:ring-1 focus:ring-ring focus:border-info bg-background"
>
<option value="all">All Status</option>
@ -1041,7 +1041,7 @@ export function TeamGuardrailsTab({ accessToken }: TeamGuardrailsTabProps) {
isSelected={selectedId === g.id}
isHeadersExpanded={expandedHeaders.has(g.id)}
isAdmin={isAdmin}
onSelect={() => setSelectedId(selectedId === g.id ? null : g.id)}
onSelect={() => (selectedId === g.id ? closeSubmission() : openSubmission(g.id))}
onToggleForwardKey={() => toggleForwardKey(g.id)}
onToggleHeaders={() => toggleHeaders(g.id)}
onApprove={() => setConfirmAction({ id: g.id, action: "approve" })}
@ -1054,7 +1054,7 @@ export function TeamGuardrailsTab({ accessToken }: TeamGuardrailsTabProps) {
<DetailPanel
guardrail={selected}
isAdmin={isAdmin}
onClose={() => setSelectedId(null)}
onClose={closeSubmission}
onApprove={() => setConfirmAction({ id: selected.id, action: "approve" })}
onReject={() => setConfirmAction({ id: selected.id, action: "reject" })}
onToggleForwardKey={() => toggleForwardKey(selected.id)}

View file

@ -1,6 +1,7 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { render, screen } from "@testing-library/react";
import { fireEvent, render, renderWithProviders, screen, waitFor } from "@/../tests/test-utils";
import userEvent from "@testing-library/user-event";
import { NuqsTestingAdapter, type OnUrlUpdateFunction } from "nuqs/adapters/testing";
import GuardrailGarden from "./guardrail_garden";
import { ALL_CARDS } from "./guardrail_garden_data";
@ -17,12 +18,19 @@ vi.mock("./guardrail_garden_detail", () => ({
const LITELLM_CARDS = ALL_CARDS.filter((c) => c.category === "litellm");
const PARTNER_CARDS = ALL_CARDS.filter((c) => c.category === "partner");
const lastUrlUpdate = (onUrlUpdate: ReturnType<typeof vi.fn<OnUrlUpdateFunction>>) =>
onUrlUpdate.mock.calls.at(-1)?.[0];
describe("GuardrailGarden", () => {
beforeEach(() => {
vi.clearAllMocks();
});
const renderGarden = () => render(<GuardrailGarden accessToken="test-token" onGuardrailCreated={vi.fn()} />);
const renderGarden = (searchParams?: string, onUrlUpdate?: OnUrlUpdateFunction) =>
renderWithProviders(<GuardrailGarden accessToken="test-token" onGuardrailCreated={vi.fn()} />, {
searchParams,
onUrlUpdate,
});
it("should render both sections with their descriptions", () => {
renderGarden();
@ -62,11 +70,10 @@ describe("GuardrailGarden", () => {
});
it("should filter cards by the search query", async () => {
const user = userEvent.setup();
renderGarden();
const target = PARTNER_CARDS[0];
await user.type(screen.getByPlaceholderText("Search guardrails"), target.name);
fireEvent.change(screen.getByPlaceholderText("Search guardrails"), { target: { value: target.name } });
expect(await screen.findByText(target.name)).toBeInTheDocument();
const otherPartner = PARTNER_CARDS.find((c) => c.name !== target.name);
@ -76,12 +83,13 @@ describe("GuardrailGarden", () => {
});
it("should show an empty result set for a query that matches nothing", async () => {
const user = userEvent.setup();
renderGarden();
await user.type(screen.getByPlaceholderText("Search guardrails"), "zzzzznotaguardrailzzzzz");
fireEvent.change(screen.getByPlaceholderText("Search guardrails"), {
target: { value: "zzzzznotaguardrailzzzzz" },
});
expect(screen.getByText("Show all (0)")).toBeInTheDocument();
expect(await screen.findByText("Show all (0)")).toBeInTheDocument();
PARTNER_CARDS.forEach((card) => {
expect(screen.queryByText(card.name)).not.toBeInTheDocument();
});
@ -101,4 +109,106 @@ describe("GuardrailGarden", () => {
expect(await screen.findByPlaceholderText("Search guardrails")).toBeInTheDocument();
});
describe("URL state", () => {
it("should filter cards and prefill the search box from ?garden_q=", () => {
const [target, other] = PARTNER_CARDS;
renderGarden(`?garden_q=${encodeURIComponent(target.name)}`);
expect(screen.getByPlaceholderText("Search guardrails")).toHaveValue(target.name);
expect(screen.getByText(target.name)).toBeInTheDocument();
expect(screen.queryByText(other.name)).not.toBeInTheDocument();
});
it("should write the search query to ?garden_q= and drop it once the box is cleared", async () => {
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderGarden(undefined, onUrlUpdate);
const input = screen.getByPlaceholderText("Search guardrails");
fireEvent.change(input, { target: { value: "bedrock" } });
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("garden_q")).toBe("bedrock"));
fireEvent.change(input, { target: { value: "" } });
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("garden_q")).toBe(false));
});
it("should show every litellm card when ?garden_all=true", () => {
renderGarden("?garden_all=true");
expect(screen.getByText("Show less")).toBeInTheDocument();
expect(screen.getByText(LITELLM_CARDS[LITELLM_CARDS.length - 1].name)).toBeInTheDocument();
});
it("should write ?garden_all=true when show all is clicked and remove it on show less", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderGarden(undefined, onUrlUpdate);
await user.click(screen.getByText(`Show all (${LITELLM_CARDS.length})`));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("garden_all")).toBe("true"));
await user.click(screen.getByText("Show less"));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("garden_all")).toBe(false));
});
it("should open the card named by ?garden_card=", () => {
const target = PARTNER_CARDS[1];
renderGarden(`?garden_card=${target.id}`);
expect(screen.getByText(`Detail for ${target.name}`)).toBeInTheDocument();
expect(screen.queryByPlaceholderText("Search guardrails")).not.toBeInTheDocument();
});
it("should push ?garden_card= and reset the detail tab when a card is clicked", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
const target = PARTNER_CARDS[0];
renderGarden("?garden_tab=eval", onUrlUpdate);
await user.click(screen.getByText(target.name));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("garden_card")).toBe(target.id));
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("garden_tab")).toBe(false);
expect(lastUrlUpdate(onUrlUpdate)?.options.history).toBe("push");
});
it("should clear the card and its detail tab with a history replace when going back", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
const target = LITELLM_CARDS[0];
renderGarden(`?garden_card=${target.id}&garden_tab=eval&garden_q=x`, onUrlUpdate);
await user.click(screen.getByRole("button", { name: "Back to garden" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("garden_card")).toBe(false));
const update = lastUrlUpdate(onUrlUpdate);
expect(update?.searchParams.has("garden_tab")).toBe(false);
expect(update?.searchParams.get("garden_q")).toBe("x");
expect(update?.options.history).toBe("replace");
expect(await screen.findByPlaceholderText("Search guardrails")).toBeInTheDocument();
});
it("should show the garden and drop an unknown ?garden_card= from the URL", async () => {
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
render(<GuardrailGarden accessToken="test-token" onGuardrailCreated={vi.fn()} />, {
wrapper: ({ children }) => (
<NuqsTestingAdapter
searchParams="?garden_card=not-a-card&garden_all=true"
onUrlUpdate={onUrlUpdate}
hasMemory
resetUrlUpdateQueueOnMount={false}
>
{children}
</NuqsTestingAdapter>
),
});
expect(screen.getByPlaceholderText("Search guardrails")).toBeInTheDocument();
await waitFor(() => expect(onUrlUpdate).toHaveBeenCalled());
const update = lastUrlUpdate(onUrlUpdate);
expect(update?.searchParams.has("garden_card")).toBe(false);
expect(update?.searchParams.get("garden_all")).toBe("true");
expect(update?.options.history).toBe("replace");
});
});
});

View file

@ -1,9 +1,18 @@
import React, { useState } from "react";
import React, { useEffect } from "react";
import { ArrowRight, Search } from "lucide-react";
import { parseAsBoolean, parseAsString, useQueryState, useQueryStates } from "nuqs";
import { InputGroup, InputGroupAddon, InputGroupInput } from "@/components/ui/input-group";
import { GuardrailCardInfo, ALL_CARDS } from "./guardrail_garden_data";
import { ALL_CARDS } from "./guardrail_garden_data";
import GuardrailCard from "./guardrail_garden_card";
import GuardrailDetailView from "./guardrail_garden_detail";
import { GARDEN_TAB_KEY } from "./useGardenDetailTab";
const searchParser = parseAsString.withDefault("");
const showAllParser = parseAsBoolean.withDefault(false);
const selectedCardParsers = {
garden_card: parseAsString.withOptions({ history: "push" }),
[GARDEN_TAB_KEY]: parseAsString,
};
interface GuardrailGardenProps {
accessToken: string | null;
@ -11,9 +20,10 @@ interface GuardrailGardenProps {
}
const GuardrailGarden: React.FC<GuardrailGardenProps> = ({ accessToken, onGuardrailCreated }) => {
const [searchQuery, setSearchQuery] = useState("");
const [selectedCard, setSelectedCard] = useState<GuardrailCardInfo | null>(null);
const [showAllLitellm, setShowAllLitellm] = useState(false);
const [searchQuery, setSearchQuery] = useQueryState("garden_q", searchParser);
const [showAllLitellm, setShowAllLitellm] = useQueryState("garden_all", showAllParser);
const [{ garden_card: selectedCardId }, setSelectedCardState] = useQueryStates(selectedCardParsers);
const selectedCard = ALL_CARDS.find((card) => card.id === selectedCardId) ?? null;
const CARDS_PER_ROW = 5;
const VISIBLE_ROWS = 2;
@ -30,11 +40,19 @@ const GuardrailGarden: React.FC<GuardrailGardenProps> = ({ accessToken, onGuardr
const litellmCards = filteredCards.filter((c) => c.category === "litellm");
const partnerCards = filteredCards.filter((c) => c.category === "partner");
const unknownCardSelected = selectedCardId !== null && selectedCard === null;
useEffect(() => {
if (unknownCardSelected) void setSelectedCardState(null, { history: "replace" });
}, [unknownCardSelected, setSelectedCardState]);
const openCard = (cardId: string) => void setSelectedCardState({ garden_card: cardId, [GARDEN_TAB_KEY]: null });
const closeCard = () => void setSelectedCardState(null, { history: "replace" });
if (selectedCard) {
return (
<GuardrailDetailView
card={selectedCard}
onBack={() => setSelectedCard(null)}
onBack={closeCard}
accessToken={accessToken}
onGuardrailCreated={onGuardrailCreated}
/>
@ -51,7 +69,7 @@ const GuardrailGarden: React.FC<GuardrailGardenProps> = ({ accessToken, onGuardr
<InputGroupInput
placeholder="Search guardrails"
value={searchQuery}
onChange={(e) => setSearchQuery(e.target.value)}
onChange={(e) => void setSearchQuery(e.target.value)}
/>
</InputGroup>
</div>
@ -61,7 +79,7 @@ const GuardrailGarden: React.FC<GuardrailGardenProps> = ({ accessToken, onGuardr
<h2 className="m-0 text-xl font-semibold text-foreground">LiteLLM Content Filter</h2>
<span
className="inline-flex cursor-pointer items-center gap-1.5 text-sm text-primary"
onClick={() => setShowAllLitellm(!showAllLitellm)}
onClick={() => void setShowAllLitellm(!showAllLitellm)}
>
{showAllLitellm ? (
<>Show less</>
@ -78,7 +96,7 @@ const GuardrailGarden: React.FC<GuardrailGardenProps> = ({ accessToken, onGuardr
</p>
<div className="grid grid-cols-[repeat(auto-fill,minmax(220px,1fr))] gap-4">
{(showAllLitellm ? litellmCards : litellmCards.slice(0, CARDS_PER_ROW * VISIBLE_ROWS)).map((card) => (
<GuardrailCard key={card.id} card={card} onClick={() => setSelectedCard(card)} />
<GuardrailCard key={card.id} card={card} onClick={() => openCard(card.id)} />
))}
</div>
</div>
@ -90,7 +108,7 @@ const GuardrailGarden: React.FC<GuardrailGardenProps> = ({ accessToken, onGuardr
</p>
<div className="grid grid-cols-[repeat(auto-fill,minmax(220px,1fr))] gap-4">
{partnerCards.map((card) => (
<GuardrailCard key={card.id} card={card} onClick={() => setSelectedCard(card)} />
<GuardrailCard key={card.id} card={card} onClick={() => openCard(card.id)} />
))}
</div>
</div>

View file

@ -1,4 +1,6 @@
import { render, screen } from "@testing-library/react";
import { render, renderWithProviders, screen, waitFor } from "@/../tests/test-utils";
import userEvent from "@testing-library/user-event";
import { NuqsTestingAdapter, type OnUrlUpdateFunction } from "nuqs/adapters/testing";
import { describe, expect, it, vi } from "vitest";
import GuardrailDetailView from "./guardrail_garden_detail";
import type { GuardrailCardInfo } from "./guardrail_garden_data";
@ -15,8 +17,22 @@ const makeCard = (overrides: Partial<GuardrailCardInfo> = {}): GuardrailCardInfo
...overrides,
});
const renderDetail = (card: GuardrailCardInfo) =>
render(<GuardrailDetailView card={card} onBack={vi.fn()} accessToken={null} onGuardrailCreated={vi.fn()} />);
const evalCardOverrides: Partial<GuardrailCardInfo> = {
id: "cf_denied_financial",
name: "Denied Financial Advice",
category: "litellm",
eval: { f1: 97, precision: 98, recall: 96, testCases: 207, latency: "<0.1ms" },
};
const cardWithEval = makeCard(evalCardOverrides);
const renderDetail = (card: GuardrailCardInfo, searchParams?: string, onUrlUpdate?: OnUrlUpdateFunction) =>
renderWithProviders(
<GuardrailDetailView card={card} onBack={vi.fn()} accessToken={null} onGuardrailCreated={vi.fn()} />,
{ searchParams, onUrlUpdate },
);
const lastUrlUpdate = (onUrlUpdate: ReturnType<typeof vi.fn<OnUrlUpdateFunction>>) =>
onUrlUpdate.mock.calls.at(-1)?.[0];
describe("GuardrailDetailView logo", () => {
it("renders the card logo through the shared Logo component with the bundled src", () => {
@ -30,3 +46,54 @@ describe("GuardrailDetailView logo", () => {
expect(screen.getByText("B")).toBeInTheDocument();
});
});
describe("GuardrailDetailView tabs", () => {
it("shows the overview when the URL names no tab", () => {
renderDetail(cardWithEval);
expect(screen.getByText("Guardrail Details")).toBeInTheDocument();
expect(screen.queryByText("F1 Score")).not.toBeInTheDocument();
});
it("shows the eval results when ?garden_tab=eval", () => {
renderDetail(cardWithEval, "?garden_tab=eval");
expect(screen.getByText("F1 Score")).toBeInTheDocument();
expect(screen.getByText("97%")).toBeInTheDocument();
expect(screen.queryByText("Guardrail Details")).not.toBeInTheDocument();
});
it("writes ?garden_tab= when a tab is clicked and removes it when going back to the overview", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderDetail(cardWithEval, undefined, onUrlUpdate);
await user.click(screen.getByText("Eval Results"));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("garden_tab")).toBe("eval"));
expect(screen.getByText("F1 Score")).toBeInTheDocument();
await user.click(screen.getByText("Overview"));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("garden_tab")).toBe(false));
expect(screen.getByText("Guardrail Details")).toBeInTheDocument();
});
it("falls back to the overview and drops ?garden_tab=eval for a card without eval results", async () => {
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
render(<GuardrailDetailView card={makeCard()} onBack={vi.fn()} accessToken={null} onGuardrailCreated={vi.fn()} />, {
wrapper: ({ children }) => (
<NuqsTestingAdapter
searchParams="?garden_tab=eval&garden_card=bedrock"
onUrlUpdate={onUrlUpdate}
hasMemory
resetUrlUpdateQueueOnMount={false}
>
{children}
</NuqsTestingAdapter>
),
});
expect(screen.getByText("Guardrail Details")).toBeInTheDocument();
expect(screen.queryByText("Eval Results")).not.toBeInTheDocument();
await waitFor(() => expect(onUrlUpdate).toHaveBeenCalled());
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("garden_tab")).toBe(false);
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("garden_card")).toBe("bedrock");
});
});

View file

@ -6,6 +6,7 @@ import AddGuardrailForm from "./add_guardrail_form";
import { Logo } from "@/components/molecules/logo/Logo";
import { GUARDRAIL_PRESETS } from "./guardrail_garden_configs";
import { GuardrailCardInfo } from "./guardrail_garden_data";
import { useGardenDetailTab } from "./useGardenDetailTab";
interface GuardrailDetailViewProps {
card: GuardrailCardInfo;
@ -16,7 +17,7 @@ interface GuardrailDetailViewProps {
const GuardrailDetailView: React.FC<GuardrailDetailViewProps> = ({ card, onBack, accessToken, onGuardrailCreated }) => {
const [isAddFormVisible, setIsAddFormVisible] = useState(false);
const [activeTab, setActiveTab] = useState("overview");
const [activeTab, setActiveTab] = useGardenDetailTab(Boolean(card.eval));
const detailRows = [
{ property: "Provider", value: card.category === "litellm" ? "LiteLLM Content Filter" : "Partner Guardrail" },
@ -38,7 +39,10 @@ const GuardrailDetailView: React.FC<GuardrailDetailViewProps> = ({ card, onBack,
]
: [];
const tabs = [{ key: "overview", label: "Overview" }, ...(card.eval ? [{ key: "eval", label: "Eval Results" }] : [])];
const tabs = [
{ key: "overview" as const, label: "Overview" },
...(card.eval ? [{ key: "eval" as const, label: "Eval Results" }] : []),
];
return (
<div className="mx-auto max-w-[960px]">

View file

@ -1,9 +1,9 @@
import * as networking from "@/components/networking";
import { render, screen, waitFor } from "@testing-library/react";
import { screen, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { beforeEach, describe, expect, it, vi } from "vitest";
import GuardrailInfoView from "./guardrail_info";
import { chooseSelectOption } from "@/../tests/test-utils";
import { chooseSelectOption, renderWithProviders } from "@/../tests/test-utils";
vi.mock("@/components/networking", () => ({
getGuardrailInfo: vi.fn(),
@ -83,7 +83,8 @@ const saveChanges = async (user: ReturnType<typeof userEvent.setup>) => {
await user.click(screen.getByText("Save Changes"));
};
const renderView = () => render(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin />);
const renderView = () =>
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin />);
const lastPayload = () => vi.mocked(networking.updateGuardrailCall).mock.calls.at(-1)?.[2];

View file

@ -1,6 +1,8 @@
import * as networking from "@/components/networking";
import { fireEvent, render, waitFor, within, screen } from "@testing-library/react";
import { renderWithProviders } from "@/../tests/test-utils";
import userEvent from "@testing-library/user-event";
import { NuqsTestingAdapter, type OnUrlUpdateFunction } from "nuqs/adapters/testing";
import { afterEach, describe, expect, it, vi } from "vitest";
import GuardrailInfoView from "./guardrail_info";
@ -65,7 +67,7 @@ describe("Guardrail Info", () => {
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
render(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
// Wait for the loading to complete and data to be rendered
await waitFor(() => {
@ -103,7 +105,7 @@ describe("Guardrail Info", () => {
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
render(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
expect(await screen.findAllByText("pre_call, post_call (tag-based)")).not.toHaveLength(0);
});
@ -131,7 +133,7 @@ describe("Guardrail Info", () => {
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
render(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
const logo = await screen.findByAltText("Presidio PII logo");
expect(logo).toHaveAttribute("src", expect.stringContaining("microsoft_azure.svg"));
@ -161,7 +163,7 @@ describe("Guardrail Info", () => {
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
const { container } = render(
const { container } = renderWithProviders(
<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />,
);
@ -212,7 +214,7 @@ describe("Guardrail Info", () => {
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
render(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
await waitFor(() => {
expect(screen.getByText("PII Entity Configuration")).toBeInTheDocument();
@ -245,7 +247,7 @@ describe("Guardrail Info", () => {
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
vi.mocked(networking.updateGuardrailCall).mockResolvedValue({ status: "success" });
render(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
await waitFor(() => {
expect(screen.getByText("Settings")).toBeInTheDocument();
@ -331,7 +333,7 @@ describe("Guardrail Info", () => {
});
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
render(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={true} />);
expect(await screen.findByRole("tab", { name: "Overview" })).toHaveAttribute("aria-selected", "true");
expect(screen.getByRole("tab", { name: "Settings" })).toHaveAttribute("aria-selected", "false");
@ -355,10 +357,90 @@ describe("Guardrail Info when the guardrail cannot be loaded", () => {
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
const onClose = vi.fn();
render(<GuardrailInfoView guardrailId="stale-id" onClose={onClose} accessToken="123" isAdmin={true} />);
renderWithProviders(
<GuardrailInfoView guardrailId="stale-id" onClose={onClose} accessToken="123" isAdmin={true} />,
);
expect(await screen.findByText("Guardrail not found")).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: /back to guardrails/i }));
expect(onClose).toHaveBeenCalledTimes(1);
});
});
describe("Guardrail Info detail tab in the URL", () => {
const loadedGuardrail = {
guardrail_id: "123",
guardrail_name: "Test Guardrail",
litellm_params: { guardrail: "presidio", mode: "pre_call", default_on: true },
created_at: "2024-01-01T00:00:00Z",
updated_at: "2024-01-01T00:00:00Z",
guardrail_definition_location: "database",
};
const uiSettings = {
supported_entities: [],
supported_actions: [],
pii_entity_categories: [],
supported_modes: ["pre_call"],
};
const mockLoadedGuardrail = () => {
vi.mocked(networking.getGuardrailInfo).mockResolvedValue(loadedGuardrail);
vi.mocked(networking.getGuardrailUISettings).mockResolvedValue(uiSettings);
vi.mocked(networking.getGuardrailProviderSpecificParams).mockResolvedValue({});
};
const lastUrlUpdate = (onUrlUpdate: ReturnType<typeof vi.fn<OnUrlUpdateFunction>>) =>
onUrlUpdate.mock.calls.at(-1)?.[0];
afterEach(() => {
vi.clearAllMocks();
});
it("selects the Settings tab when ?detail_tab=settings", async () => {
mockLoadedGuardrail();
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin />, {
searchParams: "?detail_tab=settings",
});
expect(await screen.findByRole("tab", { name: "Settings" })).toHaveAttribute("aria-selected", "true");
expect(screen.getByRole("tab", { name: "Overview" })).toHaveAttribute("aria-selected", "false");
});
it("writes ?detail_tab= when a tab is clicked and removes it for the overview", async () => {
mockLoadedGuardrail();
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderWithProviders(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin />, {
onUrlUpdate,
});
await user.click(await screen.findByRole("tab", { name: "Settings" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("detail_tab")).toBe("settings"));
expect(screen.getByRole("tab", { name: "Settings" })).toHaveAttribute("aria-selected", "true");
await user.click(screen.getByRole("tab", { name: "Overview" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("detail_tab")).toBe(false));
expect(screen.getByRole("tab", { name: "Overview" })).toHaveAttribute("aria-selected", "true");
});
it("shows the overview to a non-admin and drops ?detail_tab=settings from the URL", async () => {
mockLoadedGuardrail();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
render(<GuardrailInfoView guardrailId="123" onClose={() => {}} accessToken="123" isAdmin={false} />, {
wrapper: ({ children }) => (
<NuqsTestingAdapter
searchParams="?detail_tab=settings&guardrail=123"
onUrlUpdate={onUrlUpdate}
hasMemory
resetUrlUpdateQueueOnMount={false}
>
{children}
</NuqsTestingAdapter>
),
});
expect(await screen.findByRole("tab", { name: "Overview" })).toHaveAttribute("aria-selected", "true");
expect(screen.queryByRole("tab", { name: "Settings" })).not.toBeInTheDocument();
await waitFor(() => expect(onUrlUpdate).toHaveBeenCalled());
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("detail_tab")).toBe(false);
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("guardrail")).toBe("123");
});
});

View file

@ -45,6 +45,7 @@ import GuardrailOptionalParams from "./guardrail_optional_params";
import GuardrailProviderFields from "./guardrail_provider_fields";
import PiiConfiguration from "./pii_configuration";
import ToolPermissionRulesEditor, { ToolPermissionConfig } from "./tool_permission/ToolPermissionRulesEditor";
import { useGuardrailDetailTab } from "./useGuardrailDetailTab";
const DEFAULT_ON_ITEMS = [
{ label: "Yes", value: true },
@ -70,6 +71,7 @@ const GuardrailInfoView: React.FC<GuardrailInfoProps> = ({ guardrailId, onClose,
const [guardrailProviderSpecificParams, setGuardrailProviderSpecificParams] = useState<any>(null);
const [loading, setLoading] = useState(true);
const [isEditing, setIsEditing] = useState(false);
const [detailTab, setDetailTab] = useGuardrailDetailTab(isAdmin);
const form = useForm<GuardrailFormValues>({ defaultValues: {} });
const [selectedPiiEntities, setSelectedPiiEntities] = useState<string[]>([]);
const [selectedPiiActions, setSelectedPiiActions] = useState<{ [key: string]: string }>({});
@ -532,7 +534,7 @@ const GuardrailInfoView: React.FC<GuardrailInfoProps> = ({ guardrailId, onClose,
</div>
</div>
<Tabs defaultValue="overview">
<Tabs value={detailTab} onValueChange={setDetailTab}>
<TabsList variant="line" className="mb-4 h-auto w-full justify-start rounded-none border-b p-0">
<TabsTrigger value="overview" className="flex-none rounded-none px-4 py-2">
Overview

View file

@ -1,5 +1,6 @@
import { render, screen } from "@testing-library/react";
import { renderWithProviders, screen, waitFor } from "@/../tests/test-utils";
import userEvent from "@testing-library/user-event";
import type { OnUrlUpdateFunction } from "nuqs/adapters/testing";
import { describe, it, expect, vi } from "vitest";
import GuardrailTable from "./guardrail_table";
@ -24,14 +25,14 @@ const makeGuardrail = (overrides: Partial<Guardrail> = {}): Guardrail => ({
describe("GuardrailTable", () => {
it("renders every column header", () => {
render(<GuardrailTable guardrailsList={[]} {...baseProps} />);
renderWithProviders(<GuardrailTable guardrailsList={[]} {...baseProps} />);
for (const header of ["Guardrail ID", "Name", "Provider", "Mode", "Default On", "Created At", "Updated At"]) {
expect(screen.getByText(header)).toBeInTheDocument();
}
});
it("renders the provider logo from the bundled guardrail logo map", () => {
render(<GuardrailTable guardrailsList={[makeGuardrail()]} {...baseProps} />);
renderWithProviders(<GuardrailTable guardrailsList={[makeGuardrail()]} {...baseProps} />);
const logo = screen.getByAltText("Presidio PII logo");
expect(logo).toHaveAttribute("src", expect.stringContaining("microsoft_azure.svg"));
});
@ -40,7 +41,7 @@ describe("GuardrailTable", () => {
const guardrail = makeGuardrail({
litellm_params: { guardrail: "mystery_guard", mode: "pre_call", default_on: false },
});
render(<GuardrailTable guardrailsList={[guardrail]} {...baseProps} />);
renderWithProviders(<GuardrailTable guardrailsList={[guardrail]} {...baseProps} />);
expect(screen.getByText("mystery_guard")).toBeInTheDocument();
expect(screen.queryByAltText("mystery_guard logo")).not.toBeInTheDocument();
expect(screen.getByText("m")).toBeInTheDocument();
@ -54,7 +55,7 @@ describe("GuardrailTable", () => {
default_on: true,
},
});
render(<GuardrailTable guardrailsList={[guardrail]} {...baseProps} />);
renderWithProviders(<GuardrailTable guardrailsList={[guardrail]} {...baseProps} />);
expect(screen.getByText("pre_call, post_call (tag-based)")).toBeInTheDocument();
});
@ -62,7 +63,7 @@ describe("GuardrailTable", () => {
const user = userEvent.setup();
const onDeleteClick = vi.fn();
const guardrail = makeGuardrail({ guardrail_id: "gr-9", guardrail_name: "Toxicity Filter" });
render(<GuardrailTable guardrailsList={[guardrail]} {...baseProps} onDeleteClick={onDeleteClick} />);
renderWithProviders(<GuardrailTable guardrailsList={[guardrail]} {...baseProps} onDeleteClick={onDeleteClick} />);
await user.click(screen.getByTestId("guardrail-actions-gr-9"));
await user.click(await screen.findByTestId("guardrail-action-delete"));
@ -78,7 +79,7 @@ describe("GuardrailTable", () => {
guardrail_name: "Config Guardrail",
guardrail_definition_location: GuardrailDefinitionLocation.CONFIG,
});
render(<GuardrailTable guardrailsList={[guardrail]} {...baseProps} onDeleteClick={onDeleteClick} />);
renderWithProviders(<GuardrailTable guardrailsList={[guardrail]} {...baseProps} onDeleteClick={onDeleteClick} />);
await user.click(screen.getByTestId("guardrail-actions-cfg-1"));
const deleteItem = await screen.findByTestId("guardrail-action-delete");
@ -86,4 +87,78 @@ describe("GuardrailTable", () => {
expect(deleteItem).toHaveAttribute("data-disabled");
expect(onDeleteClick).not.toHaveBeenCalled();
});
describe("URL state", () => {
const named = [
makeGuardrail({ guardrail_id: "gr-b", guardrail_name: "name-bravo", created_at: "2024-03-01" }),
makeGuardrail({ guardrail_id: "gr-c", guardrail_name: "name-charlie", created_at: "2024-01-01" }),
makeGuardrail({ guardrail_id: "gr-a", guardrail_name: "name-alpha", created_at: "2024-02-01" }),
];
const renderedNames = () => screen.getAllByTitle(/^name-/).map((cell) => cell.textContent);
const manyGuardrails = Array.from({ length: 30 }, (_, index) =>
makeGuardrail({ guardrail_id: `gr-${index}`, guardrail_name: `name-${index}` }),
);
const lastUrlUpdate = (onUrlUpdate: ReturnType<typeof vi.fn<OnUrlUpdateFunction>>) =>
onUrlUpdate.mock.calls.at(-1)?.[0];
it("sorts by newest created first when the URL has no sort", () => {
renderWithProviders(<GuardrailTable guardrailsList={named} {...baseProps} />);
expect(renderedNames()).toEqual(["name-bravo", "name-alpha", "name-charlie"]);
});
it("sorts by the column and direction in ?sort_by= and ?sort_order=", () => {
renderWithProviders(<GuardrailTable guardrailsList={named} {...baseProps} />, {
searchParams: "?sort_by=guardrail_name&sort_order=asc",
});
expect(renderedNames()).toEqual(["name-alpha", "name-bravo", "name-charlie"]);
});
it("falls back to the default sort for a column that cannot be sorted", () => {
renderWithProviders(<GuardrailTable guardrailsList={named} {...baseProps} />, {
searchParams: "?sort_by=provider&sort_order=desc",
});
expect(renderedNames()).toEqual(["name-bravo", "name-alpha", "name-charlie"]);
});
it("writes the clicked sort column and direction to the URL", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderWithProviders(<GuardrailTable guardrailsList={named} {...baseProps} />, { onUrlUpdate });
await user.click(screen.getByTestId("sort-header-guardrail_name"));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("sort_by")).toBe("guardrail_name"));
expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("sort_order")).toBe("asc");
expect(renderedNames()).toEqual(["name-alpha", "name-bravo", "name-charlie"]);
});
it("shows the page in ?page= and writes page changes back", async () => {
const user = userEvent.setup();
const onUrlUpdate = vi.fn<OnUrlUpdateFunction>();
renderWithProviders(<GuardrailTable guardrailsList={manyGuardrails} {...baseProps} />, {
searchParams: "?page=2",
onUrlUpdate,
});
expect(screen.getByTestId("pagination-page")).toHaveTextContent("Page 2 of 2");
expect(screen.getAllByTitle(/^name-/)).toHaveLength(5);
await user.click(screen.getByRole("button", { name: "Go to previous page" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.has("page")).toBe(false));
expect(screen.getByTestId("pagination-page")).toHaveTextContent("Page 1 of 2");
expect(screen.getAllByTitle(/^name-/)).toHaveLength(25);
await user.click(screen.getByRole("button", { name: "Go to next page" }));
await waitFor(() => expect(lastUrlUpdate(onUrlUpdate)?.searchParams.get("page")).toBe("2"));
});
it("uses the page size in ?page_size=", () => {
renderWithProviders(<GuardrailTable guardrailsList={manyGuardrails} {...baseProps} />, {
searchParams: "?page_size=50",
});
expect(screen.getByTestId("pagination-page")).toHaveTextContent("Page 1 of 1");
expect(screen.getAllByTitle(/^name-/)).toHaveLength(30);
});
});
});

View file

@ -1,10 +1,9 @@
"use client";
import { SortingState } from "@tanstack/react-table";
import { Inbox } from "lucide-react";
import React, { useMemo, useState } from "react";
import React, { useMemo } from "react";
import { DataTable } from "@/components/shared/DataTable";
import { DataTable, useUrlTableState, type UrlTableStateOptions } from "@/components/shared/DataTable";
import { Guardrail } from "@/components/guardrails/types";
import { getGuardrailTableColumns } from "./guardrailTableColumns";
@ -16,7 +15,12 @@ interface GuardrailTableProps {
onGuardrailClick: (id: string) => void;
}
const DEFAULT_SORTING: SortingState = [{ id: "created_at", desc: true }];
const TABLE_STATE_OPTIONS: UrlTableStateOptions<never> = {
sortFields: ["guardrail_id", "guardrail_name", "created_at", "updated_at"],
defaultSort: { id: "created_at", desc: true },
defaultPageSize: 25,
filterColumns: [],
};
function EmptyState() {
return (
@ -36,7 +40,7 @@ const GuardrailTable: React.FC<GuardrailTableProps> = ({
onDeleteClick,
onGuardrailClick,
}) => {
const [sorting, setSorting] = useState<SortingState>(DEFAULT_SORTING);
const { sorting, onSortingChange, pagination, onPaginationChange } = useUrlTableState(TABLE_STATE_OPTIONS);
const columns = useMemo(
() => getGuardrailTableColumns({ onGuardrailClick, onDeleteClick }),
@ -47,11 +51,13 @@ const GuardrailTable: React.FC<GuardrailTableProps> = ({
<DataTable
data={guardrailsList}
paginationMode="client"
pagination={pagination}
onPaginationChange={onPaginationChange}
columns={columns}
getRowId={(guardrail, index) => guardrail.guardrail_id || String(index)}
sortingMode="client"
sorting={sorting}
onSortingChange={setSorting}
onSortingChange={onSortingChange}
isLoading={isLoading}
loadingMessage="Loading guardrails…"
noDataMessage={<EmptyState />}

View file

@ -0,0 +1,10 @@
import { useUrlTab } from "@/hooks/useUrlTab";
export const GARDEN_TAB_KEY = "garden_tab";
const GARDEN_TABS_WITH_EVAL = ["overview", "eval"] as const;
type GardenTab = (typeof GARDEN_TABS_WITH_EVAL)[number];
const GARDEN_TABS_WITHOUT_EVAL: readonly GardenTab[] = ["overview"];
export const useGardenDetailTab = (hasEval: boolean) =>
useUrlTab(hasEval ? GARDEN_TABS_WITH_EVAL : GARDEN_TABS_WITHOUT_EVAL, "overview", GARDEN_TAB_KEY);

View file

@ -0,0 +1,10 @@
import { useUrlTab } from "@/hooks/useUrlTab";
export const GUARDRAIL_DETAIL_TAB_KEY = "detail_tab";
const ADMIN_DETAIL_TABS = ["overview", "settings"] as const;
type GuardrailDetailTab = (typeof ADMIN_DETAIL_TABS)[number];
const VIEWER_DETAIL_TABS: readonly GuardrailDetailTab[] = ["overview"];
export const useGuardrailDetailTab = (isAdmin: boolean) =>
useUrlTab(isAdmin ? ADMIN_DETAIL_TABS : VIEWER_DETAIL_TABS, "overview", GUARDRAIL_DETAIL_TAB_KEY);

View file

@ -0,0 +1,24 @@
import { parseAsString, parseAsStringLiteral, useQueryState } from "nuqs";
import { useCallback } from "react";
const STATUS_FILTERS = ["all", "pending", "active", "rejected"] as const;
const searchParser = parseAsString.withDefault("");
const statusParser = parseAsStringLiteral(STATUS_FILTERS).withDefault("all");
const submissionParser = parseAsString.withOptions({ history: "push" });
export function useTeamGuardrailsUrlState() {
const [search, setSearchParam] = useQueryState("sub_q", searchParser);
const [statusFilter, setStatusParam] = useQueryState("sub_status", statusParser);
const [selectedId, setSelectedParam] = useQueryState("submission", submissionParser);
const setSearch = useCallback((value: string) => void setSearchParam(value), [setSearchParam]);
const setStatusFilter = useCallback(
(value: string) => void setStatusParam(statusParser.parse(value)),
[setStatusParam],
);
const openSubmission = useCallback((id: string) => void setSelectedParam(id), [setSelectedParam]);
const closeSubmission = useCallback(() => void setSelectedParam(null, { history: "replace" }), [setSelectedParam]);
return { search, setSearch, statusFilter, setStatusFilter, selectedId, openSubmission, closeSubmission };
}

View file

@ -5,6 +5,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
import { renderWithProviders, screen, testQueryClient, waitFor, within } from "../../../tests/test-utils";
import type { LogEntry as SpendLogEntry } from "@/components/view_logs/columns";
import { LogViewer } from "./LogViewer";
import type { LogViewerState } from "./useLogViewerState";
vi.mock("@/components/networking", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/components/networking")>();
@ -14,14 +15,17 @@ vi.mock("@/components/networking", async (importOriginal) => {
vi.mock("@/components/view_logs/LogDetailsDrawer", () => ({
LogDetailsDrawer: function LogDetailsDrawerMock({
open,
onClose,
logEntry,
}: {
open: boolean;
onClose: () => void;
logEntry?: { request_id: string } | null;
}) {
return (
<div data-testid="log-details-drawer" data-log-id={logEntry?.request_id ?? ""}>
{open ? "open" : "closed"}
<button onClick={onClose}>close drawer</button>
</div>
);
},
@ -108,3 +112,82 @@ describe("GuardrailsMonitor LogViewer not_run rows", () => {
expect(within(row).queryByText("Blocked")).not.toBeInTheDocument();
});
});
describe("GuardrailsMonitor LogViewer view state", () => {
const logs = [
{ id: "log-passed", timestamp: "2026-09-02 09:50:13", action: "passed" as const, input_snippet: "safe prompt" },
{ id: "log-blocked", timestamp: "2026-09-02 09:51:13", action: "blocked" as const, input_snippet: "bad prompt" },
];
const makeViewState = (overrides: Partial<LogViewerState> = {}): LogViewerState => ({
filter: "all",
setFilter: vi.fn(),
sampleSize: 10,
setSampleSize: vi.fn(),
requestId: null,
setRequestId: vi.fn(),
...overrides,
});
beforeEach(() => {
vi.mocked(uiSpendLogsCall).mockReset();
vi.mocked(uiSpendLogsCall).mockResolvedValue({ data: [], total: 0 });
testQueryClient.clear();
});
it("shows the filter, sample size and open request that the caller passes in", () => {
const viewState = makeViewState({ filter: "blocked", sampleSize: 50, requestId: "log-blocked" });
renderWithProviders(<LogViewer logs={logs} accessToken="sk-test" viewState={viewState} />);
expect(screen.queryByText("safe prompt")).not.toBeInTheDocument();
expect(screen.getByText("bad prompt")).toBeInTheDocument();
expect(screen.getByRole("button", { name: "50" })).toHaveClass("bg-primary");
expect(screen.getByRole("button", { name: "10" })).not.toHaveClass("bg-primary");
expect(screen.getByRole("button", { name: "Blocked" })).toHaveClass("bg-primary");
expect(screen.getByTestId("log-details-drawer")).toHaveTextContent("open");
expect(vi.mocked(uiSpendLogsCall)).toHaveBeenCalledWith(
expect.objectContaining({ params: { request_id: "log-blocked" } }),
);
});
it("reports filter, sample size, row and drawer changes to the caller instead of keeping them", async () => {
const user = userEvent.setup();
const viewState = makeViewState();
renderWithProviders(<LogViewer logs={logs} accessToken="sk-test" viewState={viewState} />);
await user.click(screen.getByRole("button", { name: "Blocked" }));
expect(viewState.setFilter).toHaveBeenCalledWith("blocked");
expect(screen.getByText("safe prompt")).toBeInTheDocument();
await user.click(screen.getByRole("button", { name: "100" }));
expect(viewState.setSampleSize).toHaveBeenCalledWith(100);
await user.click(screen.getByText("bad prompt"));
expect(viewState.setRequestId).toHaveBeenLastCalledWith("log-blocked");
expect(screen.getByTestId("log-details-drawer")).toHaveTextContent("closed");
await user.click(screen.getByRole("button", { name: "close drawer" }));
expect(viewState.setRequestId).toHaveBeenLastCalledWith(null);
});
it("keeps its own filter and drawer state when the caller passes none", async () => {
const user = userEvent.setup();
renderWithProviders(<LogViewer logs={logs} accessToken="sk-test" />);
await user.click(screen.getByRole("button", { name: "Blocked" }));
expect(screen.queryByText("safe prompt")).not.toBeInTheDocument();
expect(screen.getByText("bad prompt")).toBeInTheDocument();
await user.click(screen.getByText("bad prompt"));
expect(screen.getByTestId("log-details-drawer")).toHaveTextContent("open");
await user.click(screen.getByRole("button", { name: "close drawer" }));
expect(screen.getByTestId("log-details-drawer")).toHaveTextContent("closed");
});
it("starts on the filter given by filterAction when the caller passes no view state", () => {
renderWithProviders(<LogViewer logs={logs} filterAction="passed" />);
expect(screen.getByText("safe prompt")).toBeInTheDocument();
expect(screen.queryByText("bad prompt")).not.toBeInTheDocument();
});
});

View file

@ -1,13 +1,20 @@
import { CircleCheck, ChevronDown, MinusCircle, TriangleAlert, X } from "lucide-react";
import { useQuery } from "@tanstack/react-query";
import moment from "moment";
import React, { useState } from "react";
import React from "react";
import { Button } from "@/components/ui/button";
import { UiLoadingSpinner } from "@/components/ui/ui-loading-spinner";
import { uiSpendLogsCall } from "@/components/networking";
import { LogDetailsDrawer } from "@/components/view_logs/LogDetailsDrawer";
import type { LogEntry as ViewLogsLogEntry } from "@/components/view_logs/columns";
import type { LogEntry } from "./mockData";
import {
LOG_FILTERS,
LOG_SAMPLE_SIZES,
type LogFilter,
type LogViewerState,
useLocalLogViewerState,
} from "./useLogViewerState";
const actionConfig: Record<
"blocked" | "passed" | "flagged" | "not_run",
@ -45,13 +52,14 @@ const actionConfig: Record<
interface LogViewerProps {
guardrailName?: string;
filterAction?: "all" | "blocked" | "passed" | "flagged";
filterAction?: LogFilter;
logs?: LogEntry[];
logsLoading?: boolean;
totalLogs?: number;
accessToken?: string | null;
startDate?: string;
endDate?: string;
viewState?: LogViewerState;
}
export function LogViewer({
@ -63,17 +71,22 @@ export function LogViewer({
accessToken = null,
startDate = "",
endDate = "",
viewState,
}: LogViewerProps) {
const [sampleSize, setSampleSize] = useState(10);
const [activeFilter, setActiveFilter] = useState<string>(filterAction);
const [selectedRequestId, setSelectedRequestId] = useState<string | null>(null);
const [drawerOpen, setDrawerOpen] = useState(false);
const localState = useLocalLogViewerState(filterAction);
const {
filter: activeFilter,
setFilter: setActiveFilter,
sampleSize,
setSampleSize,
requestId: selectedRequestId,
setRequestId: setSelectedRequestId,
} = viewState ?? localState;
const drawerOpen = selectedRequestId !== null;
const filteredLogs = logs.filter((log) => activeFilter === "all" || log.action === activeFilter);
const displayLogs = filteredLogs.slice(0, sampleSize);
const total = totalLogs ?? logs.length;
const sampleSizes = [10, 50, 100];
const filters: Array<"all" | "blocked" | "flagged" | "passed"> = ["all", "blocked", "flagged", "passed"];
const startTime = startDate
? moment(startDate).utc().format("YYYY-MM-DD HH:mm:ss")
@ -96,22 +109,12 @@ export function LogViewer({
});
return res as { data: ViewLogsLogEntry[]; total: number };
},
enabled: Boolean(accessToken && selectedRequestId && drawerOpen),
enabled: Boolean(accessToken && selectedRequestId),
});
const selectedLog: ViewLogsLogEntry | null =
fullLogResponse?.data?.find((log) => log.request_id === selectedRequestId) ?? fullLogResponse?.data?.[0] ?? null;
const handleLogClick = (log: LogEntry) => {
setSelectedRequestId(log.id);
setDrawerOpen(true);
};
const handleCloseDrawer = () => {
setDrawerOpen(false);
setSelectedRequestId(null);
};
return (
<div className="bg-card border border-border rounded-lg">
<div className="p-4 border-b border-border">
@ -131,7 +134,7 @@ export function LogViewer({
{logs.length > 0 && (
<div className="flex items-center gap-4">
<div className="flex items-center gap-1">
{filters.map((f) => (
{LOG_FILTERS.map((f) => (
<Button
key={f}
variant={activeFilter === f ? "default" : "outline"}
@ -145,7 +148,7 @@ export function LogViewer({
<div className="h-4 w-px bg-border" />
<div className="flex items-center gap-1">
<span className="text-xs text-muted-foreground mr-1">Sample:</span>
{sampleSizes.map((size) => (
{LOG_SAMPLE_SIZES.map((size) => (
<Button
key={size}
variant={sampleSize === size ? "default" : "outline"}
@ -180,7 +183,7 @@ export function LogViewer({
<button
key={log.id}
type="button"
onClick={() => handleLogClick(log)}
onClick={() => setSelectedRequestId(log.id)}
className="w-full text-left px-4 py-3 hover:bg-accent transition-colors flex items-start gap-3"
>
<ActionIcon className={`w-4 h-4 mt-0.5 shrink-0 ${config.color}`} />
@ -208,7 +211,7 @@ export function LogViewer({
<LogDetailsDrawer
open={drawerOpen}
onClose={handleCloseDrawer}
onClose={() => setSelectedRequestId(null)}
logEntry={selectedLog}
accessToken={accessToken}
allLogs={selectedLog ? [selectedLog] : []}

View file

@ -0,0 +1,22 @@
import { useState } from "react";
export const LOG_FILTERS = ["all", "blocked", "flagged", "passed"] as const;
export type LogFilter = (typeof LOG_FILTERS)[number];
export const LOG_SAMPLE_SIZES = [10, 50, 100] as const;
export type LogSampleSize = (typeof LOG_SAMPLE_SIZES)[number];
export interface LogViewerState {
filter: LogFilter;
setFilter: (filter: LogFilter) => void;
sampleSize: LogSampleSize;
setSampleSize: (size: LogSampleSize) => void;
requestId: string | null;
setRequestId: (requestId: string | null) => void;
}
export function useLocalLogViewerState(initialFilter: LogFilter): LogViewerState {
const [filter, setFilter] = useState<LogFilter>(initialFilter);
const [sampleSize, setSampleSize] = useState<LogSampleSize>(10);
const [requestId, setRequestId] = useState<string | null>(null);
return { filter, setFilter, sampleSize, setSampleSize, requestId, setRequestId };
}