Dotta
d4c3899ca4
## Thinking Path > - Paperclip orchestrates AI agents for zero-human companies > - Operators rely on issue, inbox, and routine views to understand what the company is doing in real time > - Those views need to stay fast and readable even when issue lists, markdown comments, and run metadata get large > - The current branch had a coherent set of UI and live-update improvements spread across issue search, issue detail rendering, routine affordances, and workspace lookups > - This pull request groups those board-facing changes into one standalone branch that can merge independently of the heartbeat/runtime work > - The benefit is a faster, clearer issue and routine workflow without changing the underlying task model ## What Changed - Show routine execution issues by default and rename the filter to `Hide routine runs` so the default state no longer looks like an active filter. - Show the routine name in the run dialog and tighten the issue properties pane with a workspace link, copy-on-click behavior, and an inline parent arrow. - Reduce issue detail rerenders, keep queued issue chat mounted, improve issues page search responsiveness, and speed up issues first paint. - Add inbox "other search results", refresh visible issue runs after status updates, and optimize workspace lookups through summary-mode execution workspace queries. - Improve markdown wrapping and scrolling behavior for long strings and self-comment code blocks. - Relax the markdown sanitizer assertion so the test still validates safety after the new wrap-friendly inline styles. ## Verification - `pnpm vitest run ui/src/components/IssuesList.test.tsx ui/src/lib/inbox.test.ts ui/src/pages/Issues.test.tsx ui/src/context/BreadcrumbContext.test.tsx ui/src/context/LiveUpdatesProvider.test.ts ui/src/components/MarkdownBody.test.tsx ui/src/api/execution-workspaces.test.ts server/src/__tests__/execution-workspaces-routes.test.ts` ## Risks - This touches several issue-facing UI surfaces at once, so regressions would most likely show up as stale rendering, search result mismatches, or small markdown presentation differences. - The workspace lookup optimization depends on the summary-mode route shape staying aligned between server and UI. ## Model Used - OpenAI Codex, GPT-5-based coding agent in the Codex CLI environment. Exact backend model deployment ID was not exposed in-session. Tool-assisted editing and shell execution were used. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [ ] If this change affects the UI, I have included before/after screenshots - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [x] I will address all Greptile and reviewer comments before requesting merge --------- Co-authored-by: Paperclip <noreply@paperclip.ing>
725 lines
21 KiB
TypeScript
725 lines
21 KiB
TypeScript
// @vitest-environment node
|
|
|
|
const { getCommentMock } = vi.hoisted(() => ({
|
|
getCommentMock: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("../api/issues", () => ({
|
|
issuesApi: {
|
|
getComment: getCommentMock,
|
|
},
|
|
}));
|
|
|
|
import { describe, expect, it, vi } from "vitest";
|
|
import { __liveUpdatesTestUtils } from "./LiveUpdatesProvider";
|
|
import { queryKeys } from "../lib/queryKeys";
|
|
|
|
describe("LiveUpdatesProvider issue invalidation", () => {
|
|
it("refreshes touched inbox queries and only the changed issue data for issue updates", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: () => undefined,
|
|
};
|
|
|
|
__liveUpdatesTestUtils.invalidateActivityQueries(
|
|
queryClient as never,
|
|
"company-1",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
action: "issue.updated",
|
|
details: null,
|
|
},
|
|
{ userId: null, agentId: null },
|
|
);
|
|
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.listMineByMe("company-1"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.listTouchedByMe("company-1"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.listUnreadTouchedByMe("company-1"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.detail("issue-1"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.activity("issue-1"),
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.comments("issue-1"),
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.runs("issue-1"),
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.documents("issue-1"),
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.attachments("issue-1"),
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.approvals("issue-1"),
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.liveRuns("issue-1"),
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.activeRun("issue-1"),
|
|
});
|
|
});
|
|
|
|
it("still refreshes comments when a comment activity event arrives", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: () => undefined,
|
|
};
|
|
|
|
__liveUpdatesTestUtils.invalidateActivityQueries(
|
|
queryClient as never,
|
|
"company-1",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
action: "issue.comment_added",
|
|
details: null,
|
|
},
|
|
{ userId: null, agentId: null },
|
|
);
|
|
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.comments("issue-1"),
|
|
});
|
|
});
|
|
|
|
it("keeps self-authored comment events from refetching the active issue tree", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: () => undefined,
|
|
};
|
|
|
|
__liveUpdatesTestUtils.invalidateActivityQueries(
|
|
queryClient as never,
|
|
"company-1",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
action: "issue.comment_added",
|
|
actorType: "user",
|
|
actorId: "user-1",
|
|
details: null,
|
|
},
|
|
{ userId: "user-1", agentId: null },
|
|
);
|
|
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.detail("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.activity("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.comments("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
});
|
|
|
|
it("treats self-authored comment-driven issue updates as inactive-only refreshes", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: () => undefined,
|
|
};
|
|
|
|
__liveUpdatesTestUtils.invalidateActivityQueries(
|
|
queryClient as never,
|
|
"company-1",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
action: "issue.updated",
|
|
actorType: "user",
|
|
actorId: "user-1",
|
|
details: { source: "comment" },
|
|
},
|
|
{ userId: "user-1", agentId: null },
|
|
);
|
|
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.detail("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.activity("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.comments("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
});
|
|
|
|
it("keeps visible issue detail refetches inactive for downstream agent updates", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: (key: unknown) => {
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
|
|
return {
|
|
id: "issue-1",
|
|
identifier: "PAP-759",
|
|
assigneeAgentId: "agent-1",
|
|
};
|
|
}
|
|
return undefined;
|
|
},
|
|
};
|
|
|
|
__liveUpdatesTestUtils.invalidateActivityQueries(
|
|
queryClient as never,
|
|
"company-1",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
action: "issue.updated",
|
|
actorType: "system",
|
|
actorId: "heartbeat",
|
|
details: {
|
|
identifier: "PAP-759",
|
|
source: "deferred_comment_wake",
|
|
},
|
|
},
|
|
{ userId: null, agentId: null },
|
|
{ pathname: "/PAP/issues/PAP-759", isForegrounded: true },
|
|
);
|
|
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.detail("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.activity("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
});
|
|
|
|
it("still actively refetches visible issue detail for board-authored updates", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: (key: unknown) => {
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
|
|
return {
|
|
id: "issue-1",
|
|
identifier: "PAP-759",
|
|
assigneeAgentId: "agent-1",
|
|
};
|
|
}
|
|
return undefined;
|
|
},
|
|
};
|
|
|
|
__liveUpdatesTestUtils.invalidateActivityQueries(
|
|
queryClient as never,
|
|
"company-1",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
action: "issue.updated",
|
|
actorType: "user",
|
|
actorId: "user-2",
|
|
details: {
|
|
identifier: "PAP-759",
|
|
status: "in_progress",
|
|
},
|
|
},
|
|
{ userId: "user-1", agentId: null },
|
|
{ pathname: "/PAP/issues/PAP-759", isForegrounded: true },
|
|
);
|
|
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.detail("issue-1"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.activity("issue-1"),
|
|
});
|
|
expect(invalidations).not.toContainEqual({
|
|
queryKey: queryKeys.issues.detail("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
});
|
|
|
|
it("keeps visible issue comment updates inactive-only instead of active refetching", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: (key: unknown) => {
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
|
|
return {
|
|
id: "issue-1",
|
|
identifier: "PAP-759",
|
|
assigneeAgentId: "agent-1",
|
|
};
|
|
}
|
|
return undefined;
|
|
},
|
|
};
|
|
|
|
__liveUpdatesTestUtils.invalidateActivityQueries(
|
|
queryClient as never,
|
|
"company-1",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
action: "issue.comment_added",
|
|
actorType: "agent",
|
|
actorId: "agent-1",
|
|
details: {
|
|
identifier: "PAP-759",
|
|
commentId: "comment-1",
|
|
bodySnippet: "New agent comment",
|
|
},
|
|
},
|
|
{ userId: null, agentId: null },
|
|
{ pathname: "/PAP/issues/PAP-759", isForegrounded: true },
|
|
);
|
|
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.detail("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.activity("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.comments("issue-1"),
|
|
refetchType: "inactive",
|
|
});
|
|
});
|
|
|
|
it("refreshes visible issue run queries when the displayed run changes status", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: (key: unknown) => {
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
|
|
return {
|
|
id: "issue-1",
|
|
identifier: "PAP-759",
|
|
assigneeAgentId: "agent-1",
|
|
};
|
|
}
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.activeRun("PAP-759"))) {
|
|
return {
|
|
id: "run-1",
|
|
};
|
|
}
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.liveRuns("PAP-759"))) {
|
|
return [{ id: "run-1" }];
|
|
}
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.runs("PAP-759"))) {
|
|
return [{ runId: "run-1" }];
|
|
}
|
|
return undefined;
|
|
},
|
|
};
|
|
|
|
const invalidated = __liveUpdatesTestUtils.invalidateVisibleIssueRunQueries(
|
|
queryClient as never,
|
|
"/PAP/issues/PAP-759",
|
|
{
|
|
runId: "run-1",
|
|
agentId: "agent-1",
|
|
status: "succeeded",
|
|
},
|
|
{ isForegrounded: true },
|
|
);
|
|
|
|
expect(invalidated).toBe(true);
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.detail("PAP-759"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.activity("PAP-759"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.runs("PAP-759"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.liveRuns("PAP-759"),
|
|
});
|
|
expect(invalidations).toContainEqual({
|
|
queryKey: queryKeys.issues.activeRun("PAP-759"),
|
|
});
|
|
});
|
|
|
|
it("ignores run status events for other issues", () => {
|
|
const invalidations: unknown[] = [];
|
|
const queryClient = {
|
|
invalidateQueries: (input: unknown) => {
|
|
invalidations.push(input);
|
|
},
|
|
getQueryData: (key: unknown) => {
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
|
|
return {
|
|
id: "issue-1",
|
|
identifier: "PAP-759",
|
|
assigneeAgentId: "agent-1",
|
|
};
|
|
}
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.activeRun("PAP-759"))) {
|
|
return {
|
|
id: "run-1",
|
|
};
|
|
}
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.liveRuns("PAP-759"))) {
|
|
return [{ id: "run-1" }];
|
|
}
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.runs("PAP-759"))) {
|
|
return [{ runId: "run-1" }];
|
|
}
|
|
return undefined;
|
|
},
|
|
};
|
|
|
|
const invalidated = __liveUpdatesTestUtils.invalidateVisibleIssueRunQueries(
|
|
queryClient as never,
|
|
"/PAP/issues/PAP-759",
|
|
{
|
|
runId: "run-2",
|
|
agentId: "agent-2",
|
|
status: "succeeded",
|
|
},
|
|
{ isForegrounded: true },
|
|
);
|
|
|
|
expect(invalidated).toBe(false);
|
|
expect(invalidations).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("LiveUpdatesProvider visible issue comment hydration", () => {
|
|
it("hydrates the visible issue comments cache with only the new comment", async () => {
|
|
getCommentMock.mockResolvedValueOnce({
|
|
id: "comment-2",
|
|
companyId: "company-1",
|
|
issueId: "issue-1",
|
|
authorAgentId: "agent-1",
|
|
authorUserId: null,
|
|
body: "Second comment",
|
|
createdAt: "2026-04-13T15:00:00.000Z",
|
|
updatedAt: "2026-04-13T15:00:00.000Z",
|
|
});
|
|
|
|
const setCalls: Array<{ key: unknown; value: unknown }> = [];
|
|
const queryClient = {
|
|
getQueryData: (key: unknown) => {
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
|
|
return {
|
|
id: "issue-1",
|
|
identifier: "PAP-759",
|
|
assigneeAgentId: "agent-1",
|
|
};
|
|
}
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.comments("PAP-759"))) {
|
|
return {
|
|
pages: [[{
|
|
id: "comment-1",
|
|
companyId: "company-1",
|
|
issueId: "issue-1",
|
|
authorAgentId: null,
|
|
authorUserId: "user-1",
|
|
body: "First comment",
|
|
createdAt: "2026-04-13T14:00:00.000Z",
|
|
updatedAt: "2026-04-13T14:00:00.000Z",
|
|
}]],
|
|
pageParams: [null],
|
|
};
|
|
}
|
|
return undefined;
|
|
},
|
|
setQueryData: (key: unknown, updater: (value: unknown) => unknown) => {
|
|
const current = queryClient.getQueryData(key);
|
|
setCalls.push({ key, value: updater(current) });
|
|
},
|
|
invalidateQueries: vi.fn(),
|
|
};
|
|
|
|
await __liveUpdatesTestUtils.hydrateVisibleIssueComment(
|
|
queryClient as never,
|
|
"/PAP/issues/PAP-759",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
action: "issue.comment_added",
|
|
details: {
|
|
identifier: "PAP-759",
|
|
commentId: "comment-2",
|
|
},
|
|
},
|
|
{ isForegrounded: true },
|
|
);
|
|
|
|
expect(getCommentMock).toHaveBeenCalledWith("PAP-759", "comment-2");
|
|
expect(setCalls).toHaveLength(1);
|
|
expect(setCalls[0]?.key).toEqual(queryKeys.issues.comments("PAP-759"));
|
|
expect(setCalls[0]?.value).toEqual({
|
|
pages: [[
|
|
{
|
|
id: "comment-2",
|
|
companyId: "company-1",
|
|
issueId: "issue-1",
|
|
authorAgentId: "agent-1",
|
|
authorUserId: null,
|
|
body: "Second comment",
|
|
createdAt: "2026-04-13T15:00:00.000Z",
|
|
updatedAt: "2026-04-13T15:00:00.000Z",
|
|
},
|
|
{
|
|
id: "comment-1",
|
|
companyId: "company-1",
|
|
issueId: "issue-1",
|
|
authorAgentId: null,
|
|
authorUserId: "user-1",
|
|
body: "First comment",
|
|
createdAt: "2026-04-13T14:00:00.000Z",
|
|
updatedAt: "2026-04-13T14:00:00.000Z",
|
|
},
|
|
]],
|
|
pageParams: [null],
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("LiveUpdatesProvider visible issue toast suppression", () => {
|
|
it("suppresses activity toasts for the issue page currently in view", () => {
|
|
const queryClient = {
|
|
getQueryData: (key: unknown) => {
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
|
|
return {
|
|
id: "issue-1",
|
|
identifier: "PAP-759",
|
|
assigneeAgentId: "agent-1",
|
|
};
|
|
}
|
|
return undefined;
|
|
},
|
|
};
|
|
|
|
expect(
|
|
__liveUpdatesTestUtils.shouldSuppressActivityToastForVisibleIssue(
|
|
queryClient as never,
|
|
"/PAP/issues/PAP-759",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-1",
|
|
details: { identifier: "PAP-759" },
|
|
},
|
|
{ isForegrounded: true },
|
|
),
|
|
).toBe(true);
|
|
|
|
expect(
|
|
__liveUpdatesTestUtils.shouldSuppressActivityToastForVisibleIssue(
|
|
queryClient as never,
|
|
"/PAP/issues/PAP-759",
|
|
{
|
|
entityType: "issue",
|
|
entityId: "issue-2",
|
|
details: { identifier: "PAP-760" },
|
|
},
|
|
{ isForegrounded: true },
|
|
),
|
|
).toBe(false);
|
|
});
|
|
|
|
it("suppresses run and agent status toasts for the assignee of the visible issue", () => {
|
|
const queryClient = {
|
|
getQueryData: (key: unknown) => {
|
|
if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
|
|
return {
|
|
id: "issue-1",
|
|
identifier: "PAP-759",
|
|
assigneeAgentId: "agent-1",
|
|
};
|
|
}
|
|
return undefined;
|
|
},
|
|
};
|
|
|
|
expect(
|
|
__liveUpdatesTestUtils.shouldSuppressRunStatusToastForVisibleIssue(
|
|
queryClient as never,
|
|
"/PAP/issues/PAP-759",
|
|
{
|
|
runId: "run-1",
|
|
agentId: "agent-1",
|
|
},
|
|
{ isForegrounded: true },
|
|
),
|
|
).toBe(true);
|
|
|
|
expect(
|
|
__liveUpdatesTestUtils.shouldSuppressAgentStatusToastForVisibleIssue(
|
|
queryClient as never,
|
|
"/PAP/issues/PAP-759",
|
|
{
|
|
agentId: "agent-1",
|
|
status: "running",
|
|
},
|
|
{ isForegrounded: true },
|
|
),
|
|
).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("LiveUpdatesProvider run lifecycle toasts", () => {
|
|
it("does not build start or success toasts for agent runs", () => {
|
|
const queryClient = {
|
|
getQueryData: () => [],
|
|
};
|
|
|
|
expect(
|
|
__liveUpdatesTestUtils.buildAgentStatusToast(
|
|
{
|
|
agentId: "agent-1",
|
|
status: "running",
|
|
},
|
|
() => "CodexCoder",
|
|
queryClient as never,
|
|
"company-1",
|
|
),
|
|
).toBeNull();
|
|
|
|
expect(
|
|
__liveUpdatesTestUtils.buildRunStatusToast(
|
|
{
|
|
runId: "run-1",
|
|
agentId: "agent-1",
|
|
status: "succeeded",
|
|
},
|
|
() => "CodexCoder",
|
|
),
|
|
).toBeNull();
|
|
});
|
|
|
|
it("still builds failure toasts for agent errors and failed runs", () => {
|
|
const queryClient = {
|
|
getQueryData: () => [
|
|
{
|
|
id: "agent-1",
|
|
title: "Software Engineer",
|
|
},
|
|
],
|
|
};
|
|
|
|
expect(
|
|
__liveUpdatesTestUtils.buildAgentStatusToast(
|
|
{
|
|
agentId: "agent-1",
|
|
status: "error",
|
|
},
|
|
() => "CodexCoder",
|
|
queryClient as never,
|
|
"company-1",
|
|
),
|
|
).toMatchObject({
|
|
title: "CodexCoder errored",
|
|
body: "Software Engineer",
|
|
tone: "error",
|
|
});
|
|
|
|
expect(
|
|
__liveUpdatesTestUtils.buildRunStatusToast(
|
|
{
|
|
runId: "run-1",
|
|
agentId: "agent-1",
|
|
status: "failed",
|
|
error: "boom",
|
|
},
|
|
() => "CodexCoder",
|
|
),
|
|
).toMatchObject({
|
|
title: "CodexCoder run failed",
|
|
body: "boom",
|
|
tone: "error",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("LiveUpdatesProvider socket helpers", () => {
|
|
it("waits for the selected company object to catch up before connecting", () => {
|
|
expect(__liveUpdatesTestUtils.resolveLiveCompanyId("company-1", null)).toBeNull();
|
|
expect(__liveUpdatesTestUtils.resolveLiveCompanyId("company-1", "company-2")).toBeNull();
|
|
expect(__liveUpdatesTestUtils.resolveLiveCompanyId("company-1", "company-1")).toBe("company-1");
|
|
});
|
|
|
|
it("defers close until onopen for sockets that are still connecting", () => {
|
|
const socket = {
|
|
readyState: 0,
|
|
onopen: (() => undefined) as (() => void) | null,
|
|
onmessage: (() => undefined) as (() => void) | null,
|
|
onerror: (() => undefined) as (() => void) | null,
|
|
onclose: (() => undefined) as (() => void) | null,
|
|
close: vi.fn(),
|
|
};
|
|
|
|
__liveUpdatesTestUtils.closeSocketQuietly(socket as never, "provider_unmount");
|
|
|
|
expect(socket.close).not.toHaveBeenCalled();
|
|
expect(socket.onmessage).toBeNull();
|
|
expect(socket.onclose).toBeNull();
|
|
expect(socket.onopen).toBeTypeOf("function");
|
|
expect(socket.onerror).toBeTypeOf("function");
|
|
|
|
socket.onopen?.();
|
|
|
|
expect(socket.close).toHaveBeenCalledWith(1000, "provider_unmount");
|
|
expect(socket.onopen).toBeNull();
|
|
expect(socket.onerror).toBeNull();
|
|
});
|
|
|
|
it("closes open sockets immediately without leaving handlers behind", () => {
|
|
const socket = {
|
|
readyState: 1,
|
|
onopen: (() => undefined) as (() => void) | null,
|
|
onmessage: (() => undefined) as (() => void) | null,
|
|
onerror: (() => undefined) as (() => void) | null,
|
|
onclose: (() => undefined) as (() => void) | null,
|
|
close: vi.fn(),
|
|
};
|
|
|
|
__liveUpdatesTestUtils.closeSocketQuietly(socket as never, "stale_connection");
|
|
|
|
expect(socket.close).toHaveBeenCalledWith(1000, "stale_connection");
|
|
expect(socket.onopen).toBeNull();
|
|
expect(socket.onmessage).toBeNull();
|
|
expect(socket.onerror).toBeNull();
|
|
expect(socket.onclose).toBeNull();
|
|
});
|
|
});
|