File size: 3,224 Bytes
fc93158 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | import { beforeEach, describe, expect, it, vi } from "vitest";
import { resetInboundDedupe } from "../auto-reply/reply/inbound-dedupe.js";
import {
flush,
getSlackClient,
getSlackHandlerOrThrow,
getSlackTestState,
resetSlackTestState,
startSlackMonitor,
stopSlackMonitor,
} from "./monitor.test-helpers.js";
const { monitorSlackProvider } = await import("./monitor.js");
const slackTestState = getSlackTestState();
type SlackConversationsClient = {
history: ReturnType<typeof vi.fn>;
info: ReturnType<typeof vi.fn>;
};
function makeThreadReplyEvent() {
return {
event: {
type: "message",
user: "U1",
text: "hello",
ts: "456",
parent_user_id: "U2",
channel: "C1",
channel_type: "channel",
},
};
}
function getConversationsClient(): SlackConversationsClient {
const client = getSlackClient();
if (!client) {
throw new Error("Slack client not registered");
}
return client.conversations as SlackConversationsClient;
}
async function runMissingThreadScenario(params: {
historyResponse?: { messages: Array<{ ts?: string; thread_ts?: string }> };
historyError?: Error;
}) {
slackTestState.replyMock.mockResolvedValue({ text: "thread reply" });
const conversations = getConversationsClient();
if (params.historyError) {
conversations.history.mockRejectedValueOnce(params.historyError);
} else {
conversations.history.mockResolvedValueOnce(
params.historyResponse ?? { messages: [{ ts: "456" }] },
);
}
const { controller, run } = startSlackMonitor(monitorSlackProvider);
const handler = await getSlackHandlerOrThrow("message");
await handler(makeThreadReplyEvent());
await flush();
await stopSlackMonitor({ controller, run });
expect(slackTestState.sendMock).toHaveBeenCalledTimes(1);
return slackTestState.sendMock.mock.calls[0]?.[2];
}
beforeEach(() => {
resetInboundDedupe();
resetSlackTestState({
messages: { responsePrefix: "PFX" },
channels: {
slack: {
dm: { enabled: true, policy: "open", allowFrom: ["*"] },
groupPolicy: "open",
channels: { C1: { allow: true, requireMention: false } },
},
},
});
const conversations = getConversationsClient();
conversations.info.mockResolvedValue({
channel: { name: "general", is_channel: true },
});
});
describe("monitorSlackProvider threading", () => {
it("recovers missing thread_ts when parent_user_id is present", async () => {
const options = await runMissingThreadScenario({
historyResponse: { messages: [{ ts: "456", thread_ts: "111.222" }] },
});
expect(options).toMatchObject({ threadTs: "111.222" });
});
it("continues without thread_ts when history lookup returns no thread result", async () => {
const options = await runMissingThreadScenario({
historyResponse: { messages: [{ ts: "456" }] },
});
expect(options).not.toMatchObject({ threadTs: "111.222" });
});
it("continues without thread_ts when history lookup throws", async () => {
const options = await runMissingThreadScenario({
historyError: new Error("history failed"),
});
expect(options).not.toMatchObject({ threadTs: "111.222" });
});
});
|