Files
kandev/apps/web/components/settings/layouts/use-layout-settings.test.tsx
T
João Salavisa 8c73187239 feat(i18n): localize Settings → General → Sprites and Layouts (#2153)
Co-authored-by: Kandev Agent <agent@kandev.dev>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-02 12:30:36 +02:00

400 lines
14 KiB
TypeScript

import { type ReactNode } from "react";
import { act, cleanup, renderHook } from "@testing-library/react";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { StateProvider } from "@/components/state-provider";
import { getBuiltInLayoutProfile } from "@/lib/layout/layout-profiles";
import { defaultState } from "@/lib/state/default-state";
import type { SavedLayout, UserSettingsResponse } from "@/lib/types/http";
import { workspaceId } from "@/lib/types/ids";
const updateUserSettings = vi.fn();
const PROFILE_ID = "profile-one";
const SECOND_PROFILE_ID = "profile-two";
const ORIGINAL_NAME = "Original";
const DRAFT_NAME = "Draft name";
const LEGACY_LAYOUT = { columns: "old-format" };
vi.mock("@/lib/api", () => ({
updateUserSettings: (...args: unknown[]) => updateUserSettings(...args),
}));
import { activateLocale } from "@/lib/i18n";
import { useLayoutSettings } from "./use-layout-settings";
function profile(overrides: Partial<SavedLayout> = {}): SavedLayout {
return {
id: PROFILE_ID,
name: ORIGINAL_NAME,
is_default: false,
layout: getBuiltInLayoutProfile("default").layout as unknown as Record<string, unknown>,
created_at: "2026-07-19T10:00:00.000Z",
...overrides,
};
}
function responseWith(savedLayouts: SavedLayout[]): UserSettingsResponse {
return {
settings: {
user_id: "user-one",
workspace_id: workspaceId("workspace-one"),
repository_ids: [],
saved_layouts: savedLayouts,
updated_at: "2026-07-19T12:00:00.000Z",
},
};
}
function renderLayoutSettings(savedLayouts: SavedLayout[] = []) {
function Wrapper({ children }: { children: ReactNode }) {
return (
<StateProvider
initialState={{
userSettings: {
...defaultState.userSettings,
savedLayouts,
loaded: true,
},
}}
>
{children}
</StateProvider>
);
}
return renderHook(() => useLayoutSettings(), { wrapper: Wrapper });
}
beforeEach(() => {
updateUserSettings.mockReset();
});
afterEach(cleanup);
describe("useLayoutSettings selection and drafts", () => {
it("selects the effective default on initialization", () => {
const customDefault = profile({ is_default: true });
const builtIn = renderLayoutSettings();
const custom = renderLayoutSettings([customDefault]);
expect(builtIn.result.current).toMatchObject({
selection: { kind: "built-in", id: "default" },
selectedIsDefault: true,
defaultActionDisabled: true,
defaultActionLabel: "Default",
isDirty: false,
});
expect(custom.result.current).toMatchObject({
selection: { kind: "custom", id: PROFILE_ID },
selectedCustom: customDefault,
selectedIsDefault: true,
defaultActionDisabled: false,
defaultActionLabel: "Use built-in Default",
isDirty: false,
});
});
it("duplicates and renames a profile, then cancel restores the baseline", () => {
const { result } = renderLayoutSettings();
act(() => result.current.duplicate());
const duplicateId = result.current.selection.id;
expect(result.current).toMatchObject({
selection: { kind: "custom", id: duplicateId },
selectedName: "Default copy",
isDirty: true,
});
act(() => result.current.updateSelected({ name: DRAFT_NAME }));
expect(result.current.selectedName).toBe(DRAFT_NAME);
act(() => result.current.cancel());
expect(result.current).toMatchObject({
selection: { kind: "built-in", id: "default" },
profiles: [],
isDirty: false,
editorReset: 1,
});
});
it("creates an editable profile from the built-in Default", () => {
const { result } = renderLayoutSettings([profile()]);
act(() => result.current.create());
expect(result.current.profiles).toHaveLength(2);
expect(result.current.selectedCustom).toMatchObject({
id: result.current.selection.id,
name: "Untitled layout",
is_default: false,
});
expect(result.current.compatibility?.status).toBe("editable");
expect(result.current.isDirty).toBe(true);
});
it("sets a custom default and clears it through the built-in Default", () => {
const second = profile({ id: SECOND_PROFILE_ID, name: "Second" });
const { result } = renderLayoutSettings([profile(), second]);
act(() => result.current.setSelection({ kind: "custom", id: SECOND_PROFILE_ID }));
act(() => result.current.setDefault());
expect(result.current.profiles.map((candidate) => candidate.is_default)).toEqual([false, true]);
act(() => result.current.setSelection({ kind: "built-in", id: "default" }));
expect(result.current.defaultActionDisabled).toBe(false);
act(() => result.current.setDefault());
expect(result.current.profiles.map((candidate) => candidate.is_default)).toEqual([
false,
false,
]);
expect(result.current.selectedIsDefault).toBe(true);
expect(result.current.defaultActionDisabled).toBe(true);
});
it("disables an invalid legacy non-default but permits clearing an invalid default", () => {
const unavailable = profile({ layout: LEGACY_LAYOUT });
const nonDefault = renderLayoutSettings([unavailable]);
act(() => nonDefault.result.current.setSelection({ kind: "custom", id: PROFILE_ID }));
expect(nonDefault.result.current).toMatchObject({
compatibility: { status: "legacy" },
defaultActionDisabled: true,
selectedIsDefault: false,
});
const invalidDefault = renderLayoutSettings([
profile({ layout: LEGACY_LAYOUT, is_default: true }),
]);
expect(invalidDefault.result.current).toMatchObject({
selection: { kind: "built-in", id: "default" },
selectedIsDefault: true,
defaultActionDisabled: true,
});
act(() => invalidDefault.result.current.setSelection({ kind: "custom", id: PROFILE_ID }));
expect(invalidDefault.result.current).toMatchObject({
compatibility: { status: "legacy" },
defaultActionDisabled: false,
defaultActionLabel: "Use built-in Default",
selectedIsDefault: false,
});
act(() => invalidDefault.result.current.setDefault());
expect(invalidDefault.result.current.profiles[0].is_default).toBe(false);
expect(invalidDefault.result.current.defaultActionDisabled).toBe(true);
});
});
describe("useLayoutSettings built-in editing", () => {
it("edits the built-in Default directly as a custom default draft", () => {
const { result } = renderLayoutSettings();
const layout = getBuiltInLayoutProfile("default").layout;
layout.columns = layout.columns
.map((column) => ({
...column,
groups: column.groups
.map((group) => ({
...group,
panels: group.panels.filter((panel) => panel.id !== "terminal-default"),
}))
.filter((group) => group.panels.length > 0),
}))
.filter((column) => column.groups.length > 0);
act(() => result.current.updateLayout(layout));
expect(result.current).toMatchObject({
selection: { kind: "built-in", id: "default" },
selectedName: "Default",
selectedIsDefault: true,
defaultActionLabel: "Default",
isDirty: true,
});
expect(result.current.selectedBuiltInOverride).toMatchObject({
name: "Default",
is_default: true,
});
expect(result.current.profiles).toHaveLength(1);
expect(
result.current.editorLayout?.columns
.flatMap((column) => column.groups)
.flatMap((group) => group.panels)
.map((panel) => panel.id),
).not.toContain("terminal-default");
});
it("preserves a custom default when editing the built-in Default", () => {
const customDefault = profile({ is_default: true });
const { result } = renderLayoutSettings([customDefault]);
const layout = getBuiltInLayoutProfile("default").layout;
layout.columns[0].width = 640;
act(() => result.current.setSelection({ kind: "built-in", id: "default" }));
act(() => result.current.updateLayout(layout));
expect(result.current.profiles).toEqual([
customDefault,
expect.objectContaining({
id: "layout-override-default",
is_default: false,
}),
]);
expect(result.current.selectedIsDefault).toBe(false);
});
it("resets a built-in override without affecting custom profiles", () => {
const custom = profile({ id: SECOND_PROFILE_ID, name: "Custom" });
const { result } = renderLayoutSettings([custom]);
const layout = getBuiltInLayoutProfile("default").layout;
layout.columns[1].groups = layout.columns[1].groups.slice(0, 1);
act(() => result.current.updateLayout(layout));
expect(result.current.selectedBuiltInOverride).not.toBeNull();
act(() => result.current.resetBuiltIn());
expect(result.current.selectedBuiltInOverride).toBeNull();
expect(result.current.profiles).toEqual([custom]);
expect(result.current.editorLayout).toEqual(getBuiltInLayoutProfile("default").layout);
});
it("preserves a non-Default built-in override as default when editing it", () => {
const { result } = renderLayoutSettings();
act(() => result.current.setSelection({ kind: "built-in", id: "plan" }));
act(() => result.current.setDefault());
const layout = getBuiltInLayoutProfile("plan").layout;
layout.columns[0].width = 640;
act(() => result.current.updateLayout(layout));
expect(result.current.selectedBuiltInOverride?.is_default).toBe(true);
expect(result.current.selectedIsDefault).toBe(true);
});
});
describe("useLayoutSettings persistence", () => {
it("keeps a customized built-in selected after a successful save", async () => {
const { result } = renderLayoutSettings();
const layout = getBuiltInLayoutProfile("plan").layout;
layout.columns[0].width = 640;
act(() => result.current.setSelection({ kind: "built-in", id: "plan" }));
act(() => result.current.updateLayout(layout));
updateUserSettings.mockResolvedValueOnce(
responseWith(structuredClone(result.current.profiles)),
);
await act(async () => result.current.save());
expect(result.current.selection).toEqual({ kind: "built-in", id: "plan" });
expect(result.current.editorLayout?.columns[0].width).toBe(640);
});
it("adopts the successful PATCH response as the authoritative baseline", async () => {
const authoritative = profile({ name: "Server name", is_default: true });
updateUserSettings.mockResolvedValueOnce(responseWith([authoritative]));
const { result } = renderLayoutSettings([profile()]);
act(() => result.current.setSelection({ kind: "custom", id: PROFILE_ID }));
act(() => result.current.updateSelected({ name: DRAFT_NAME }));
await act(async () => result.current.save());
expect(updateUserSettings).toHaveBeenCalledWith({
saved_layouts: [profile({ name: DRAFT_NAME })],
});
expect(result.current).toMatchObject({
profiles: [authoritative],
baseline: [authoritative],
selection: { kind: "custom", id: PROFILE_ID },
selectedName: "Server name",
saveStatus: "success",
error: null,
isDirty: false,
});
});
it("preserves the unsaved draft and reports a failed PATCH", async () => {
updateUserSettings.mockRejectedValueOnce(new Error("save failed"));
const original = profile();
const { result } = renderLayoutSettings([original]);
act(() => result.current.setSelection({ kind: "custom", id: PROFILE_ID }));
act(() => result.current.updateSelected({ name: DRAFT_NAME }));
await act(async () => {
await expect(result.current.save()).rejects.toThrow("save failed");
});
expect(result.current).toMatchObject({
profiles: [profile({ name: DRAFT_NAME })],
baseline: [original],
selectedName: DRAFT_NAME,
saveStatus: "error",
error: "save failed",
isDirty: true,
});
});
});
/**
* These strings leave the hook as plain text, so `i18next/no-literal-string`
* cannot see them — a hardcoded English literal here is invisible to lint and,
* once allowlisted in the pseudo-coverage oracle, invisible there too. Asserting
* that the pseudo locale actually changes them is what proves they resolve
* through the catalog rather than being baked in.
*/
describe("useLayoutSettings localization", () => {
afterEach(async () => {
await activateLocale("en");
});
it("resolves the default-action labels through the catalog", async () => {
await act(async () => {
await activateLocale("pseudo");
});
const builtInDefault = renderLayoutSettings();
const customDefault = renderLayoutSettings([profile({ is_default: true })]);
// The built-in-Default branch used to return a hardcoded "Default".
expect(builtInDefault.result.current.defaultActionLabel).not.toBe("Default");
expect(customDefault.result.current.defaultActionLabel).not.toBe("Use built-in Default");
});
it("interpolates the source name into a localized duplicated profile name", async () => {
await act(async () => {
await activateLocale("pseudo");
});
const { result } = renderLayoutSettings([profile({ name: "My Layout" })]);
act(() => result.current.setSelection({ kind: "custom", id: PROFILE_ID }));
act(() => result.current.duplicate());
// Both halves of the contract: the source name is user data and survives
// verbatim, while the surrounding " copy" resolves through the catalog.
expect(result.current.selectedName).toContain("My Layout");
expect(result.current.selectedName).not.toBe("My Layout copy");
});
it("names a newly created profile and reports validation errors from the catalog", async () => {
await act(async () => {
await activateLocale("pseudo");
});
const { result } = renderLayoutSettings();
act(() => result.current.create());
expect(result.current.selectedCustom?.name).not.toBe("Untitled layout");
act(() => result.current.updateSelected({ name: " " }));
await act(async () => {
await result.current.save();
});
expect(updateUserSettings).not.toHaveBeenCalled();
expect(result.current.saveStatus).toBe("error");
expect(result.current.error).toBeTruthy();
expect(result.current.error).not.toBe("Layout profile names must not be empty");
});
});