@cursor/july 0.1.26 → 0.1.28

package/src/channels/slack/block-actions.test.ts

@@ -1,469 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type {
-  ArtifactsApi,
-  ChannelSession,
-  SendMessageFn,
-} from "../../types.js";
-import { blockActionAuth } from "./auth.js";
-import {
-  mrkdwnSections,
-  SLACK_SECTION_MRKDWN_MAX,
-  SLACK_TABLE_MAX_COLUMNS,
-  SLACK_TABLE_MAX_ROWS,
-  slackLinkCell,
-  slackRawTextCell,
-  slackTableBlock,
-} from "./blocks.js";
-import { createSlackLogger } from "./index.js";
-import {
-  dispatchBlockAction,
-  parseSlackBlockAction,
-  resolveBlockActionCard,
-} from "./interactive.js";
-import type { SlackBlockAction } from "./types.js";
-
-const testAuth = {
-  authenticator: "slack",
-  principalId: "slack:T1:C9:5.0",
-  principalType: "user" as const,
-  attributes: { channel_id: "C9", thread_ts: "5.0", user_id: "U7" },
-};
-
-function mockSession(id = "ses_click"): ChannelSession {
-  return {
-    id,
-    continuationToken: null,
-    isNew: true,
-    info: {
-      id,
-      channelId: "slack",
-      mode: "chat",
-      auth: testAuth,
-    },
-    getEventStream: async () => new ReadableStream(),
-    waitForCompletion: async () => ({ status: "finished" }),
-    setContinuationToken: async () => undefined,
-  };
-}
-
-function createSendRecorder(): {
-  send: SendMessageFn;
-  calls: Array<{ message: string; options: Parameters<SendMessageFn>[1] }>;
-} {
-  const calls: Array<{
-    message: string;
-    options: Parameters<SendMessageFn>[1];
-  }> = [];
-  const send: SendMessageFn = async (message, sendOptions) => {
-    calls.push({ message, options: sendOptions });
-    return mockSession();
-  };
-  return { send, calls };
-}
-
-function testArtifacts(): ArtifactsApi {
-  return {
-    tag: async () => {
-      throw new Error("artifacts not configured in test");
-    },
-    list: async () => [],
-  };
-}
-
-function testHost() {
-  return {
-    mcp: {
-      names: () => [] as string[],
-      listTools: async () => [],
-      callTool: async () => ({ content: [] }),
-    },
-    github: {
-      getOctokit: async () => {
-        throw new Error("github client not configured in test");
-      },
-    },
-    slack: {
-      getClient: async () => {
-        throw new Error("slack client not configured in test");
-      },
-    },
-    kv: {
-      get: async () => undefined,
-      put: async () => {},
-      delete: async () => {},
-    },
-  };
-}
-
-function blockActionsPayload(
-  overrides: { actionId?: string; value?: string; threadTs?: string } = {}
-): Record<string, unknown> {
-  return {
-    type: "block_actions",
-    team: { id: "T1", domain: "acme" },
-    user: { id: "U7", username: "netto", team_id: "T1" },
-    channel: { id: "C9", name: "deploys" },
-    container: { type: "message", message_ts: "5.0", channel_id: "C9" },
-    message: {
-      ts: "5.0",
-      text: "the ask",
-      ...(overrides.threadTs === undefined
-        ? {}
-        : { thread_ts: overrides.threadTs }),
-      blocks: [{ type: "section" }, { type: "actions", block_id: "b1" }],
-    },
-    actions: [
-      {
-        type: "button",
-        action_id: overrides.actionId ?? "my_button",
-        block_id: "b1",
-        value: overrides.value ?? '{"pr":"https://example.test/pr/1"}',
-        text: { type: "plain_text", text: "Deploy" },
-        action_ts: "6.123456",
-      },
-    ],
-  };
-}
-
-describe("parseSlackBlockAction", () => {
-  it("parses a button click with label, clicker, and message blocks", () => {
-    const action = parseSlackBlockAction(blockActionsPayload());
-    expect(action).toMatchObject({
-      actionId: "my_button",
-      blockId: "b1",
-      value: '{"pr":"https://example.test/pr/1"}',
-      label: "Deploy",
-      channelId: "C9",
-      // Top-level message: the click stays in that message's thread.
-      threadTs: "5.0",
-      messageTs: "5.0",
-      userId: "U7",
-      userName: "netto",
-      teamId: "T1",
-      actionTs: "6.123456",
-    });
-    expect(action?.messageBlocks).toHaveLength(2);
-  });
-
-  it("prefers the message thread_ts for replies", () => {
-    const action = parseSlackBlockAction(
-      blockActionsPayload({ threadTs: "1.0" })
-    );
-    expect(action?.threadTs).toBe("1.0");
-    expect(action?.messageTs).toBe("5.0");
-  });
-
-  it("defaults a missing button value to the empty string", () => {
-    const payload = blockActionsPayload();
-    delete (
-      (payload.actions as Array<Record<string, unknown>>)[0] as Record<
-        string,
-        unknown
-      >
-    ).value;
-    expect(parseSlackBlockAction(payload)?.value).toBe("");
-  });
-
-  it("returns null for non-block_actions payloads", () => {
-    expect(parseSlackBlockAction({ type: "view_submission" })).toBeNull();
-    expect(parseSlackBlockAction(null)).toBeNull();
-    expect(
-      parseSlackBlockAction({ type: "block_actions", actions: [] })
-    ).toBeNull();
-  });
-});
-
-describe("dispatchBlockAction", () => {
-  it("dispatches the handler decision on the click's thread", async () => {
-    const { send, calls } = createSendRecorder();
-    const seen: SlackBlockAction[] = [];
-    const handled = await dispatchBlockAction(blockActionsPayload(), {
-      handler: (_ctx, action) => {
-        seen.push(action);
-        return { auth: testAuth, message: "U7 clicked Deploy — ship it." };
-      },
-      send,
-      credentials: undefined,
-      artifacts: testArtifacts(),
-      host: testHost(),
-      log: createSlackLogger(() => undefined),
-    });
-    expect(handled).toBe(true);
-    expect(seen).toHaveLength(1);
-    expect(seen[0]?.actionId).toBe("my_button");
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.options?.continuationToken).toBe("C9:5.0");
-    expect(calls[0]?.message).toContain("<slack_context>");
-    expect(calls[0]?.message).toContain("U7 clicked Deploy — ship it.");
-    const state = calls[0]?.options?.state as {
-      channelId?: string;
-      threadTs?: string;
-      triggeringUserId?: string;
-    };
-    expect(state.channelId).toBe("C9");
-    expect(state.threadTs).toBe("5.0");
-    expect(state.triggeringUserId).toBe("U7");
-  });
-
-  it("skips clicks without an action_ts (would alias dedupe keys)", async () => {
-    const { send, calls } = createSendRecorder();
-    const payload = blockActionsPayload();
-    delete (
-      (payload.actions as Array<Record<string, unknown>>)[0] as Record<
-        string,
-        unknown
-      >
-    ).action_ts;
-    const handled = await dispatchBlockAction(payload, {
-      handler: () => ({ auth: testAuth }),
-      send,
-      credentials: undefined,
-      artifacts: testArtifacts(),
-      host: testHost(),
-      log: createSlackLogger(() => undefined),
-    });
-    expect(handled).toBe(true);
-    expect(calls).toHaveLength(0);
-  });
-
-  it("skips dispatch when the handler returns null", async () => {
-    const { send, calls } = createSendRecorder();
-    const handled = await dispatchBlockAction(blockActionsPayload(), {
-      handler: () => null,
-      send,
-      credentials: undefined,
-      artifacts: testArtifacts(),
-      host: testHost(),
-      log: createSlackLogger(() => undefined),
-    });
-    expect(handled).toBe(true);
-    expect(calls).toHaveLength(0);
-  });
-
-  it("returns false for payloads that are not block actions", async () => {
-    const { send, calls } = createSendRecorder();
-    const handled = await dispatchBlockAction(
-      { type: "view_submission" },
-      {
-        handler: () => ({ auth: testAuth }),
-        send,
-        credentials: undefined,
-        artifacts: testArtifacts(),
-        host: testHost(),
-        log: createSlackLogger(() => undefined),
-      }
-    );
-    expect(handled).toBe(false);
-    expect(calls).toHaveLength(0);
-  });
-});
-
-describe("resolveBlockActionCard", () => {
-  function parsedAction(): SlackBlockAction {
-    const action = parseSlackBlockAction(blockActionsPayload());
-    if (action === null) {
-      throw new Error("fixture must parse");
-    }
-    return action;
-  }
-
-  it("swaps only the clicked actions row for the note", async () => {
-    const calls: Array<{ method: string; args: Record<string, unknown> }> = [];
-    const action = parsedAction();
-    action.messageBlocks = [
-      ...(action.messageBlocks ?? []),
-      { type: "actions", block_id: "someone_elses_row" },
-    ];
-    const ok = await resolveBlockActionCard({
-      botToken: {
-        kind: "api-transport",
-        label: "test",
-        async call(method: string, args: Record<string, unknown>) {
-          calls.push({ method, args });
-          return { ok: true };
-        },
-      },
-      action,
-      note: "resolved by <@U7>",
-    });
-    expect(ok).toBe(true);
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.method).toBe("chat.update");
-    expect(calls[0]?.args.ts).toBe("5.0");
-    const updated = JSON.stringify(calls[0]?.args.blocks);
-    expect(updated).not.toContain('"block_id":"b1"');
-    expect(updated).toContain("someone_elses_row");
-    expect(updated).toContain("resolved by <@U7>");
-  });
-
-  it("returns false when the payload carried no message blocks", async () => {
-    const action = parsedAction();
-    action.messageBlocks = undefined;
-    const ok = await resolveBlockActionCard({
-      botToken: {
-        kind: "api-transport",
-        label: "test",
-        async call() {
-          throw new Error("must not call Slack");
-        },
-      },
-      action,
-      note: "resolved",
-    });
-    expect(ok).toBe(false);
-  });
-});
-
-describe("blockActionAuth", () => {
-  it("builds the click's thread-scoped principal with the clicker", () => {
-    const action = parseSlackBlockAction(blockActionsPayload());
-    const auth = blockActionAuth(action as SlackBlockAction);
-    expect(auth.principalId).toBe("slack:T1:C9:5.0");
-    expect(auth.attributes?.user_id).toBe("U7");
-    expect(auth.attributes?.user_name).toBe("netto");
-  });
-});
-
-describe("mrkdwnSections", () => {
-  it("packs lines into capped sections preserving order", () => {
-    const lines = Array.from(
-      { length: 200 },
-      (_, i) => `• item-${i}-${"x".repeat(20)}`
-    );
-    const sections = mrkdwnSections(["Header:", ...lines]) as Array<{
-      type: string;
-      text: { type: string; text: string };
-    }>;
-    expect(sections.length).toBeGreaterThan(1);
-    for (const section of sections) {
-      expect(section.type).toBe("section");
-      expect(section.text.text.length).toBeLessThanOrEqual(
-        SLACK_SECTION_MRKDWN_MAX
-      );
-    }
-    const joined = sections.map((section) => section.text.text).join("\n");
-    expect(joined.startsWith("Header:")).toBe(true);
-    for (const line of lines) {
-      expect(joined).toContain(line);
-    }
-  });
-
-  it("keeps a short list in one section", () => {
-    expect(mrkdwnSections(["Header:", "• a", "• b"])).toHaveLength(1);
-  });
-
-  it("hard-splits a single oversized line at the cap", () => {
-    const sections = mrkdwnSections([
-      "x".repeat(SLACK_SECTION_MRKDWN_MAX + 500),
-    ]) as Array<{ text: { text: string } }>;
-    expect(sections).toHaveLength(2);
-    expect(sections[0]?.text.text.length).toBe(SLACK_SECTION_MRKDWN_MAX);
-    expect(sections[1]?.text.text.length).toBe(500);
-  });
-});
-
-describe("slackTableBlock", () => {
-  it("builds a native table with header + rich_text link cells", () => {
-    const block = slackTableBlock({
-      headers: ["Service", "SHA", "Anyship", "Logs"],
-      columnSettings: [
-        { is_wrapped: true },
-        { align: "left" },
-        { align: "left" },
-        { align: "left" },
-      ],
-      rows: [
-        [
-          slackRawTextCell("portal-website"),
-          slackLinkCell({
-            url: "https://github.com/anysphere/everysphere/commit/abc",
-            text: "abcdef0",
-          }),
-          slackLinkCell({
-            url: "https://anytool.corp.anysphere.co/anyship/deployments?deployment=d1",
-            text: "open",
-          }),
-          slackRawTextCell("—"),
-        ],
-      ],
-    });
-    expect(block).toEqual({
-      type: "table",
-      column_settings: [
-        { is_wrapped: true },
-        { align: "left" },
-        { align: "left" },
-        { align: "left" },
-      ],
-      rows: [
-        [
-          { type: "raw_text", text: "Service" },
-          { type: "raw_text", text: "SHA" },
-          { type: "raw_text", text: "Anyship" },
-          { type: "raw_text", text: "Logs" },
-        ],
-        [
-          { type: "raw_text", text: "portal-website" },
-          {
-            type: "rich_text",
-            elements: [
-              {
-                type: "rich_text_section",
-                elements: [
-                  {
-                    type: "link",
-                    url: "https://github.com/anysphere/everysphere/commit/abc",
-                    text: "abcdef0",
-                  },
-                ],
-              },
-            ],
-          },
-          {
-            type: "rich_text",
-            elements: [
-              {
-                type: "rich_text_section",
-                elements: [
-                  {
-                    type: "link",
-                    url: "https://anytool.corp.anysphere.co/anyship/deployments?deployment=d1",
-                    text: "open",
-                  },
-                ],
-              },
-            ],
-          },
-          { type: "raw_text", text: "—" },
-        ],
-      ],
-    });
-  });
-
-  it("returns undefined for empty headers", () => {
-    expect(slackTableBlock({ headers: [], rows: [] })).toBeUndefined();
-  });
-
-  it("rejects oversized or jagged tables", () => {
-    expect(() =>
-      slackTableBlock({
-        headers: Array.from({ length: SLACK_TABLE_MAX_COLUMNS + 1 }, () => "c"),
-        rows: [],
-      })
-    ).toThrow(/columns exceeds/);
-    expect(() =>
-      slackTableBlock({
-        headers: ["A"],
-        rows: Array.from({ length: SLACK_TABLE_MAX_ROWS }, () => [
-          slackRawTextCell("x"),
-        ]),
-      })
-    ).toThrow(/rows exceeds/);
-    expect(() =>
-      slackTableBlock({
-        headers: ["A", "B"],
-        rows: [[slackRawTextCell("only-one")]],
-      })
-    ).toThrow(/expected 2/);
-  });
-});