Files
memos/web/tests/usage-limits-settings.test.tsx

313 lines
14 KiB
TypeScript

import { create } from "@bufbuild/protobuf";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { fireEvent, render, screen, waitFor, within } from "@testing-library/react";
import type { PropsWithChildren } from "react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import UsageLimitDialog from "@/components/Settings/UsageLimitDialog";
import UsageLimitsSection from "@/components/Settings/UsageLimitsSection";
import UsageSection from "@/components/Settings/UsageSection";
import { newUsageLimitEntry } from "@/components/Settings/usageLimitValues";
import type { UsageLimitEntry } from "@/hooks/useUsageLimitQueries";
import { InstanceSettingSchema } from "@/types/proto/api/instance_service_pb";
import { UserSchema, UserUsageSchema } from "@/types/proto/api/user_service_pb";
import english from "../src/locales/en.json";
const MIB = 1024n * 1024n;
const mocks = vi.hoisted(() => ({
getUserUsage: vi.fn(),
listUsers: vi.fn(),
getInstanceSetting: vi.fn(),
updateInstanceSetting: vi.fn(),
}));
vi.mock("@/connect", () => ({
userServiceClient: { getUserUsage: mocks.getUserUsage, listUsers: mocks.listUsers },
instanceServiceClient: { getInstanceSetting: mocks.getInstanceSetting, updateInstanceSetting: mocks.updateInstanceSetting },
}));
vi.mock("@/hooks/useCurrentUser", () => ({ default: () => ({ name: "users/alice" }) }));
vi.mock("@/lib/toast", () => ({ toast: { add: vi.fn(), close: vi.fn() }, showErrorToast: vi.fn() }));
// Render the English copy, so the assertions read like the screen.
vi.mock("@/utils/i18n", () => ({
useTranslate: () => (key: string, params?: Record<string, unknown>) => {
const text = key.split(".").reduce<unknown>((node, part) => (node as Record<string, unknown>)?.[part], english);
return typeof text === "string" ? text.replace(/\{\{(\w+)\}\}/g, (_, name) => String(params?.[name])) : key;
},
}));
const wrapper = ({ children }: PropsWithChildren) => (
<QueryClientProvider client={new QueryClient({ defaultOptions: { queries: { retry: false }, mutations: { retry: false } } })}>
{children}
</QueryClientProvider>
);
const settingOf = (limits: UsageLimitEntry[]) =>
create(InstanceSettingSchema, { name: "instance/settings/USAGE_LIMITS", value: { case: "usageLimitsSetting", value: { limits } } });
const alice = create(UserSchema, { name: "users/alice", username: "alice", displayName: "Alice" });
const bob = create(UserSchema, { name: "users/bob", username: "bob" });
const carol = create(UserSchema, { name: "users/carol", username: "carol" });
const defaults = newUsageLimitEntry({ allUsers: true, memoCount: 100n, memoContentBytes: 8192n, storageBytes: 1024n * MIB });
beforeEach(() => {
for (const mock of Object.values(mocks)) mock.mockReset();
mocks.listUsers.mockResolvedValue({ users: [alice, bob, carol], nextPageToken: "" });
mocks.updateInstanceSetting.mockImplementation(async ({ instanceSetting }) => instanceSetting);
});
describe("UsageSection", () => {
it("is hidden when no limit applies", async () => {
mocks.getUserUsage.mockResolvedValue(create(UserUsageSchema, { memoCount: 5n, limits: { memoCount: 0n } }));
const { container } = render(<UsageSection />, { wrapper });
await waitFor(() => expect(mocks.getUserUsage).toHaveBeenCalledWith({ name: "users/alice/usage" }));
expect(container).toBeEmptyDOMElement();
});
it("shows usage against the limit set in effect", async () => {
mocks.getUserUsage.mockResolvedValue(
create(UserUsageSchema, {
memoCount: 12n,
storageBytes: 512n * MIB,
limits: { memoCount: 1000n, storageBytes: 1024n * MIB },
limitIndex: 1,
}),
);
render(<UsageSection />, { wrapper });
expect(await screen.findByText("Usage limits")).toBeInTheDocument();
expect(screen.getByText("12 of 1,000")).toBeInTheDocument();
expect(screen.getByText("512.0 MB of 1.0 GB")).toBeInTheDocument();
expect(screen.queryByText("Largest file")).not.toBeInTheDocument();
});
});
// The user picker is a Combobox: open it from its trigger, type to filter, then pick.
const chooseUser = async (query: string, option: string) => {
fireEvent.click(screen.getByRole("button", { name: "Users" }));
fireEvent.change(screen.getByRole("combobox"), { target: { value: query } });
fireEvent.click(await screen.findByRole("option", { name: option }));
};
const openRowMenu = async (name: string, item: string) => {
fireEvent.click(await screen.findByRole("button", { name: `Actions for entry ${name}` }));
fireEvent.click(await screen.findByRole("menuitem", { name: item }));
};
const savedLimits = () =>
(mocks.updateInstanceSetting.mock.calls[0][0].instanceSetting.value.value as { limits: UsageLimitEntry[] }).limits;
describe("UsageLimitsSection", () => {
it("shows the entries in the order they are checked, the default last", async () => {
mocks.getInstanceSetting.mockResolvedValue(
settingOf([
newUsageLimitEntry({ users: ["users/bob"], storageBytes: 5n * 1024n * MIB }),
newUsageLimitEntry({ users: ["users/bob", "users/carol"], memoCount: 0n, memoContentBytes: 8192n }),
defaults,
]),
);
render(<UsageLimitsSection />, { wrapper });
expect(await screen.findByText(/checked from top to bottom/)).toBeInTheDocument();
await screen.findByText("carol");
const rows = screen.getAllByRole("row").slice(1);
const text = (row: HTMLElement) =>
within(row)
.getAllByRole("cell")
.map((cell) => cell.textContent);
expect(rows).toHaveLength(3);
expect(text(rows[0])).toEqual(["1", "bob", "Unlimited", "Unlimited", "5.0 GB", "Unlimited", ""]);
expect(text(rows[1])).toEqual(["2", "bobcarol", "Unlimited", "8.0 KB", "Unlimited", "Unlimited", ""]);
expect(text(rows[2])).toEqual([
"3",
"All usersEveryone not named above. This is the default.",
"100",
"8.0 KB",
"1.0 GB",
"Unlimited",
"",
]);
expect(screen.queryByText("Never applies")).not.toBeInTheDocument();
});
it("flags an entry that an earlier entry shadows completely", async () => {
mocks.getInstanceSetting.mockResolvedValue(
settingOf([
newUsageLimitEntry({ users: ["users/bob", "users/carol"], memoCount: 10n }),
newUsageLimitEntry({ users: ["users/bob"], memoCount: 20n }),
defaults,
]),
);
render(<UsageLimitsSection />, { wrapper });
const badge = await screen.findByText("Never applies");
expect(badge.closest("tr")).toBe(screen.getAllByRole("row")[2]);
});
it("moves an entry up and saves the whole list", async () => {
const first = newUsageLimitEntry({ users: ["users/bob"], memoCount: 10n });
const second = newUsageLimitEntry({ users: ["users/carol"], memoCount: 20n });
mocks.getInstanceSetting.mockResolvedValue(settingOf([first, second, defaults]));
render(<UsageLimitsSection />, { wrapper });
await screen.findByText("carol");
await openRowMenu("2", "Move up");
await waitFor(() => expect(mocks.updateInstanceSetting).toHaveBeenCalledTimes(1));
expect(savedLimits().map((entry) => entry.users)).toEqual([["users/carol"], ["users/bob"], []]);
});
it("does not let the default move or be removed", async () => {
mocks.getInstanceSetting.mockResolvedValue(settingOf([newUsageLimitEntry({ users: ["users/bob"] }), defaults]));
render(<UsageLimitsSection />, { wrapper });
await screen.findByText("bob");
fireEvent.click(await screen.findByRole("button", { name: "Actions for entry All users" }));
expect(await screen.findByRole("menuitem", { name: "Edit" })).toBeInTheDocument();
expect(screen.queryByRole("menuitem", { name: "Remove" })).not.toBeInTheDocument();
expect(screen.queryByRole("menuitem", { name: "Move up" })).not.toBeInTheDocument();
});
it("removes an entry after confirmation", async () => {
mocks.getInstanceSetting.mockResolvedValue(settingOf([newUsageLimitEntry({ users: ["users/bob"], memoCount: 10n }), defaults]));
render(<UsageLimitsSection />, { wrapper });
await screen.findByText("bob");
await openRowMenu("1", "Remove");
expect(await screen.findByText("Remove this entry?")).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Remove" }));
await waitFor(() => expect(mocks.updateInstanceSetting).toHaveBeenCalledTimes(1));
expect(savedLimits()).toHaveLength(1);
expect(savedLimits()[0].allUsers).toBe(true);
});
});
describe("UsageLimitDialog", () => {
it("edits the limits for all users", async () => {
const onSave = vi.fn().mockResolvedValue(undefined);
render(
<UsageLimitDialog
open
onOpenChange={vi.fn()}
entry={defaults}
defaults={defaults}
users={[alice, bob]}
saving={false}
onSave={onSave}
/>,
{
wrapper,
},
);
expect(await screen.findByText("Limits for all users")).toBeInTheDocument();
expect(screen.queryByRole("combobox")).not.toBeInTheDocument();
const memos = screen.getByRole("textbox", { name: "Memos" });
expect(memos).toHaveValue("100");
expect(screen.getByRole("textbox", { name: "Storage (MiB)" })).toHaveValue("1024");
const content = screen.getByRole("textbox", { name: "Memo content (KiB)" });
expect(content).toHaveValue("8");
expect(screen.getByRole("textbox", { name: "Largest file (MiB)" })).toHaveAttribute("placeholder", "Unlimited");
fireEvent.change(memos, { target: { value: "200" } });
fireEvent.change(content, { target: { value: "4" } });
fireEvent.change(screen.getByRole("textbox", { name: "Storage (MiB)" }), { target: { value: "" } });
fireEvent.change(screen.getByRole("textbox", { name: "Largest file (MiB)" }), { target: { value: "10" } });
fireEvent.click(screen.getByRole("button", { name: "Save" }));
await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
const saved = onSave.mock.calls[0][0] as UsageLimitEntry;
expect(saved.allUsers).toBe(true);
expect(saved.users).toEqual([]);
expect(saved.memoCount).toBe(200n);
expect(saved.memoContentBytes).toBe(4096n);
expect(saved.storageBytes).toBeUndefined();
expect(saved.uploadBytes).toBe(10n * MIB);
});
it("adds an entry for picked users, starting from the default values", async () => {
const onSave = vi.fn().mockResolvedValue(undefined);
render(
<UsageLimitDialog open onOpenChange={vi.fn()} defaults={defaults} users={[alice, bob, carol]} saving={false} onSave={onSave} />,
{
wrapper,
},
);
expect(await screen.findByRole("heading", { name: "Add entry" })).toBeInTheDocument();
expect(screen.getByRole("textbox", { name: "Memos" })).toHaveValue("100");
expect(screen.getByRole("button", { name: "Save" })).toBeDisabled();
await chooseUser("carol", "@carol");
await waitFor(() => expect(screen.getByRole("button", { name: "Save" })).toBeEnabled());
fireEvent.change(screen.getByRole("textbox", { name: "Largest file (MiB)" }), { target: { value: "10" } });
fireEvent.change(screen.getByRole("textbox", { name: "Memos" }), { target: { value: "0" } });
fireEvent.click(screen.getByRole("button", { name: "Save" }));
await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
const saved = onSave.mock.calls[0][0] as UsageLimitEntry;
expect(saved.allUsers).toBe(false);
expect(saved.users).toEqual(["users/carol"]);
expect(saved.uploadBytes).toBe(10n * MIB);
expect(saved.memoCount).toBeUndefined();
expect(saved.memoContentBytes).toBe(8192n);
});
it("keeps the stored value of a field the admin did not touch", async () => {
const onSave = vi.fn().mockResolvedValue(undefined);
// 8,193 bytes displays as 8 KiB; re-parsing the text would turn it into 8,192.
const entry = newUsageLimitEntry({ users: ["users/bob"], memoContentBytes: 8193n, storageBytes: 1n });
render(
<UsageLimitDialog open onOpenChange={vi.fn()} entry={entry} defaults={defaults} users={[bob]} saving={false} onSave={onSave} />,
{
wrapper,
},
);
expect(await screen.findByRole("textbox", { name: "Memo content (KiB)" })).toHaveValue("8");
expect(screen.getByRole("textbox", { name: "Storage (MiB)" })).not.toHaveValue("0");
fireEvent.change(screen.getByRole("textbox", { name: "Memos" }), { target: { value: "5" } });
fireEvent.click(screen.getByRole("button", { name: "Save" }));
await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
const saved = onSave.mock.calls[0][0] as UsageLimitEntry;
expect(saved.memoContentBytes).toBe(8193n);
expect(saved.storageBytes).toBe(1n);
expect(saved.memoCount).toBe(5n);
});
it("rejects a byte size that does not fit an integer instead of throwing", async () => {
const onSave = vi.fn().mockResolvedValue(undefined);
render(
<UsageLimitDialog open onOpenChange={vi.fn()} entry={defaults} defaults={defaults} users={[]} saving={false} onSave={onSave} />,
{
wrapper,
},
);
const storage = await screen.findByRole("textbox", { name: "Storage (MiB)" });
fireEvent.change(storage, { target: { value: "9".repeat(400) } });
expect(storage).toHaveAttribute("aria-invalid", "true");
expect(screen.getByRole("button", { name: "Save" })).toBeDisabled();
});
it("removes a user from the entry", async () => {
const onSave = vi.fn().mockResolvedValue(undefined);
const entry = newUsageLimitEntry({ users: ["users/bob", "users/carol"], memoCount: 10n });
render(
<UsageLimitDialog
open
onOpenChange={vi.fn()}
entry={entry}
defaults={defaults}
users={[bob, carol]}
saving={false}
onSave={onSave}
/>,
{
wrapper,
},
);
expect(await screen.findByRole("heading", { name: "Edit entry" })).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Remove bob" }));
fireEvent.click(screen.getByRole("button", { name: "Save" }));
await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
expect((onSave.mock.calls[0][0] as UsageLimitEntry).users).toEqual(["users/carol"]);
});
});