@cursor/july 0.1.20 → 0.1.22

package/src/channels/slack/defaults.final-post.test.ts

@@ -0,0 +1,182 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type {
+  ChannelEventContext,
+  ChannelEventHandlers,
+  SessionContext,
+  SessionEvent,
+} from "../../types.js";
+import type { SlackChannelState } from "./types.js";
+
+const mocks = vi.hoisted(() => ({
+  postMessage: vi.fn(),
+  updateMessage: vi.fn(),
+  setThreadStatus: vi.fn(),
+  startChatStream: vi.fn(),
+  appendChatStream: vi.fn(),
+  stopChatStream: vi.fn(),
+}));
+
+vi.mock("./api.js", () => ({
+  postMessage: mocks.postMessage,
+  updateMessage: mocks.updateMessage,
+  setThreadStatus: mocks.setThreadStatus,
+  startChatStream: mocks.startChatStream,
+  appendChatStream: mocks.appendChatStream,
+  stopChatStream: mocks.stopChatStream,
+  truncateTypingStatus: (text: string) => text.slice(0, 50),
+}));
+
+vi.mock("./assistant.js", () => ({
+  firstNonEmptyLine: (text: string) =>
+    text
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0),
+  maybeSetSuggestedPrompts: vi.fn(),
+}));
+
+import { buildDefaultEvents } from "./defaults.js";
+
+let eventIndex = 0;
+
+function evt<T extends SessionEvent["type"]>(
+  partial: Omit<Extract<SessionEvent, { type: T }>, "index" | "at"> &
+    Partial<Pick<SessionEvent, "index" | "at">>
+): Extract<SessionEvent, { type: T }> {
+  return {
+    index: eventIndex++,
+    at: new Date().toISOString(),
+    ...partial,
+  } as Extract<SessionEvent, { type: T }>;
+}
+
+function channelOf(
+  state: SlackChannelState
+): ChannelEventContext<SlackChannelState> {
+  return {
+    channelId: "slack",
+    state,
+    continuationToken: null,
+    setContinuationToken: async () => {},
+  };
+}
+
+const sessionCtx: SessionContext = {
+  session: {
+    id: "s1",
+    channelId: "slack",
+    mode: "chat",
+    auth: null,
+  },
+};
+
+describe("buildDefaultEvents streaming:false (cursorAccount)", () => {
+  let handlers: ChannelEventHandlers<SlackChannelState>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    eventIndex = 0;
+    mocks.postMessage.mockResolvedValue({ ts: "9.9" });
+    mocks.setThreadStatus.mockResolvedValue(undefined);
+    handlers = buildDefaultEvents({ streaming: false });
+  });
+
+  it("uses setStatus for thinking and a single final postMessage", async () => {
+    const channel = channelOf({
+      channelId: "C1",
+      threadTs: "1.0",
+      teamId: "T1",
+      triggeringUserId: "U1",
+      pendingToolCallMessage: null,
+      lastReasoningTypingAtMs: null,
+      lastReasoningTypingStatus: null,
+      streamTs: null,
+      streamChannelId: null,
+      lastPostedText: null,
+    });
+
+    await handlers["turn.started"]!(
+      evt({
+        type: "turn.started",
+        sessionId: "s1",
+        turnId: "t1",
+        data: {},
+      }),
+      channel,
+      sessionCtx
+    );
+    expect(mocks.startChatStream).not.toHaveBeenCalled();
+    expect(mocks.postMessage).not.toHaveBeenCalled();
+    expect(mocks.setThreadStatus).toHaveBeenCalledWith(
+      expect.objectContaining({ status: "Working…" })
+    );
+
+    await handlers["actions.requested"]!(
+      evt({
+        type: "actions.requested",
+        sessionId: "s1",
+        turnId: "t1",
+        data: {
+          calls: [{ callId: "c1", toolName: "get_weather", args: {} }],
+        },
+      }),
+      channel,
+      sessionCtx
+    );
+    expect(mocks.updateMessage).not.toHaveBeenCalled();
+    expect(mocks.setThreadStatus).toHaveBeenCalledWith(
+      expect.objectContaining({ status: "Running get_weather…" })
+    );
+
+    await handlers["message.completed"]!(
+      evt({
+        type: "message.completed",
+        sessionId: "s1",
+        turnId: "t1",
+        data: { text: "Sunny in SF", finishReason: "stop" },
+      }),
+      channel,
+      sessionCtx
+    );
+    expect(mocks.updateMessage).not.toHaveBeenCalled();
+    expect(mocks.postMessage).toHaveBeenCalledTimes(1);
+    expect(mocks.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({ text: "Sunny in SF" })
+    );
+  });
+
+  it("posts the scrubbed turn.failed reason into the thread", async () => {
+    const channel = channelOf({
+      channelId: "C1",
+      threadTs: "1.0",
+      teamId: "T1",
+      triggeringUserId: "U1",
+      pendingToolCallMessage: null,
+      lastReasoningTypingAtMs: null,
+      lastReasoningTypingStatus: null,
+      streamTs: null,
+      streamChannelId: null,
+      lastPostedText: null,
+    });
+
+    await handlers["turn.failed"]!(
+      evt({
+        type: "turn.failed",
+        sessionId: "s1",
+        turnId: "t1",
+        data: {
+          message: String.raw`Authentication error at C:\Users\alice\secret and /home/ubuntu/secret`,
+        },
+      }),
+      channel,
+      sessionCtx
+    );
+
+    expect(mocks.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        text: "I hit an error while handling your request: Authentication error at [path] and [path]",
+        threadTs: "1.0",
+      })
+    );
+  });
+});