791 lines
24 KiB
TypeScript
791 lines
24 KiB
TypeScript
/* eslint-disable max-lines -- User-settings notification cases share one handler contract file. */
|
|
|
|
import { describe, expect, it } from "vitest";
|
|
import { createStore } from "zustand/vanilla";
|
|
import { registerUsersHandlers } from "./users";
|
|
import { defaultState } from "@/lib/state/default-state";
|
|
import type { AppState } from "@/lib/state/store";
|
|
import type { BackendMessageMap } from "@/lib/types/backend";
|
|
|
|
/** Creates a vanilla Zustand store seeded with a structured clone of the default app state. */
|
|
function makeStore() {
|
|
return createStore<AppState>(() => structuredClone(defaultState) as AppState);
|
|
}
|
|
|
|
const LOCAL_VIEW_ID = "view-local";
|
|
|
|
/** Builds a `user.settings.updated` notification frame merging the given payload over default values. */
|
|
function userSettingsMessage(
|
|
payload: Partial<BackendMessageMap["user.settings.updated"]["payload"]>,
|
|
): BackendMessageMap["user.settings.updated"] {
|
|
return {
|
|
type: "notification",
|
|
action: "user.settings.updated",
|
|
payload: {
|
|
user_id: "default",
|
|
workspace_id: "workspace",
|
|
repository_ids: [],
|
|
...payload,
|
|
},
|
|
};
|
|
}
|
|
|
|
function recentUseMessage(
|
|
payload: Partial<BackendMessageMap["user.agent_profile_recent_use.updated"]["payload"]>,
|
|
): BackendMessageMap["user.agent_profile_recent_use.updated"] {
|
|
return {
|
|
type: "notification",
|
|
action: "user.agent_profile_recent_use.updated",
|
|
payload: {
|
|
context: "task_create",
|
|
profile_ids: [],
|
|
revision: 1,
|
|
updated_at: "2026-08-27T12:00:00Z",
|
|
...payload,
|
|
},
|
|
};
|
|
}
|
|
|
|
describe("agent profile recent-use websocket sync", () => {
|
|
it("keeps newer context revisions and accepts independent contexts", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
agentProfileRecentUse: {
|
|
loaded: true,
|
|
records: {
|
|
task_create: { profileIds: ["profile-new"], revision: 2, updatedAt: "later" },
|
|
},
|
|
},
|
|
}));
|
|
|
|
const handler = registerUsersHandlers(store)["user.agent_profile_recent_use.updated"];
|
|
handler?.(
|
|
recentUseMessage({
|
|
profile_ids: ["profile-old"],
|
|
revision: 1,
|
|
updated_at: "older",
|
|
}),
|
|
);
|
|
expect(store.getState().agentProfileRecentUse.records.task_create?.profileIds).toEqual([
|
|
"profile-new",
|
|
]);
|
|
|
|
handler?.(
|
|
recentUseMessage({
|
|
context: "quick_chat",
|
|
profile_ids: ["profile-chat"],
|
|
revision: 1,
|
|
}),
|
|
);
|
|
expect(store.getState().agentProfileRecentUse.records.quick_chat?.profileIds).toEqual([
|
|
"profile-chat",
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("startup page websocket sync", () => {
|
|
it("applies startup page preferences and normalizes unknown values", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
startup_page: "last_task",
|
|
} as unknown as Partial<BackendMessageMap["user.settings.updated"]["payload"]>),
|
|
);
|
|
expect(store.getState().userSettings.startupPage).toBe("last_task");
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
startup_page: "unexpected",
|
|
} as unknown as Partial<BackendMessageMap["user.settings.updated"]["payload"]>),
|
|
);
|
|
expect(store.getState().userSettings.startupPage).toBe("task_overview");
|
|
});
|
|
});
|
|
|
|
describe("status bar visibility websocket sync", () => {
|
|
it("updates status bar visibility and preserves it when omitted", () => {
|
|
const store = makeStore();
|
|
|
|
expect(
|
|
(store.getState().userSettings as unknown as Record<string, unknown>).appStatusBarEnabled,
|
|
).toBe(false);
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
app_status_bar_enabled: true,
|
|
} as unknown as Partial<BackendMessageMap["user.settings.updated"]["payload"]>),
|
|
);
|
|
expect(
|
|
(store.getState().userSettings as unknown as Record<string, unknown>).appStatusBarEnabled,
|
|
).toBe(true);
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(
|
|
(store.getState().userSettings as unknown as Record<string, unknown>).appStatusBarEnabled,
|
|
).toBe(true);
|
|
});
|
|
|
|
it("ignores older settings revisions and accepts newer ones", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
userSettings: {
|
|
...state.userSettings,
|
|
appStatusBarEnabled: false,
|
|
revision: 2,
|
|
},
|
|
}));
|
|
const handler = registerUsersHandlers(store)["user.settings.updated"];
|
|
|
|
handler?.(
|
|
userSettingsMessage({
|
|
app_status_bar_enabled: true,
|
|
revision: 1,
|
|
}),
|
|
);
|
|
expect(store.getState().userSettings).toMatchObject({
|
|
appStatusBarEnabled: false,
|
|
revision: 2,
|
|
});
|
|
|
|
handler?.(
|
|
userSettingsMessage({
|
|
app_status_bar_enabled: true,
|
|
revision: 3,
|
|
}),
|
|
);
|
|
expect(store.getState().userSettings).toMatchObject({
|
|
appStatusBarEnabled: true,
|
|
revision: 3,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("session hostname resolution websocket sync", () => {
|
|
it("updates the setting and preserves it when omitted", () => {
|
|
const store = makeStore();
|
|
const handler = registerUsersHandlers(store)["user.settings.updated"];
|
|
|
|
handler?.(
|
|
userSettingsMessage({
|
|
resolve_session_hostnames: true,
|
|
}),
|
|
);
|
|
expect(store.getState().userSettings.resolveSessionHostnames).toBe(true);
|
|
|
|
handler?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.resolveSessionHostnames).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("manual task-color websocket sync", () => {
|
|
it("applies the normalized server map, including clear tombstones", () => {
|
|
const store = makeStore();
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
revision: 1,
|
|
sidebar_task_colors: {
|
|
"task-red": "red",
|
|
"task-cleared": null,
|
|
},
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().userSettings.sidebarTaskColors).toEqual({
|
|
"task-red": "red",
|
|
"task-cleared": null,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("last seen display websocket sync", () => {
|
|
it("applies a relative value and normalizes unknown values", () => {
|
|
const store = makeStore();
|
|
expect(store.getState().userSettings.lastSeenDisplay).toBe("absolute");
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ last_seen_display: "relative" }),
|
|
);
|
|
expect(store.getState().userSettings.lastSeenDisplay).toBe("relative");
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
last_seen_display: "unexpected",
|
|
} as unknown as Partial<BackendMessageMap["user.settings.updated"]["payload"]>),
|
|
);
|
|
expect(store.getState().userSettings.lastSeenDisplay).toBe("absolute");
|
|
});
|
|
|
|
it("preserves the current value when omitted", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
userSettings: { ...state.userSettings, lastSeenDisplay: "relative" },
|
|
}));
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.lastSeenDisplay).toBe("relative");
|
|
});
|
|
|
|
it("ignores older settings revisions", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
userSettings: { ...state.userSettings, lastSeenDisplay: "absolute", revision: 2 },
|
|
}));
|
|
const handler = registerUsersHandlers(store)["user.settings.updated"];
|
|
handler?.(userSettingsMessage({ last_seen_display: "relative", revision: 1 }));
|
|
expect(store.getState().userSettings.lastSeenDisplay).toBe("absolute");
|
|
});
|
|
});
|
|
|
|
// eslint-disable-next-line max-lines-per-function -- The handler contract cases share one store fixture and revision setup.
|
|
describe("user settings websocket handler", () => {
|
|
it("hydrates Threads views independently from sidebar views", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
sidebarViews: {
|
|
...state.sidebarViews,
|
|
activeViewId: "view-all-tasks",
|
|
},
|
|
}));
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
thread_views: [
|
|
{
|
|
id: "thread-view",
|
|
name: "Thread view",
|
|
task_scope: { mode: "all", task_ids: [] },
|
|
filters: [],
|
|
sort: { key: "attention", direction: "asc" },
|
|
max_columns: 3,
|
|
},
|
|
],
|
|
thread_active_view_id: "thread-view",
|
|
thread_view_draft: null,
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().threadViews.activeViewId).toBe("thread-view");
|
|
expect(store.getState().threadViews.views).toHaveLength(1);
|
|
expect(store.getState().threadViews.draft).toBeNull();
|
|
expect(store.getState().sidebarViews.activeViewId).toBe("view-all-tasks");
|
|
});
|
|
|
|
it("does not replace optimistic Threads views while a local write is pending", () => {
|
|
const store = makeStore();
|
|
const draft = {
|
|
baseViewId: LOCAL_VIEW_ID,
|
|
taskScope: { mode: "all" as const, taskIds: [] as [] },
|
|
filters: [],
|
|
sort: { key: "attention" as const, direction: "asc" as const },
|
|
maxColumns: 1,
|
|
};
|
|
store.setState((state) => ({
|
|
...state,
|
|
threadViews: {
|
|
...state.threadViews,
|
|
views: [
|
|
{
|
|
id: LOCAL_VIEW_ID,
|
|
name: "Local",
|
|
taskScope: { mode: "all", taskIds: [] },
|
|
filters: [],
|
|
sort: { key: "attention", direction: "asc" },
|
|
maxColumns: null,
|
|
},
|
|
],
|
|
activeViewId: LOCAL_VIEW_ID,
|
|
draft,
|
|
syncPending: true,
|
|
},
|
|
}));
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
revision: 1,
|
|
thread_views: [
|
|
{
|
|
id: "view-server",
|
|
name: "Server",
|
|
task_scope: { mode: "all", task_ids: [] },
|
|
filters: [],
|
|
sort: { key: "attention", direction: "asc" },
|
|
max_columns: null,
|
|
},
|
|
],
|
|
thread_active_view_id: "view-server",
|
|
thread_view_draft: null,
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().threadViews).toMatchObject({
|
|
activeViewId: LOCAL_VIEW_ID,
|
|
draft,
|
|
syncPending: true,
|
|
});
|
|
expect(store.getState().threadViews.views[0].id).toBe(LOCAL_VIEW_ID);
|
|
});
|
|
|
|
it("updates LSP status location, normalizes unknown values, and preserves omissions", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ lsp_status_location: "status_bar" }),
|
|
);
|
|
expect(store.getState().userSettings.lspStatusLocation).toBe("status_bar");
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.lspStatusLocation).toBe("status_bar");
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
lsp_status_location: "sidebar",
|
|
} as unknown as Partial<BackendMessageMap["user.settings.updated"]["payload"]>),
|
|
);
|
|
expect(store.getState().userSettings.lspStatusLocation).toBe("toolbar");
|
|
});
|
|
|
|
it("updates the List detail preference and preserves it when omitted", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ tasks_list_show_details: true }),
|
|
);
|
|
expect(store.getState().userSettings.tasksListShowDetails).toBe(true);
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.tasksListShowDetails).toBe(true);
|
|
});
|
|
|
|
it("normalizes the simplified metrics preference from live updates", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
system_metrics_display: { show_in_topbar: true, simplified: true } as never,
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().userSettings.systemMetricsDisplay).toEqual({
|
|
showInTopbar: true,
|
|
simplified: true,
|
|
});
|
|
});
|
|
|
|
it("replaces portable status order when present and preserves it when omitted", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
app_status_bar_order: {
|
|
left_item_ids: ["builtin:metrics"],
|
|
right_item_ids: ["builtin:connection"],
|
|
},
|
|
}),
|
|
);
|
|
expect(store.getState().userSettings.appStatusBarOrder).toEqual({
|
|
leftItemIds: ["builtin:metrics"],
|
|
rightItemIds: ["builtin:connection"],
|
|
});
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.appStatusBarOrder).toEqual({
|
|
leftItemIds: ["builtin:metrics"],
|
|
rightItemIds: ["builtin:connection"],
|
|
});
|
|
});
|
|
|
|
it("applies valid MCP task profile preferences and normalizes unknown values", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
mcp_task_agent_profile_default: "workspace_default",
|
|
}),
|
|
);
|
|
expect(store.getState().userSettings.mcpTaskAgentProfileDefault).toBe("workspace_default");
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
mcp_task_agent_profile_default: "unexpected",
|
|
} as unknown as Partial<BackendMessageMap["user.settings.updated"]["payload"]>),
|
|
);
|
|
expect(store.getState().userSettings.mcpTaskAgentProfileDefault).toBe("current_task");
|
|
});
|
|
|
|
it("applies archive confirmation preferences and preserves them when omitted", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ confirm_task_archive: false }),
|
|
);
|
|
expect(store.getState().userSettings.confirmTaskArchive).toBe(false);
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.confirmTaskArchive).toBe(false);
|
|
});
|
|
|
|
it("syncs the agent-generated title preference", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ agent_generated_task_titles: true }),
|
|
);
|
|
expect(store.getState().userSettings.agentGeneratedTaskTitles).toBe(true);
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.agentGeneratedTaskTitles).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("user settings websocket transcript navigation", () => {
|
|
it("syncs transcript navigation preferences and uses the documented defaults", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
show_anchored_prompt_bar: false,
|
|
show_scroll_to_last_prompt: false,
|
|
show_scroll_to_start: false,
|
|
}),
|
|
);
|
|
expect(store.getState().userSettings).toMatchObject({
|
|
showAnchoredPromptBar: false,
|
|
showScrollToLastPrompt: false,
|
|
showScrollToStart: false,
|
|
});
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings).toMatchObject({
|
|
showAnchoredPromptBar: false,
|
|
showScrollToLastPrompt: false,
|
|
showScrollToStart: false,
|
|
showTranscriptAutoScrollControl: false,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("todo list panel websocket sync", () => {
|
|
it("syncs the todo list panel preference and preserves it when omitted", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ show_todo_list_panel: true }),
|
|
);
|
|
expect(store.getState().userSettings.showTodoListPanel).toBe(true);
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.showTodoListPanel).toBe(true);
|
|
});
|
|
|
|
it("syncs the not-empty sub-option and preserves it when omitted", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ show_todo_list_panel_only_when_not_empty: true }),
|
|
);
|
|
expect(store.getState().userSettings.showTodoListPanelOnlyWhenNotEmpty).toBe(true);
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
expect(store.getState().userSettings.showTodoListPanelOnlyWhenNotEmpty).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("user settings websocket partial updates", () => {
|
|
it("preserves normalized preferences omitted from a partial live update", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
unread_divider: true,
|
|
show_transcript_auto_scroll_control: true,
|
|
}),
|
|
);
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ preferred_shell: "zsh" }),
|
|
);
|
|
|
|
expect(store.getState().userSettings).toMatchObject({
|
|
unreadDivider: true,
|
|
showTranscriptAutoScrollControl: true,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("user settings websocket sidebar sync", () => {
|
|
it("preserves local collapsed groups when syncing sidebar views", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
sidebarViews: {
|
|
...state.sidebarViews,
|
|
activeViewId: "view-1",
|
|
views: [
|
|
{
|
|
id: "view-1",
|
|
name: "Local",
|
|
filters: [],
|
|
sort: { key: "state", direction: "asc" },
|
|
group: "state",
|
|
collapsedGroups: ["state:todo"],
|
|
},
|
|
],
|
|
},
|
|
}));
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
sidebar_views: [
|
|
{
|
|
id: "view-1",
|
|
name: "Remote",
|
|
filters: [],
|
|
sort: { key: "updatedAt", direction: "desc" },
|
|
group: "workflow",
|
|
collapsed_groups: [],
|
|
},
|
|
],
|
|
sidebar_active_view_id: "view-1",
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().sidebarViews.views[0]).toMatchObject({
|
|
id: "view-1",
|
|
name: "Remote",
|
|
collapsedGroups: ["state:todo"],
|
|
});
|
|
});
|
|
|
|
it("applies draft clears even when the broadcast has no sidebar views", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
sidebarViews: {
|
|
...state.sidebarViews,
|
|
draft: {
|
|
baseViewId: "view-1",
|
|
filters: [],
|
|
sort: { key: "state", direction: "asc" },
|
|
group: "state",
|
|
},
|
|
},
|
|
}));
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ sidebar_views: [], sidebar_draft: null }),
|
|
);
|
|
|
|
expect(store.getState().sidebarViews.draft).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("user settings websocket task-create last-used", () => {
|
|
it("does not mark empty task-create last-used broadcasts as synced", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ task_create_last_used: {} }),
|
|
);
|
|
|
|
expect(store.getState().userSettings.taskCreateLastUsed).toEqual({
|
|
repositoryId: null,
|
|
branch: null,
|
|
agentProfileId: null,
|
|
executorProfileId: null,
|
|
workflowIdsByWorkspace: {},
|
|
synced: false,
|
|
});
|
|
});
|
|
|
|
it("marks task-create last-used broadcasts as synced when a field is present", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ task_create_last_used: { repository_id: "repo-1" } }),
|
|
);
|
|
|
|
expect(store.getState().userSettings.taskCreateLastUsed).toMatchObject({
|
|
repositoryId: "repo-1",
|
|
synced: true,
|
|
});
|
|
});
|
|
|
|
it("maps workspace-scoped workflow history from broadcasts", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
task_create_last_used: {
|
|
workflow_ids_by_workspace: {
|
|
"workspace-1": "workflow-1",
|
|
},
|
|
},
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().userSettings.taskCreateLastUsed).toMatchObject({
|
|
workflowIdsByWorkspace: { "workspace-1": "workflow-1" },
|
|
synced: true,
|
|
});
|
|
});
|
|
|
|
it("preserves task-create last-used state when broadcasts omit it", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
userSettings: {
|
|
...state.userSettings,
|
|
taskCreateLastUsed: {
|
|
repositoryId: "repo-1",
|
|
branch: "main",
|
|
agentProfileId: "agent-1",
|
|
executorProfileId: "exec-1",
|
|
workflowIdsByWorkspace: {},
|
|
synced: true,
|
|
},
|
|
},
|
|
}));
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({ keyboard_shortcuts: {} }),
|
|
);
|
|
|
|
expect(store.getState().userSettings.taskCreateLastUsed).toEqual({
|
|
repositoryId: "repo-1",
|
|
branch: "main",
|
|
agentProfileId: "agent-1",
|
|
executorProfileId: "exec-1",
|
|
workflowIdsByWorkspace: {},
|
|
synced: true,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("user settings websocket sidebar draft migration", () => {
|
|
it("preserves an archived clause in a live draft", () => {
|
|
const store = makeStore();
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
sidebar_views: [],
|
|
sidebar_draft: {
|
|
base_view_id: "all",
|
|
filters: [{ id: "archived", dimension: "archived", op: "is", value: true }],
|
|
sort: { key: "state", direction: "asc" },
|
|
group: "none",
|
|
},
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().sidebarViews.draft?.filters).toEqual([
|
|
{ id: "archived", dimension: "archived", op: "is", value: true },
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("user settings websocket sidebar settings", () => {
|
|
it("preserves userSettings sidebar fields when payload omits them", () => {
|
|
const store = makeStore();
|
|
const sidebarView = {
|
|
id: "all",
|
|
name: "All",
|
|
filters: [],
|
|
sort: { key: "state" as const, direction: "asc" as const },
|
|
group: "state" as const,
|
|
collapsedGroups: [],
|
|
};
|
|
store.setState((state) => ({
|
|
...state,
|
|
userSettings: {
|
|
...state.userSettings,
|
|
sidebarViews: [sidebarView],
|
|
sidebarActiveViewId: "all",
|
|
sidebarDraft: {
|
|
baseViewId: "all",
|
|
filters: [],
|
|
sort: { key: "state", direction: "asc" },
|
|
group: "state",
|
|
},
|
|
sidebarTaskPrefs: {
|
|
pinnedTaskIds: ["task-1"],
|
|
orderedTaskIds: ["task-2"],
|
|
subtaskOrderByParentId: { parent: ["child"] },
|
|
},
|
|
},
|
|
}));
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(userSettingsMessage({}));
|
|
|
|
expect(store.getState().userSettings.sidebarActiveViewId).toBe("all");
|
|
expect(store.getState().userSettings.sidebarDraft).toMatchObject({ baseViewId: "all" });
|
|
expect(store.getState().userSettings.sidebarTaskPrefs).toEqual({
|
|
pinnedTaskIds: ["task-1"],
|
|
orderedTaskIds: ["task-2"],
|
|
subtaskOrderByParentId: { parent: ["child"] },
|
|
});
|
|
});
|
|
|
|
it("preserves pending local sidebar task prefs when server broadcasts stale prefs", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
sidebarTaskPrefs: {
|
|
pinnedTaskIds: ["local"],
|
|
orderedTaskIds: ["local"],
|
|
subtaskOrderByParentId: {},
|
|
syncPending: true,
|
|
},
|
|
}));
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
sidebar_task_prefs: {
|
|
pinned_task_ids: ["server"],
|
|
ordered_task_ids: ["server"],
|
|
subtask_order_by_parent_id: {},
|
|
},
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().sidebarTaskPrefs).toMatchObject({
|
|
pinnedTaskIds: ["local"],
|
|
orderedTaskIds: ["local"],
|
|
syncPending: true,
|
|
});
|
|
});
|
|
|
|
it("applies server sidebar task prefs after a failed sync is no longer pending", () => {
|
|
const store = makeStore();
|
|
store.setState((state) => ({
|
|
...state,
|
|
sidebarTaskPrefs: {
|
|
pinnedTaskIds: ["local"],
|
|
orderedTaskIds: ["local"],
|
|
subtaskOrderByParentId: {},
|
|
syncError: "Failed to sync",
|
|
syncPending: false,
|
|
},
|
|
}));
|
|
|
|
registerUsersHandlers(store)["user.settings.updated"]?.(
|
|
userSettingsMessage({
|
|
sidebar_task_prefs: {
|
|
pinned_task_ids: ["server"],
|
|
ordered_task_ids: ["server"],
|
|
subtask_order_by_parent_id: {},
|
|
},
|
|
}),
|
|
);
|
|
|
|
expect(store.getState().sidebarTaskPrefs).toMatchObject({
|
|
pinnedTaskIds: ["server"],
|
|
orderedTaskIds: ["server"],
|
|
syncError: "Failed to sync",
|
|
});
|
|
});
|
|
});
|