Skip to content

Open-source status page, incident response and uptime monitoring

5.8 KB
Raw Blame
// Test double for @slack/web-api (only WebClient is used), swapped in via
// --import-map. Captures chat calls into the shared slack test state.
import {
  type HistoryArgs,
  type MembersArgs,
  slackTestState as s,
} from "./slack-test-state.ts";

export class WebClient {
  chat = {
    postMessage: (args: Record<string, unknown>) => {
      if (s.postMessageOverride) return s.postMessageOverride(args);
      s.calls.push({ method: "postMessage", args });
      return Promise.resolve({ ts: "msg.ts" });
    },
    update: (args: Record<string, unknown>) => {
      if (s.updateOverride) return s.updateOverride(args);
      s.calls.push({ method: "update", args });
      return Promise.resolve({ ts: "msg.ts" });
    },
    postEphemeral: (args: Record<string, unknown>) => {
      if (s.postEphemeralOverride) return s.postEphemeralOverride(args);
      s.calls.push({ method: "postEphemeral", args });
      return Promise.resolve();
    },
    getPermalink: (args: Record<string, unknown>) => {
      s.calls.push({ method: "chat.getPermalink", args });
      return Promise.resolve({
        ok: true,
        permalink: `https://slack.test/archives/${args.channel}/p${String(args.message_ts).replace(".", "")}`,
      });
    },
  };
  reactions = {
    get: (args: Record<string, unknown>) => {
      s.calls.push({ method: "reactions.get", args });
      return s.reactionsGetImpl(args);
    },
    add: (args: Record<string, unknown>) => {
      s.calls.push({ method: "reactions.add", args });
      return Promise.resolve({ ok: true });
    },
  };
  // Mirrors ChatStreamer: `ts` is undefined until the first append or stop.
  chatStream = (args: Record<string, unknown>) => {
    if (!s.chatStreamEnabled) {
      throw new Error("chat streaming is not enabled for this workspace");
    }
    s.calls.push({ method: "chatStream", args });
    let ts: string | undefined;
    let appends = 0;
    return {
      get ts() {
        return ts;
      },
      append: (a: Record<string, unknown>) => {
        if (
          s.streamAppendFailAfter !== null &&
          appends >= s.streamAppendFailAfter
        ) {
          return Promise.reject(new Error("stream append failed"));
        }
        appends++;
        ts = "stream.ts";
        s.calls.push({ method: "stream.append", args: a });
        return Promise.resolve(null);
      },
      stop: (a?: Record<string, unknown>) => {
        ts = "stream.ts";
        s.calls.push({ method: "stream.stop", args: a ?? {} });
        if (s.streamStopFail) {
          return Promise.reject(new Error("stream already closed"));
        }
        return Promise.resolve({ ok: true, ts });
      },
    };
  };
  conversations = {
    replies: (args: Record<string, unknown>) => {
      s.calls.push({ method: "conversations.replies", args });
      return s.repliesImpl(args);
    },
    join: (args: Record<string, unknown>) => {
      s.calls.push({ method: "conversations.join", args });
      return Promise.resolve({ ok: true });
    },
    history: (args: HistoryArgs) => {
      s.calls.push({ method: "conversations.history", args });
      return s.historyImpl(args);
    },
    info: (args: Record<string, unknown>) => {
      s.calls.push({ method: "conversations.info", args });
      return s.conversationsInfoImpl(args);
    },
    members: (args: MembersArgs) => {
      s.calls.push({ method: "conversations.members", args });
      return s.membersImpl(args);
    },
    create: (args: Record<string, unknown>) => {
      s.calls.push({ method: "conversations.create", args });
      return Promise.resolve({
        ok: true,
        channel: { id: "C_INCIDENT", name: args.name },
      });
    },
    invite: (args: Record<string, unknown>) => {
      s.calls.push({ method: "conversations.invite", args });
      return Promise.resolve({ ok: true });
    },
    setTopic: (args: Record<string, unknown>) => {
      s.calls.push({ method: "conversations.setTopic", args });
      return Promise.resolve({ ok: true });
    },
    archive: (args: { channel: string }) => {
      s.calls.push({ method: "conversations.archive", args });
      return s.archiveImpl(args);
    },
  };
  pins = {
    add: (args: Record<string, unknown>) => {
      s.calls.push({ method: "pins.add", args });
      return Promise.resolve({ ok: true });
    },
  };
  agents = {
    sessions: {
      setStatus: (args: Record<string, unknown>) => {
        if (s.sessionStatusOverride) return s.sessionStatusOverride(args);
        s.calls.push({ method: "agents.sessions.setStatus", args });
        return Promise.resolve({ ok: true });
      },
      rename: (args: Record<string, unknown>) => {
        if (s.renameOverride) return s.renameOverride(args);
        s.calls.push({ method: "agents.sessions.rename", args });
        return Promise.resolve({ ok: true });
      },
    },
  };
  assistant = {
    threads: {
      setStatus: (args: Record<string, unknown>) => {
        s.calls.push({ method: "assistant.threads.setStatus", args });
        return Promise.resolve({ ok: true });
      },
    },
  };
  users = {
    info: (args: Record<string, unknown>) => {
      s.calls.push({ method: "users.info", args });
      return s.usersInfoImpl(args);
    },
    lookupByEmail: (args: Record<string, unknown>) => {
      s.calls.push({ method: "users.lookupByEmail", args });
      return Promise.reject(new Error("users_not_found"));
    },
  };
  views = {
    publish: (args: Record<string, unknown>) => {
      s.calls.push({ method: "views.publish", args });
      return Promise.resolve({ ok: true });
    },
    open: (args: Record<string, unknown>) => {
      s.calls.push({ method: "views.open", args });
      return Promise.resolve({ ok: true });
    },
    update: (args: Record<string, unknown>) => {
      s.calls.push({ method: "views.update", args });
      return Promise.resolve({ ok: true });
    },
  };
}